Some deformers as skin and shape deformer need an object to update
a blender mesh, but this object must own the blender mesh. To do
so we used previously a argument in some deformer constructor to
pass a blender object owning the blender mesh.
But in case the mesh is replaced the blender object of a game object
can't be used, in these case we looked at a blender object registered
along the blender mesh during the conversion.

With the recent merge of deformer creation into BL_DeformableGameObject::LoadDeformer
the look at blender object from mesh was always used. This worked fine
only when only one game object used a deformer for one blender mesh,
when two deformer used the same mesh the both conflicted and no update
appeared.
To solve this issue we first check if the blender object of the game
object own the blender mesh, else we do the look at.

Previously when a modifier deformer was detect the code checked if
a armature deformer or shape deformer was present to, in this case
the modifier deformer was created with an aramture object.

This cuased issues when the a shape deformer existed but without
any armature parent object. To avoid both checks, we only check if
the parent is an armature object.

Fix issue: #628.

When we subclass a proxy we previously incref the proxy to
make sure the game data keep the proxy alive, but in case
of proxy owning the game data, we should not incref to
make sure the proxy can be freed independtly of the game
data.

Previously multiple issue related to the render area were noticed.
They are the all due to a common issue: the width and height get
in RAS_Rect return the number of pixel between the corner (x1 - x2)
giving the maximum pixel index but not the real number of pixels
which is one pixel more.
This issue wasn't unknown as "+ 1" were spread in all the code for
the functions SetViewport and SetScissor of the rasterizer.

But the python function to get window size didn't used the + 1 and
gave wrong values to the user compared to filter off screen size
which were correct.

To avoid all futur issues the functions GetWidth and GetHeight in
RAS_Rect include the addition of 1 and the + 1 workaround is removed
is the rest of the code.

After testing with a custom shape cursor (a simple dot), it seems that linux
cursor doesn't use the corner of the cursor but the corner without the little
white margin contrary to windows which use the corner with the margin.
The mouse event code was introducing a offset for linux cursor, as this
offset is wrong in windows and the window dimensions are right, the mouse
offset is removed.

Fix issue: #560.

Previously the force computed in servo control logic brick was multiplied
by the mass. This behaviour is correct because bullet in
btRigidBody::integrateVelocities compute the linear velocity using force / mass.
But the angular velocity doesn't use this formula. For the angular
velocity we have to multiply the torque by the inertia of the body because
bullet compute angular velocity with: torque * inertia_tensor.

Previously the vertex were using a common base class named RAS_IVertex
which owned basic vertex data as position, normal, tangent. This base
class also defined function to mutate these value and virtual functions
for value in subclasses. The subclasses were RAS_Vertex, a template class,
which owned the uv and color data with size depending on the template
paramaters. This class also defined the virtual function to access uv or color.

This conception is correct as it allows using small vertex memory if the
user doesn't need a lot of uv or color layers. But the usage of virtual
function imposed the class to store a virtual ptr table, this table is
meanly a pointer (8o), this pointer was send to VBO and used memory for
nothing from OpenGL side.

To avoid this vptr, the vertex class is split in two classes: RAS_VertexData
and RAS_Vertex.
The first class is only vertex data without function. It use template
parameters for uvs and colors and is based upon RAS_VertexDataBasic for
the position, color, normal data.
The second class is containing the functions and used only to mutate the
vertex data. When accessing a vertex a RAS_Vertex instance is created with as
parameters the vertex data pointer and the vertex format. This vertex
format is used in uv and color getter to compute the return value based
on the vertex data pointer plus a gap corresponding to the looked layer.

As RAS_Vertex is now a new class, it functions names are cleaned using
CamelCase.

Previously the vertex was using float array converted to Moto
type and converted back to float array. To avoid these two
conversion stages the function RAS_IDisplayArray::CreateVertex now
accept float arrays.
The previous CreateVertex function is still keep for future mesh builder.

The activity culling helps to disable the physics or logic
of an object depending of its distance to the nearest camera.

From user side options were added in both UI and python API
to control this feature. In UI the activity culling is put
in three level, scene, camera, object. The two first level
are enabled as default and the last disabled. Also the object
panel expose option to enabled physics or logic culling with
a different radius.
In python the attribute activityCulling is added to these
three levels and KX_GameObject receive four attributes to
enabled physics and logic culling and controlling their
radius.

In internal sources the activity culling info are stored into
KX_GameObject::ActivityCullingInfo which is owned by in
KX_GameObject::m_activityCullingInfo.

To suspend logic we suspend from SCA_IObject calling Suspend
and Resume but in the same time we need to suspend animation
as they are independant of logic and that it will be hard
to control them when the object doesn't run its logic.
To do so BL_ActionManager implement a suspend flag which disallow
any task creation in KX_Scene::UpdateAnimations.

Thanks for youle's work on this.

The recursive argument of this function was always known at
compile time, it is converted to a template parameter.

Previously the camera were able to use custom viewport only
in python.
An UI is created to do the same based on entire viewport
ratios. The UI expose an option named "Custom Viewport"
and four ratio for left, right, bottom and top. These ratio
correspond with the width or height of the canvas multiplied
by the ratio.

These utilities instore a mechanism where multiple clients are
checking for modifications of a common server, but the client
are not looking at the server at the same time and the server
state is changing.
To ensure that all client know that the server is modified,
at each update the server iterate over all the clients registered
and set a modification state to true in each client if the
update flag from the server match a part of a filter from the
clients.

The client class is CM_UpdateClient, the server CM_UpdateServer,
these both class use a template paramter for the type studied
for update in the perspective to avoid messing clients and
servers of different types.

This doesn't change the behaviour of the servo control.

KX_CullingNode is not interesting as is goal was just to offer
a pointer to the game object using it and the SG_CullingNode
API.
This class can be replaced by KX_GameObject in KX_CullingHandler
which still get the culling node, but this time only SG_CullingNode.

The usage of undocumented python function _PyArg_ParseTupleAndKeywordsFast
(already used in blender) helps to improve performance spend during
function argument parsing. After some test this new function is 2/3 of
the runnign time of the previous parsing function.

But this function has a drawback: it request more code and variable to be
used especially a python parser pre created. To avoid to write this code
each time the template function EXP_ParseTupleArgsAndKeywords is used.
This function receive the args and kwds tuples, the format, the keywords
name and pointers converted values.

The sanitizer is enabled only for the game engine sources compilation,
it is enabled from cmake and the argument passed can also be customized.

…ject.

as BL_DeformableGameObject::m_activePriority was not used and as
m_lastframe was always set in SetActiveAction, this function is replaced
by SetlastFrame which just update m_lastframe attribute.

The skip transform value from deformer is used to know if during
render we have to apply the object matrix or not, only soft body
deformers are using it.
The goal of this commit is to access only time to this value while
creating a display array bucket, to do so we have first to ensure
that the construction of DAB is not in the constructor of deformers
because it will mean that any virtual call will be invalid as the
vptr is not yet complete. To avoid this a function called
InitDisplayArrays is implemented in RAS_Deformer and called in
BL_DeformableGameObject::LoadDeformer.
After these modification it is now possible to call SkipVertexTransform
in DAB constructor and affect its value to m_applyMatrix.

Previously in CcdPhysicsEnvironment::ConvertObject we iterate over all
the parents from the object tree to find the closer object possibly
used as a compound shape parent. But by doing this we affected the
search of just the root parent object to disable dynamic or just for
tracking (e.g for fh spring).
To found both the root parent and the root compound parent, two
variables are used in COnvertObject, compoundParent and parentRoot.
Also to clairfy, the function in physics controller named SetParentCtrl
is rename SetParentRoot as it was used to set the root parent controller
only, not the parent controller.

Fix issue: #634.

This commit fix the vertex reading from triangles in display array.

Currently in the conversion vertex data are always allocated,
checked for redundant then maybe copied and free.
To avoid frequently allocation a memory pool is used for
each display array type, this memory pool is a boost::object_pool.

Tested with sintel desert_level.blend file:
Before: 0.85s
After: 0.82s

Previously when we only get a float array and wanted to convert
it to python vector we were obligated to convert first to MT_Vector.
To avoid this extra conversion PyObjectFrom is also implemented
for float array of a template size.
This improvement is used mainly in KX_VertexProxy, but in consideration
the data passed to PyObjectFrom must be a array reference not a
pointer, to do so the getter in RAS_Vertex are modified.

The "Form Factor" UI value was not working anymore since a long time,
this was caused by the fact that UpdateCcdPhysicsController was
always called on conversion and that this function recalculated
the inertia tensor without the factor.

In this bug two parts are fixed, first the factor is applied
properly everytime setMassProps is called.
Secondly the call to UpdateCcdPhysicsController is avoided during
conversion. This call was proceeded because the functions
SetUserCollision[Group/mask] are calling RefreshCollisions. To avoid
these calls the collision group and mask are moved fully to
physics part, now KX_GameObject is reading and setting these bitmask
from the PHY_IPhysicsController API. The group and mask is initialized
along physics controller in ConvertObject function.

If empty array are detected in a mesh they are not added in the
tracked list of the boundign box, if this list is empty a dummy
bounding box is created instead of a mesh bouning box.

When a near sensor is used a physics controller using a sphere shape
is created through CreateSphereController. But previously the construction
info was memset to 0 instead using the CcdConstructionInfo constructor.
This caused issues by setting the collision mask/group to zero.
The memset is removed as it doesn't do more than the constructor and
that the similar funciton CreateConeController isn't requesting it.

In the same time the usage of memset 0 for PHY_PHY_RayCastResult is
removed in favor of a constructor.

Moving the management in KX_Scene avoid KX_KetsjiEngine to call
the animaiton update for every scene even if only one is needed.
The memeber m_previousAnimTime is added in KX_Scene and UpdateAnimations
now accept a restrict bool arguments.

Maximum slope is bullet feature which can be used to restrict the
player movements, this value is between 0 and pi/2, exposed
in UI and in python under KX_CharacterWrapper.maxSlope.

IN the same time the PHY_ShapeProps struct is removed as its
purpose was just to store blender data used in ConvertObject
function but this function was already doing data conversion from
blender directly, instead mixing different levels, this struct is
removed.

Previously if the user wanted to know if two objects were colliding
he needed a collision sensor or a collision callback and then
check for every objects collided or use a specific mask for target
object only. This technic was pretty complex for an operation looking
simpler from the user point of view.

To know if two object are colliding a method named KX_GameObject.collide(obj)
is implemented in python, this method return a tuple of a boolean
(colliding state) and a list of contact points (KX_CollisionContactPoint)
or None.

This function is using the new internal function named CollisionTest
in the physcis environment which returns a struct with essentially the
same information than the user gets. This function is checking for the
presence of a broadphase pair in bullet cache and then getting the
manifold.

This cleanup contains:
- uncrustify pass
- move definition to .cpp
- remove use of void *
- remove unused enum in PHY_DynamicTypes.h

…ent.

The attributes management inherited from the BFBGE conception, these attributes
were computed in blender shader, material or custom shader and set globally
through the rasterizer with calls like SetAttribs/SetTexCo. Then these
attributes were pulled back in VBO storage when creating the VAO.
The issues of this conception is the useless process of updating global
attributes as the VBO storage need it only once at its creation. Also the VBO
storage is used for both display array storage (vertices and indices) and for
attributes storage (VAOs per draw type), so when reconstructing the attributes
was needed the VBO was also destructed.

To avoid these issues first of all the VBO and VAO are split in two different
class, respectively RAS_DisplayArrayStorage and RAS_AttributeArrayStorage.
RAS_DisplayArrayStorage is owned by RAS_DisplayArray and is dedicated to wrap
RAS_StorageVbo following a pimpl idiom. This storage is created via function
RAS_IDisplayArray::ConstructStorage called from RAS_DisplayArrayBucket the first
render time when the modified flag STORAGE_INVALID is set, this is designed to
delay storage creation to handle asynchronous libloading where the OpenGL
context is inaccessible. Excepted these the functions are IndexPrimitves[...]...
do the same work as before.
RAS_AttributeArrayStorage is owned by a new class named RAS_AttributeArray, and
this last class is owned by the display array bucket using it. The purpose of
RAS_AttributeArray is to store the list of attributes description (location,
type, layer, flag) and lazily create a RAS_DisplayArrayStorage depending on the
drawing mode used. This process is done by the function GetStorage called at
every render step in RAS_DisplayArrayBucket::UpdateActiveMeshSlots. Similar to
RAS_DisplayArrayStorage, RAS_AttributeArrayStorage wrap RAS_StorageVao using
pimpl and offers the function Bind/UnbindPrimitives. RAS_DisplayArrayStorage and
RAS_AttributeArrayStorage are both referenced in RAS_DisplayArrayNodeData to be
used by node callbacks from display array bucket level and mesh slot level.

As described before the attributes are not anymore a global variable, instead
they are build and get in the same time RAS_AttributeArray is created via a call
to RAS_IPolyMaterial::GetAttribs which redirect (at KX_BlenderMaterial level) to
functions from BL_BLenderShader or BL_Shader.
In consideration BL_BLenderShader remove its parsing and store mechanism. The
display array bucket is noticed that the attributes changed by checking a update
client (CM_UpdateClient) tracked to the used material, to do so
RAS_IPolyMaterial is inherited from CM_UpdateServer and use two flags:
ATTRIBUTES_MODIFIED and SHADER_MODIFIED. These both flags are viewed from the
display array bucket and set by BL_Shader and BL_BLenderShader.

Because the display array storage is created in the constructor of the display
array it's not possible to call any virtual functions from the display array,
the previous function used for memory format of the used vertex data type can't
be used anymore, to fill this gap, a struct named RAS_VertexDataMemoryFormat is
implemented and initialized from the function
RAS_VertexData<>::GetMemoryFormat(), this struct is now used in both
RAS_DisplayArrayStorage and RAS_AttributeArrayStorage.

Previously the VAO was optional because instancing was poorly mixed with the VAO
behavior. The correct behavior is while the VAO is bound to bind once the
instancing buffer, bind the attributes and unbind the buffer. By doing this
there's no conflict of attributes and buffer. In consideration all unbind
instancing function are now unused and so removed.

The previous math library Moto is replaced in this commit by the recent mathfu
library, this replacement is motivated by multiple points:
- The Moto API was pretty limited and its updated version (2014 Moto version)
was totally incompatible with the current usage of the library.
- Mathfu was offering a lot more of functions and also the capability of working
with multiple types, int or float vector through a template API.
- Mathfu was using column major matrix contrary to Moto which help to transfer
data to OpenGL or blender functions without transposing back into a temporary
array.
- Mathfu implemented SSE optimizations even for various platforms.

Mathfu was also preferred from other math library as Eigen because of its well
compatible API to the one used from Moto, the main compatibility issues were
fixed by renaming functions calls and object types.

But some compatibility were harder to manage, especially column major matrix
instead of older row major matrix. Moto was mainly row major but the constructor
using a float array and functions setValue/getValue were transposing from/to
column major model. So matrices constructed from an array must not inverse the
row/column access, but matrices computed (e.g perspective projection) needed to
inverse the access row/column.

The new usage of the math library is described as follow: the type names are
similar to GLSL names, they are mt::vec2/3/4 mt::mat3/4 only two types are not
in GLSL: mt::mat3x4 (the old MT_Transform) and mt::quat. To access these types
mathfu.h must be included.
Following GLSL convention the dot and cross product are written: mt::dot(v1, v2)
mt::cross(v1, v2), for the other operators the mathfu functions names are used.
Mathfu introduced some constant vector, so a vector of zeros can be initialized
from mt::zero2/3/4 and for a vector of ones mt::ones2/3/4.
Finally the raw vector data can be accessed through function Data, this function
return an array (not a pointer) which help to remove cast in case of matrix data
passed to blender functions. Else to copy in a raw array the function Pack is
used.

Mathfu is only include files.

Two issues were noticed into CallbackTriggers function.
First manifolds for objects ignoring contact response were
automatically removed, apparently this was needed for older version
of bullet which didn't updated the manifold. This behaviour caused
to always send a invalid contact point list to the user in case of
ghost object collision. To solve this issue the clear is removed as
after some test the bug is not anymore present.
Secondly debug draw of contact points was proceed in CallbackTriggers
but btIDebugDraw is already managing it the same…
The manual debug draw is removed.

Fix issue #636.

A quaternion issue caused a erronous behaviour of the slow parent
relation. This issue came from the slerp function which called
a sub function ToAngleAxis when multiplying a quaternion by a
scalar, in this function a axis vector was normalized. If the axis
was a zero vector (happen when we interpolate the same quaternions)
the normalized failed a return a vector of NaN. To fix this issue
quaternion now use a SafeNormalize instead of Normalize vector
function.

Fix issue: #639.

Previously since BFBGE the UV layers through texture coord
for custom shader were wrongly managed. Every texture used
a unique UV layer which forced vertices to have always 8
UV layers for maximum 8 textures.
But in UPBGE the UV layer managed by vertices is variable
and so this behaviour is wrong as it could defines texture
coord with invalid memory offset of inexistant layers.

To solve this issue the behaviour for material attributes
is applied to texture coord: they are defined for every
textures but can use shared UV layers depending on the
UV layer used by the texture.
To get the proper layer index, in BL_Shader::GetAttrib
an iteration over all the UV layers from the mesh is proceeded
to match the UV name from the material texture.

Fix issue: #644.

Compatiblity initialization of max slope for character
was missing.

Fix issue: #647.

Previously a call to RecalcNormals was procceded in BL_ShapeDeformer
when we detected that the deformer was usign modifiers, but the update
normal function work upon m_transverts and m_transnorms which are not
updated in case of BL_ModifierDeformer and even worse doesn't contain
the same number of elements.
This ends in an invalid memory read.
To fix this issue the normals are not updated manually, this wans't
necessary as the modifiers are already giving correct normal during
conversion.

Using a globally memory pool cause a lot of issues,
it sometimes during modifier deformer convertion and
make async load of meshes of the same type very dangerous.

Before the action actuator a member m_lastUpdate was used in the
update process of the actuator, when the actuator was duplicated
this member was set to -1 as for the constructor of the actuator.
The refactor removed this member because it was redundant, but
nothing compensated it during the duplication of the actuator.
To do so the flag of the actuator is reset to 0 excepted for
continue flag, as again the actuator constructor.

In the same time unused members of the action actuator were removed
and the python attribute blendTime which was inffective since BFBGE
was removed.

The previous algorithm used to update parent relation was wrong because
it tried to compute scale, position and rotation separatly. The correct
algorithm must convert position, scale and rotation to a transform (mat3x4)
then multiply the parent world transform by the child local transform.
After this we extract the position, scale and rotation.
This algorithm is applied to all parent node relation.

In the same time the convertion of the inverse parent matrix in converter
is simplified by using mat4_to_loc_rot_size and supporting the delta
scale in the global scale.

CcdPhysicsEnvironment::CallbackTriggers was testing only if the
second colliding controller was using callback, now it checks
for both controllers.

Since the KX_CollisionSensor cleanup, some virtual functions
used PHY_IPhysicsController instead of void pointer, but the
same function were not updated in KX_NearSensor which inherited
from KX_CollisionSensor and so the function in near sensor
were never used.
The functions signature are updated in KX_NearSensor.

This cleanup includes:
- uncrustify pass
- add const

This cleanup includes:
- uncrusitfy pass
- add const
- remove dynamic_cast

The type KX_NavMeshObject::PathType alias a std::vector of mt::vec3.
It is used by function FindPath and DrawPath in KX_NavMeshObject.

…ormer.

Previously the display array and display array bucket tracked by deformers
were stored in two separated listes, m_displayArrayList and
m_displayArrayBucketList. But futur feature will request to store more
information related to the display arrays. To fix this inconvenient a slot
struct is introduced: DisplayArraySlot stored under list m_slots.
This struct contains the new DA and DAB but also the original DA for update
listening and the original mesh material for replication.

Previously the layers were all sotred in the same list, so any code
reading them needed to check the type of the layer. In some code it
can be inconvenient.
A better system is to store uv and color layers info in separated
listes. In consideration the type doesn't have any reason to stay.

Previously the display array was notify for an update thanks to a modification
flag, but different user were reading this flag and one user was setting clearing
it. This caused to not notify some user that the display array was modified.

To fix this issue the new CM_Update[Server/Client] utilities are used,
display array inherit from CM_UpdateServer and the users RAS_MeshBoundingBox,
RAS_Deformer and RAS_DisplayArrayBucket are owning a update client registered
into a display array.

But before using the update client/server mechanism, CM_UpdateClient needed
to be modified to track a integer for the update flag and not only a boolean,
thsi is used in DAB to catch any update from the DA but after a call to
GetInvalidAndClear make a check of what is modified actually.

RAS_MeshBoundingBox wans't really designed to handle update client as not
struct was used to represent and used DA in the bounding box. Similar to
RAS_Deformer, RAS_MeshBoundingBox use a DisplayArraySLot struct, this
struct store the tracked DA and it's update client.

Previously the BL_ArmatureChannel list stored under name m_poseChannels
in BL_ArmatureObject was shared between duplicated armatures. But blender
armature channels are unique per armature, this caused that only the original
armature was affected by any update of the duplicated armatures.

To fix this issue the BL_ArmatureChannel are made unique per armature.

Fix issue: #629.

This cleanup includes:
- uncrustify pass
- move function definition
- remove extra class keyword
- add const
- use static_cast
- reword comments

This member was used only locally in a function, its visibility
is restricted then.

The blender group object member in KX_GameObject (m_blenderGroupObject)
was a redundant information has it is similar to
m_dupliGroupObject->GetBlenderObject().

This member is removed and its usage is replaced by calling function
GetBlenderObject of the dupli game object.

Previously when calling python function obj.collide(...)
the collision data PHY_ICollData was owned by noone and
so leaked in memory.

To fix this issue the owner ship if transfered to
KX_CollisionContactPointList.

Also a function KX_GameObject::HasCollisionCallbacks is
implemented to not create contact point list for nothing.

…emplate.

Instead using two parameters to intanciate the RAS_VertexData template
class, one struct is used: RAS_VertexFormatType, this struct also include
the enum for the uv and color size.

The display array templates classes need a switch to create
the proper display array instance corresponding on the format
given.

This was proceded thanks to macros but these macro were duplicated
for regular display array and batch display array. As new
classes using format to get template paramater will be used
later a general function is implemented.

This function is named CM_InstantiateTemplateSwitch,
it receives as explicit template parameters the base class to down
cast to, the up class using templates and a tuple of all the
template parameters possible for the up class. Also the function
receive a key to select compare with the tuple element instantiated
and a list of arguments passed to the up class constructor.

For display array classes purpose, a tuple is defined in RAS_VertexFormat.h
containing all RAS_VertexFormatType possible: RAS_VertexFormatTuple.
RAS_VertexFormatType now have a comparaison operator with RAS_VertexFormat
to be working properly in CM_InstantiateTemplateSwitch when compared
with the key.

…n ones)

This commit expose all solver iterations for position, velocity, cluster
and drift solvers.
In the same time the RNA definition of new parameters is a bit cleaned and
the UI defined in python is simplified to fit in two columns insteasd of
three.

Previously the mass of the soft body was set after creating the cluster,
causing incorrect mass in the clusters and incorrect behavior in collision.

Previously the game objects were all storing a constraint list used for
the creation of physics constraint from user settings, but once the object
created, this list has no interest and over all it can be shared between
duplicated objects.

To solve this situation a BL_ConvertObjectInfo struct is introduced, this struct
store a pointer to the blender object which was converted and a list of the
blender constraints. These convert info are created in BL_BlenderSceneConverter
and kept in BL_BlenderConverter after conversion, as promissed they are shared
between game objects under a pointer member: m_convertInfo.

Getter GetBlenderObject and GetConstraints are rewritten to return data from
the convert info.

A special case is dedicated in GetBlenderObject to default camera which doesn't
have any convert info.

Always try to not see ketsji from other parts.

Using a function like SetProg and an argument to decide to bind or
not obligate to use a condition. This condition can be totally
avoided if we the enable argument is not dynamic as in our case.

This function is split in two, BindProg and UnbindProg. For
BL_Shader the BindProg function is override non virtually as the only
caller is KX_BlenderMaterial which has a BL_Shader pointer.

This operation is important for the default camera.

The item passed to PyDict_SetItemString will be incref, so if the item
is constructed in the current scope and not stored in an external data,
the item must be decref.

These rules are applied to KX_PythonInit.cpp and remove the usage of
PyDict_Clear in LA_Launcher.

Previously python was created and initialized the same way for the
blenderplayer through the function setupGamePython. This caused that
when reloading the launcher because of game reload (same file or other file)
we had to take care to not call anything related to python, and the
management of the global dict in blenderplayer was harder.
Because of this difficulties the global dict wasn't shared between game
reload contrary to the shared behaviour in embedded player.

To solve this issue the python initialization and module initialization
is split in two functions: initPlayerPython for constructing python and
initGamePython to initialize a context with all the modules and the
previous global dict.

In the same time the prefix bpy_ is removed in BL_BlenderConverter, and
python joysticks, keyboard and mouse are now using std::unique_ptr
in KX_PythonInit.cpp.

Struct DisplayArraySlot contains mt::vec3 which must be aligned on
16 bytes, in consideration RAS_BoundingBox::m_slots uses
mt::simd_allocator to allocate with the proper alignement.

The user is now able to duplicate a KX_Mesh using the python function
mesh.copy().

Internally this function copy construct KX_Mesh and RAS_Mesh and its
RAS_MeshMaterial, then the mesh conversion is finalized and registered
to the converter.
For this last operation it was needed to store a KX_Scene pointer into
KX_Mesh and to be able to replace it in case of lib loading.