wip bullet/webgl demo

1 files changed, 206722 insertions, 0 deletions

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>"
+  
+  var __struct_btAlignedObjectArray_short_unsigned_int_____SIZE = 20; // %"struct.btAlignedObjectArray<short unsigned int>"
+  
+  var __struct_btAlignedObjectArray_unsigned_int_____SIZE = 20; // %"struct.btAlignedObjectArray<unsigned int>"
+  
+  var _struct_btAxisSweep3___SIZE = 116; // %struct.btAxisSweep3
+  
+  var __struct_btAxisSweep3Internal_short_unsigned_int_____SIZE = 116; // %"struct.btAxisSweep3Internal<short unsigned int>"
+  var __struct_btAxisSweep3Internal_short_unsigned_int_____FLATTENER = [0,4,6,8,24,40,56,58,60,64,68,80,92,96,100,104,108,112];
+  var __struct_btAxisSweep3Internal_short_unsigned_int___Edge____SIZE = 4; // %"struct.btAxisSweep3Internal<short unsigned int>::Edge"
+  
+  var __struct_btAxisSweep3Internal_short_unsigned_int___Handle____SIZE = 68; // %"struct.btAxisSweep3Internal<short unsigned int>::Handle"
+  var __struct_btAxisSweep3Internal_short_unsigned_int___Handle____FLATTENER = [0,48,56,64];
+  var __struct_btAxisSweep3Internal_unsigned_int_____SIZE = 124; // %"struct.btAxisSweep3Internal<unsigned int>"
+  var __struct_btAxisSweep3Internal_unsigned_int_____FLATTENER = [0,4,8,12,28,44,60,64,68,72,76,88,100,104,108,112,116,120];
+  var __struct_btAxisSweep3Internal_unsigned_int___Edge____SIZE = 8; // %"struct.btAxisSweep3Internal<unsigned int>::Edge"
+  
+  var __struct_btAxisSweep3Internal_unsigned_int___Handle____SIZE = 76; // %"struct.btAxisSweep3Internal<unsigned int>::Handle"
+  var __struct_btAxisSweep3Internal_unsigned_int___Handle____FLATTENER = [0,48,60,72];
+  var _struct_btBU_Simplex1to4___SIZE = 156; // %struct.btBU_Simplex1to4
+  var _struct_btBU_Simplex1to4___FLATTENER = [0,88,92];
+  var _struct_btBlock___SIZE = 8; // %struct.btBlock
+  
+  var _struct_btBox2dBox2dCollisionAlgorithm___SIZE = 16; // %struct.btBox2dBox2dCollisionAlgorithm
+  var _struct_btBox2dBox2dCollisionAlgorithm___FLATTENER = [0,8,12];
+  var _struct_btBox2dShape___SIZE = 196; // %struct.btBox2dShape
+  var _struct_btBox2dShape___FLATTENER = [0,52,68,132];
+  var _struct_btBoxBoxCollisionAlgorithm___SIZE = 16; // %struct.btBoxBoxCollisionAlgorithm
+  var _struct_btBoxBoxCollisionAlgorithm___FLATTENER = [0,8,12];
+  var __struct_btBoxBoxCollisionAlgorithm__CreateFunc____SIZE = 8; // %"struct.btBoxBoxCollisionAlgorithm::CreateFunc"
+  
+  var _struct_btBoxBoxDetector___SIZE = 12; // %struct.btBoxBoxDetector
+  
+  var _struct_btBoxShape___SIZE = 52; // %struct.btBoxShape
+  
+  var _struct_btBridgedManifoldResult___SIZE = 164; // %struct.btBridgedManifoldResult
+  
+  var _struct_btBroadphaseAabbCallback___SIZE = 4; // %struct.btBroadphaseAabbCallback
+  
+  var _struct_btBroadphaseInterface___SIZE = 4; // %struct.btBroadphaseInterface
+  
+  var _struct_btBroadphasePair___SIZE = 16; // %struct.btBroadphasePair
+  
+  var _struct_btBroadphasePairArray___SIZE = 20; // %struct.btBroadphasePairArray
+  
+  var _struct_btBroadphaseProxy___SIZE = 48; // %struct.btBroadphaseProxy
+  var _struct_btBroadphaseProxy___FLATTENER = [0,4,6,8,12,16,32];
+  var _struct_btBroadphaseRayCallback___SIZE = 36; // %struct.btBroadphaseRayCallback
+  var _struct_btBroadphaseRayCallback___FLATTENER = [0,4,20,32];
+  var _struct_btBvhSubtreeInfo___SIZE = 36; // %struct.btBvhSubtreeInfo
+  var _struct_btBvhSubtreeInfo___FLATTENER = [0,8,16,20,24];
+  var _struct_btBvhSubtreeInfoData___SIZE = 24; // %struct.btBvhSubtreeInfoData
+  var _struct_btBvhSubtreeInfoData___FLATTENER = [0,4,8,16];
+  var _struct_btBvhTree___SIZE = 24; // %struct.btBvhTree
+  
+  var _struct_btBvhTriangleMeshShape___SIZE = 76; // %struct.btBvhTriangleMeshShape
+  var _struct_btBvhTriangleMeshShape___FLATTENER = [0,52,56,60,61,64];
+  var _struct_btCapsuleShape___SIZE = 56; // %struct.btCapsuleShape
+  
+  var _struct_btCapsuleShapeX___SIZE = 56; // %struct.btCapsuleShapeX
+  
+  var _struct_btCharacterControllerInterface___SIZE = 4; // %struct.btCharacterControllerInterface
+  
+  var _struct_btChunk___SIZE = 20; // %struct.btChunk
+  
+  var _struct_btClock___SIZE = 4; // %struct.btClock
+  
+  var _struct_btClockData___SIZE = 8; // %struct.btClockData
+  
+  var _struct_btClosestNotMeConvexResultCallback___SIZE = 96; // %struct.btClosestNotMeConvexResultCallback
+  var _struct_btClosestNotMeConvexResultCallback___FLATTENER = [0,80,84,88,92];
+  var _struct_btCollisionAlgorithm___SIZE = 8; // %struct.btCollisionAlgorithm
+  
+  var _struct_btCollisionAlgorithmConstructionInfo___SIZE = 8; // %struct.btCollisionAlgorithmConstructionInfo
+  
+  var _struct_btCollisionAlgorithmCreateFunc___SIZE = 8; // %struct.btCollisionAlgorithmCreateFunc
+  
+  var _struct_btCollisionConfiguration___SIZE = 4; // %struct.btCollisionConfiguration
+  
+  var _struct_btCollisionDispatcher___SIZE = 5388; // %struct.btCollisionDispatcher
+  var _struct_btCollisionDispatcher___FLATTENER = [0,4,8,28,188,192,196,200,5384];
+  var _struct_btCollisionObject___SIZE = 256; // %struct.btCollisionObject
+  var _struct_btCollisionObject___FLATTENER = [0,4,68,132,148,164,180,184,188,192,196,200,204,208,212,216,220,224,228,232,236,240,244,248,252];
+  var _struct_btCollisionObjectArray___SIZE = 20; // %struct.btCollisionObjectArray
+  
+  var _struct_btCollisionObjectFloatData___SIZE = 248; // %struct.btCollisionObjectFloatData
+  var _struct_btCollisionObjectFloatData___FLATTENER = [0,4,8,12,16,80,144,160,176,192,196,200,204,208,212,216,220,224,228,232,236,240,244];
+  var _struct_btCollisionPairCallback___SIZE = 12; // %struct.btCollisionPairCallback
+  
+  var _struct_btCollisionShape___SIZE = 12; // %struct.btCollisionShape
+  
+  var _struct_btCollisionShapeData___SIZE = 12; // %struct.btCollisionShapeData
+  
+  var _struct_btCollisionWorld___SIZE = 92; // %struct.btCollisionWorld
+  var _struct_btCollisionWorld___FLATTENER = [0,4,24,28,76,80,84,88];
+  var _struct_btCollisionWorld_base_32___SIZE = 92; // %struct.btCollisionWorld.base.32
+  var _struct_btCollisionWorld_base_32___FLATTENER = [0,4,24,28,76,80,84,88];
+  var __struct_btCollisionWorld__ClosestConvexResultCallback____SIZE = 80; // %"struct.btCollisionWorld::ClosestConvexResultCallback"
+  var __struct_btCollisionWorld__ClosestConvexResultCallback____FLATTENER = [0,12,28,44,60,76];
+  var __struct_btCollisionWorld__ClosestRayResultCallback____SIZE = 84; // %"struct.btCollisionWorld::ClosestRayResultCallback"
+  var __struct_btCollisionWorld__ClosestRayResultCallback____FLATTENER = [0,20,36,52,68];
+  var __struct_btCollisionWorld__ContactResultCallback____SIZE = 8; // %"struct.btCollisionWorld::ContactResultCallback"
+  var __struct_btCollisionWorld__ContactResultCallback____FLATTENER = [0,4,6];
+  var __struct_btCollisionWorld__ConvexResultCallback____SIZE = 12; // %"struct.btCollisionWorld::ConvexResultCallback"
+  var __struct_btCollisionWorld__ConvexResultCallback____FLATTENER = [0,4,8,10];
+  var __struct_btCollisionWorld__LocalConvexResult____SIZE = 44; // %"struct.btCollisionWorld::LocalConvexResult"
+  var __struct_btCollisionWorld__LocalConvexResult____FLATTENER = [0,4,8,24,40];
+  var __struct_btCollisionWorld__LocalRayResult____SIZE = 28; // %"struct.btCollisionWorld::LocalRayResult"
+  var __struct_btCollisionWorld__LocalRayResult____FLATTENER = [0,4,8,24];
+  var __struct_btCollisionWorld__LocalShapeInfo____SIZE = 8; // %"struct.btCollisionWorld::LocalShapeInfo"
+  
+  var __struct_btCollisionWorld__RayResultCallback____SIZE = 20; // %"struct.btCollisionWorld::RayResultCallback"
+  var __struct_btCollisionWorld__RayResultCallback____FLATTENER = [0,4,8,12,14,16];
+  var _struct_btCompoundCollisionAlgorithm___SIZE = 44; // %struct.btCompoundCollisionAlgorithm
+  var _struct_btCompoundCollisionAlgorithm___FLATTENER = [0,8,28,32,36,40];
+  var _struct_btCompoundLeafCallback___SIZE = 32; // %struct.btCompoundLeafCallback
+  
+  var _struct_btCompoundShape___SIZE = 92; // %struct.btCompoundShape
+  var _struct_btCompoundShape___FLATTENER = [0,12,32,48,64,68,72,76];
+  var _struct_btCompoundShapeChild___SIZE = 80; // %struct.btCompoundShapeChild
+  var _struct_btCompoundShapeChild___FLATTENER = [0,64,68,72,76];
+  var _struct_btCompoundShapeChildData___SIZE = 76; // %struct.btCompoundShapeChildData
+  var _struct_btCompoundShapeChildData___FLATTENER = [0,64,68,72];
+  var _struct_btConcaveShape___SIZE = 16; // %struct.btConcaveShape
+  
+  var _struct_btConeShape___SIZE = 76; // %struct.btConeShape
+  var _struct_btConeShape___FLATTENER = [0,52,56,60,64];
+  var _struct_btConeShapeX___SIZE = 76; // %struct.btConeShapeX
+  
+  var _struct_btConeTwistConstraint___SIZE = 596; // %struct.btConeTwistConstraint
+  var _struct_btConeTwistConstraint___FLATTENER = [0,36,288,352,416,420,424,428,432,436,440,444,448,464,480,484,488,492,496,500,504,508,512,513,514,515,516,520,524,540,541,544,560,564,580,584,588,592];
+  var _struct_btConnectivityProcessor___SIZE = 20; // %struct.btConnectivityProcessor
+  
+  var _struct_btConstraintArray___SIZE = 20; // %struct.btConstraintArray
+  
+  var _struct_btConstraintSetting___SIZE = 12; // %struct.btConstraintSetting
+  
+  var _struct_btConstraintSolver___SIZE = 4; // %struct.btConstraintSolver
+  
+  var _struct_btContactArray___SIZE = 20; // %struct.btContactArray
+  
+  var _struct_btContactConstraint___SIZE = 1176; // %struct.btContactConstraint
+  
+  var _struct_btContactSolverInfo___SIZE = 72; // %struct.btContactSolverInfo
+  
+  var _struct_btContactSolverInfoData___SIZE = 72; // %struct.btContactSolverInfoData
+  
+  var _struct_btContinuousConvexCollision___SIZE = 20; // %struct.btContinuousConvexCollision
+  
+  var _struct_btContinuousDynamicsWorld___SIZE = 272; // %struct.btContinuousDynamicsWorld
+  
+  var _struct_btConvex2dConvex2dAlgorithm___SIZE = 36; // %struct.btConvex2dConvex2dAlgorithm
+  var _struct_btConvex2dConvex2dAlgorithm___FLATTENER = [0,8,12,16,20,24,28,32];
+  var __struct_btConvex2dConvex2dAlgorithm__CreateFunc____SIZE = 24; // %"struct.btConvex2dConvex2dAlgorithm::CreateFunc"
+  var __struct_btConvex2dConvex2dAlgorithm__CreateFunc____FLATTENER = [0,8,12,16,20];
+  var _struct_btConvex2dShape___SIZE = 16; // %struct.btConvex2dShape
+  
+  var _struct_btConvexCast___SIZE = 4; // %struct.btConvexCast
+  
+  var __struct_btConvexCast__CastResult____SIZE = 176; // %"struct.btC