Member functions are cheaper to call than std::function.

…tionship.[h/cpp].

ReplaceMesh function was placed into KX_Scene for no real reason, its
place is more correct into KX_GameObject directly. In the same time the
code part reinstancing the deformers is moved in a new function named
LoadDeformer in class BL_DeformableObject. This funciton is also used by
the converter to init deformes after the parenting step (for armatures).

…ion.cpp.

This uniform is frequently changed between the viewport settings and
in game settings, to avoid recompiling the materials only for it
and has this uniform is a more a flag than a value: this uniform
back to dynamic uniform.

Fix issue: #609.

Previously the code parts computing AABB were using a condition
to detect the first point computed used to initialize the AABB
dimensions. But this method requiered a test at each points and
also to be able to detect the first point.
To avoid these restrictions the AABB dimension is initialized to
float min for max and float max for min. This make sure that any
point will affect the AABB the first time.

THe deformer conversion have some extra constraint, first it had to be placed
before the RAS_MeshUser are created with AddMeshUser, secondly BL_ShapeDeformer
have to check the case when parent object is null.

Also the function BL_SkinDeformer::SetArmature became useless and the construtors
in deformers in case of conversion of non-replicated object are removed because
unused anymore.

The call to ConvertScene wasn't taking care if the scene existed
because it's name was valid. This function call is moved down
in a if block.

Fix issue: #615.

This cleanup contains a uncrusty pass.

Previously the servo control logic brick was able to control only
the linear velocity using force. But some users showed that in some
non-rare case it could be needed to servo control the angular velocity
via torques.

To fill this gap, the servo control logic brick exposes a enum named
"Servo Type" to select either linear or angular velocity, linear is
the default. This option is used in KX_ObjectActuator to compute
from linear or angular velocity a force or torque.

Note: The reference object in case of angular velocity is just used to
substract its angular velocity contrary to linear velocity which compute
the linear velocity of the reference object on the position of the affected
object.

This cleanup contains:
- uncrustify pass
- use range loop
- remove friend class

Previously the inexistance of a python component manager forced
in KX_Scene to iterate over all the object to ask for a component
update. The implementation of a manager with a registering
mechanism help to avoid this iteration and optimize as much as
possible the case where a scene doesn't update any components.

…::GetChildren.

The functions GetChildren and GetChildrenRecursive were not used only for
the python API but also for the animation and duplication process, in these
last cases the creation of a std::vector is cheaper and more easy to use.
For the python API prupose, EXP_ListValue now had a constructor taking
a std::vector to copy items from.

The properties in EXP_Value now use a std::map value instead of a
pointer to std::map, the economy is pretty low with a pointer.
The m_error flag is removed in favor of a virtual function IsError
redefined in EXP_ErrorValue to return true.

This reverts commit 1a47594.

Previously the vertex remap was resized with default value to -1 but if
this list wasn't empty the previous value were kept. To initialize all
values to -1 std::fill is used.

Fix issue: #622.

Two functions are added to replace frequently used behaviour:
remove if an element is found in a list, or add if an element is
not present in a list. The functions CM_ListRemoveIfFound
and CM_ListAddIfNotFound assume these goal, they are defined in
new file CM_List.h.

FLT_MIN is not the maximum negative value of a float.

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.