aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--demos/webgl/HelloWorld.cpp142
-rw-r--r--demos/webgl/README.txt9
-rw-r--r--demos/webgl/bullet.js206722
-rw-r--r--demos/webgl/bullet_demo.js31
-rw-r--r--demos/webgl/demo.html80
-rwxr-xr-xdemos/webgl/doit.sh14
-rw-r--r--demos/webgl/glge.js7883
-rw-r--r--demos/webgl/glge_math.js1158
-rw-r--r--demos/webgl/scene.xml44
-rwxr-xr-xdemos/webgl/server.sh2
-rw-r--r--demos/webgl/skin1.jpgbin0 -> 75652 bytes
-rw-r--r--demos/webgl/skin3.jpgbin0 -> 49262 bytes
-rw-r--r--src/library.js2
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>"
+
+ 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];