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.

"BL_" and "Blender" is redundant.

…olator.[h/cpp].

This cleanup includes:
- uncrustify pass
- remove extra class/struct keyword
- move function definition to .cpp.

This commits add an empty SetOption function in SG_Controller to avoid redefinition
in subclasses, also the attributes m_modified and m_ipotime which are used in all
controller classes are moved into the base class SG_Controller, in consideration
the function SetSimulationTime is de-virtualized and moved into SG_Controller.

Interpolator list was a common attribut of all the classes derived from
SG_Controller, in consideration this attribut is moved into SG_Controller
and the function Update iterate over all the interpolators and call for
update.

In the same time the function UpdateSpatialData always call for parent
relation update as before all the controller subclasses were returning
false in function Update.

The code in Update function could be simplified by using loops for check
on all axis.

m_ipo_xform is not a pointer in KX_IpoSGController and using this
instead of its addresse will end in the same result.

After the begining of the Update function we know that variables
m_ipo_start_initialized and m_ipo_euler_initialized are set to
true and then the check later of these two variables is useless.

A function ProcessReplica is introduced in SG_Controller to duplicate the
interpolator and set a correct target. To have this function we needed first
to make SG_ScalarInterpolator and merge KX_ScalarInterpolator to SG_Interpolator.

Some pointer in KX_GameObject corresponded to data owned by the
game object or inexistant. In this case std::unique_ptr could be used
to ensure the free of data.

The only drawback is the requierment of a copy constructor to duplicate
the data or set they to nullptr.

Also m_clientInfo is now not anymore a pointer as it is never nullptr
and owned by the game object.

See comments in the commit.
Test file: http://pasteall.org/blend/index.php?id=48626

Using VBO and VAO allow to render all the lines in one command
and to render all the AABB and frustum using instancing in one
command too.

The usage of VBO request that all the structs for lines, aabbs,
frustum and boxes use array instead of mathfu types to avoid
SSE padding and alignement.

Four shaders are introduced to help debug drawing using instancing.
The first is just for drawing lines using a flat color, the second
is for wire boxes, the third for solid boxes with in and out color
and the fourth for 2d boxes.
All the these geometry type use geometry instancing.

For each type RAS_OpenGLDebugDraw allocate a VAO and multiples VBOs,
they are stored into m_vbos and m_vaos and accessed thanks to enums.
The VAO are initialized in RAS_OpenGlDebugDraw constructor pointing
to the uninitialized VBOs, some VBOs as unit 3d and 2d box and IBOs
are initialized in the same time.

At each render step the VBO containing data about instancing or
geometry are updated from the data list contained into RAS_DebugDraw.
Then the render is procceed binding the VAO and calling the proper
draw call.

2d boxes receive a special treatment. The boxes are rendered using
a vertically inverted ortho matrix because the Y axis is from the
top of the screen.

All these modification ends in a significant speedup for debug drawing
and makes the code easier to move to blender 2.8.

The duplication of sg controller is useless as the controllers
duplicated are finally used by no one because the action manager
of the new object is inexistant.

Allocating SG_Interpolator on heap is useless as only SG_Controller see
and modify they.

We should use at least box of one pixel.

In the same time the replacement of the logic manager into the event manager
is removed in the scene merging as the event manager are deleted just after
the merge of the scene.

Functions like glVertexAttribDivisor and glDraw[Arrays/Elements]Instanced
are requiering OpenGL 3.0/3, but some GPU could not offer it and so they
must use the ARB extension instead.

Previously when the mouse actuator was deactivated then activated
the mouse gap from the mouse position on the last activation was taken
causing a high movement. This behaviour is unconsistent with the first
activation of the mouse actuator which ignore the last mouse position
(set to -1) and then just init the mouse position for the next frame.
This commit mimic this behaviour when the actuator is deactived by setting
the previous mouse position to -1.

Fix issue: #663.

This way we can update gamecontrollerdb.txt file easier than before
(only it is necessary overwrite the file)

Put a less stressful development cycle

@panzergame : Please, give a look to check if my fixes are ok.

As is indicated in the Blender web (https://www.blender.org/about/
logo/), the logo and the brand name “Blender” are not part of the GNU
GPL, and can only be used commercially by the Blender Foundation on
products, websites, and publications.

Due to this, we would have to move Blender logo and trademark to UPBGE
ones before next release, pointing out in a clear way that this is fork
of Blender-BGE to avoid any future issues.

The new option is at user preferences under system tab. The component
execution is disable by default (similar to scripts).

It is not necessary to repeat that a function is from a scene graph
class when we call it from a scene graph class.

Previously the SG_Controller were helding a pointer to the node owning them,
but this pointer was used only in Update function called by the node.
So the member is removed and the function Update receive the node pointer
instead.

Also BL_Action use an helper function AddController to add a valid controller,
controllers without any interpolators (Empty()) are ignored.

Now it uses the same DEFINE as the python script auto-exec disable.

As blend component executation on loading as component registration or
component reloading are disable by default.

Warning notifications were added to top-bar and console.

UPBGE: Add the option to disable component execution on game start

Somehow the case in RAS_IDisplayArray::ConstructArray was ignoring the
vertex formats with an 8th UV or color layer.

Intent to fix issue #699.

This way we can modify current game engine addons and to add a new ones

PyObjectFrom is now a template function to adapt on different vector
size and matrix sizes.
Support of vecX_mapped is addded.

A check of prop.size() == 0 was rewritten in prop.size() instead of prop.empty().

In the same time the function CheckRayCastObject is implemented to factorise the
proprety and mask check made in RayHit and NeedRayCast.
CheckRayCastObject also add a little optimization by not getting the object collision
group when the mask accept all objects.

Fix issue #671.

To ease the definition of a component a button named "Create Component" is added.
This button ask for a path module.Class and generates a script named module.py
with a component class Class inside.
This template class contains a start and update function commented
and a definition block before the class for global game engine variable.

If the file already exists an error is raised.

The previous button named Add Component is now renamed Register Component.

X & 0 means nothing contrary to X == 0.

EXP_ListWrapper is now a template class based upon EXP_BaseListWraper.
The template parameter are the Object and its memeber functions to call.
These memeber fuctions are encapsulated in static function defined in EXP_ListWrapper.

This function is placed in KX_Globals.h under the name KX_GetPhysicsEnvironment
and directly call for KX_Scene::GetPhysicsEnvironment().

From blenderplayer the user pref flags are not copied to
Global. To do so we mimic wm_init_userdef by checking and copying
USER_SCRIPT_AUTOEXEC_DISABLE flag.

In the same time any call to GetProxy implictly incref the proxy,
so if we don't return it as for attributes or methods we must decref
the proxy after.

The blenderplayer was not calling explicit initialization of mathutils and other
modules and let the user calls the initialization when importing them.
But some of the types defined on these modules can be returned by a python
function without requering to import the module, for example KX_GameObject.worldPosition
return a mathutils.Vector and some scripts don't import mathutils.

To solve this issue the initialization of the modules are explicitly called into
initPlayerPython by looping over bge_internal_modules and calling
PyImport_ImportModuleLevel.

It fix a major issue in blenderplayer scripts.

The camera zoom setting was previously only stored into the ketsji engine,
to avoid storing a setting only for override camera, this zoom is stored
in RAS_CameraData. Then the override camera zoom is initialized easily
from LA_BlenderPlayer and for other camera, the zoom is copied from
BL_Converter global zoom variable (m_camZoom) initialized at the converter
construction from the launcher.

* UPBGE: Improve frustum culling performance.

Frustum culling was improved in two ways. First, simplificate the bounding
box update. Second the test are parallelized using TBB range loop.

The bounding box update is simplified by adding the call to RAS_Deformer::UpdateBuckets
in KX_GameObject::UpdateBounds after we checked that the objects as a
bounding box. By doing this we avoid a call to GetDeformer for all objects
without a bounding box, with an unmodified bounding box or without auto
update.

All the computation of culling objects is moved into KX_CullingHandler,
this class construct it's own objects list and returns it in Process function.
Process function build a CullTask and launch it usign tbb::parallal_reduce.

Each CullTask have an operator() to test a range of object, any objects passing
the culling test is added in a task local objects list. Once the tests
finished the CullTask merge these objects list in function join to end
up with the list of all non-culled objects.
This technique of reduce of list is way better than using a shared object
list for all tasks and lock a mutex before adding an object. The method
with mutex was always slower than without parallelization.

This patch was tested with cube meshes :
number of object | previous time | new time
1000 | 0.06 | 0.07
8000 | 1.04 | 0.55
27000 | 3.81 | 1.90
125000 | 16.16 | 8.31

RAS_MeshSlot are owned by RAS_MeshUser, there's no need to allocate them on
heap to after hold their pointers in a list, just allocate in the list
directly.

Tested with sintel desert level.

Previously the debug draw (RAS_DebugDraw) was get from the rasterizer with
a scene as identifier, but the scene could simply store an instance of
RAS_DebugDraw and avoid lookup in rasterizer.
In the same time the ketsji engine request a debug draw only for profiling
render.

The principle of AoS (array of structure) is to store an element structure in a
array e.g:

struct Vertex
{
	mt::vec3_packed pos;
	mt::vec3_packed nor;
};

std::vector<Vertex> vertices;

This kind of structure is very easy to use and totally tolerated for big
structure or small amount of elements, also a reference or a pointer to a Vertex
can be passed to any functions.
Unfortunatly the memory cache usage is most of the time not efficient. Imagining
a function modifying only the position of vertices, at each iteration the Vertex
struct will be loaded in cache and only the member pos will be used, so 12 bytes
on 24, the left 12 bytes will pollute the cache and cause more cache loads. If
our function is modifying all the member of Vertex the cache isn't an issue.

The opposite way SoA (structure of array) stores in a structure an array for
each member, e.g:

struct Vertices
{
	std::vector<mt::vec3_packed> pos;
	std::vector<mt::vec3_packed> nor;
};

With this method passing a vertex to an other function is quite complicated as
it ends up passing the Vertices instance and the vertex index to sample pos and
nor. But on the cache side, if we back to our function modifying the positions,
this function will load cache pages of only position and not waste memory at
loading other unused data. Also for the case of modifying positions and normals,
the both array will be stored in different cache pages without performance
decrease compared to AoS.

For CPU using SoA is generally an improvement, for GPU too, excepted for old GPU
which might prefer interleaved data but nothing really confirms it.

Previously in UPBGE and BGE, the vertices were stored in AoS idiom, UPBGE make
more complex the vertices by adding different vertex struct for each combination
of UV and color layer. All was accessed through an interface RAS_Vertex which
hold a pointer to a RAS_IVertexData, the base class of any vertex data of any
format. In the same time RAS_IDisplayArray was an interface to
RAS_DisplayArray<VertexData>.
By using SoA, RAS_DisplayArray owns a VertexData struct with a list for all
vertex members (position, normal, tangent, 8 uv and 8 color), depending on the
format some UV and color array are left empty. In the same time function for
getting and setting all the member data are added, these function takes a vertex
index, UV/color index for uv and color, and for setter a value too.
By this way BL_SkinDeformer update the position just by calling
RAS_DisplayArray::SetPosition(i, pos) instead of getting the RAS_Vertex via
RAS_DisplayArray::GetVertex(i) and calling RAS_Vertex::SetXYZ.

With these modifications RAS_DisplayArray<>, RAS_VertexData<> are removed and
RAS_BatchDisplayArray doesn't need anymore virtual inheritance.

On the conversion side, without RAS_VertexData the structure
BL_SharedVertexPredicate used to find similar vertices is now copying the
normal, tangent, uv and color data inside. Once a vertex is unique, it is added
to the display array through RAS_DisplayArray::AddVertex(pos, nor, tan, uvs,
colors, origIndex, flag) which append the vertex data to m_vertexData and
construct the vertex info.

VBO don't try to re-interleave the data as the time cost is too expensive,
instead each member are sent to the VBO one by one, this is proceeded in
RAS_StorageVbo::CopyVertexData. An other advantage of SoA is allowing to update
only one kind of data, if the positions are modified these data are just copied
to the beginning of the VBO without touching of the other data. This technique
is used in RAS_StorageVbo::CopyVertexData by checking a modification flag.
OpenGL attributes (VAO) are changed too because of the new VBO layout. The
RAS_VertexDataMemoryFormat is replaced by RAS_DisplayArrayLayout which is not
constant after the display array creation as modifying the size of the array
change the offset of each data type in the VBO. In consideration
RAS_DisplayArray::GetLayout return a new RAS_DisplayArrayLayout with the proper
offsets. To recreate the attributes, RAS_AttributeArray::Clear is called when
detecting a size update in RAS_DisplayArrayBucket::UpdateActiveMeshSlots.

To summarize the advantages of using SoA are the cache friendly load, the
possibility to update only modified data in VBO and the simplification of
storing multiple vertex formats. But the inconveniences could be some old GPU
limitation and the recreation of the VAO at each display array size update in
modifier deformers.

This patch was tested with 3 files :

The first file is 1600 cubes of 384 faces deformed by an armature.
If the cube have only the default UV and color layer :
			Previous	Current
Animation	9.6			6.3
Rasterizer	17.5		10.8

With 8 UV and color layers :
			Previous	Current
Animation	17.5		6.7
Rasterizer	42.7		11.9

The second and third files are about modification of vertex position from python
or rendering a mesh with a huge amount of vertices, both files didn't show a
time difference.

Previously SetViewMatrix requested view matrix, position and scale. Position
is useless at it could be found in the inverse view matrix which is computed
anyway. Scale is not needed for users of this function not using any scale
for example shadow and texture renderers.

In consideration the user could call :
SetViewMatrix(viewmat)
SetViewMatrix(viewmat, scale)

The second function test if the scale is negative and negate the rows of the
view matrix.