wip bullet/webgl demo

13 files changed, 216087 insertions, 0 deletions

diff --git a/demos/webgl/HelloWorld.cpp b/demos/webgl/HelloWorld.cpp
new file mode 100644
index 00000000..cacd128e
--- /dev/null
+++ b/demos/webgl/HelloWorld.cpp
@@ -0,0 +1,142 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2007 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#include "btBulletDynamicsCommon.h"
+#include <stdio.h>
+
+/// This is a Hello World program for running a basic Bullet physics simulation
+
+  btDefaultCollisionConfiguration* zz_collisionConfiguration;
+  btCollisionDispatcher* zz_dispatcher;
+  btBroadphaseInterface* zz_overlappingPairCache;
+  btSequentialImpulseConstraintSolver* zz_solver;
+  btDiscreteDynamicsWorld* zz_dynamicsWorld;
+
+void zz_prepare()
+{
+
+  int i;
+
+  ///collision configuration contains default setup for memory, collision setup. Advanced users can create their own configuration.
+  zz_collisionConfiguration = new btDefaultCollisionConfiguration();
+
+  ///use the default collision zz_dispatcher. For parallel processing you can use a diffent zz_dispatcher (see Extras/BulletMultiThreaded)
+  zz_dispatcher = new  btCollisionDispatcher(zz_collisionConfiguration);
+
+  ///btDbvtBroadphase is a good general purpose broadphase. You can also try out btAxis3Sweep.
+  zz_overlappingPairCache = new btDbvtBroadphase();
+
+  ///the default constraint zz_solver. For parallel processing you can use a different zz_solver (see Extras/BulletMultiThreaded)
+  zz_solver = new btSequentialImpulseConstraintSolver;
+
+  zz_dynamicsWorld = new btDiscreteDynamicsWorld(zz_dispatcher,zz_overlappingPairCache,zz_solver,zz_collisionConfiguration);
+
+  zz_dynamicsWorld->setGravity(btVector3(0,-10,0));
+
+  ///create a few basic rigid bodies
+  btCollisionShape* groundShape = new btStaticPlaneShape(btVector3(btScalar(0.),btScalar(1.),btScalar(0.)), 0);
+
+  btTransform groundTransform;
+  groundTransform.setIdentity();
+  groundTransform.setOrigin(btVector3(0,-6,0));
+
+  {
+    btScalar mass(0.);
+
+    //rigidbody is dynamic if and only if mass is non zero, otherwise static
+    bool isDynamic = (mass != 0.f);
+
+    btVector3 localInertia(0,0,0);
+    if (isDynamic)
+      groundShape->calculateLocalInertia(mass,localInertia);
+
+    //using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+    btDefaultMotionState* myMotionState = new btDefaultMotionState(groundTransform);
+    btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,myMotionState,groundShape,localInertia);
+    btRigidBody* body = new btRigidBody(rbInfo);
+
+    //add the body to the dynamics world
+    zz_dynamicsWorld->addRigidBody(body);
+  }
+
+
+  for (int i = 0; i < 5; i++)
+  {
+    //create a dynamic rigidbody
+
+    btCollisionShape* colShape = new btBoxShape(btVector3(1,1,1));
+    //btCollisionShape* colShape = new btSphereShape(btScalar(1.));
+
+    /// Create Dynamic Objects
+    btTransform startTransform;
+    startTransform.setIdentity();
+
+    btScalar  mass(1.f);
+
+    //rigidbody is dynamic if and only if mass is non zero, otherwise static
+    bool isDynamic = (mass != 0.f);
+
+    btVector3 localInertia(0,0,0);
+    if (isDynamic)
+      colShape->calculateLocalInertia(mass,localInertia);
+
+      startTransform.setOrigin(btVector3(0,4+i*2.1,0));
+    
+      //using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+      btDefaultMotionState* myMotionState = new btDefaultMotionState(startTransform);
+      btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,myMotionState,colShape,localInertia);
+      btRigidBody* body = new btRigidBody(rbInfo);
+
+      zz_dynamicsWorld->addRigidBody(body);
+  }
+}
+
+
+/// Do some simulation
+
+
+void zz_simulate(float diff) {
+  zz_dynamicsWorld->stepSimulation(diff);
+}
+
+void zz_read(int j, btVector3& location, btQuaternion& rotation)
+{
+  {
+    btCollisionObject* obj = zz_dynamicsWorld->getCollisionObjectArray()[j];
+    btRigidBody* body = btRigidBody::upcast(obj);
+    if (body && body->getMotionState())
+    {
+      btTransform trans;
+      body->getMotionState()->getWorldTransform(trans);
+      location = trans.getOrigin();
+      rotation = trans.getRotation();
+      //printf("world pos = %.5f,%.5f,%.5f\n",float(location.getX()),float(location.getY()),float(location.getZ()));
+    }
+  }
+}
+
+int main(int argc, char** argv)
+{
+  zz_prepare();
+  zz_simulate(1/60.);//new btVector3);
+  btVector3 location;
+  btQuaternion rotation;
+  zz_read(1, location, rotation);
+  printf("world pos = %.5f,%.5f,%.5f   rot=%.5f,%.5f,%.5f,%.5f\n",float(location.getX()),float(location.getY()),float(location.getZ()),
+      float(rotation.getX()), float(rotation.getY()), float(rotation.getZ()), float(rotation.getW())
+    );
+}
+
diff --git a/demos/webgl/README.txt b/demos/webgl/README.txt
new file mode 100644
index 00000000..5ff384b0
--- /dev/null
+++ b/demos/webgl/README.txt
@@ -0,0 +1,9 @@
+work-in-progress demo with bullet and webgl (glge)
+
+run ./server.sh (chrome does not like XHR on file://), then run one of
+
+  google-chrome --enable-webgl 127.0.0.1:8991/demo.html
+  firefox 127.0.0.1:8991/demo.html
+
+(for firefox, requires beta7, preferably minefield/nightly builds).
+
diff --git a/demos/webgl/bullet.js b/demos/webgl/bullet.js
new file mode 100644
index 00000000..2b839801
--- /dev/null
+++ b/demos/webgl/bullet.js
@@ -0,0 +1,206722 @@
+var Bullet = (function(Module, args) {
+  Module = Module || {};
+  args = args || [];
+
+//// Runs much faster, for some reason
+//var Module = {};
+//var args = arguments;
+    // === Auto-generated preamble library stuff ===
+  
+  Runtime = {
+    stackAlloc: function stackAlloc(size) { var ret = STACKTOP; assert(size > 0); STACKTOP += size;STACKTOP = Math.ceil(STACKTOP/4)*4;; assert(STACKTOP < STACK_ROOT + STACK_MAX); return ret; },
+    staticAlloc: function staticAlloc(size) { var ret = STATICTOP; assert(size > 0); STATICTOP += size;STATICTOP = Math.ceil(STATICTOP/4)*4;; return ret; },
+    alignMemory: function alignMemory(size,quantum) { var ret = size = Math.ceil(size/(quantum ? quantum : 4))*(quantum ? quantum : 4);; return ret; },
+    getFunctionIndex: function getFunctionIndex(func, ident) {
+      var key = FUNCTION_TABLE.length;
+      FUNCTION_TABLE[key] = func;
+      FUNCTION_TABLE[key+1] = null; // Need to have keys be even numbers, see |polymorph| test
+      Module[ident] = func; // Export using full name, for Closure Compiler
+      return key;
+    },
+    isNumberType: function (type) {
+      return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
+    },
+    isPointerType: function isPointerType(type) {
+    return pointingLevels(type) > 0;
+  },
+    isStructType: function isStructType(type) {
+    if (isPointerType(type)) return false;
+    if (new RegExp(/^\[\d+\ x\ (.*)\]/g).test(type)) return true; // [15 x ?] blocks. Like structs
+    // See comment in isStructPointerType()
+    return !Runtime.isNumberType(type) && type[0] == '%';
+  },
+    INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
+    FLOAT_TYPES: {"float":0,"double":0},
+    getNativeFieldSize: function getNativeFieldSize(field, alone) {
+    var size;
+    if (4 > 1) {
+      size = {
+        'i1': alone ? 1 : 4, // inside a struct, aligned to 4,
+        'i8': alone ? 1 : 4, // most likely...? XXX
+        'i16': alone ? 2 : 4, // ditto
+        'i32': 4,
+        'i64': 8,
+        'float': 4,
+        'double':8
+      }[field]; // XXX 32/64 bit stuff
+      if (!size) {
+        size = 4; // Must be a pointer XXX 32/64
+      }
+    } else {
+      size = 1;
+    }
+    return size;
+  },
+    dedup: function dedup(items, ident) {
+    var seen = {};
+    if (ident) {
+      return items.filter(function(item) {
+        if (seen[item[ident]]) return false;
+        seen[item[ident]] = true;
+        return true;
+      });
+    } else {
+      return items.filter(function(item) {
+        if (seen[item]) return false;
+        seen[item] = true;
+        return true;
+      });
+    }
+  },
+    calculateStructAlignment: function calculateStructAlignment(type, otherTypes) {
+      type.flatSize = 0;
+      var diffs = [];
+      var prev = -1, maxSize = -1;
+      type.flatIndexes = type.fields.map(function(field) {
+        var size;
+        if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
+          size = Runtime.getNativeFieldSize(field, true); // pack char; char; in structs, also char[X]s.
+          maxSize = Math.max(maxSize, size);
+        } else if (Runtime.isStructType(field)) {
+          size = otherTypes[field].flatSize;
+          maxSize = Math.max(maxSize, 4);
+        } else {
+          dprint('Unclear type in struct: ' + field + ', in ' + type.name_);
+          assert(0);
+        }
+        var curr = Runtime.alignMemory(type.flatSize, Math.min(4, size)); // if necessary, place this on aligned memory
+        type.flatSize = curr + size;
+        if (prev >= 0) {
+          diffs.push(curr-prev);
+        }
+        prev = curr;
+        return curr;
+      });
+      type.flatSize = Runtime.alignMemory(type.flatSize, maxSize);
+      if (diffs.length == 0) {
+        type.flatFactor = type.flatSize;
+      } else if (Runtime.dedup(diffs).length == 1) {
+        type.flatFactor = diffs[0];
+      }
+      type.needsFlattening = (type.flatFactor != 1);
+      return type.flatIndexes;
+    },
+    __dummy__: 0
+  }
+  
+  
+  function __globalConstructor__() {
+  }
+  
+  // Maps ints ==> functions. This lets us pass around ints, which are
+  // actually pointers to functions, and we convert at call()time
+  var FUNCTION_TABLE = [];
+  
+  var __THREW__ = false; // Used in checking for thrown exceptions.
+  
+  var __ATEXIT__ = [];
+  
+  
+  
+  
+  var ABORT = false;
+  
+  function assert(condition, text) {
+    if (!condition) {
+      var text = "Assertion failed: " + text;
+      print(text + ':\n' + (new Error).stack);
+      ABORT = true;
+      throw "Assertion: " + text;
+    }
+  }
+  
+  function Pointer_niceify(ptr) {
+    return { slab: IHEAP, pos: ptr };
+  }
+  
+  // Creates a pointer for a certain slab and a certain address in that slab.
+  // If just a slab is given, will allocate room for it and copy it there. In
+  // other words, do whatever is necessary in order to return a pointer, that
+  // points to the slab (and possibly position) we are given.
+  
+  var ALLOC_NORMAL = 0; // Tries to use _malloc()
+  var ALLOC_STACK = 1; // Lives for the duration of the current function call
+  var ALLOC_STATIC = 2; // Cannot be freed
+  
+  function Pointer_make(slab, pos, allocator) {
+    pos = pos ? pos : 0;
+    if (slab === HEAP) return pos;
+    // Flatten out - needed for global consts/vars
+    function flatten(slab) {
+      if (!slab || slab.length === undefined || typeof slab === 'function') return [slab];
+      return slab.map(flatten).reduce(function(a,b) { return a.concat(b) }, []);
+    }
+    var slab = flatten(slab);
+    // Finalize
+    var ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc][allocator ? allocator : ALLOC_STATIC](Math.max(slab.length - pos, 1));
+    for (var i = 0; i < slab.length - pos; i++) {
+      var curr = slab[pos + i];
+      if (curr === undefined) throw 'Invalid element in slab'; // This can be caught, and you can try again to allocate later, see globalFuncs in run()
+      if (typeof curr === 'function') {
+        curr = Runtime.getFunctionIndex(curr);
+      }
+      // TODO: Check - also in non-typedarray case - for functions, and if so add |.__index__|
+      if (typeof curr === 'number' || typeof curr === 'boolean') {
+        IHEAP[ret + i] = curr; // TODO: optimize. Can easily detect floats, but 1.0 might look like an int...
+        FHEAP[ret + i] = curr;
+      } else {
+        HEAP[ret + i] = curr;
+      }
+    }
+    return ret;
+  }
+  
+  function Pointer_stringify(ptr) {
+    ptr = Pointer_niceify(ptr);
+  
+    var ret = "";
+    var i = 0;
+    var t;
+    while (1) {
+  //    if ((ptr.pos + i) >= ptr.slab.length) { return "<< Invalid read: " + (ptr.pos+i) + " : " + ptr.slab.length + " >>"; } else {}
+      if ((ptr.pos+i) >= ptr.slab.length) { break; } else {}
+      t = String.fromCharCode(ptr.slab[ptr.pos + i]);
+      if (t == "\0") { break; } else {}
+      ret += t;
+      i += 1;
+    }
+    return ret;
+  }
+  
+  // Memory management
+  
+  var PAGE_SIZE = 4096;
+  function alignMemoryPage(x) {
+    return Math.ceil(x/PAGE_SIZE)*PAGE_SIZE;
+  }
+  
+  var HEAP, IHEAP, FHEAP;
+  var STACK_ROOT, STACKTOP, STACK_MAX;
+  var STATICTOP;
+  
+  // Mangled |new| and |free| (various manglings, for int, long params; new and new[], etc.
+  var _malloc, _free, __Znwj, __Znaj, __Znam, __Znwm, __ZdlPv, __ZdaPv;
+  
+  function __initializeRuntime__() {
+    // If we don't have malloc/free implemented, use a simple implementation.
+    Module['_malloc'] = _malloc = __Znwj = __Znaj = __Znam = __Znwm = Module['_malloc'] ? Module['_malloc'] : Runtime.staticAlloc;
+    Module['_free']   = _free = __ZdlPv = __ZdaPv =                   Module['_free']   ? Module['_free']   : function() { };
+  
+    HEAP = intArrayFromString('(null)'); // So printing %s of NULL gives '(null)'
+                                         // Also this ensures we leave 0 as an invalid address, 'NULL'
+    if (!this['TOTAL_MEMORY']) TOTAL_MEMORY = 50*1024*1024;
+    if (this['Int32Array']) { // check for engine support
+      IHEAP = new Int32Array(TOTAL_MEMORY);
+      for (var i = 0; i < HEAP.length; i++) {
+        IHEAP[i] = HEAP[i];
+      }
+    } else {
+      IHEAP = HEAP; // fallback
+    }
+    if (this['Float64Array']) { // check for engine support
+      FHEAP = new Float64Array(TOTAL_MEMORY);
+    } else {
+      FHEAP = HEAP; // fallback
+    }
+  
+    Module['HEAP'] = HEAP;
+    Module['IHEAP'] = IHEAP;
+    Module['FHEAP'] = FHEAP;
+  
+    STACK_ROOT = STACKTOP = alignMemoryPage(10);
+    if (!this['TOTAL_STACK']) TOTAL_STACK = 1024*1024; // Reserved room for stack
+    STACK_MAX = STACK_ROOT + TOTAL_STACK;
+  
+    STATICTOP = alignMemoryPage(STACK_MAX);
+  }
+  
+  // stdio.h
+  
+  // C-style: we work on ints on the HEAP.
+  function __formatString() {
+    var textIndex = arguments[0];
+    var argIndex = 1;
+    var ret = [];
+    var curr = -1;
+    while (curr != 0) {
+      curr = IHEAP[textIndex];
+      next = IHEAP[textIndex+1];
+      if (curr == '%'.charCodeAt(0) && ['d', 'u', 'f', '.'].indexOf(String.fromCharCode(next)) != -1) {
+        var argText = String(+arguments[argIndex]); // +: boolean=>int
+        // Handle very very simply formatting, namely only %.Xf
+        if (next == '.'.charCodeAt(0)) {
+          var limit = parseInt(String.fromCharCode(IHEAP[textIndex+2]));
+          var dotIndex = argText.indexOf('.');
+          if (dotIndex == -1) {
+            dotIndex = argText.length;
+            argText += '.';
+          }
+          argText += '00000000000'; // padding
+          argText = argText.substr(0, dotIndex+1+limit);
+          textIndex += 2;
+        } else if (next == 'u'.charCodeAt(0)) {
+          argText = String(unSign(arguments[argIndex], 32));
+        }
+        argText.split('').forEach(function(chr) {
+          ret.push(chr.charCodeAt(0));
+        });
+        argIndex += 1;
+        textIndex += 2;
+      } else if (curr == '%'.charCodeAt(0) && next == 's'.charCodeAt(0)) {
+        ret = ret.concat(String_copy(arguments[argIndex]));
+        argIndex += 1;
+        textIndex += 2;
+      } else if (curr == '%'.charCodeAt(0) && next == 'c'.charCodeAt(0)) {
+        ret = ret.concat(arguments[argIndex]);
+        argIndex += 1;
+        textIndex += 2;
+      } else {
+        ret.push(curr);
+        textIndex += 1;
+      }
+    }
+    return Pointer_make(ret, 0, ALLOC_STACK); // NB: Stored on the stack
+  }
+  
+  // Copies a list of num items on the HEAP into a
+  // a normal JavaScript array of numbers
+  function Array_copy(ptr, num) {
+    return Array.prototype.slice.call(IHEAP.slice(ptr, ptr+num)); // Make a normal array out of the typed one
+  }
+  
+  // Copies a C-style string, terminated by a zero, from the HEAP into
+  // a normal JavaScript array of numbers
+  function String_copy(ptr, addZero) {
+    return Array_copy(ptr, _strlen(ptr)).concat(addZero ? [0] : []);
+  }
+  
+  // stdlib.h
+  
+  // Get a pointer, return int value of the string it points to
+  function _atoi(s) {
+    return Math.floor(Number(Pointer_stringify(s)));
+  }
+  
+  function _llvm_memcpy_i32(dest, src, num, idunno) {
+  // XXX hardcoded ptr impl
+    for (var i = 0; i < num; i++) {
+      HEAP[dest + i] = HEAP[src + i];
+      // TODO: optimize somehow - this is slower than without typed arrays
+      IHEAP[dest + i] = IHEAP[src + i];
+      FHEAP[dest + i] = FHEAP[src + i];
+    }
+  //  dest = Pointer_niceify(dest);
+  //  src = Pointer_niceify(src);
+  //  dest.slab = src.slab.slice(src.pos);
+  }
+  _llvm_memcpy_i64 = _llvm_memcpy_i32;
+  _llvm_memcpy_p0i8_p0i8_i32 = _llvm_memcpy_i32;
+  
+  function llvm_memset_i32(ptr, value, num) {
+    for (var i = 0; i < num; i++) {
+      HEAP[ptr+i] = IHEAP[ptr+i] = FHEAP[ptr+i] = value;
+    }
+  }
+  _llvm_memset_p0i8_i64 = _llvm_memset_p0i8_i32 = llvm_memset_i32;
+  
+  function _strlen(ptr) {
+    var i = 0;
+    while (IHEAP[ptr+i] != 0) i++;
+    return i;
+  }
+  
+  // Tools
+  
+  PRINTBUFFER = '';
+  function __print__(text) {
+    // We print only when we see a '\n', as console JS engines always add
+    // one anyhow.
+    PRINTBUFFER = PRINTBUFFER + text;
+    var endIndex;
+    while ((endIndex = PRINTBUFFER.indexOf('\n')) != -1) {
+      print(PRINTBUFFER.substr(0, endIndex));
+      PRINTBUFFER = PRINTBUFFER.substr(endIndex + 1);
+    }
+  }
+  
+  function jrint(label, obj) { // XXX manual debugging
+    if (!obj) {
+      obj = label;
+      label = '';
+    } else
+      label = label + ' : ';
+    print(label + JSON.stringify(obj));
+  }
+  
+  // This processes a 'normal' string into a C-line array of numbers.
+  // For LLVM-originating strings, see parser.js:parseLLVMString function
+  function intArrayFromString(stringy) {
+    var ret = [];
+    var t;
+    var i = 0;
+    while (i < stringy.length) {
+      ret.push(stringy.charCodeAt(i));
+      i = i + 1;
+    }
+    ret.push(0);
+    return ret;
+  }
+  
+  // Converts a value we have as signed, into an unsigned value. For
+  // example, -1 in int32 would be a very large number as unsigned.
+  function unSign(value, bits) {
+    if (value >= 0) return value;
+    return 2*Math.abs(1 << (bits-1)) + value;
+  }
+  
+  // === Body ===
+  
+  var _0___SIZE = 8; // %0
+  
+  var _struct__0AabbCalculationCallback___SIZE = 36; // %struct..0AabbCalculationCallback
+  var _struct__0AabbCalculationCallback___FLATTENER = [0,4,20];
+  var _struct__0BridgeTriangleRaycastCallback___SIZE = 120; // %struct..0BridgeTriangleRaycastCallback
+  var _struct__0BridgeTriangleRaycastCallback___FLATTENER = [0,44,48,52,56];
+  var _struct__0CenterCallback___SIZE = 44; // %struct..0CenterCallback
+  var _struct__0CenterCallback___FLATTENER = [0,4,8,24,40];
+  var _struct__0CleanPairCallback___SIZE = 16; // %struct..0CleanPairCallback
+  
+  var _struct__0FilteredCallback___SIZE = 40; // %struct..0FilteredCallback
+  var _struct__0FilteredCallback___FLATTENER = [0,4,8,24];
+  var _struct__0InplaceSolverIslandCallback___SIZE = 92; // %struct..0InplaceSolverIslandCallback
+  var _struct__0InplaceSolverIslandCallback___FLATTENER = [0,4,8,12,16,20,24,28,32,52,72];
+  var _struct__0LocalTriangleSphereCastCallback___SIZE = 204; // %struct..0LocalTriangleSphereCastCallback
+  var _struct__0LocalTriangleSphereCastCallback___FLATTENER = [0,4,68,132,196,200];
+  var _struct__0MyNodeOverlapCallback___SIZE = 12; // %struct..0MyNodeOverlapCallback
+  
+  var _struct__0NodeTriangleCallback___SIZE = 8; // %struct..0NodeTriangleCallback
+  
+  var _struct__0btIntermediateResult___SIZE = 44; // %struct..0btIntermediateResult
+  var _struct__0btIntermediateResult___FLATTENER = [0,4,20,36,40];
+  var _struct__0btMultiSapOverlapFilterCallback___SIZE = 4; // %struct..0btMultiSapOverlapFilterCallback
+  
+  var _struct__1BridgeTriangleRaycastCallback___SIZE = 120; // %struct..1BridgeTriangleRaycastCallback
+  var _struct__1BridgeTriangleRaycastCallback___FLATTENER = [0,44,48,52,56];
+  var _struct__1InertiaCallback___SIZE = 68; // %struct..1InertiaCallback
+  var _struct__1InertiaCallback___FLATTENER = [0,4,52];
+  var _struct__1MyNodeOverlapCallback___SIZE = 16; // %struct..1MyNodeOverlapCallback
+  
+  var _struct__1QuantizedNodeTriangleCallback___SIZE = 12; // %struct..1QuantizedNodeTriangleCallback
+  
+  var _struct__1RemovePairCallback___SIZE = 8; // %struct..1RemovePairCallback
+  
+  var _struct__2LocalInfoAdder2___SIZE = 28; // %struct..2LocalInfoAdder2
+  var _struct__2LocalInfoAdder2___FLATTENER = [0,20,24];
+  var _struct__2MyNodeOverlapCallback___SIZE = 60; // %struct..2MyNodeOverlapCallback
+  
+  var _struct__3BridgeTriangleConvexcastCallback___SIZE = 220; // %struct..3BridgeTriangleConvexcastCallback
+  var _struct__3BridgeTriangleConvexcastCallback___FLATTENER = [0,208,212,216];
+  var _struct__4BridgeTriangleConvexcastCallback___SIZE = 220; // %struct..4BridgeTriangleConvexcastCallback
+  var _struct__4BridgeTriangleConvexcastCallback___FLATTENER = [0,208,212,216];
+  var _struct__5LocalInfoAdder___SIZE = 20; // %struct..5LocalInfoAdder
+  var _struct__5LocalInfoAdder___FLATTENER = [0,12,16];
+  var _struct_BT_BOX_BOX_TRANSFORM_CACHE___SIZE = 112; // %struct.BT_BOX_BOX_TRANSFORM_CACHE
+  var _struct_BT_BOX_BOX_TRANSFORM_CACHE___FLATTENER = [0,16,64];
+  var _struct_BT_QUANTIZED_BVH_NODE___SIZE = 20; // %struct.BT_QUANTIZED_BVH_NODE
+  
+  var _struct_BroadphaseAabbTester___SIZE = 8; // %struct.BroadphaseAabbTester
+  
+  var _struct_BroadphaseRayTester___SIZE = 8; // %struct.BroadphaseRayTester
+  
+  var _struct_BvhSubtreeInfoArray___SIZE = 20; // %struct.BvhSubtreeInfoArray
+  
+  var _struct_CONTACT_KEY_TOKEN___SIZE = 8; // %struct.CONTACT_KEY_TOKEN
+  
+  var _struct_CONTACT_KEY_TOKEN_COMP___SIZE = 1; // %struct.CONTACT_KEY_TOKEN_COMP
+  
+  var _struct_CProfileIterator___SIZE = 8; // %struct.CProfileIterator
+  
+  var _struct_CProfileNode___SIZE = 32; // %struct.CProfileNode
+  
+  var _struct_CProfileSample___SIZE = 1; // %struct.CProfileSample
+  
+  var _struct_ClipVertex___SIZE = 20; // %struct.ClipVertex
+  
+  var _struct_ConvexH___SIZE = 60; // %struct.ConvexH
+  
+  var __struct_ConvexH__HalfEdge____SIZE = 4; // %"struct.ConvexH::HalfEdge"
+  var __struct_ConvexH__HalfEdge____FLATTENER = [0,2,3];
+  var _struct_DISTANCE_PLANE_3D_FUNC___SIZE = 1; // %struct.DISTANCE_PLANE_3D_FUNC
+  
+  var _struct_DebugDrawcallback___SIZE = 92; // %struct.DebugDrawcallback
+  var _struct_DebugDrawcallback___FLATTENER = [0,4,8,12,28];
+  var _struct_GIM_AABB___SIZE = 32; // %struct.GIM_AABB
+  
+  var _struct_GIM_AABB_DATA___SIZE = 36; // %struct.GIM_AABB_DATA
+  
+  var _struct_GIM_BOX_TREE___SIZE = 16; // %struct.GIM_BOX_TREE
+  
+  var _struct_GIM_BOX_TREE_NODE___SIZE = 48; // %struct.GIM_BOX_TREE_NODE
+  var _struct_GIM_BOX_TREE_NODE___FLATTENER = [0,32,36,40,44];
+  var _struct_GIM_BVH_DATA___SIZE = 36; // %struct.GIM_BVH_DATA
+  
+  var _struct_GIM_BVH_DATA_ARRAY___SIZE = 20; // %struct.GIM_BVH_DATA_ARRAY
+  
+  var _struct_GIM_CONTACT___SIZE = 48; // %struct.GIM_CONTACT
+  var _struct_GIM_CONTACT___FLATTENER = [0,16,32,36,40,44];
+  var _struct_GIM_PAIR___SIZE = 8; // %struct.GIM_PAIR
+  
+  var _struct_GIM_QUANTIZED_BVH_NODE_ARRAY___SIZE = 20; // %struct.GIM_QUANTIZED_BVH_NODE_ARRAY
+  
+  var _struct_GIM_RSORT_TOKEN___SIZE = 8; // %struct.GIM_RSORT_TOKEN
+  
+  var _struct_GIM_RSORT_TOKEN_COMPARATOR___SIZE = 1; // %struct.GIM_RSORT_TOKEN_COMPARATOR
+  
+  var _struct_GIM_STANDARD_ALLOCATOR___SIZE = 80; // %struct.GIM_STANDARD_ALLOCATOR
+  
+  var _struct_GIM_ShapeRetriever___SIZE = 288; // %struct.GIM_ShapeRetriever
+  var _struct_GIM_ShapeRetriever___FLATTENER = [0,4,104,260,268,276,284];
+  var __struct_GIM_ShapeRetriever__ChildShapeRetriever____SIZE = 8; // %"struct.GIM_ShapeRetriever::ChildShapeRetriever"
+  
+  var __struct_GIM_ShapeRetriever__TetraShapeRetriever____SIZE = 8; // %"struct.GIM_ShapeRetriever::TetraShapeRetriever"
+  
+  var _struct_GIM_TRIANGLE___SIZE = 52; // %struct.GIM_TRIANGLE
+  
+  var _struct_GIM_TRIANGLE_CALCULATION_CACHE___SIZE = 1012; // %struct.GIM_TRIANGLE_CALCULATION_CACHE
+  var _struct_GIM_TRIANGLE_CALCULATION_CACHE___FLATTENER = [0,4,52,100,116,132,148,164,180,196,212,216,220,236,240,244,500,756];
+  var _struct_GIM_TRIANGLE_CONTACT___SIZE = 280; // %struct.GIM_TRIANGLE_CONTACT
+  var _struct_GIM_TRIANGLE_CONTACT___FLATTENER = [0,4,8,24];
+  var _struct_GIM_TRIANGLE_CONTACT_DATA___SIZE = 280; // %struct.GIM_TRIANGLE_CONTACT_DATA
+  var _struct_GIM_TRIANGLE_CONTACT_DATA___FLATTENER = [0,4,8,24];
+  var _struct_HullDesc___SIZE = 28; // %struct.HullDesc
+  
+  var _struct_HullLibrary___SIZE = 40; // %struct.HullLibrary
+  
+  var _struct_HullResult___SIZE = 56; // %struct.HullResult
+  var _struct_HullResult___FLATTENER = [0,4,8,28,32,36];
+  var _struct_IndexedMeshArray___SIZE = 20; // %struct.IndexedMeshArray
+  
+  var _struct_LocalSupportVertexCallback___SIZE = 40; // %struct.LocalSupportVertexCallback
+  var _struct_LocalSupportVertexCallback___FLATTENER = [0,4,20,24];
+  var _struct_MaterialArray___SIZE = 20; // %struct.MaterialArray
+  
+  var _struct_NodeArray___SIZE = 20; // %struct.NodeArray
+  
+  var _struct_PHullResult___SIZE = 36; // %struct.PHullResult
+  
+  var _struct_PfxConstraintRow___SIZE = 32; // %struct.PfxConstraintRow
+  var _struct_PfxConstraintRow___FLATTENER = [0,12,16,20,24,28];
+  var _struct_QuantizedNodeArray___SIZE = 20; // %struct.QuantizedNodeArray
+  
+  var _struct_SphereTriangleDetector___SIZE = 16; // %struct.SphereTriangleDetector
+  
+  var _struct_SupportVertexCallback___SIZE = 104; // %struct.SupportVertexCallback
+  var _struct_SupportVertexCallback___FLATTENER = [0,4,20,84,88];
+  var _struct___base_class_type_info_pseudo___SIZE = 8; // %struct.__base_class_type_info_pseudo
+  
+  var _struct___class_type_info_pseudo___SIZE = 8; // %struct.__class_type_info_pseudo
+  
+  var _struct___si_class_type_info_pseudo___SIZE = 12; // %struct.__si_class_type_info_pseudo
+  
+  var _struct___type_info_pseudo___SIZE = 8; // %struct.__type_info_pseudo
+  
+  var _struct___vmi_class_type_info_pseudo1___SIZE = 24; // %struct.__vmi_class_type_info_pseudo1
+  var _struct___vmi_class_type_info_pseudo1___FLATTENER = [0,8,12,16];
+  var _struct___vmi_class_type_info_pseudo2___SIZE = 32; // %struct.__vmi_class_type_info_pseudo2
+  var _struct___vmi_class_type_info_pseudo2___FLATTENER = [0,8,12,16];
+  var _struct_anon___SIZE = 8; // %struct.anon
+  
+  var _struct_bt32BitAxisSweep3___SIZE = 124; // %struct.bt32BitAxisSweep3
+  
+  var _struct_btAABB___SIZE = 32; // %struct.btAABB
+  
+  var _struct_btActionInterface___SIZE = 4; // %struct.btActionInterface
+  
+  var _struct_btActivatingCollisionAlgorithm___SIZE = 8; // %struct.btActivatingCollisionAlgorithm
+  
+  var __struct_btAlignedAllocator_BT_QUANTIZED_BVH_NODE_16u_____SIZE = 1; // %"struct.btAlignedAllocator<BT_QUANTIZED_BVH_NODE,16u>"
+  
+  var __struct_btAlignedAllocator_ConvexH__HalfEdge_16u_____SIZE = 1; // %"struct.btAlignedAllocator<ConvexH::HalfEdge,16u>"
+  
+  var __struct_btAlignedAllocator_GIM_BVH_DATA_16u_____SIZE = 1; // %"struct.btAlignedAllocator<GIM_BVH_DATA,16u>"
+  
+  var __struct_btAlignedAllocator_btActionInterface__16u_____SIZE = 1; // %"struct.btAlignedAllocator<btActionInterface*,16u>"
+  
+  var __struct_btAlignedAllocator_btBroadphaseInterface__16u_____SIZE = 1; // %"struct.btAlignedAllocator<btBroadphaseInterface*,16u>"
+  
+  var __struct_btAlignedAllocator_btBroadphasePair_16u_____SIZE = 1; // %"struct.btAlignedAllocator<btBroadphasePair,16u>"
+  
+  var __struct_btAlignedAllocator_btBvhSubtreeInfo_16u_____SIZE = 1; // %"struct.btAlignedAllocator<btBvhSubtreeInfo,16u>"
+  
+  var __struct_btAlignedAllocator_btCollisionAlgorithm__16u_____SIZE = 1; // %"struct.btAlignedAllocator<btCollisionAlgorithm*,16u>"
+  
+  var __struct_btAlignedAllocator_btCollisionObject__16u_____SIZE = 1; // %"struct.btAlignedAllocator<btCollisionObject*,16u>"
+  
+  var __struct_btAlignedAllocator_btCollisionShape__16u_____SIZE = 1; // %"struct.btAlignedAllocator<btCollisionShape*,16u>"
+  
+  var __struct_btAlignedAllocator_btCompoundShapeChild_16u_____SIZE = 1; // %"struct.btAlignedAllocator<btCompoundShapeChild,16u>"
+  
+  var __struct_btAlignedAllocator_btDbvt__sStkCLN_16u_____SIZE = 1; // %"struct.btAlignedAllocator<btDbvt::sStkCLN,16u>"
+  
+  var __struct_btAlignedAllocator_btDbvt__sStkNN_16u_____SIZE = 1; // %"struct.btAlignedAllocator<btDbvt::sStkNN,16u>"
+  
+  var __struct_btAlignedAllocator_btElement_16u_____SIZE = 1; // %"struct.btAlignedAllocator<btElement,16u>"
+  
+  var __struct_btAlignedAllocator_btHashInt_16u_____SIZE = 1; // %"struct.btAlignedAllocator<btHashInt,16u>"
+  
+  var __struct_btAlignedAllocator_btHullTriangle__16u_____SIZE = 1; // %"struct.btAlignedAllocator<btHullTriangle*,16u>"
+  
+  var __struct_btAlignedAllocator_btIndexedMesh_16u_____SIZE = 1; // %"struct.btAlignedAllocator<btIndexedMesh,16u>"
+  
+  var __struct_btAlignedAllocator_btPersistentManifold__16u_____SIZE = 1; // %"struct.btAlignedAllocator<btPersistentManifold*,16u>"
+  
+  var __struct_btAlignedAllocator_btRigidBody__16u_____SIZE = 1; // %"struct.btAlignedAllocator<btRigidBody*,16u>"
+  
+  var __struct_btAlignedAllocator_btSolverConstraint_16u_____SIZE = 1; // %"struct.btAlignedAllocator<btSolverConstraint,16u>"
+  
+  var __struct_btAlignedAllocator_btTriangle_16u_____SIZE = 1; // %"struct.btAlignedAllocator<btTriangle,16u>"
+  
+  var __struct_btAlignedAllocator_btTriangleInfo_16u_____SIZE = 1; // %"struct.btAlignedAllocator<btTriangleInfo,16u>"
+  
+  var __struct_btAlignedAllocator_btTypedConstraint__16u_____SIZE = 1; // %"struct.btAlignedAllocator<btTypedConstraint*,16u>"
+  
+  var __struct_btAlignedAllocator_btTypedConstraint__btConstraintInfo1_16u_____SIZE = 1; // %"struct.btAlignedAllocator<btTypedConstraint::btConstraintInfo1,16u>"
+  
+  var __struct_btAlignedAllocator_btVector3_16u_____SIZE = 1; // %"struct.btAlignedAllocator<btVector3,16u>"
+  
+  var __struct_btAlignedAllocator_int_16u_____SIZE = 1; // %"struct.btAlignedAllocator<int,16u>"
+  
+  var __struct_btAlignedObjectArray_BT_QUANTIZED_BVH_NODE_____SIZE = 20; // %"struct.btAlignedObjectArray<BT_QUANTIZED_BVH_NODE>"
+  
+  var __struct_btAlignedObjectArray_BT_QUANTIZED_BVH_NODE__base_32____SIZE = 20; // %"struct.btAlignedObjectArray<BT_QUANTIZED_BVH_NODE>.base.32"
+  
+  var __struct_btAlignedObjectArray_CONTACT_KEY_TOKEN_____SIZE = 20; // %"struct.btAlignedObjectArray<CONTACT_KEY_TOKEN>"
+  
+  var __struct_btAlignedObjectArray_ConvexH__HalfEdge_____SIZE = 20; // %"struct.btAlignedObjectArray<ConvexH::HalfEdge>"
+  
+  var __struct_btAlignedObjectArray_GIM_BVH_DATA_____SIZE = 20; // %"struct.btAlignedObjectArray<GIM_BVH_DATA>"
+  
+  var __struct_btAlignedObjectArray_GIM_CONTACT_____SIZE = 20; // %"struct.btAlignedObjectArray<GIM_CONTACT>"
+  
+  var __struct_btAlignedObjectArray_GIM_PAIR_____SIZE = 20; // %"struct.btAlignedObjectArray<GIM_PAIR>"
+  
+  var __struct_btAlignedObjectArray_btActionInterface______SIZE = 20; // %"struct.btAlignedObjectArray<btActionInterface*>"
+  
+  var __struct_btAlignedObjectArray_btBroadphasePair_____SIZE = 20; // %"struct.btAlignedObjectArray<btBroadphasePair>"
+  
+  var __struct_btAlignedObjectArray_btCollisionAlgorithm______SIZE = 20; // %"struct.btAlignedObjectArray<btCollisionAlgorithm*>"
+  
+  var __struct_btAlignedObjectArray_btCollisionObject______SIZE = 20; // %"struct.btAlignedObjectArray<btCollisionObject*>"
+  
+  var __struct_btAlignedObjectArray_btCollisionShape______SIZE = 20; // %"struct.btAlignedObjectArray<btCollisionShape*>"
+  
+  var __struct_btAlignedObjectArray_btCompoundShapeChild_____SIZE = 20; // %"struct.btAlignedObjectArray<btCompoundShapeChild>"
+  
+  var __struct_btAlignedObjectArray_btDbvt__sStkCLN_____SIZE = 20; // %"struct.btAlignedObjectArray<btDbvt::sStkCLN>"
+  
+  var __struct_btAlignedObjectArray_btDbvt__sStkNN_____SIZE = 20; // %"struct.btAlignedObjectArray<btDbvt::sStkNN>"
+  
+  var __struct_btAlignedObjectArray_btDbvtNode______SIZE = 20; // %"struct.btAlignedObjectArray<btDbvtNode*>"
+  
+  var __struct_btAlignedObjectArray_btElement_____SIZE = 20; // %"struct.btAlignedObjectArray<btElement>"
+  
+  var __struct_btAlignedObjectArray_btGImpactMeshShapePart______SIZE = 20; // %"struct.btAlignedObjectArray<btGImpactMeshShapePart*>"
+  
+  var __struct_btAlignedObjectArray_btHashInt_____SIZE = 20; // %"struct.btAlignedObjectArray<btHashInt>"
+  
+  var __struct_btAlignedObjectArray_btHashPtr_____SIZE = 20; // %"struct.btAlignedObjectArray<btHashPtr>"
+  
+  var __struct_btAlignedObjectArray_btHullTriangle______SIZE = 20; // %"struct.btAlignedObjectArray<btHullTriangle*>"
+  
+  var __struct_btAlignedObjectArray_btMaterial______SIZE = 20; // %"struct.btAlignedObjectArray<btMaterial*>"
+  
+  var __struct_btAlignedObjectArray_btMultiSapBroadphase__btBridgeProxy______SIZE = 20; // %"struct.btAlignedObjectArray<btMultiSapBroadphase::btBridgeProxy*>"
+  
+  var __struct_btAlignedObjectArray_btMultiSapBroadphase__btMultiSapProxy______SIZE = 20; // %"struct.btAlignedObjectArray<btMultiSapBroadphase::btMultiSapProxy*>"
+  
+  var __struct_btAlignedObjectArray_btPersistentManifold______SIZE = 20; // %"struct.btAlignedObjectArray<btPersistentManifold*>"
+  
+  var __struct_btAlignedObjectArray_btPlane_____SIZE = 20; // %"struct.btAlignedObjectArray<btPlane>"
+  
+  var __struct_btAlignedObjectArray_btRigidBody______SIZE = 20; // %"struct.btAlignedObjectArray<btRigidBody*>"
+  
+  var __struct_btAlignedObjectArray_btTransform_____SIZE = 20; // %"struct.btAlignedObjectArray<btTransform>"
+  
+  var __struct_btAlignedObjectArray_btTriangle_____SIZE = 20; // %"struct.btAlignedObjectArray<btTriangle>"
+  
+  var __struct_btAlignedObjectArray_btTriangleInfo_____SIZE = 20; // %"struct.btAlignedObjectArray<btTriangleInfo>"
+  
+  var __struct_btAlignedObjectArray_btTypedConstraint______SIZE = 20; // %"struct.btAlignedObjectArray<btTypedConstraint*>"
+  
+  var __struct_btAlignedObjectArray_btTypedConstraint__btConstraintInfo1_____SIZE = 20; // %"struct.btAlignedObjectArray<btTypedConstraint::btConstraintInfo1>"
+  
+  var __struct_btAlignedObjectArray_btVector3_____SIZE = 20; // %"struct.btAlignedObjectArray<btVector3>"
+  
+  var __struct_btAlignedObjectArray_btWheelInfo_____SIZE = 20; // %"struct.btAlignedObjectArray<btWheelInfo>"
+  
+  var __struct_btAlignedObjectArray_float_____SIZE = 20; // %"struct.btAlignedObjectArray<float>"
+  
+  var __struct_btAlignedObjectArray_int_____SIZE = 20; // %"struct.btAlignedObjectArray<int>"
+  
+