Blender Git Loki

Extension of the C-API for Bullet in Blender, to enable customized
collision detection outside of rigid body dynamics.

These extensions consist of a few major changes:
* Support for "btGhost" objects.

These are Bullet collision objects, but not rigid bodies. They can be
added to a btCollisionWorld, or they can be used for immediate
individual collision detection. Ghost objects don't have any effect on
rigid bodies or other collision objects.

Ghost objects are "one-way" colliders: they register contacts with
actual collision objects, but don't themselves generate contacts in
other bodies. This makes them useful for accessing Bullet's advanced
contact generation algorithms in simulation systems that don't
actually interact with rigid bodies (e.g. hair or cloth).

* Better low-level access to collision shapes.

Collision shapes can now be allocated outside of the API using static
size variables. This allows more efficient allocation schemes, such
as bulk array allocation and mempools/memarenas. The Bullet engine
itself expects callers to allocate and manage class instances in fact,
but due to the optional linking with Bullet and the differences
between C/C++ the allocation was left to single collision shape
instances so far.

* Compound shapes can now be constructed explicitly as well. Previously
only the primitive shapes were supported, with compounds limited to
special cases.

* Contact callback functions (contact and proximity tests) can now do
complete reports of all manifold contact points.

Taken together, these API improvements will open up Bullet to a wider
range of features inside Blender, for rigid body simulations as well as
other uses.

Differential Revision: https://developer.blender.org/D1268

Added API representation of manifold contact points and the direct
contact test function from btCollisionWorld.

This function can be used for testing individual collision objects
(rigid bodies or ghosts) against objects in the world. It is only
useful for one-way interaction (rigid bodies don't react to the tested
object), but allows collision detection without adding objects into the
world. The current build process for the scene dynamics world is very
much centered on Blender Objects and extending it is difficult.

Reorganizing Bullet world rebuilding in scene updates to allow pure
collision-only time steps and (uncached) ghost objects.

This will allow non-rigidbody sims (e.g. hair, softbody) to hook into
bullet collision detection via "ghost objects". These are Bullet objects
without rigid body dynamics (btCollisionObject). The contacts are
generated just like for rigid bodies, but their internal solvers can
then work like before without having to use Bullet stepping.

Support for btGhostObjects in the Bullet API.

Ghost objects are pure collision objects that have no effect on rigid
bodies, but can be used to hook into the collision detection of Bullet.

This way Blender can utilize the optimized collision detection in Bullet
as well as its contact caching, which is necessary for stable collision
response in many softbody-type algorithms that implement Coulomb
friction cones.

API for compound collision shapes in the Blender RigidBody module.

Refactoring internal btCollisionShape storage in the rbCollisionShape
wrapper class.

Now there are a matching subclasses of `rbCollisionShape` for each of
the used `btCollisionShape` equivalents. They store a bt shapes as
direct members, which means the internal memory allocation can be
largely avoided later, which is useful for efficient creation of many
shapes in mempools etc.

"Init" variants of shape constructor functions for simple implicit
shapes.

These functions allow external memory allocation (using the associated
***_size values) for efficiency. An array or memory pool can then be
used to create lots of shapes and initialize them with the internal
Bullet data using the API.

Note that doing this for mesh-based shapes (triangle mesh, GImpact and
convex hull shapes) is not very useful, because they allocate data
internally and should not be created in massive numbers. The init
variants are supposed to be used for small fixed-size shapes (boxes,
spheres, etc.) which can then be combined into compound shapes.

"Free" function for shapes which only deconstructs the object, but does
not handle deallocation.

Generalized the convex-sweep test API function to also support ghost
objects.

All collision test functions work with btCollisionObject, but for the
C API they need explicit variants for rbRigidBody and rbGhostObject.