// This code implements the `-sMODULARIZE` settings by taking the generated
// JS program code (INNER_JS_CODE) and wrapping it in a factory function.

// When targetting node and ES6 we use `await import ..` in the generated code
// so the outer function needs to be marked as async.
async function PhysX(moduleArg = {}) {
  var moduleRtn;

// include: shell.js
// include: minimum_runtime_check.js
(function() {
  // "30.0.0" -> 300000
  function humanReadableVersionToPacked(str) {
    str = str.split('-')[0]; // Remove any trailing part from e.g. "12.53.3-alpha"
    var vers = str.split('.').slice(0, 3);
    while(vers.length < 3) vers.push('00');
    vers = vers.map((n, i, arr) => n.padStart(2, '0'));
    return vers.join('');
  }
  // 300000 -> "30.0.0"
  var packedVersionToHumanReadable = n => [n / 10000 | 0, (n / 100 | 0) % 100, n % 100].join('.');

  var TARGET_NOT_SUPPORTED = 2147483647;

  // Note: We use a typeof check here instead of optional chaining using
  // globalThis because older browsers might not have globalThis defined.
  var currentNodeVersion = typeof process !== 'undefined' && process.versions?.node ? humanReadableVersionToPacked(process.versions.node) : TARGET_NOT_SUPPORTED;
  if (currentNodeVersion < TARGET_NOT_SUPPORTED) {
    throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');
  }
  if (currentNodeVersion < 2147483647) {
    throw new Error(`This emscripten-generated code requires node v${ packedVersionToHumanReadable(2147483647) } (detected v${packedVersionToHumanReadable(currentNodeVersion)})`);
  }

  var currentSafariVersion = typeof navigator !== 'undefined' && navigator.userAgent?.includes("Safari/") && navigator.userAgent.match(/Version\/(\d+\.?\d*\.?\d*)/) ? humanReadableVersionToPacked(navigator.userAgent.match(/Version\/(\d+\.?\d*\.?\d*)/)[1]) : TARGET_NOT_SUPPORTED;
  if (currentSafariVersion < 150000) {
    throw new Error(`This emscripten-generated code requires Safari v${ packedVersionToHumanReadable(150000) } (detected v${currentSafariVersion})`);
  }

  var currentFirefoxVersion = typeof navigator !== 'undefined' && navigator.userAgent?.match(/Firefox\/(\d+(?:\.\d+)?)/) ? parseFloat(navigator.userAgent.match(/Firefox\/(\d+(?:\.\d+)?)/)[1]) : TARGET_NOT_SUPPORTED;
  if (currentFirefoxVersion < 79) {
    throw new Error(`This emscripten-generated code requires Firefox v79 (detected v${currentFirefoxVersion})`);
  }

  var currentChromeVersion = typeof navigator !== 'undefined' && navigator.userAgent?.match(/Chrome\/(\d+(?:\.\d+)?)/) ? parseFloat(navigator.userAgent.match(/Chrome\/(\d+(?:\.\d+)?)/)[1]) : TARGET_NOT_SUPPORTED;
  if (currentChromeVersion < 85) {
    throw new Error(`This emscripten-generated code requires Chrome v85 (detected v${currentChromeVersion})`);
  }
})();

// end include: minimum_runtime_check.js
// The Module object: Our interface to the outside world. We import
// and export values on it. There are various ways Module can be used:
// 1. Not defined. We create it here
// 2. A function parameter, function(moduleArg) => Promise<Module>
// 3. pre-run appended it, var Module = {}; ..generated code..
// 4. External script tag defines var Module.
// We need to check if Module already exists (e.g. case 3 above).
// Substitution will be replaced with actual code on later stage of the build,
// this way Closure Compiler will not mangle it (e.g. case 4. above).
// Note that if you want to run closure, and also to use Module
// after the generated code, you will need to define   var Module = {};
// before the code. Then that object will be used in the code, and you
// can continue to use Module afterwards as well.
var Module = moduleArg;

// Determine the runtime environment we are in. You can customize this by
// setting the ENVIRONMENT setting at compile time (see settings.js).

// Attempt to auto-detect the environment
var ENVIRONMENT_IS_WEB = !!globalThis.window;
var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
// N.b. Electron.js environment is simultaneously a NODE-environment, but
// also a web environment.
var ENVIRONMENT_IS_NODE = globalThis.process?.versions?.node && globalThis.process?.type != 'renderer';
var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;

// --pre-jses are emitted after the Module integration code, so that they can
// refer to Module (if they choose; they can also define Module)


var arguments_ = [];
var thisProgram = './this.program';
var quit_ = (status, toThrow) => {
  throw toThrow;
};

var _scriptName = import.meta.url;

// `/` should be present at the end if `scriptDirectory` is not empty
var scriptDirectory = '';
function locateFile(path) {
  if (Module['locateFile']) {
    return Module['locateFile'](path, scriptDirectory);
  }
  return scriptDirectory + path;
}

// Hooks that are implemented differently in different runtime environments.
var readAsync, readBinary;

if (ENVIRONMENT_IS_SHELL) {

} else

// Note that this includes Node.js workers when relevant (pthreads is enabled).
// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
// ENVIRONMENT_IS_NODE.
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
  try {
    scriptDirectory = new URL('.', _scriptName).href; // includes trailing slash
  } catch {
    // Must be a `blob:` or `data:` URL (e.g. `blob:http://site.com/etc/etc`), we cannot
    // infer anything from them.
  }

  if (!(globalThis.window || globalThis.WorkerGlobalScope)) throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');

  {
// include: web_or_worker_shell_read.js
if (ENVIRONMENT_IS_WORKER) {
    readBinary = (url) => {
      var xhr = new XMLHttpRequest();
      xhr.open('GET', url, false);
      xhr.responseType = 'arraybuffer';
      xhr.send(null);
      return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response));
    };
  }

  readAsync = async (url) => {
    assert(!isFileURI(url), "readAsync does not work with file:// URLs");
    var response = await fetch(url, { credentials: 'same-origin' });
    if (response.ok) {
      return response.arrayBuffer();
    }
    throw new Error(response.status + ' : ' + response.url);
  };
// end include: web_or_worker_shell_read.js
  }
} else
{
  throw new Error('environment detection error');
}

var out = console.log.bind(console);
var err = console.error.bind(console);

var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js';
var PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js';
var WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js';
var FETCHFS = 'FETCHFS is no longer included by default; build with -lfetchfs.js';
var ICASEFS = 'ICASEFS is no longer included by default; build with -licasefs.js';
var JSFILEFS = 'JSFILEFS is no longer included by default; build with -ljsfilefs.js';
var OPFS = 'OPFS is no longer included by default; build with -lopfs.js';

var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js';

// perform assertions in shell.js after we set up out() and err(), as otherwise
// if an assertion fails it cannot print the message

assert(!ENVIRONMENT_IS_NODE, 'node environment detected but not enabled at build time.  Add `node` to `-sENVIRONMENT` to enable.');

assert(!ENVIRONMENT_IS_SHELL, 'shell environment detected but not enabled at build time.  Add `shell` to `-sENVIRONMENT` to enable.');

// end include: shell.js

// include: preamble.js
// === Preamble library stuff ===

// Documentation for the public APIs defined in this file must be updated in:
//    site/source/docs/api_reference/preamble.js.rst
// A prebuilt local version of the documentation is available at:
//    site/build/text/docs/api_reference/preamble.js.txt
// You can also build docs locally as HTML or other formats in site/
// An online HTML version (which may be of a different version of Emscripten)
//    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html

var wasmBinary;

if (!globalThis.WebAssembly) {
  err('no native wasm support detected');
}

// Wasm globals

//========================================
// Runtime essentials
//========================================

// whether we are quitting the application. no code should run after this.
// set in exit() and abort()
var ABORT = false;

// set by exit() and abort().  Passed to 'onExit' handler.
// NOTE: This is also used as the process return code code in shell environments
// but only when noExitRuntime is false.
var EXITSTATUS;

// In STRICT mode, we only define assert() when ASSERTIONS is set.  i.e. we
// don't define it at all in release modes.  This matches the behaviour of
// MINIMAL_RUNTIME.
// TODO(sbc): Make this the default even without STRICT enabled.
/** @type {function(*, string=)} */
function assert(condition, text) {
  if (!condition) {
    abort('Assertion failed' + (text ? ': ' + text : ''));
  }
}

// We used to include malloc/free by default in the past. Show a helpful error in
// builds with assertions.
function _free() {
  // Show a helpful error since we used to include free by default in the past.
  abort('free() called but not included in the build - add `_free` to EXPORTED_FUNCTIONS');
}

/**
 * Indicates whether filename is delivered via file protocol (as opposed to http/https)
 * @noinline
 */
var isFileURI = (filename) => filename.startsWith('file://');

// include: runtime_common.js
// include: runtime_stack_check.js
// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.
function writeStackCookie() {
  var max = _emscripten_stack_get_end();
  assert((max & 3) == 0);
  // If the stack ends at address zero we write our cookies 4 bytes into the
  // stack.  This prevents interference with SAFE_HEAP and ASAN which also
  // monitor writes to address zero.
  if (max == 0) {
    max += 4;
  }
  // The stack grow downwards towards _emscripten_stack_get_end.
  // We write cookies to the final two words in the stack and detect if they are
  // ever overwritten.
  HEAPU32[((max)>>2)] = 0x02135467;
  HEAPU32[(((max)+(4))>>2)] = 0x89BACDFE;
  // Also test the global address 0 for integrity.
  HEAPU32[((0)>>2)] = 1668509029;
}

function checkStackCookie() {
  if (ABORT) return;
  var max = _emscripten_stack_get_end();
  // See writeStackCookie().
  if (max == 0) {
    max += 4;
  }
  var cookie1 = HEAPU32[((max)>>2)];
  var cookie2 = HEAPU32[(((max)+(4))>>2)];
  if (cookie1 != 0x02135467 || cookie2 != 0x89BACDFE) {
    abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);
  }
  // Also test the global address 0 for integrity.
  if (HEAPU32[((0)>>2)] != 0x63736d65 /* 'emsc' */) {
    abort('Runtime error: The application has corrupted its heap memory area (address zero)!');
  }
}
// end include: runtime_stack_check.js
// include: runtime_exceptions.js
// end include: runtime_exceptions.js
// include: runtime_debug.js
var runtimeDebug = true; // Switch to false at runtime to disable logging at the right times

// Used by XXXXX_DEBUG settings to output debug messages.
function dbg(...args) {
  if (!runtimeDebug && typeof runtimeDebug != 'undefined') return;
  // TODO(sbc): Make this configurable somehow.  Its not always convenient for
  // logging to show up as warnings.
  console.warn(...args);
}

// Endianness check
(() => {
  var h16 = new Int16Array(1);
  var h8 = new Int8Array(h16.buffer);
  h16[0] = 0x6373;
  if (h8[0] !== 0x73 || h8[1] !== 0x63) abort('Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)');
})();

function consumedModuleProp(prop) {
  if (!Object.getOwnPropertyDescriptor(Module, prop)) {
    Object.defineProperty(Module, prop, {
      configurable: true,
      set() {
        abort(`Attempt to set \`Module.${prop}\` after it has already been processed.  This can happen, for example, when code is injected via '--post-js' rather than '--pre-js'`);

      }
    });
  }
}

function makeInvalidEarlyAccess(name) {
  return () => assert(false, `call to '${name}' via reference taken before Wasm module initialization`);

}

function ignoredModuleProp(prop) {
  if (Object.getOwnPropertyDescriptor(Module, prop)) {
    abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`);
  }
}

// forcing the filesystem exports a few things by default
function isExportedByForceFilesystem(name) {
  return name === 'FS_createPath' ||
         name === 'FS_createDataFile' ||
         name === 'FS_createPreloadedFile' ||
         name === 'FS_preloadFile' ||
         name === 'FS_unlink' ||
         name === 'addRunDependency' ||
         // The old FS has some functionality that WasmFS lacks.
         name === 'FS_createLazyFile' ||
         name === 'FS_createDevice' ||
         name === 'removeRunDependency';
}

function missingLibrarySymbol(sym) {

  // Any symbol that is not included from the JS library is also (by definition)
  // not exported on the Module object.
  unexportedRuntimeSymbol(sym);
}

function unexportedRuntimeSymbol(sym) {
  if (!Object.getOwnPropertyDescriptor(Module, sym)) {
    Object.defineProperty(Module, sym, {
      configurable: true,
      get() {
        var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;
        if (isExportedByForceFilesystem(sym)) {
          msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you';
        }
        abort(msg);
      },
    });
  }
}

// end include: runtime_debug.js
var readyPromiseResolve, readyPromiseReject;

// Memory management
var
/** @type {!Int8Array} */
  HEAP8,
/** @type {!Uint8Array} */
  HEAPU8,
/** @type {!Int16Array} */
  HEAP16,
/** @type {!Uint16Array} */
  HEAPU16,
/** @type {!Int32Array} */
  HEAP32,
/** @type {!Uint32Array} */
  HEAPU32,
/** @type {!Float32Array} */
  HEAPF32,
/** @type {!Float64Array} */
  HEAPF64;

// BigInt64Array type is not correctly defined in closure
var
/** not-@type {!BigInt64Array} */
  HEAP64,
/* BigUint64Array type is not correctly defined in closure
/** not-@type {!BigUint64Array} */
  HEAPU64;

var runtimeInitialized = false;



function updateMemoryViews() {
  var b = wasmMemory.buffer;
  HEAP8 = new Int8Array(b);
  HEAP16 = new Int16Array(b);
  Module['HEAPU8'] = HEAPU8 = new Uint8Array(b);
  Module['HEAPU16'] = HEAPU16 = new Uint16Array(b);
  HEAP32 = new Int32Array(b);
  Module['HEAPU32'] = HEAPU32 = new Uint32Array(b);
  HEAPF32 = new Float32Array(b);
  HEAPF64 = new Float64Array(b);
  HEAP64 = new BigInt64Array(b);
  HEAPU64 = new BigUint64Array(b);
}

// include: memoryprofiler.js
// end include: memoryprofiler.js
// end include: runtime_common.js
assert(globalThis.Int32Array && globalThis.Float64Array && Int32Array.prototype.subarray && Int32Array.prototype.set,
       'JS engine does not provide full typed array support');

function preRun() {
  if (Module['preRun']) {
    if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
    while (Module['preRun'].length) {
      addOnPreRun(Module['preRun'].shift());
    }
  }
  consumedModuleProp('preRun');
  // Begin ATPRERUNS hooks
  callRuntimeCallbacks(onPreRuns);
  // End ATPRERUNS hooks
}

function initRuntime() {
  assert(!runtimeInitialized);
  runtimeInitialized = true;

  checkStackCookie();

  // Begin ATINITS hooks
  callRuntimeCallbacks(onInits);
  // End ATINITS hooks

  wasmExports['__wasm_call_ctors']();

  // No ATPOSTCTORS hooks
}

function postRun() {
  checkStackCookie();
   // PThreads reuse the runtime from the main thread.

  if (Module['postRun']) {
    if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
    while (Module['postRun'].length) {
      addOnPostRun(Module['postRun'].shift());
    }
  }
  consumedModuleProp('postRun');

  // Begin ATPOSTRUNS hooks
  callRuntimeCallbacks(onPostRuns);
  // End ATPOSTRUNS hooks
}

/** @param {string|number=} what */
function abort(what) {
  Module['onAbort']?.(what);

  what = 'Aborted(' + what + ')';
  // TODO(sbc): Should we remove printing and leave it up to whoever
  // catches the exception?
  err(what);

  ABORT = true;

  // Use a wasm runtime error, because a JS error might be seen as a foreign
  // exception, which means we'd run destructors on it. We need the error to
  // simply make the program stop.
  // FIXME This approach does not work in Wasm EH because it currently does not assume
  // all RuntimeErrors are from traps; it decides whether a RuntimeError is from
  // a trap or not based on a hidden field within the object. So at the moment
  // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that
  // allows this in the wasm spec.

  // Suppress closure compiler warning here. Closure compiler's builtin extern
  // definition for WebAssembly.RuntimeError claims it takes no arguments even
  // though it can.
  // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
  /** @suppress {checkTypes} */
  var e = new WebAssembly.RuntimeError(what);

  readyPromiseReject?.(e);
  // Throw the error whether or not MODULARIZE is set because abort is used
  // in code paths apart from instantiation where an exception is expected
  // to be thrown when abort is called.
  throw e;
}

// show errors on likely calls to FS when it was not included
var FS = {
  error() {
    abort('Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with -sFORCE_FILESYSTEM');
  },
  init() { FS.error() },
  createDataFile() { FS.error() },
  createPreloadedFile() { FS.error() },
  createLazyFile() { FS.error() },
  open() { FS.error() },
  mkdev() { FS.error() },
  registerDevice() { FS.error() },
  analyzePath() { FS.error() },

  ErrnoError() { FS.error() },
};


function createExportWrapper(name, nargs) {
  return (...args) => {
    assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`);
    var f = wasmExports[name];
    assert(f, `exported native function \`${name}\` not found`);
    // Only assert for too many arguments. Too few can be valid since the missing arguments will be zero filled.
    assert(args.length <= nargs, `native function \`${name}\` called with ${args.length} args but expects ${nargs}`);
    return f(...args);
  };
}

var wasmBinaryFile;

function findWasmBinary() {

  if (Module['locateFile']) {
    return locateFile('physx-js-webidl.wasm');
  }

  // Use bundler-friendly `new URL(..., import.meta.url)` pattern; works in browsers too.
  return new URL('physx-js-webidl.wasm', import.meta.url).href;

}

function getBinarySync(file) {
  if (file == wasmBinaryFile && wasmBinary) {
    return new Uint8Array(wasmBinary);
  }
  if (readBinary) {
    return readBinary(file);
  }
  // Throwing a plain string here, even though it not normally adviables since
  // this gets turning into an `abort` in instantiateArrayBuffer.
  throw 'both async and sync fetching of the wasm failed';
}

async function getWasmBinary(binaryFile) {
  // If we don't have the binary yet, load it asynchronously using readAsync.
  if (!wasmBinary) {
    // Fetch the binary using readAsync
    try {
      var response = await readAsync(binaryFile);
      return new Uint8Array(response);
    } catch {
      // Fall back to getBinarySync below;
    }
  }

  // Otherwise, getBinarySync should be able to get it synchronously
  return getBinarySync(binaryFile);
}

async function instantiateArrayBuffer(binaryFile, imports) {
  try {
    var binary = await getWasmBinary(binaryFile);
    var instance = await WebAssembly.instantiate(binary, imports);
    return instance;
  } catch (reason) {
    err(`failed to asynchronously prepare wasm: ${reason}`);

    // Warn on some common problems.
    if (isFileURI(binaryFile)) {
      err(`warning: Loading from a file URI (${binaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`);
    }
    abort(reason);
  }
}

async function instantiateAsync(binary, binaryFile, imports) {
  if (!binary
     ) {
    try {
      var response = fetch(binaryFile, { credentials: 'same-origin' });
      var instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
      return instantiationResult;
    } catch (reason) {
      // We expect the most common failure cause to be a bad MIME type for the binary,
      // in which case falling back to ArrayBuffer instantiation should work.
      err(`wasm streaming compile failed: ${reason}`);
      err('falling back to ArrayBuffer instantiation');
      // fall back of instantiateArrayBuffer below
    };
  }
  return instantiateArrayBuffer(binaryFile, imports);
}

function getWasmImports() {
  // prepare imports
  var imports = {
    'env': wasmImports,
    'wasi_snapshot_preview1': wasmImports,
  };
  return imports;
}

// Create the wasm instance.
// Receives the wasm imports, returns the exports.
async function createWasm() {
  // Load the wasm module and create an instance of using native support in the JS engine.
  // handle a generated wasm instance, receiving its exports and
  // performing other necessary setup
  /** @param {WebAssembly.Module=} module*/
  function receiveInstance(instance, module) {
    wasmExports = instance.exports;

    assignWasmExports(wasmExports);

    updateMemoryViews();

    return wasmExports;
  }

  // Prefer streaming instantiation if available.
  // Async compilation can be confusing when an error on the page overwrites Module
  // (for example, if the order of elements is wrong, and the one defining Module is
  // later), so we save Module and check it later.
  var trueModule = Module;
  function receiveInstantiationResult(result) {
    // 'result' is a ResultObject object which has both the module and instance.
    // receiveInstance() will swap in the exports (to Module.asm) so they can be called
    assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?');
    trueModule = null;
    // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
    // When the regression is fixed, can restore the above PTHREADS-enabled path.
    return receiveInstance(result['instance']);
  }

  var info = getWasmImports();

  // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
  // to manually instantiate the Wasm module themselves. This allows pages to
  // run the instantiation parallel to any other async startup actions they are
  // performing.
  // Also pthreads and wasm workers initialize the wasm instance through this
  // path.
  if (Module['instantiateWasm']) {
    return new Promise((resolve, reject) => {
      try {
        Module['instantiateWasm'](info, (inst, mod) => {
          resolve(receiveInstance(inst, mod));
        });
      } catch(e) {
        err(`Module.instantiateWasm callback failed with error: ${e}`);
        reject(e);
      }
    });
  }

  wasmBinaryFile ??= findWasmBinary();
  var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
  var exports = receiveInstantiationResult(result);
  return exports;
}

// end include: preamble.js

// Begin JS library code


  class ExitStatus {
      name = 'ExitStatus';
      constructor(status) {
        this.message = `Program terminated with exit(${status})`;
        this.status = status;
      }
    }

  var callRuntimeCallbacks = (callbacks) => {
      while (callbacks.length > 0) {
        // Pass the module as the first argument.
        callbacks.shift()(Module);
      }
    };
  var onPostRuns = [];
  var addOnPostRun = (cb) => onPostRuns.push(cb);

  var onPreRuns = [];
  var addOnPreRun = (cb) => onPreRuns.push(cb);


  
    /**
     * @param {number} ptr
     * @param {string} type
     */
  function getValue(ptr, type = 'i8') {
    if (type.endsWith('*')) type = '*';
    switch (type) {
      case 'i1': return HEAP8[ptr];
      case 'i8': return HEAP8[ptr];
      case 'i16': return HEAP16[((ptr)>>1)];
      case 'i32': return HEAP32[((ptr)>>2)];
      case 'i64': return HEAP64[((ptr)>>3)];
      case 'float': return HEAPF32[((ptr)>>2)];
      case 'double': return HEAPF64[((ptr)>>3)];
      case '*': return HEAPU32[((ptr)>>2)];
      default: abort(`invalid type for getValue: ${type}`);
    }
  }

  var noExitRuntime = true;

  var ptrToString = (ptr) => {
      assert(typeof ptr === 'number', `ptrToString expects a number, got ${typeof ptr}`);
      // Convert to 32-bit unsigned value
      ptr >>>= 0;
      return '0x' + ptr.toString(16).padStart(8, '0');
    };

  
    /**
     * @param {number} ptr
     * @param {number} value
     * @param {string} type
     */
  function setValue(ptr, value, type = 'i8') {
    if (type.endsWith('*')) type = '*';
    switch (type) {
      case 'i1': HEAP8[ptr] = value; break;
      case 'i8': HEAP8[ptr] = value; break;
      case 'i16': HEAP16[((ptr)>>1)] = value; break;
      case 'i32': HEAP32[((ptr)>>2)] = value; break;
      case 'i64': HEAP64[((ptr)>>3)] = BigInt(value); break;
      case 'float': HEAPF32[((ptr)>>2)] = value; break;
      case 'double': HEAPF64[((ptr)>>3)] = value; break;
      case '*': HEAPU32[((ptr)>>2)] = value; break;
      default: abort(`invalid type for setValue: ${type}`);
    }
  }

  var stackRestore = (val) => __emscripten_stack_restore(val);

  var stackSave = () => _emscripten_stack_get_current();

  var warnOnce = (text) => {
      warnOnce.shown ||= {};
      if (!warnOnce.shown[text]) {
        warnOnce.shown[text] = 1;
        err(text);
      }
    };

  

  var __abort_js = () =>
      abort('native code called abort()');

  var _emscripten_get_now = () => performance.now();
  
  var _emscripten_date_now = () => Date.now();
  
  var nowIsMonotonic = 1;
  
  var checkWasiClock = (clock_id) => clock_id >= 0 && clock_id <= 3;
  
  var INT53_MAX = 9007199254740992;
  
  var INT53_MIN = -9007199254740992;
  var bigintToI53Checked = (num) => (num < INT53_MIN || num > INT53_MAX) ? NaN : Number(num);
  function _clock_time_get(clk_id, ignored_precision, ptime) {
    ignored_precision = bigintToI53Checked(ignored_precision);
  
  
      if (!checkWasiClock(clk_id)) {
        return 28;
      }
      var now;
      // all wasi clocks but realtime are monotonic
      if (clk_id === 0) {
        now = _emscripten_date_now();
      } else if (nowIsMonotonic) {
        now = _emscripten_get_now();
      } else {
        return 52;
      }
      // "now" is in ms, and wasi times are in ns.
      var nsec = Math.round(now * 1000 * 1000);
      HEAP64[((ptime)>>3)] = BigInt(nsec);
      return 0;
    ;
  }

  var readEmAsmArgsArray = [];
  var readEmAsmArgs = (sigPtr, buf) => {
      // Nobody should have mutated _readEmAsmArgsArray underneath us to be something else than an array.
      assert(Array.isArray(readEmAsmArgsArray));
      // The input buffer is allocated on the stack, so it must be stack-aligned.
      assert(buf % 16 == 0);
      readEmAsmArgsArray.length = 0;
      var ch;
      // Most arguments are i32s, so shift the buffer pointer so it is a plain
      // index into HEAP32.
      while (ch = HEAPU8[sigPtr++]) {
        var chr = String.fromCharCode(ch);
        var validChars = ['d', 'f', 'i', 'p'];
        // In WASM_BIGINT mode we support passing i64 values as bigint.
        validChars.push('j');
        assert(validChars.includes(chr), `Invalid character ${ch}("${chr}") in readEmAsmArgs! Use only [${validChars}], and do not specify "v" for void return argument.`);
        // Floats are always passed as doubles, so all types except for 'i'
        // are 8 bytes and require alignment.
        var wide = (ch != 105);
        wide &= (ch != 112);
        buf += wide && (buf % 8) ? 4 : 0;
        readEmAsmArgsArray.push(
          // Special case for pointers under wasm64 or CAN_ADDRESS_2GB mode.
          ch == 112 ? HEAPU32[((buf)>>2)] :
          ch == 106 ? HEAP64[((buf)>>3)] :
          ch == 105 ?
            HEAP32[((buf)>>2)] :
            HEAPF64[((buf)>>3)]
        );
        buf += wide ? 8 : 4;
      }
      return readEmAsmArgsArray;
    };
  var runEmAsmFunction = (code, sigPtr, argbuf) => {
      var args = readEmAsmArgs(sigPtr, argbuf);
      assert(ASM_CONSTS.hasOwnProperty(code), `No EM_ASM constant found at address ${code}.  The loaded WebAssembly file is likely out of sync with the generated JavaScript.`);
      return ASM_CONSTS[code](...args);
    };
  var _emscripten_asm_const_double = (code, sigPtr, argbuf) => {
      return runEmAsmFunction(code, sigPtr, argbuf);
    };

  var _emscripten_asm_const_int = (code, sigPtr, argbuf) => {
      return runEmAsmFunction(code, sigPtr, argbuf);
    };



  var getHeapMax = () =>
      // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
      // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
      // for any code that deals with heap sizes, which would require special
      // casing all heap size related code to treat 0 specially.
      2147483648;
  
  var alignMemory = (size, alignment) => {
      assert(alignment, "alignment argument is required");
      return Math.ceil(size / alignment) * alignment;
    };
  
  var growMemory = (size) => {
      var oldHeapSize = wasmMemory.buffer.byteLength;
      var pages = ((size - oldHeapSize + 65535) / 65536) | 0;
      try {
        // round size grow request up to wasm page size (fixed 64KB per spec)
        wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size
        updateMemoryViews();
        return 1 /*success*/;
      } catch(e) {
        err(`growMemory: Attempted to grow heap from ${oldHeapSize} bytes to ${size} bytes, but got error: ${e}`);
      }
      // implicit 0 return to save code size (caller will cast "undefined" into 0
      // anyhow)
    };
  var _emscripten_resize_heap = (requestedSize) => {
      var oldSize = HEAPU8.length;
      // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
      requestedSize >>>= 0;
      // With multithreaded builds, races can happen (another thread might increase the size
      // in between), so return a failure, and let the caller retry.
      assert(requestedSize > oldSize);
  
      // Memory resize rules:
      // 1.  Always increase heap size to at least the requested size, rounded up
      //     to next page multiple.
      // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap
      //     geometrically: increase the heap size according to
      //     MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most
      //     overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
      // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap
      //     linearly: increase the heap size by at least
      //     MEMORY_GROWTH_LINEAR_STEP bytes.
      // 3.  Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by
      //     MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
      // 4.  If we were unable to allocate as much memory, it may be due to
      //     over-eager decision to excessively reserve due to (3) above.
      //     Hence if an allocation fails, cut down on the amount of excess
      //     growth, in an attempt to succeed to perform a smaller allocation.
  
      // A limit is set for how much we can grow. We should not exceed that
      // (the wasm binary specifies it, so if we tried, we'd fail anyhow).
      var maxHeapSize = getHeapMax();
      if (requestedSize > maxHeapSize) {
        err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);
        return false;
      }
  
      // Loop through potential heap size increases. If we attempt a too eager
      // reservation that fails, cut down on the attempted size and reserve a
      // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
        var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth
        // but limit overreserving (default to capping at +96MB overgrowth at most)
        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 );
  
        var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
  
        var replacement = growMemory(newSize);
        if (replacement) {
  
          return true;
        }
      }
      err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`);
      return false;
    };

  
  var runtimeKeepaliveCounter = 0;
  var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
  var _proc_exit = (code) => {
      EXITSTATUS = code;
      if (!keepRuntimeAlive()) {
        Module['onExit']?.(code);
        ABORT = true;
      }
      quit_(code, new ExitStatus(code));
    };
  
  
  /** @param {boolean|number=} implicit */
  var exitJS = (status, implicit) => {
      EXITSTATUS = status;
  
      checkUnflushedContent();
  
      // if exit() was called explicitly, warn the user if the runtime isn't actually being shut down
      if (keepRuntimeAlive() && !implicit) {
        var msg = `program exited (with status: ${status}), but keepRuntimeAlive() is set (counter=${runtimeKeepaliveCounter}) due to an async operation, so halting execution but not exiting the runtime or preventing further async execution (you can use emscripten_force_exit, if you want to force a true shutdown)`;
        readyPromiseReject?.(msg);
        err(msg);
      }
  
      _proc_exit(status);
    };
  var _exit = exitJS;

  var UTF8Decoder = globalThis.TextDecoder && new TextDecoder();
  
  var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
      var maxIdx = idx + maxBytesToRead;
      if (ignoreNul) return maxIdx;
      // TextDecoder needs to know the byte length in advance, it doesn't stop on
      // null terminator by itself.
      // As a tiny code save trick, compare idx against maxIdx using a negation,
      // so that maxBytesToRead=undefined/NaN means Infinity.
      while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
      return idx;
    };
  
  
    /**
     * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
     * array that contains uint8 values, returns a copy of that string as a
     * Javascript String object.
     * heapOrArray is either a regular array, or a JavaScript typed array view.
     * @param {number=} idx
     * @param {number=} maxBytesToRead
     * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character.
     * @return {string}
     */
  var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
  
      var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
  
      // When using conditional TextDecoder, skip it for short strings as the overhead of the native call is not worth it.
      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
        return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
      }
      var str = '';
      while (idx < endPtr) {
        // For UTF8 byte structure, see:
        // http://en.wikipedia.org/wiki/UTF-8#Description
        // https://www.ietf.org/rfc/rfc2279.txt
        // https://tools.ietf.org/html/rfc3629
        var u0 = heapOrArray[idx++];
        if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }
        var u1 = heapOrArray[idx++] & 63;
        if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }
        var u2 = heapOrArray[idx++] & 63;
        if ((u0 & 0xF0) == 0xE0) {
          u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
        } else {
          if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte ' + ptrToString(u0) + ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!');
          u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
        }
  
        if (u0 < 0x10000) {
          str += String.fromCharCode(u0);
        } else {
          var ch = u0 - 0x10000;
          str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
        }
      }
      return str;
    };
  
    /**
     * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
     * emscripten HEAP, returns a copy of that string as a Javascript String object.
     *
     * @param {number} ptr
     * @param {number=} maxBytesToRead - An optional length that specifies the
     *   maximum number of bytes to read. You can omit this parameter to scan the
     *   string until the first 0 byte. If maxBytesToRead is passed, and the string
     *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
     *   string will cut short at that byte index.
     * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character.
     * @return {string}
     */
  var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => {
      assert(typeof ptr == 'number', `UTF8ToString expects a number (got ${typeof ptr})`);
      return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : '';
    };
  var SYSCALLS = {
  varargs:undefined,
  getStr(ptr) {
        var ret = UTF8ToString(ptr);
        return ret;
      },
  };
  var _fd_close = (fd) => {
      abort('fd_close called without SYSCALLS_REQUIRE_FILESYSTEM');
    };

  function _fd_seek(fd, offset, whence, newOffset) {
    offset = bigintToI53Checked(offset);
  
  
      return 70;
    ;
  }

  var printCharBuffers = [null,[],[]];
  
  var printChar = (stream, curr) => {
      var buffer = printCharBuffers[stream];
      assert(buffer);
      if (curr === 0 || curr === 10) {
        (stream === 1 ? out : err)(UTF8ArrayToString(buffer));
        buffer.length = 0;
      } else {
        buffer.push(curr);
      }
    };
  
  var flush_NO_FILESYSTEM = () => {
      // flush anything remaining in the buffers during shutdown
      _fflush(0);
      if (printCharBuffers[1].length) printChar(1, 10);
      if (printCharBuffers[2].length) printChar(2, 10);
    };
  
  
  var _fd_write = (fd, iov, iovcnt, pnum) => {
      // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0
      var num = 0;
      for (var i = 0; i < iovcnt; i++) {
        var ptr = HEAPU32[((iov)>>2)];
        var len = HEAPU32[(((iov)+(4))>>2)];
        iov += 8;
        for (var j = 0; j < len; j++) {
          printChar(fd, HEAPU8[ptr+j]);
        }
        num += len;
      }
      HEAPU32[((pnum)>>2)] = num;
      return 0;
    };

  var lengthBytesUTF8 = (str) => {
      var len = 0;
      for (var i = 0; i < str.length; ++i) {
        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
        // unit, not a Unicode code point of the character! So decode
        // UTF16->UTF32->UTF8.
        // See http://unicode.org/faq/utf_bom.html#utf16-3
        var c = str.charCodeAt(i); // possibly a lead surrogate
        if (c <= 0x7F) {
          len++;
        } else if (c <= 0x7FF) {
          len += 2;
        } else if (c >= 0xD800 && c <= 0xDFFF) {
          len += 4; ++i;
        } else {
          len += 3;
        }
      }
      return len;
    };
  
  var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
      assert(typeof str === 'string', `stringToUTF8Array expects a string (got ${typeof str})`);
      // Parameter maxBytesToWrite is not optional. Negative values, 0, null,
      // undefined and false each don't write out any bytes.
      if (!(maxBytesToWrite > 0))
        return 0;
  
      var startIdx = outIdx;
      var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
      for (var i = 0; i < str.length; ++i) {
        // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description
        // and https://www.ietf.org/rfc/rfc2279.txt
        // and https://tools.ietf.org/html/rfc3629
        var u = str.codePointAt(i);
        if (u <= 0x7F) {
          if (outIdx >= endIdx) break;
          heap[outIdx++] = u;
        } else if (u <= 0x7FF) {
          if (outIdx + 1 >= endIdx) break;
          heap[outIdx++] = 0xC0 | (u >> 6);
          heap[outIdx++] = 0x80 | (u & 63);
        } else if (u <= 0xFFFF) {
          if (outIdx + 2 >= endIdx) break;
          heap[outIdx++] = 0xE0 | (u >> 12);
          heap[outIdx++] = 0x80 | ((u >> 6) & 63);
          heap[outIdx++] = 0x80 | (u & 63);
        } else {
          if (outIdx + 3 >= endIdx) break;
          if (u > 0x10FFFF) warnOnce('Invalid Unicode code point ' + ptrToString(u) + ' encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).');
          heap[outIdx++] = 0xF0 | (u >> 18);
          heap[outIdx++] = 0x80 | ((u >> 12) & 63);
          heap[outIdx++] = 0x80 | ((u >> 6) & 63);
          heap[outIdx++] = 0x80 | (u & 63);
          // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16.
          // We need to manually skip over the second code unit for correct iteration.
          i++;
        }
      }
      // Null-terminate the pointer to the buffer.
      heap[outIdx] = 0;
      return outIdx - startIdx;
    };
  /** @type {function(string, boolean=, number=)} */
  var intArrayFromString = (stringy, dontAddNull, length) => {
      var len = length > 0 ? length : lengthBytesUTF8(stringy)+1;
      var u8array = new Array(len);
      var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
      if (dontAddNull) u8array.length = numBytesWritten;
      return u8array;
    };



  var onInits = [];
  var addOnInit = (cb) => onInits.push(cb);



  var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
// End JS library code

// include: postlibrary.js
// This file is included after the automatically-generated JS library code
// but before the wasm module is created.

{

  // Begin ATMODULES hooks
  if (Module['noExitRuntime']) noExitRuntime = Module['noExitRuntime'];
if (Module['print']) out = Module['print'];
if (Module['printErr']) err = Module['printErr'];
if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];

Module['FS_createDataFile'] = FS.createDataFile;
Module['FS_createPreloadedFile'] = FS.createPreloadedFile;

  // End ATMODULES hooks

  checkIncomingModuleAPI();

  if (Module['arguments']) arguments_ = Module['arguments'];
  if (Module['thisProgram']) thisProgram = Module['thisProgram'];

  // Assertions on removed incoming Module JS APIs.
  assert(typeof Module['memoryInitializerPrefixURL'] == 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead');
  assert(typeof Module['pthreadMainPrefixURL'] == 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead');
  assert(typeof Module['cdInitializerPrefixURL'] == 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead');
  assert(typeof Module['filePackagePrefixURL'] == 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead');
  assert(typeof Module['read'] == 'undefined', 'Module.read option was removed');
  assert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)');
  assert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)');
  assert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)');
  assert(typeof Module['TOTAL_MEMORY'] == 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY');
  assert(typeof Module['ENVIRONMENT'] == 'undefined', 'Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)');
  assert(typeof Module['STACK_SIZE'] == 'undefined', 'STACK_SIZE can no longer be set at runtime.  Use -sSTACK_SIZE at link time')
  // If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY
  assert(typeof Module['wasmMemory'] == 'undefined', 'Use of `wasmMemory` detected.  Use -sIMPORTED_MEMORY to define wasmMemory externally');
  assert(typeof Module['INITIAL_MEMORY'] == 'undefined', 'Detected runtime INITIAL_MEMORY setting.  Use -sIMPORTED_MEMORY to define wasmMemory dynamically');

  if (Module['preInit']) {
    if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
    while (Module['preInit'].length > 0) {
      Module['preInit'].shift()();
    }
  }
  consumedModuleProp('preInit');
}

// Begin runtime exports
  Module['stackSave'] = stackSave;
  Module['stackRestore'] = stackRestore;
  Module['stackAlloc'] = stackAlloc;
  var missingLibrarySymbols = [
  'writeI53ToI64',
  'writeI53ToI64Clamped',
  'writeI53ToI64Signaling',
  'writeI53ToU64Clamped',
  'writeI53ToU64Signaling',
  'readI53FromI64',
  'readI53FromU64',
  'convertI32PairToI53',
  'convertI32PairToI53Checked',
  'convertU32PairToI53',
  'getTempRet0',
  'setTempRet0',
  'createNamedFunction',
  'zeroMemory',
  'withStackSave',
  'strError',
  'inetPton4',
  'inetNtop4',
  'inetPton6',
  'inetNtop6',
  'readSockaddr',
  'writeSockaddr',
  'runMainThreadEmAsm',
  'jstoi_q',
  'getExecutableName',
  'autoResumeAudioContext',
  'getDynCaller',
  'dynCall',
  'handleException',
  'runtimeKeepalivePush',
  'runtimeKeepalivePop',
  'callUserCallback',
  'maybeExit',
  'asyncLoad',
  'asmjsMangle',
  'mmapAlloc',
  'HandleAllocator',
  'getUniqueRunDependency',
  'addRunDependency',
  'removeRunDependency',
  'addOnPostCtor',
  'addOnPreMain',
  'addOnExit',
  'STACK_SIZE',
  'STACK_ALIGN',
  'POINTER_SIZE',
  'ASSERTIONS',
  'ccall',
  'cwrap',
  'convertJsFunctionToWasm',
  'getEmptyTableSlot',
  'updateTableMap',
  'getFunctionAddress',
  'addFunction',
  'removeFunction',
  'stringToUTF8',
  'intArrayToString',
  'AsciiToString',
  'stringToAscii',
  'UTF16ToString',
  'stringToUTF16',
  'lengthBytesUTF16',
  'UTF32ToString',
  'stringToUTF32',
  'lengthBytesUTF32',
  'stringToNewUTF8',
  'stringToUTF8OnStack',
  'writeArrayToMemory',
  'registerKeyEventCallback',
  'maybeCStringToJsString',
  'findEventTarget',
  'getBoundingClientRect',
  'fillMouseEventData',
  'registerMouseEventCallback',
  'registerWheelEventCallback',
  'registerUiEventCallback',
  'registerFocusEventCallback',
  'fillDeviceOrientationEventData',
  'registerDeviceOrientationEventCallback',
  'fillDeviceMotionEventData',
  'registerDeviceMotionEventCallback',
  'screenOrientation',
  'fillOrientationChangeEventData',
  'registerOrientationChangeEventCallback',
  'fillFullscreenChangeEventData',
  'registerFullscreenChangeEventCallback',
  'JSEvents_requestFullscreen',
  'JSEvents_resizeCanvasForFullscreen',
  'registerRestoreOldStyle',
  'hideEverythingExceptGivenElement',
  'restoreHiddenElements',
  'setLetterbox',
  'softFullscreenResizeWebGLRenderTarget',
  'doRequestFullscreen',
  'fillPointerlockChangeEventData',
  'registerPointerlockChangeEventCallback',
  'registerPointerlockErrorEventCallback',
  'requestPointerLock',
  'fillVisibilityChangeEventData',
  'registerVisibilityChangeEventCallback',
  'registerTouchEventCallback',
  'fillGamepadEventData',
  'registerGamepadEventCallback',
  'registerBeforeUnloadEventCallback',
  'fillBatteryEventData',
  'registerBatteryEventCallback',
  'setCanvasElementSize',
  'getCanvasElementSize',
  'jsStackTrace',
  'getCallstack',
  'convertPCtoSourceLocation',
  'getEnvStrings',
  'wasiRightsToMuslOFlags',
  'wasiOFlagsToMuslOFlags',
  'initRandomFill',
  'randomFill',
  'safeSetTimeout',
  'setImmediateWrapped',
  'safeRequestAnimationFrame',
  'clearImmediateWrapped',
  'registerPostMainLoop',
  'registerPreMainLoop',
  'getPromise',
  'makePromise',
  'idsToPromises',
  'makePromiseCallback',
  'Browser_asyncPrepareDataCounter',
  'isLeapYear',
  'ydayFromDate',
  'arraySum',
  'addDays',
  'getSocketFromFD',
  'getSocketAddress',
  'heapObjectForWebGLType',
  'toTypedArrayIndex',
  'webgl_enable_ANGLE_instanced_arrays',
  'webgl_enable_OES_vertex_array_object',
  'webgl_enable_WEBGL_draw_buffers',
  'webgl_enable_WEBGL_multi_draw',
  'webgl_enable_EXT_polygon_offset_clamp',
  'webgl_enable_EXT_clip_control',
  'webgl_enable_WEBGL_polygon_mode',
  'emscriptenWebGLGet',
  'computeUnpackAlignedImageSize',
  'colorChannelsInGlTextureFormat',
  'emscriptenWebGLGetTexPixelData',
  'emscriptenWebGLGetUniform',
  'webglGetUniformLocation',
  'webglPrepareUniformLocationsBeforeFirstUse',
  'webglGetLeftBracePos',
  'emscriptenWebGLGetVertexAttrib',
  '__glGetActiveAttribOrUniform',
  'writeGLArray',
  'registerWebGlEventCallback',
  'runAndAbortIfError',
  'ALLOC_NORMAL',
  'ALLOC_STACK',
  'allocate',
  'writeStringToMemory',
  'writeAsciiToMemory',
  'allocateUTF8',
  'allocateUTF8OnStack',
  'demangle',
  'stackTrace',
  'getNativeTypeSize',
];
missingLibrarySymbols.forEach(missingLibrarySymbol)

  var unexportedSymbols = [
  'run',
  'out',
  'err',
  'callMain',
  'abort',
  'wasmExports',
  'HEAPF32',
  'HEAPF64',
  'HEAP8',
  'HEAP16',
  'HEAP32',
  'HEAP64',
  'HEAPU64',
  'writeStackCookie',
  'checkStackCookie',
  'INT53_MAX',
  'INT53_MIN',
  'bigintToI53Checked',
  'ptrToString',
  'exitJS',
  'getHeapMax',
  'growMemory',
  'ENV',
  'ERRNO_CODES',
  'DNS',
  'Protocols',
  'Sockets',
  'timers',
  'warnOnce',
  'readEmAsmArgsArray',
  'readEmAsmArgs',
  'runEmAsmFunction',
  'keepRuntimeAlive',
  'alignMemory',
  'wasmTable',
  'wasmMemory',
  'noExitRuntime',
  'addOnPreRun',
  'addOnInit',
  'addOnPostRun',
  'freeTableIndexes',
  'functionsInTableMap',
  'setValue',
  'getValue',
  'PATH',
  'PATH_FS',
  'UTF8Decoder',
  'UTF8ArrayToString',
  'UTF8ToString',
  'stringToUTF8Array',
  'lengthBytesUTF8',
  'intArrayFromString',
  'UTF16Decoder',
  'JSEvents',
  'specialHTMLTargets',
  'findCanvasEventTarget',
  'currentFullscreenStrategy',
  'restoreOldWindowedStyle',
  'UNWIND_CACHE',
  'ExitStatus',
  'checkWasiClock',
  'flush_NO_FILESYSTEM',
  'emSetImmediate',
  'emClearImmediate_deps',
  'emClearImmediate',
  'promiseMap',
  'Browser',
  'requestFullscreen',
  'requestFullScreen',
  'setCanvasSize',
  'getUserMedia',
  'createContext',
  'getPreloadedImageData__data',
  'wget',
  'MONTH_DAYS_REGULAR',
  'MONTH_DAYS_LEAP',
  'MONTH_DAYS_REGULAR_CUMULATIVE',
  'MONTH_DAYS_LEAP_CUMULATIVE',
  'SYSCALLS',
  'tempFixedLengthArray',
  'miniTempWebGLFloatBuffers',
  'miniTempWebGLIntBuffers',
  'GL',
  'AL',
  'GLUT',
  'EGL',
  'GLEW',
  'IDBStore',
  'SDL',
  'SDL_gfx',
  'print',
  'printErr',
  'jstoi_s',
];
unexportedSymbols.forEach(unexportedRuntimeSymbol);

  // End runtime exports
  // Begin JS library exports
  // End JS library exports

// end include: postlibrary.js

function checkIncomingModuleAPI() {
  ignoredModuleProp('fetchSettings');
}
var ASM_CONSTS = {
  269986: ($0) => { var self = Module['getCache'](Module['CustomSupportImpl'])[$0]; if (!self.hasOwnProperty('getCustomMargin')) throw 'a JSImplementation must implement all functions, you forgot CustomSupportImpl::getCustomMargin.'; return self['getCustomMargin'](); },  
 270238: ($0, $1, $2) => { var self = Module['getCache'](Module['CustomSupportImpl'])[$0]; if (!self.hasOwnProperty('getCustomSupportLocal')) throw 'a JSImplementation must implement all functions, you forgot CustomSupportImpl::getCustomSupportLocal.'; self['getCustomSupportLocal']($1,$2); },  
 270506: ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) => { var self = Module['getCache'](Module['PassThroughFilterShaderImpl'])[$0]; if (!self.hasOwnProperty('filterShader')) throw 'a JSImplementation must implement all functions, you forgot PassThroughFilterShaderImpl::filterShader.'; return self['filterShader']($1,$2,$3,$4,$5,$6,$7,$8,$9,$10); },  
 270799: ($0, $1, $2) => { var self = Module['getCache'](Module['PxControllerBehaviorCallbackImpl'])[$0]; if (!self.hasOwnProperty('getShapeBehaviorFlags')) throw 'a JSImplementation must implement all functions, you forgot PxControllerBehaviorCallbackImpl::getShapeBehaviorFlags.'; return self['getShapeBehaviorFlags']($1,$2); },  
 271104: ($0, $1) => { var self = Module['getCache'](Module['PxControllerBehaviorCallbackImpl'])[$0]; if (!self.hasOwnProperty('getControllerBehaviorFlags')) throw 'a JSImplementation must implement all functions, you forgot PxControllerBehaviorCallbackImpl::getControllerBehaviorFlags.'; return self['getControllerBehaviorFlags']($1); },  
 271421: ($0, $1) => { var self = Module['getCache'](Module['PxControllerBehaviorCallbackImpl'])[$0]; if (!self.hasOwnProperty('getObstacleBehaviorFlags')) throw 'a JSImplementation must implement all functions, you forgot PxControllerBehaviorCallbackImpl::getObstacleBehaviorFlags.'; return self['getObstacleBehaviorFlags']($1); },  
 271732: ($0, $1, $2) => { var self = Module['getCache'](Module['PxControllerFilterCallbackImpl'])[$0]; if (!self.hasOwnProperty('filter')) throw 'a JSImplementation must implement all functions, you forgot PxControllerFilterCallbackImpl::filter.'; return self['filter']($1,$2); },  
 271988: ($0, $1, $2, $3, $4) => { var self = Module['getCache'](Module['PxErrorCallbackImpl'])[$0]; if (!self.hasOwnProperty('reportError')) throw 'a JSImplementation must implement all functions, you forgot PxErrorCallbackImpl::reportError.'; self['reportError']($1,$2,$3,$4); },  
 272236: ($0, $1, $2, $3, $4) => { var self = Module['getCache'](Module['PxQueryFilterCallbackImpl'])[$0]; if (!self.hasOwnProperty('simplePreFilter')) throw 'a JSImplementation must implement all functions, you forgot PxQueryFilterCallbackImpl::simplePreFilter.'; return self['simplePreFilter']($1,$2,$3,$4); },  
 272515: ($0, $1, $2, $3, $4) => { var self = Module['getCache'](Module['PxQueryFilterCallbackImpl'])[$0]; if (!self.hasOwnProperty('simplePostFilter')) throw 'a JSImplementation must implement all functions, you forgot PxQueryFilterCallbackImpl::simplePostFilter.'; return self['simplePostFilter']($1,$2,$3,$4); },  
 272797: ($0, $1, $2) => { var self = Module['getCache'](Module['PxSimulationEventCallbackImpl'])[$0]; if (!self.hasOwnProperty('onConstraintBreak')) throw 'a JSImplementation must implement all functions, you forgot PxSimulationEventCallbackImpl::onConstraintBreak.'; self['onConstraintBreak']($1,$2); },  
 273077: ($0, $1, $2) => { var self = Module['getCache'](Module['PxSimulationEventCallbackImpl'])[$0]; if (!self.hasOwnProperty('onWake')) throw 'a JSImplementation must implement all functions, you forgot PxSimulationEventCallbackImpl::onWake.'; self['onWake']($1,$2); },  
 273324: ($0, $1, $2) => { var self = Module['getCache'](Module['PxSimulationEventCallbackImpl'])[$0]; if (!self.hasOwnProperty('onSleep')) throw 'a JSImplementation must implement all functions, you forgot PxSimulationEventCallbackImpl::onSleep.'; self['onSleep']($1,$2); },  
 273574: ($0, $1, $2, $3) => { var self = Module['getCache'](Module['PxSimulationEventCallbackImpl'])[$0]; if (!self.hasOwnProperty('onContact')) throw 'a JSImplementation must implement all functions, you forgot PxSimulationEventCallbackImpl::onContact.'; self['onContact']($1,$2,$3); },  
 273833: ($0, $1, $2) => { var self = Module['getCache'](Module['PxSimulationEventCallbackImpl'])[$0]; if (!self.hasOwnProperty('onTrigger')) throw 'a JSImplementation must implement all functions, you forgot PxSimulationEventCallbackImpl::onTrigger.'; self['onTrigger']($1,$2); },  
 274089: ($0, $1) => { var self = Module['getCache'](Module['PxUserControllerHitReportImpl'])[$0]; if (!self.hasOwnProperty('onShapeHit')) throw 'a JSImplementation must implement all functions, you forgot PxUserControllerHitReportImpl::onShapeHit.'; self['onShapeHit']($1); },  
 274345: ($0, $1) => { var self = Module['getCache'](Module['PxUserControllerHitReportImpl'])[$0]; if (!self.hasOwnProperty('onControllerHit')) throw 'a JSImplementation must implement all functions, you forgot PxUserControllerHitReportImpl::onControllerHit.'; self['onControllerHit']($1); },  
 274616: ($0, $1) => { var self = Module['getCache'](Module['PxUserControllerHitReportImpl'])[$0]; if (!self.hasOwnProperty('onObstacleHit')) throw 'a JSImplementation must implement all functions, you forgot PxUserControllerHitReportImpl::onObstacleHit.'; self['onObstacleHit']($1); },  
 274881: ($0) => { var self = Module['getCache'](Module['SimplPvdTransportImpl'])[$0]; if (!self.hasOwnProperty('connect')) throw 'a JSImplementation must implement all functions, you forgot SimplPvdTransportImpl::connect.'; return self['connect'](); },  
 275117: ($0) => { var self = Module['getCache'](Module['SimplPvdTransportImpl'])[$0]; if (!self.hasOwnProperty('disconnect')) throw 'a JSImplementation must implement all functions, you forgot SimplPvdTransportImpl::disconnect.'; self['disconnect'](); },  
 275355: ($0) => { var self = Module['getCache'](Module['SimplPvdTransportImpl'])[$0]; if (!self.hasOwnProperty('isConnected')) throw 'a JSImplementation must implement all functions, you forgot SimplPvdTransportImpl::isConnected.'; return self['isConnected'](); },  
 275603: ($0) => { var self = Module['getCache'](Module['SimplPvdTransportImpl'])[$0]; if (!self.hasOwnProperty('flush')) throw 'a JSImplementation must implement all functions, you forgot SimplPvdTransportImpl::flush.'; self['flush'](); },  
 275826: ($0, $1, $2) => { var self = Module['getCache'](Module['SimplPvdTransportImpl'])[$0]; if (!self.hasOwnProperty('send')) throw 'a JSImplementation must implement all functions, you forgot SimplPvdTransportImpl::send.'; self['send']($1,$2); }
};

// Imports from the Wasm binary.
var _webidl_free = Module['_webidl_free'] = makeInvalidEarlyAccess('_webidl_free');
var _webidl_malloc = Module['_webidl_malloc'] = makeInvalidEarlyAccess('_webidl_malloc');
var _malloc = Module['_malloc'] = makeInvalidEarlyAccess('_malloc');
var _emscripten_bind_PxBase_release_0 = Module['_emscripten_bind_PxBase_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBase_release_0');
var _emscripten_bind_PxBase_getConcreteTypeName_0 = Module['_emscripten_bind_PxBase_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBase_getConcreteTypeName_0');
var _emscripten_bind_PxBase_getConcreteType_0 = Module['_emscripten_bind_PxBase_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBase_getConcreteType_0');
var _emscripten_bind_PxBase_setBaseFlag_2 = Module['_emscripten_bind_PxBase_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxBase_setBaseFlag_2');
var _emscripten_bind_PxBase_setBaseFlags_1 = Module['_emscripten_bind_PxBase_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBase_setBaseFlags_1');
var _emscripten_bind_PxBase_getBaseFlags_0 = Module['_emscripten_bind_PxBase_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBase_getBaseFlags_0');
var _emscripten_bind_PxBase_isReleasable_0 = Module['_emscripten_bind_PxBase_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBase_isReleasable_0');
var _emscripten_bind_PxActor_getType_0 = Module['_emscripten_bind_PxActor_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_getType_0');
var _emscripten_bind_PxActor_getScene_0 = Module['_emscripten_bind_PxActor_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_getScene_0');
var _emscripten_bind_PxActor_setName_1 = Module['_emscripten_bind_PxActor_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_setName_1');
var _emscripten_bind_PxActor_getName_0 = Module['_emscripten_bind_PxActor_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_getName_0');
var _emscripten_bind_PxActor_getWorldBounds_0 = Module['_emscripten_bind_PxActor_getWorldBounds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_getWorldBounds_0');
var _emscripten_bind_PxActor_getWorldBounds_1 = Module['_emscripten_bind_PxActor_getWorldBounds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_getWorldBounds_1');
var _emscripten_bind_PxActor_setActorFlag_2 = Module['_emscripten_bind_PxActor_setActorFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_setActorFlag_2');
var _emscripten_bind_PxActor_setActorFlags_1 = Module['_emscripten_bind_PxActor_setActorFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_setActorFlags_1');
var _emscripten_bind_PxActor_getActorFlags_0 = Module['_emscripten_bind_PxActor_getActorFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_getActorFlags_0');
var _emscripten_bind_PxActor_setDominanceGroup_1 = Module['_emscripten_bind_PxActor_setDominanceGroup_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_setDominanceGroup_1');
var _emscripten_bind_PxActor_getDominanceGroup_0 = Module['_emscripten_bind_PxActor_getDominanceGroup_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_getDominanceGroup_0');
var _emscripten_bind_PxActor_setOwnerClient_1 = Module['_emscripten_bind_PxActor_setOwnerClient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_setOwnerClient_1');
var _emscripten_bind_PxActor_getOwnerClient_0 = Module['_emscripten_bind_PxActor_getOwnerClient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_getOwnerClient_0');
var _emscripten_bind_PxActor_release_0 = Module['_emscripten_bind_PxActor_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_release_0');
var _emscripten_bind_PxActor_getConcreteTypeName_0 = Module['_emscripten_bind_PxActor_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_getConcreteTypeName_0');
var _emscripten_bind_PxActor_getConcreteType_0 = Module['_emscripten_bind_PxActor_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_getConcreteType_0');
var _emscripten_bind_PxActor_setBaseFlag_2 = Module['_emscripten_bind_PxActor_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_setBaseFlag_2');
var _emscripten_bind_PxActor_setBaseFlags_1 = Module['_emscripten_bind_PxActor_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_setBaseFlags_1');
var _emscripten_bind_PxActor_getBaseFlags_0 = Module['_emscripten_bind_PxActor_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_getBaseFlags_0');
var _emscripten_bind_PxActor_isReleasable_0 = Module['_emscripten_bind_PxActor_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_isReleasable_0');
var _emscripten_bind_PxActor_get_userData_0 = Module['_emscripten_bind_PxActor_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_get_userData_0');
var _emscripten_bind_PxActor_set_userData_1 = Module['_emscripten_bind_PxActor_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActor_set_userData_1');
var _emscripten_bind_PxQueryHit_get_faceIndex_0 = Module['_emscripten_bind_PxQueryHit_get_faceIndex_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryHit_get_faceIndex_0');
var _emscripten_bind_PxQueryHit_set_faceIndex_1 = Module['_emscripten_bind_PxQueryHit_set_faceIndex_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryHit_set_faceIndex_1');
var _emscripten_bind_PxQueryHit___destroy___0 = Module['_emscripten_bind_PxQueryHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryHit___destroy___0');
var _emscripten_bind_BaseVehicle_initialize_0 = Module['_emscripten_bind_BaseVehicle_initialize_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicle_initialize_0');
var _emscripten_bind_BaseVehicle_destroyState_0 = Module['_emscripten_bind_BaseVehicle_destroyState_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicle_destroyState_0');
var _emscripten_bind_BaseVehicle_initComponentSequence_1 = Module['_emscripten_bind_BaseVehicle_initComponentSequence_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicle_initComponentSequence_1');
var _emscripten_bind_BaseVehicle_step_2 = Module['_emscripten_bind_BaseVehicle_step_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicle_step_2');
var _emscripten_bind_BaseVehicle_get_baseParams_0 = Module['_emscripten_bind_BaseVehicle_get_baseParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicle_get_baseParams_0');
var _emscripten_bind_BaseVehicle_set_baseParams_1 = Module['_emscripten_bind_BaseVehicle_set_baseParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicle_set_baseParams_1');
var _emscripten_bind_BaseVehicle_get_baseState_0 = Module['_emscripten_bind_BaseVehicle_get_baseState_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicle_get_baseState_0');
var _emscripten_bind_BaseVehicle_set_baseState_1 = Module['_emscripten_bind_BaseVehicle_set_baseState_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicle_set_baseState_1');
var _emscripten_bind_BaseVehicle_get_componentSequence_0 = Module['_emscripten_bind_BaseVehicle_get_componentSequence_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicle_get_componentSequence_0');
var _emscripten_bind_BaseVehicle_set_componentSequence_1 = Module['_emscripten_bind_BaseVehicle_set_componentSequence_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicle_set_componentSequence_1');
var _emscripten_bind_BaseVehicle_get_componentSequenceSubstepGroupHandle_0 = Module['_emscripten_bind_BaseVehicle_get_componentSequenceSubstepGroupHandle_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicle_get_componentSequenceSubstepGroupHandle_0');
var _emscripten_bind_BaseVehicle_set_componentSequenceSubstepGroupHandle_1 = Module['_emscripten_bind_BaseVehicle_set_componentSequenceSubstepGroupHandle_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicle_set_componentSequenceSubstepGroupHandle_1');
var _emscripten_bind_BaseVehicle___destroy___0 = Module['_emscripten_bind_BaseVehicle___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicle___destroy___0');
var _emscripten_bind_PxLocationHit_get_flags_0 = Module['_emscripten_bind_PxLocationHit_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxLocationHit_get_flags_0');
var _emscripten_bind_PxLocationHit_set_flags_1 = Module['_emscripten_bind_PxLocationHit_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxLocationHit_set_flags_1');
var _emscripten_bind_PxLocationHit_get_position_0 = Module['_emscripten_bind_PxLocationHit_get_position_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxLocationHit_get_position_0');
var _emscripten_bind_PxLocationHit_set_position_1 = Module['_emscripten_bind_PxLocationHit_set_position_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxLocationHit_set_position_1');
var _emscripten_bind_PxLocationHit_get_normal_0 = Module['_emscripten_bind_PxLocationHit_get_normal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxLocationHit_get_normal_0');
var _emscripten_bind_PxLocationHit_set_normal_1 = Module['_emscripten_bind_PxLocationHit_set_normal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxLocationHit_set_normal_1');
var _emscripten_bind_PxLocationHit_get_distance_0 = Module['_emscripten_bind_PxLocationHit_get_distance_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxLocationHit_get_distance_0');
var _emscripten_bind_PxLocationHit_set_distance_1 = Module['_emscripten_bind_PxLocationHit_set_distance_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxLocationHit_set_distance_1');
var _emscripten_bind_PxLocationHit_get_faceIndex_0 = Module['_emscripten_bind_PxLocationHit_get_faceIndex_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxLocationHit_get_faceIndex_0');
var _emscripten_bind_PxLocationHit_set_faceIndex_1 = Module['_emscripten_bind_PxLocationHit_set_faceIndex_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxLocationHit_set_faceIndex_1');
var _emscripten_bind_PxLocationHit___destroy___0 = Module['_emscripten_bind_PxLocationHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxLocationHit___destroy___0');
var _emscripten_bind_PxPvdTransport_connect_0 = Module['_emscripten_bind_PxPvdTransport_connect_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdTransport_connect_0');
var _emscripten_bind_PxPvdTransport_isConnected_0 = Module['_emscripten_bind_PxPvdTransport_isConnected_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdTransport_isConnected_0');
var _emscripten_bind_PxPvdTransport_disconnect_0 = Module['_emscripten_bind_PxPvdTransport_disconnect_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdTransport_disconnect_0');
var _emscripten_bind_PxPvdTransport_release_0 = Module['_emscripten_bind_PxPvdTransport_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdTransport_release_0');
var _emscripten_bind_PxPvdTransport_flush_0 = Module['_emscripten_bind_PxPvdTransport_flush_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdTransport_flush_0');
var _emscripten_bind_PxQueryFilterCallback___destroy___0 = Module['_emscripten_bind_PxQueryFilterCallback___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFilterCallback___destroy___0');
var _emscripten_bind_PxRefCounted_getReferenceCount_0 = Module['_emscripten_bind_PxRefCounted_getReferenceCount_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRefCounted_getReferenceCount_0');
var _emscripten_bind_PxRefCounted_acquireReference_0 = Module['_emscripten_bind_PxRefCounted_acquireReference_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRefCounted_acquireReference_0');
var _emscripten_bind_PxRefCounted_release_0 = Module['_emscripten_bind_PxRefCounted_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRefCounted_release_0');
var _emscripten_bind_PxRefCounted_getConcreteTypeName_0 = Module['_emscripten_bind_PxRefCounted_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRefCounted_getConcreteTypeName_0');
var _emscripten_bind_PxRefCounted_getConcreteType_0 = Module['_emscripten_bind_PxRefCounted_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRefCounted_getConcreteType_0');
var _emscripten_bind_PxRefCounted_setBaseFlag_2 = Module['_emscripten_bind_PxRefCounted_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRefCounted_setBaseFlag_2');
var _emscripten_bind_PxRefCounted_setBaseFlags_1 = Module['_emscripten_bind_PxRefCounted_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRefCounted_setBaseFlags_1');
var _emscripten_bind_PxRefCounted_getBaseFlags_0 = Module['_emscripten_bind_PxRefCounted_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRefCounted_getBaseFlags_0');
var _emscripten_bind_PxRefCounted_isReleasable_0 = Module['_emscripten_bind_PxRefCounted_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRefCounted_isReleasable_0');
var _emscripten_bind_PxRigidActor_getGlobalPose_0 = Module['_emscripten_bind_PxRigidActor_getGlobalPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getGlobalPose_0');
var _emscripten_bind_PxRigidActor_setGlobalPose_1 = Module['_emscripten_bind_PxRigidActor_setGlobalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_setGlobalPose_1');
var _emscripten_bind_PxRigidActor_setGlobalPose_2 = Module['_emscripten_bind_PxRigidActor_setGlobalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_setGlobalPose_2');
var _emscripten_bind_PxRigidActor_attachShape_1 = Module['_emscripten_bind_PxRigidActor_attachShape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_attachShape_1');
var _emscripten_bind_PxRigidActor_detachShape_1 = Module['_emscripten_bind_PxRigidActor_detachShape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_detachShape_1');
var _emscripten_bind_PxRigidActor_detachShape_2 = Module['_emscripten_bind_PxRigidActor_detachShape_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_detachShape_2');
var _emscripten_bind_PxRigidActor_getNbShapes_0 = Module['_emscripten_bind_PxRigidActor_getNbShapes_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getNbShapes_0');
var _emscripten_bind_PxRigidActor_getShapes_3 = Module['_emscripten_bind_PxRigidActor_getShapes_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getShapes_3');
var _emscripten_bind_PxRigidActor_getNbConstraints_0 = Module['_emscripten_bind_PxRigidActor_getNbConstraints_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getNbConstraints_0');
var _emscripten_bind_PxRigidActor_getType_0 = Module['_emscripten_bind_PxRigidActor_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getType_0');
var _emscripten_bind_PxRigidActor_getScene_0 = Module['_emscripten_bind_PxRigidActor_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getScene_0');
var _emscripten_bind_PxRigidActor_setName_1 = Module['_emscripten_bind_PxRigidActor_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_setName_1');
var _emscripten_bind_PxRigidActor_getName_0 = Module['_emscripten_bind_PxRigidActor_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getName_0');
var _emscripten_bind_PxRigidActor_getWorldBounds_0 = Module['_emscripten_bind_PxRigidActor_getWorldBounds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getWorldBounds_0');
var _emscripten_bind_PxRigidActor_getWorldBounds_1 = Module['_emscripten_bind_PxRigidActor_getWorldBounds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getWorldBounds_1');
var _emscripten_bind_PxRigidActor_setActorFlag_2 = Module['_emscripten_bind_PxRigidActor_setActorFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_setActorFlag_2');
var _emscripten_bind_PxRigidActor_setActorFlags_1 = Module['_emscripten_bind_PxRigidActor_setActorFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_setActorFlags_1');
var _emscripten_bind_PxRigidActor_getActorFlags_0 = Module['_emscripten_bind_PxRigidActor_getActorFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getActorFlags_0');
var _emscripten_bind_PxRigidActor_setDominanceGroup_1 = Module['_emscripten_bind_PxRigidActor_setDominanceGroup_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_setDominanceGroup_1');
var _emscripten_bind_PxRigidActor_getDominanceGroup_0 = Module['_emscripten_bind_PxRigidActor_getDominanceGroup_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getDominanceGroup_0');
var _emscripten_bind_PxRigidActor_setOwnerClient_1 = Module['_emscripten_bind_PxRigidActor_setOwnerClient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_setOwnerClient_1');
var _emscripten_bind_PxRigidActor_getOwnerClient_0 = Module['_emscripten_bind_PxRigidActor_getOwnerClient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getOwnerClient_0');
var _emscripten_bind_PxRigidActor_release_0 = Module['_emscripten_bind_PxRigidActor_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_release_0');
var _emscripten_bind_PxRigidActor_getConcreteTypeName_0 = Module['_emscripten_bind_PxRigidActor_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getConcreteTypeName_0');
var _emscripten_bind_PxRigidActor_getConcreteType_0 = Module['_emscripten_bind_PxRigidActor_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getConcreteType_0');
var _emscripten_bind_PxRigidActor_setBaseFlag_2 = Module['_emscripten_bind_PxRigidActor_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_setBaseFlag_2');
var _emscripten_bind_PxRigidActor_setBaseFlags_1 = Module['_emscripten_bind_PxRigidActor_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_setBaseFlags_1');
var _emscripten_bind_PxRigidActor_getBaseFlags_0 = Module['_emscripten_bind_PxRigidActor_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_getBaseFlags_0');
var _emscripten_bind_PxRigidActor_isReleasable_0 = Module['_emscripten_bind_PxRigidActor_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_isReleasable_0');
var _emscripten_bind_PxRigidActor_get_userData_0 = Module['_emscripten_bind_PxRigidActor_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_get_userData_0');
var _emscripten_bind_PxRigidActor_set_userData_1 = Module['_emscripten_bind_PxRigidActor_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActor_set_userData_1');
var _emscripten_bind_PxSceneQuerySystemBase_setDynamicTreeRebuildRateHint_1 = Module['_emscripten_bind_PxSceneQuerySystemBase_setDynamicTreeRebuildRateHint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_setDynamicTreeRebuildRateHint_1');
var _emscripten_bind_PxSceneQuerySystemBase_getDynamicTreeRebuildRateHint_0 = Module['_emscripten_bind_PxSceneQuerySystemBase_getDynamicTreeRebuildRateHint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_getDynamicTreeRebuildRateHint_0');
var _emscripten_bind_PxSceneQuerySystemBase_forceRebuildDynamicTree_1 = Module['_emscripten_bind_PxSceneQuerySystemBase_forceRebuildDynamicTree_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_forceRebuildDynamicTree_1');
var _emscripten_bind_PxSceneQuerySystemBase_setUpdateMode_1 = Module['_emscripten_bind_PxSceneQuerySystemBase_setUpdateMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_setUpdateMode_1');
var _emscripten_bind_PxSceneQuerySystemBase_getUpdateMode_0 = Module['_emscripten_bind_PxSceneQuerySystemBase_getUpdateMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_getUpdateMode_0');
var _emscripten_bind_PxSceneQuerySystemBase_getStaticTimestamp_0 = Module['_emscripten_bind_PxSceneQuerySystemBase_getStaticTimestamp_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_getStaticTimestamp_0');
var _emscripten_bind_PxSceneQuerySystemBase_flushUpdates_0 = Module['_emscripten_bind_PxSceneQuerySystemBase_flushUpdates_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_flushUpdates_0');
var _emscripten_bind_PxSceneQuerySystemBase_raycast_4 = Module['_emscripten_bind_PxSceneQuerySystemBase_raycast_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_raycast_4');
var _emscripten_bind_PxSceneQuerySystemBase_raycast_5 = Module['_emscripten_bind_PxSceneQuerySystemBase_raycast_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_raycast_5');
var _emscripten_bind_PxSceneQuerySystemBase_raycast_6 = Module['_emscripten_bind_PxSceneQuerySystemBase_raycast_6'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_raycast_6');
var _emscripten_bind_PxSceneQuerySystemBase_sweep_5 = Module['_emscripten_bind_PxSceneQuerySystemBase_sweep_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_sweep_5');
var _emscripten_bind_PxSceneQuerySystemBase_sweep_6 = Module['_emscripten_bind_PxSceneQuerySystemBase_sweep_6'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_sweep_6');
var _emscripten_bind_PxSceneQuerySystemBase_sweep_7 = Module['_emscripten_bind_PxSceneQuerySystemBase_sweep_7'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_sweep_7');
var _emscripten_bind_PxSceneQuerySystemBase_overlap_3 = Module['_emscripten_bind_PxSceneQuerySystemBase_overlap_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_overlap_3');
var _emscripten_bind_PxSceneQuerySystemBase_overlap_4 = Module['_emscripten_bind_PxSceneQuerySystemBase_overlap_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneQuerySystemBase_overlap_4');
var _emscripten_bind_PxSimulationEventCallback___destroy___0 = Module['_emscripten_bind_PxSimulationEventCallback___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationEventCallback___destroy___0');
var _emscripten_bind_PxSimulationFilterShader___destroy___0 = Module['_emscripten_bind_PxSimulationFilterShader___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationFilterShader___destroy___0');
var _emscripten_bind_Support_getMargin_0 = Module['_emscripten_bind_Support_getMargin_0'] = makeInvalidEarlyAccess('_emscripten_bind_Support_getMargin_0');
var _emscripten_bind_Support_supportLocal_1 = Module['_emscripten_bind_Support_supportLocal_1'] = makeInvalidEarlyAccess('_emscripten_bind_Support_supportLocal_1');
var _emscripten_bind_Support___destroy___0 = Module['_emscripten_bind_Support___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_Support___destroy___0');
var _emscripten_bind_CustomSupport_getCustomMargin_0 = Module['_emscripten_bind_CustomSupport_getCustomMargin_0'] = makeInvalidEarlyAccess('_emscripten_bind_CustomSupport_getCustomMargin_0');
var _emscripten_bind_CustomSupport_getCustomSupportLocal_2 = Module['_emscripten_bind_CustomSupport_getCustomSupportLocal_2'] = makeInvalidEarlyAccess('_emscripten_bind_CustomSupport_getCustomSupportLocal_2');
var _emscripten_bind_CustomSupport_getMargin_0 = Module['_emscripten_bind_CustomSupport_getMargin_0'] = makeInvalidEarlyAccess('_emscripten_bind_CustomSupport_getMargin_0');
var _emscripten_bind_CustomSupport_supportLocal_1 = Module['_emscripten_bind_CustomSupport_supportLocal_1'] = makeInvalidEarlyAccess('_emscripten_bind_CustomSupport_supportLocal_1');
var _emscripten_bind_CustomSupport___destroy___0 = Module['_emscripten_bind_CustomSupport___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_CustomSupport___destroy___0');
var _emscripten_bind_PassThroughFilterShader_filterShader_10 = Module['_emscripten_bind_PassThroughFilterShader_filterShader_10'] = makeInvalidEarlyAccess('_emscripten_bind_PassThroughFilterShader_filterShader_10');
var _emscripten_bind_PassThroughFilterShader_get_outputPairFlags_0 = Module['_emscripten_bind_PassThroughFilterShader_get_outputPairFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PassThroughFilterShader_get_outputPairFlags_0');
var _emscripten_bind_PassThroughFilterShader_set_outputPairFlags_1 = Module['_emscripten_bind_PassThroughFilterShader_set_outputPairFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PassThroughFilterShader_set_outputPairFlags_1');
var _emscripten_bind_PassThroughFilterShader___destroy___0 = Module['_emscripten_bind_PassThroughFilterShader___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PassThroughFilterShader___destroy___0');
var _emscripten_bind_PhysXActorVehicle_initialize_3 = Module['_emscripten_bind_PhysXActorVehicle_initialize_3'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_initialize_3');
var _emscripten_bind_PhysXActorVehicle_destroyState_0 = Module['_emscripten_bind_PhysXActorVehicle_destroyState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_destroyState_0');
var _emscripten_bind_PhysXActorVehicle_initComponentSequence_1 = Module['_emscripten_bind_PhysXActorVehicle_initComponentSequence_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_initComponentSequence_1');
var _emscripten_bind_PhysXActorVehicle_step_2 = Module['_emscripten_bind_PhysXActorVehicle_step_2'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_step_2');
var _emscripten_bind_PhysXActorVehicle_get_physXParams_0 = Module['_emscripten_bind_PhysXActorVehicle_get_physXParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_get_physXParams_0');
var _emscripten_bind_PhysXActorVehicle_set_physXParams_1 = Module['_emscripten_bind_PhysXActorVehicle_set_physXParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_set_physXParams_1');
var _emscripten_bind_PhysXActorVehicle_get_physXState_0 = Module['_emscripten_bind_PhysXActorVehicle_get_physXState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_get_physXState_0');
var _emscripten_bind_PhysXActorVehicle_set_physXState_1 = Module['_emscripten_bind_PhysXActorVehicle_set_physXState_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_set_physXState_1');
var _emscripten_bind_PhysXActorVehicle_get_commandState_0 = Module['_emscripten_bind_PhysXActorVehicle_get_commandState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_get_commandState_0');
var _emscripten_bind_PhysXActorVehicle_set_commandState_1 = Module['_emscripten_bind_PhysXActorVehicle_set_commandState_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_set_commandState_1');
var _emscripten_bind_PhysXActorVehicle_get_baseParams_0 = Module['_emscripten_bind_PhysXActorVehicle_get_baseParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_get_baseParams_0');
var _emscripten_bind_PhysXActorVehicle_set_baseParams_1 = Module['_emscripten_bind_PhysXActorVehicle_set_baseParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_set_baseParams_1');
var _emscripten_bind_PhysXActorVehicle_get_baseState_0 = Module['_emscripten_bind_PhysXActorVehicle_get_baseState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_get_baseState_0');
var _emscripten_bind_PhysXActorVehicle_set_baseState_1 = Module['_emscripten_bind_PhysXActorVehicle_set_baseState_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_set_baseState_1');
var _emscripten_bind_PhysXActorVehicle_get_componentSequence_0 = Module['_emscripten_bind_PhysXActorVehicle_get_componentSequence_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_get_componentSequence_0');
var _emscripten_bind_PhysXActorVehicle_set_componentSequence_1 = Module['_emscripten_bind_PhysXActorVehicle_set_componentSequence_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_set_componentSequence_1');
var _emscripten_bind_PhysXActorVehicle_get_componentSequenceSubstepGroupHandle_0 = Module['_emscripten_bind_PhysXActorVehicle_get_componentSequenceSubstepGroupHandle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_get_componentSequenceSubstepGroupHandle_0');
var _emscripten_bind_PhysXActorVehicle_set_componentSequenceSubstepGroupHandle_1 = Module['_emscripten_bind_PhysXActorVehicle_set_componentSequenceSubstepGroupHandle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle_set_componentSequenceSubstepGroupHandle_1');
var _emscripten_bind_PhysXActorVehicle___destroy___0 = Module['_emscripten_bind_PhysXActorVehicle___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXActorVehicle___destroy___0');
var _emscripten_bind_PxArticulationTendon_setStiffness_1 = Module['_emscripten_bind_PxArticulationTendon_setStiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_setStiffness_1');
var _emscripten_bind_PxArticulationTendon_getStiffness_0 = Module['_emscripten_bind_PxArticulationTendon_getStiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_getStiffness_0');
var _emscripten_bind_PxArticulationTendon_setDamping_1 = Module['_emscripten_bind_PxArticulationTendon_setDamping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_setDamping_1');
var _emscripten_bind_PxArticulationTendon_getDamping_0 = Module['_emscripten_bind_PxArticulationTendon_getDamping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_getDamping_0');
var _emscripten_bind_PxArticulationTendon_setLimitStiffness_1 = Module['_emscripten_bind_PxArticulationTendon_setLimitStiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_setLimitStiffness_1');
var _emscripten_bind_PxArticulationTendon_getLimitStiffness_0 = Module['_emscripten_bind_PxArticulationTendon_getLimitStiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_getLimitStiffness_0');
var _emscripten_bind_PxArticulationTendon_setOffset_1 = Module['_emscripten_bind_PxArticulationTendon_setOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_setOffset_1');
var _emscripten_bind_PxArticulationTendon_setOffset_2 = Module['_emscripten_bind_PxArticulationTendon_setOffset_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_setOffset_2');
var _emscripten_bind_PxArticulationTendon_getOffset_0 = Module['_emscripten_bind_PxArticulationTendon_getOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_getOffset_0');
var _emscripten_bind_PxArticulationTendon_getArticulation_0 = Module['_emscripten_bind_PxArticulationTendon_getArticulation_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_getArticulation_0');
var _emscripten_bind_PxArticulationTendon_release_0 = Module['_emscripten_bind_PxArticulationTendon_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_release_0');
var _emscripten_bind_PxArticulationTendon_getConcreteTypeName_0 = Module['_emscripten_bind_PxArticulationTendon_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_getConcreteTypeName_0');
var _emscripten_bind_PxArticulationTendon_getConcreteType_0 = Module['_emscripten_bind_PxArticulationTendon_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_getConcreteType_0');
var _emscripten_bind_PxArticulationTendon_setBaseFlag_2 = Module['_emscripten_bind_PxArticulationTendon_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_setBaseFlag_2');
var _emscripten_bind_PxArticulationTendon_setBaseFlags_1 = Module['_emscripten_bind_PxArticulationTendon_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_setBaseFlags_1');
var _emscripten_bind_PxArticulationTendon_getBaseFlags_0 = Module['_emscripten_bind_PxArticulationTendon_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_getBaseFlags_0');
var _emscripten_bind_PxArticulationTendon_isReleasable_0 = Module['_emscripten_bind_PxArticulationTendon_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon_isReleasable_0');
var _emscripten_bind_PxArticulationTendon___destroy___0 = Module['_emscripten_bind_PxArticulationTendon___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendon___destroy___0');
var _emscripten_bind_PxBaseMaterial_release_0 = Module['_emscripten_bind_PxBaseMaterial_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseMaterial_release_0');
var _emscripten_bind_PxBaseMaterial_getConcreteTypeName_0 = Module['_emscripten_bind_PxBaseMaterial_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseMaterial_getConcreteTypeName_0');
var _emscripten_bind_PxBaseMaterial_getConcreteType_0 = Module['_emscripten_bind_PxBaseMaterial_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseMaterial_getConcreteType_0');
var _emscripten_bind_PxBaseMaterial_setBaseFlag_2 = Module['_emscripten_bind_PxBaseMaterial_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseMaterial_setBaseFlag_2');
var _emscripten_bind_PxBaseMaterial_setBaseFlags_1 = Module['_emscripten_bind_PxBaseMaterial_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseMaterial_setBaseFlags_1');
var _emscripten_bind_PxBaseMaterial_getBaseFlags_0 = Module['_emscripten_bind_PxBaseMaterial_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseMaterial_getBaseFlags_0');
var _emscripten_bind_PxBaseMaterial_isReleasable_0 = Module['_emscripten_bind_PxBaseMaterial_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseMaterial_isReleasable_0');
var _emscripten_bind_PxBaseMaterial_getReferenceCount_0 = Module['_emscripten_bind_PxBaseMaterial_getReferenceCount_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseMaterial_getReferenceCount_0');
var _emscripten_bind_PxBaseMaterial_acquireReference_0 = Module['_emscripten_bind_PxBaseMaterial_acquireReference_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseMaterial_acquireReference_0');
var _emscripten_bind_PxBaseMaterial___destroy___0 = Module['_emscripten_bind_PxBaseMaterial___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseMaterial___destroy___0');
var _emscripten_bind_PxConstraintConnector_prepareData_0 = Module['_emscripten_bind_PxConstraintConnector_prepareData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintConnector_prepareData_0');
var _emscripten_bind_PxConstraintConnector_updateOmniPvdProperties_0 = Module['_emscripten_bind_PxConstraintConnector_updateOmniPvdProperties_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintConnector_updateOmniPvdProperties_0');
var _emscripten_bind_PxConstraintConnector_onConstraintRelease_0 = Module['_emscripten_bind_PxConstraintConnector_onConstraintRelease_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintConnector_onConstraintRelease_0');
var _emscripten_bind_PxConstraintConnector_onComShift_1 = Module['_emscripten_bind_PxConstraintConnector_onComShift_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintConnector_onComShift_1');
var _emscripten_bind_PxConstraintConnector_onOriginShift_1 = Module['_emscripten_bind_PxConstraintConnector_onOriginShift_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintConnector_onOriginShift_1');
var _emscripten_bind_PxConstraintConnector_getSerializable_0 = Module['_emscripten_bind_PxConstraintConnector_getSerializable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintConnector_getSerializable_0');
var _emscripten_bind_PxConstraintConnector_getPrep_0 = Module['_emscripten_bind_PxConstraintConnector_getPrep_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintConnector_getPrep_0');
var _emscripten_bind_PxConstraintConnector_getConstantBlock_0 = Module['_emscripten_bind_PxConstraintConnector_getConstantBlock_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintConnector_getConstantBlock_0');
var _emscripten_bind_PxConstraintConnector_connectToConstraint_1 = Module['_emscripten_bind_PxConstraintConnector_connectToConstraint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintConnector_connectToConstraint_1');
var _emscripten_bind_PxConstraintConnector___destroy___0 = Module['_emscripten_bind_PxConstraintConnector___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintConnector___destroy___0');
var _emscripten_bind_PxController_getType_0 = Module['_emscripten_bind_PxController_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_getType_0');
var _emscripten_bind_PxController_release_0 = Module['_emscripten_bind_PxController_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_release_0');
var _emscripten_bind_PxController_move_4 = Module['_emscripten_bind_PxController_move_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_move_4');
var _emscripten_bind_PxController_move_5 = Module['_emscripten_bind_PxController_move_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_move_5');
var _emscripten_bind_PxController_setPosition_1 = Module['_emscripten_bind_PxController_setPosition_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_setPosition_1');
var _emscripten_bind_PxController_getPosition_0 = Module['_emscripten_bind_PxController_getPosition_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_getPosition_0');
var _emscripten_bind_PxController_setFootPosition_1 = Module['_emscripten_bind_PxController_setFootPosition_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_setFootPosition_1');
var _emscripten_bind_PxController_getFootPosition_0 = Module['_emscripten_bind_PxController_getFootPosition_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_getFootPosition_0');
var _emscripten_bind_PxController_getActor_0 = Module['_emscripten_bind_PxController_getActor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_getActor_0');
var _emscripten_bind_PxController_setStepOffset_1 = Module['_emscripten_bind_PxController_setStepOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_setStepOffset_1');
var _emscripten_bind_PxController_getStepOffset_0 = Module['_emscripten_bind_PxController_getStepOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_getStepOffset_0');
var _emscripten_bind_PxController_setNonWalkableMode_1 = Module['_emscripten_bind_PxController_setNonWalkableMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_setNonWalkableMode_1');
var _emscripten_bind_PxController_getNonWalkableMode_0 = Module['_emscripten_bind_PxController_getNonWalkableMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_getNonWalkableMode_0');
var _emscripten_bind_PxController_getContactOffset_0 = Module['_emscripten_bind_PxController_getContactOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_getContactOffset_0');
var _emscripten_bind_PxController_setContactOffset_1 = Module['_emscripten_bind_PxController_setContactOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_setContactOffset_1');
var _emscripten_bind_PxController_getUpDirection_0 = Module['_emscripten_bind_PxController_getUpDirection_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_getUpDirection_0');
var _emscripten_bind_PxController_setUpDirection_1 = Module['_emscripten_bind_PxController_setUpDirection_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_setUpDirection_1');
var _emscripten_bind_PxController_getSlopeLimit_0 = Module['_emscripten_bind_PxController_getSlopeLimit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_getSlopeLimit_0');
var _emscripten_bind_PxController_setSlopeLimit_1 = Module['_emscripten_bind_PxController_setSlopeLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_setSlopeLimit_1');
var _emscripten_bind_PxController_invalidateCache_0 = Module['_emscripten_bind_PxController_invalidateCache_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_invalidateCache_0');
var _emscripten_bind_PxController_getScene_0 = Module['_emscripten_bind_PxController_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_getScene_0');
var _emscripten_bind_PxController_getUserData_0 = Module['_emscripten_bind_PxController_getUserData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_getUserData_0');
var _emscripten_bind_PxController_setUserData_1 = Module['_emscripten_bind_PxController_setUserData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_setUserData_1');
var _emscripten_bind_PxController_getState_1 = Module['_emscripten_bind_PxController_getState_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_getState_1');
var _emscripten_bind_PxController_getStats_1 = Module['_emscripten_bind_PxController_getStats_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_getStats_1');
var _emscripten_bind_PxController_resize_1 = Module['_emscripten_bind_PxController_resize_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxController_resize_1');
var _emscripten_bind_PxControllerDesc_isValid_0 = Module['_emscripten_bind_PxControllerDesc_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_isValid_0');
var _emscripten_bind_PxControllerDesc_getType_0 = Module['_emscripten_bind_PxControllerDesc_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_getType_0');
var _emscripten_bind_PxControllerDesc_get_position_0 = Module['_emscripten_bind_PxControllerDesc_get_position_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_position_0');
var _emscripten_bind_PxControllerDesc_set_position_1 = Module['_emscripten_bind_PxControllerDesc_set_position_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_position_1');
var _emscripten_bind_PxControllerDesc_get_upDirection_0 = Module['_emscripten_bind_PxControllerDesc_get_upDirection_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_upDirection_0');
var _emscripten_bind_PxControllerDesc_set_upDirection_1 = Module['_emscripten_bind_PxControllerDesc_set_upDirection_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_upDirection_1');
var _emscripten_bind_PxControllerDesc_get_slopeLimit_0 = Module['_emscripten_bind_PxControllerDesc_get_slopeLimit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_slopeLimit_0');
var _emscripten_bind_PxControllerDesc_set_slopeLimit_1 = Module['_emscripten_bind_PxControllerDesc_set_slopeLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_slopeLimit_1');
var _emscripten_bind_PxControllerDesc_get_invisibleWallHeight_0 = Module['_emscripten_bind_PxControllerDesc_get_invisibleWallHeight_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_invisibleWallHeight_0');
var _emscripten_bind_PxControllerDesc_set_invisibleWallHeight_1 = Module['_emscripten_bind_PxControllerDesc_set_invisibleWallHeight_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_invisibleWallHeight_1');
var _emscripten_bind_PxControllerDesc_get_maxJumpHeight_0 = Module['_emscripten_bind_PxControllerDesc_get_maxJumpHeight_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_maxJumpHeight_0');
var _emscripten_bind_PxControllerDesc_set_maxJumpHeight_1 = Module['_emscripten_bind_PxControllerDesc_set_maxJumpHeight_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_maxJumpHeight_1');
var _emscripten_bind_PxControllerDesc_get_contactOffset_0 = Module['_emscripten_bind_PxControllerDesc_get_contactOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_contactOffset_0');
var _emscripten_bind_PxControllerDesc_set_contactOffset_1 = Module['_emscripten_bind_PxControllerDesc_set_contactOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_contactOffset_1');
var _emscripten_bind_PxControllerDesc_get_stepOffset_0 = Module['_emscripten_bind_PxControllerDesc_get_stepOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_stepOffset_0');
var _emscripten_bind_PxControllerDesc_set_stepOffset_1 = Module['_emscripten_bind_PxControllerDesc_set_stepOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_stepOffset_1');
var _emscripten_bind_PxControllerDesc_get_density_0 = Module['_emscripten_bind_PxControllerDesc_get_density_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_density_0');
var _emscripten_bind_PxControllerDesc_set_density_1 = Module['_emscripten_bind_PxControllerDesc_set_density_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_density_1');
var _emscripten_bind_PxControllerDesc_get_scaleCoeff_0 = Module['_emscripten_bind_PxControllerDesc_get_scaleCoeff_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_scaleCoeff_0');
var _emscripten_bind_PxControllerDesc_set_scaleCoeff_1 = Module['_emscripten_bind_PxControllerDesc_set_scaleCoeff_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_scaleCoeff_1');
var _emscripten_bind_PxControllerDesc_get_volumeGrowth_0 = Module['_emscripten_bind_PxControllerDesc_get_volumeGrowth_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_volumeGrowth_0');
var _emscripten_bind_PxControllerDesc_set_volumeGrowth_1 = Module['_emscripten_bind_PxControllerDesc_set_volumeGrowth_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_volumeGrowth_1');
var _emscripten_bind_PxControllerDesc_get_reportCallback_0 = Module['_emscripten_bind_PxControllerDesc_get_reportCallback_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_reportCallback_0');
var _emscripten_bind_PxControllerDesc_set_reportCallback_1 = Module['_emscripten_bind_PxControllerDesc_set_reportCallback_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_reportCallback_1');
var _emscripten_bind_PxControllerDesc_get_behaviorCallback_0 = Module['_emscripten_bind_PxControllerDesc_get_behaviorCallback_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_behaviorCallback_0');
var _emscripten_bind_PxControllerDesc_set_behaviorCallback_1 = Module['_emscripten_bind_PxControllerDesc_set_behaviorCallback_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_behaviorCallback_1');
var _emscripten_bind_PxControllerDesc_get_nonWalkableMode_0 = Module['_emscripten_bind_PxControllerDesc_get_nonWalkableMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_nonWalkableMode_0');
var _emscripten_bind_PxControllerDesc_set_nonWalkableMode_1 = Module['_emscripten_bind_PxControllerDesc_set_nonWalkableMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_nonWalkableMode_1');
var _emscripten_bind_PxControllerDesc_get_material_0 = Module['_emscripten_bind_PxControllerDesc_get_material_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_material_0');
var _emscripten_bind_PxControllerDesc_set_material_1 = Module['_emscripten_bind_PxControllerDesc_set_material_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_material_1');
var _emscripten_bind_PxControllerDesc_get_registerDeletionListener_0 = Module['_emscripten_bind_PxControllerDesc_get_registerDeletionListener_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_registerDeletionListener_0');
var _emscripten_bind_PxControllerDesc_set_registerDeletionListener_1 = Module['_emscripten_bind_PxControllerDesc_set_registerDeletionListener_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_registerDeletionListener_1');
var _emscripten_bind_PxControllerDesc_get_userData_0 = Module['_emscripten_bind_PxControllerDesc_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_get_userData_0');
var _emscripten_bind_PxControllerDesc_set_userData_1 = Module['_emscripten_bind_PxControllerDesc_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerDesc_set_userData_1');
var _emscripten_bind_PxControllerFilterCallback_filter_2 = Module['_emscripten_bind_PxControllerFilterCallback_filter_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilterCallback_filter_2');
var _emscripten_bind_PxControllerFilterCallback___destroy___0 = Module['_emscripten_bind_PxControllerFilterCallback___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilterCallback___destroy___0');
var _emscripten_bind_PxControllerHit_get_controller_0 = Module['_emscripten_bind_PxControllerHit_get_controller_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerHit_get_controller_0');
var _emscripten_bind_PxControllerHit_set_controller_1 = Module['_emscripten_bind_PxControllerHit_set_controller_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerHit_set_controller_1');
var _emscripten_bind_PxControllerHit_get_worldPos_0 = Module['_emscripten_bind_PxControllerHit_get_worldPos_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerHit_get_worldPos_0');
var _emscripten_bind_PxControllerHit_set_worldPos_1 = Module['_emscripten_bind_PxControllerHit_set_worldPos_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerHit_set_worldPos_1');
var _emscripten_bind_PxControllerHit_get_worldNormal_0 = Module['_emscripten_bind_PxControllerHit_get_worldNormal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerHit_get_worldNormal_0');
var _emscripten_bind_PxControllerHit_set_worldNormal_1 = Module['_emscripten_bind_PxControllerHit_set_worldNormal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerHit_set_worldNormal_1');
var _emscripten_bind_PxControllerHit_get_dir_0 = Module['_emscripten_bind_PxControllerHit_get_dir_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerHit_get_dir_0');
var _emscripten_bind_PxControllerHit_set_dir_1 = Module['_emscripten_bind_PxControllerHit_set_dir_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerHit_set_dir_1');
var _emscripten_bind_PxControllerHit_get_length_0 = Module['_emscripten_bind_PxControllerHit_get_length_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerHit_get_length_0');
var _emscripten_bind_PxControllerHit_set_length_1 = Module['_emscripten_bind_PxControllerHit_set_length_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerHit_set_length_1');
var _emscripten_bind_PxControllerHit___destroy___0 = Module['_emscripten_bind_PxControllerHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerHit___destroy___0');
var _emscripten_bind_PxCpuDispatcher___destroy___0 = Module['_emscripten_bind_PxCpuDispatcher___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCpuDispatcher___destroy___0');
var _emscripten_bind_PxErrorCallback_reportError_4 = Module['_emscripten_bind_PxErrorCallback_reportError_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxErrorCallback_reportError_4');
var _emscripten_bind_PxErrorCallback___destroy___0 = Module['_emscripten_bind_PxErrorCallback___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxErrorCallback___destroy___0');
var _emscripten_bind_PxGeomRaycastHit_hadInitialOverlap_0 = Module['_emscripten_bind_PxGeomRaycastHit_hadInitialOverlap_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_hadInitialOverlap_0');
var _emscripten_bind_PxGeomRaycastHit_get_u_0 = Module['_emscripten_bind_PxGeomRaycastHit_get_u_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_get_u_0');
var _emscripten_bind_PxGeomRaycastHit_set_u_1 = Module['_emscripten_bind_PxGeomRaycastHit_set_u_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_set_u_1');
var _emscripten_bind_PxGeomRaycastHit_get_v_0 = Module['_emscripten_bind_PxGeomRaycastHit_get_v_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_get_v_0');
var _emscripten_bind_PxGeomRaycastHit_set_v_1 = Module['_emscripten_bind_PxGeomRaycastHit_set_v_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_set_v_1');
var _emscripten_bind_PxGeomRaycastHit_get_flags_0 = Module['_emscripten_bind_PxGeomRaycastHit_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_get_flags_0');
var _emscripten_bind_PxGeomRaycastHit_set_flags_1 = Module['_emscripten_bind_PxGeomRaycastHit_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_set_flags_1');
var _emscripten_bind_PxGeomRaycastHit_get_position_0 = Module['_emscripten_bind_PxGeomRaycastHit_get_position_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_get_position_0');
var _emscripten_bind_PxGeomRaycastHit_set_position_1 = Module['_emscripten_bind_PxGeomRaycastHit_set_position_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_set_position_1');
var _emscripten_bind_PxGeomRaycastHit_get_normal_0 = Module['_emscripten_bind_PxGeomRaycastHit_get_normal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_get_normal_0');
var _emscripten_bind_PxGeomRaycastHit_set_normal_1 = Module['_emscripten_bind_PxGeomRaycastHit_set_normal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_set_normal_1');
var _emscripten_bind_PxGeomRaycastHit_get_distance_0 = Module['_emscripten_bind_PxGeomRaycastHit_get_distance_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_get_distance_0');
var _emscripten_bind_PxGeomRaycastHit_set_distance_1 = Module['_emscripten_bind_PxGeomRaycastHit_set_distance_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_set_distance_1');
var _emscripten_bind_PxGeomRaycastHit_get_faceIndex_0 = Module['_emscripten_bind_PxGeomRaycastHit_get_faceIndex_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_get_faceIndex_0');
var _emscripten_bind_PxGeomRaycastHit_set_faceIndex_1 = Module['_emscripten_bind_PxGeomRaycastHit_set_faceIndex_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit_set_faceIndex_1');
var _emscripten_bind_PxGeomRaycastHit___destroy___0 = Module['_emscripten_bind_PxGeomRaycastHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomRaycastHit___destroy___0');
var _emscripten_bind_PxGeomSweepHit_hadInitialOverlap_0 = Module['_emscripten_bind_PxGeomSweepHit_hadInitialOverlap_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomSweepHit_hadInitialOverlap_0');
var _emscripten_bind_PxGeomSweepHit_get_flags_0 = Module['_emscripten_bind_PxGeomSweepHit_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomSweepHit_get_flags_0');
var _emscripten_bind_PxGeomSweepHit_set_flags_1 = Module['_emscripten_bind_PxGeomSweepHit_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomSweepHit_set_flags_1');
var _emscripten_bind_PxGeomSweepHit_get_position_0 = Module['_emscripten_bind_PxGeomSweepHit_get_position_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomSweepHit_get_position_0');
var _emscripten_bind_PxGeomSweepHit_set_position_1 = Module['_emscripten_bind_PxGeomSweepHit_set_position_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomSweepHit_set_position_1');
var _emscripten_bind_PxGeomSweepHit_get_normal_0 = Module['_emscripten_bind_PxGeomSweepHit_get_normal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomSweepHit_get_normal_0');
var _emscripten_bind_PxGeomSweepHit_set_normal_1 = Module['_emscripten_bind_PxGeomSweepHit_set_normal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomSweepHit_set_normal_1');
var _emscripten_bind_PxGeomSweepHit_get_distance_0 = Module['_emscripten_bind_PxGeomSweepHit_get_distance_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomSweepHit_get_distance_0');
var _emscripten_bind_PxGeomSweepHit_set_distance_1 = Module['_emscripten_bind_PxGeomSweepHit_set_distance_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomSweepHit_set_distance_1');
var _emscripten_bind_PxGeomSweepHit_get_faceIndex_0 = Module['_emscripten_bind_PxGeomSweepHit_get_faceIndex_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomSweepHit_get_faceIndex_0');
var _emscripten_bind_PxGeomSweepHit_set_faceIndex_1 = Module['_emscripten_bind_PxGeomSweepHit_set_faceIndex_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomSweepHit_set_faceIndex_1');
var _emscripten_bind_PxGeomSweepHit___destroy___0 = Module['_emscripten_bind_PxGeomSweepHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeomSweepHit___destroy___0');
var _emscripten_bind_PxGeometry_getType_0 = Module['_emscripten_bind_PxGeometry_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometry_getType_0');
var _emscripten_bind_PxGeometry___destroy___0 = Module['_emscripten_bind_PxGeometry___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometry___destroy___0');
var _emscripten_bind_PxI32ConstPtr___destroy___0 = Module['_emscripten_bind_PxI32ConstPtr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxI32ConstPtr___destroy___0');
var _emscripten_bind_PxInputData___destroy___0 = Module['_emscripten_bind_PxInputData___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxInputData___destroy___0');
var _emscripten_bind_PxJoint_setActors_2 = Module['_emscripten_bind_PxJoint_setActors_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_setActors_2');
var _emscripten_bind_PxJoint_setLocalPose_2 = Module['_emscripten_bind_PxJoint_setLocalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_setLocalPose_2');
var _emscripten_bind_PxJoint_getLocalPose_1 = Module['_emscripten_bind_PxJoint_getLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getLocalPose_1');
var _emscripten_bind_PxJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxJoint_getRelativeTransform_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getRelativeTransform_0');
var _emscripten_bind_PxJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxJoint_getRelativeLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getRelativeLinearVelocity_0');
var _emscripten_bind_PxJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxJoint_getRelativeAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getRelativeAngularVelocity_0');
var _emscripten_bind_PxJoint_setBreakForce_2 = Module['_emscripten_bind_PxJoint_setBreakForce_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_setBreakForce_2');
var _emscripten_bind_PxJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxJoint_setConstraintFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_setConstraintFlags_1');
var _emscripten_bind_PxJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxJoint_setConstraintFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_setConstraintFlag_2');
var _emscripten_bind_PxJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxJoint_getConstraintFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getConstraintFlags_0');
var _emscripten_bind_PxJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxJoint_setInvMassScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_setInvMassScale0_1');
var _emscripten_bind_PxJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxJoint_getInvMassScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getInvMassScale0_0');
var _emscripten_bind_PxJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxJoint_setInvMassScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_setInvMassScale1_1');
var _emscripten_bind_PxJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxJoint_getInvMassScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getInvMassScale1_0');
var _emscripten_bind_PxJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxJoint_setInvInertiaScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_setInvInertiaScale0_1');
var _emscripten_bind_PxJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxJoint_getInvInertiaScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getInvInertiaScale0_0');
var _emscripten_bind_PxJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxJoint_setInvInertiaScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_setInvInertiaScale1_1');
var _emscripten_bind_PxJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxJoint_getInvInertiaScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getInvInertiaScale1_0');
var _emscripten_bind_PxJoint_getConstraint_0 = Module['_emscripten_bind_PxJoint_getConstraint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getConstraint_0');
var _emscripten_bind_PxJoint_setName_1 = Module['_emscripten_bind_PxJoint_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_setName_1');
var _emscripten_bind_PxJoint_getName_0 = Module['_emscripten_bind_PxJoint_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getName_0');
var _emscripten_bind_PxJoint_getScene_0 = Module['_emscripten_bind_PxJoint_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getScene_0');
var _emscripten_bind_PxJoint_release_0 = Module['_emscripten_bind_PxJoint_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_release_0');
var _emscripten_bind_PxJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxJoint_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getConcreteTypeName_0');
var _emscripten_bind_PxJoint_getConcreteType_0 = Module['_emscripten_bind_PxJoint_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getConcreteType_0');
var _emscripten_bind_PxJoint_setBaseFlag_2 = Module['_emscripten_bind_PxJoint_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_setBaseFlag_2');
var _emscripten_bind_PxJoint_setBaseFlags_1 = Module['_emscripten_bind_PxJoint_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_setBaseFlags_1');
var _emscripten_bind_PxJoint_getBaseFlags_0 = Module['_emscripten_bind_PxJoint_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_getBaseFlags_0');
var _emscripten_bind_PxJoint_isReleasable_0 = Module['_emscripten_bind_PxJoint_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_isReleasable_0');
var _emscripten_bind_PxJoint_get_userData_0 = Module['_emscripten_bind_PxJoint_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_get_userData_0');
var _emscripten_bind_PxJoint_set_userData_1 = Module['_emscripten_bind_PxJoint_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJoint_set_userData_1');
var _emscripten_bind_PxJointLimitParameters_isValid_0 = Module['_emscripten_bind_PxJointLimitParameters_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitParameters_isValid_0');
var _emscripten_bind_PxJointLimitParameters_isSoft_0 = Module['_emscripten_bind_PxJointLimitParameters_isSoft_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitParameters_isSoft_0');
var _emscripten_bind_PxJointLimitParameters_get_restitution_0 = Module['_emscripten_bind_PxJointLimitParameters_get_restitution_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitParameters_get_restitution_0');
var _emscripten_bind_PxJointLimitParameters_set_restitution_1 = Module['_emscripten_bind_PxJointLimitParameters_set_restitution_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitParameters_set_restitution_1');
var _emscripten_bind_PxJointLimitParameters_get_bounceThreshold_0 = Module['_emscripten_bind_PxJointLimitParameters_get_bounceThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitParameters_get_bounceThreshold_0');
var _emscripten_bind_PxJointLimitParameters_set_bounceThreshold_1 = Module['_emscripten_bind_PxJointLimitParameters_set_bounceThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitParameters_set_bounceThreshold_1');
var _emscripten_bind_PxJointLimitParameters_get_stiffness_0 = Module['_emscripten_bind_PxJointLimitParameters_get_stiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitParameters_get_stiffness_0');
var _emscripten_bind_PxJointLimitParameters_set_stiffness_1 = Module['_emscripten_bind_PxJointLimitParameters_set_stiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitParameters_set_stiffness_1');
var _emscripten_bind_PxJointLimitParameters_get_damping_0 = Module['_emscripten_bind_PxJointLimitParameters_get_damping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitParameters_get_damping_0');
var _emscripten_bind_PxJointLimitParameters_set_damping_1 = Module['_emscripten_bind_PxJointLimitParameters_set_damping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitParameters_set_damping_1');
var _emscripten_bind_PxObstacle_getType_0 = Module['_emscripten_bind_PxObstacle_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacle_getType_0');
var _emscripten_bind_PxObstacle_get_mUserData_0 = Module['_emscripten_bind_PxObstacle_get_mUserData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacle_get_mUserData_0');
var _emscripten_bind_PxObstacle_set_mUserData_1 = Module['_emscripten_bind_PxObstacle_set_mUserData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacle_set_mUserData_1');
var _emscripten_bind_PxObstacle_get_mPos_0 = Module['_emscripten_bind_PxObstacle_get_mPos_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacle_get_mPos_0');
var _emscripten_bind_PxObstacle_set_mPos_1 = Module['_emscripten_bind_PxObstacle_set_mPos_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacle_set_mPos_1');
var _emscripten_bind_PxObstacle_get_mRot_0 = Module['_emscripten_bind_PxObstacle_get_mRot_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacle_get_mRot_0');
var _emscripten_bind_PxObstacle_set_mRot_1 = Module['_emscripten_bind_PxObstacle_set_mRot_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacle_set_mRot_1');
var _emscripten_bind_PxObstacle___destroy___0 = Module['_emscripten_bind_PxObstacle___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacle___destroy___0');
var _emscripten_bind_PxOutputStream___destroy___0 = Module['_emscripten_bind_PxOutputStream___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOutputStream___destroy___0');
var _emscripten_bind_PxOverlapCallback_hasAnyHits_0 = Module['_emscripten_bind_PxOverlapCallback_hasAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapCallback_hasAnyHits_0');
var _emscripten_bind_PxOverlapCallback___destroy___0 = Module['_emscripten_bind_PxOverlapCallback___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapCallback___destroy___0');
var _emscripten_bind_PxRaycastCallback_hasAnyHits_0 = Module['_emscripten_bind_PxRaycastCallback_hasAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastCallback_hasAnyHits_0');
var _emscripten_bind_PxRaycastCallback___destroy___0 = Module['_emscripten_bind_PxRaycastCallback___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastCallback___destroy___0');
var _emscripten_bind_PxRealConstPtr___destroy___0 = Module['_emscripten_bind_PxRealConstPtr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRealConstPtr___destroy___0');
var _emscripten_bind_PxRigidBody_setCMassLocalPose_1 = Module['_emscripten_bind_PxRigidBody_setCMassLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setCMassLocalPose_1');
var _emscripten_bind_PxRigidBody_getCMassLocalPose_0 = Module['_emscripten_bind_PxRigidBody_getCMassLocalPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getCMassLocalPose_0');
var _emscripten_bind_PxRigidBody_setMass_1 = Module['_emscripten_bind_PxRigidBody_setMass_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setMass_1');
var _emscripten_bind_PxRigidBody_getMass_0 = Module['_emscripten_bind_PxRigidBody_getMass_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getMass_0');
var _emscripten_bind_PxRigidBody_getInvMass_0 = Module['_emscripten_bind_PxRigidBody_getInvMass_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getInvMass_0');
var _emscripten_bind_PxRigidBody_setMassSpaceInertiaTensor_1 = Module['_emscripten_bind_PxRigidBody_setMassSpaceInertiaTensor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setMassSpaceInertiaTensor_1');
var _emscripten_bind_PxRigidBody_getMassSpaceInertiaTensor_0 = Module['_emscripten_bind_PxRigidBody_getMassSpaceInertiaTensor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getMassSpaceInertiaTensor_0');
var _emscripten_bind_PxRigidBody_getMassSpaceInvInertiaTensor_0 = Module['_emscripten_bind_PxRigidBody_getMassSpaceInvInertiaTensor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getMassSpaceInvInertiaTensor_0');
var _emscripten_bind_PxRigidBody_setLinearDamping_1 = Module['_emscripten_bind_PxRigidBody_setLinearDamping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setLinearDamping_1');
var _emscripten_bind_PxRigidBody_getLinearDamping_0 = Module['_emscripten_bind_PxRigidBody_getLinearDamping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getLinearDamping_0');
var _emscripten_bind_PxRigidBody_setAngularDamping_1 = Module['_emscripten_bind_PxRigidBody_setAngularDamping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setAngularDamping_1');
var _emscripten_bind_PxRigidBody_getAngularDamping_0 = Module['_emscripten_bind_PxRigidBody_getAngularDamping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getAngularDamping_0');
var _emscripten_bind_PxRigidBody_getLinearVelocity_0 = Module['_emscripten_bind_PxRigidBody_getLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getLinearVelocity_0');
var _emscripten_bind_PxRigidBody_getAngularVelocity_0 = Module['_emscripten_bind_PxRigidBody_getAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getAngularVelocity_0');
var _emscripten_bind_PxRigidBody_setMaxLinearVelocity_1 = Module['_emscripten_bind_PxRigidBody_setMaxLinearVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setMaxLinearVelocity_1');
var _emscripten_bind_PxRigidBody_getMaxLinearVelocity_0 = Module['_emscripten_bind_PxRigidBody_getMaxLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getMaxLinearVelocity_0');
var _emscripten_bind_PxRigidBody_setMaxAngularVelocity_1 = Module['_emscripten_bind_PxRigidBody_setMaxAngularVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setMaxAngularVelocity_1');
var _emscripten_bind_PxRigidBody_getMaxAngularVelocity_0 = Module['_emscripten_bind_PxRigidBody_getMaxAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getMaxAngularVelocity_0');
var _emscripten_bind_PxRigidBody_addForce_1 = Module['_emscripten_bind_PxRigidBody_addForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_addForce_1');
var _emscripten_bind_PxRigidBody_addForce_2 = Module['_emscripten_bind_PxRigidBody_addForce_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_addForce_2');
var _emscripten_bind_PxRigidBody_addForce_3 = Module['_emscripten_bind_PxRigidBody_addForce_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_addForce_3');
var _emscripten_bind_PxRigidBody_addTorque_1 = Module['_emscripten_bind_PxRigidBody_addTorque_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_addTorque_1');
var _emscripten_bind_PxRigidBody_addTorque_2 = Module['_emscripten_bind_PxRigidBody_addTorque_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_addTorque_2');
var _emscripten_bind_PxRigidBody_addTorque_3 = Module['_emscripten_bind_PxRigidBody_addTorque_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_addTorque_3');
var _emscripten_bind_PxRigidBody_clearForce_1 = Module['_emscripten_bind_PxRigidBody_clearForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_clearForce_1');
var _emscripten_bind_PxRigidBody_clearTorque_1 = Module['_emscripten_bind_PxRigidBody_clearTorque_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_clearTorque_1');
var _emscripten_bind_PxRigidBody_setForceAndTorque_2 = Module['_emscripten_bind_PxRigidBody_setForceAndTorque_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setForceAndTorque_2');
var _emscripten_bind_PxRigidBody_setForceAndTorque_3 = Module['_emscripten_bind_PxRigidBody_setForceAndTorque_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setForceAndTorque_3');
var _emscripten_bind_PxRigidBody_setRigidBodyFlag_2 = Module['_emscripten_bind_PxRigidBody_setRigidBodyFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setRigidBodyFlag_2');
var _emscripten_bind_PxRigidBody_setRigidBodyFlags_1 = Module['_emscripten_bind_PxRigidBody_setRigidBodyFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setRigidBodyFlags_1');
var _emscripten_bind_PxRigidBody_getRigidBodyFlags_0 = Module['_emscripten_bind_PxRigidBody_getRigidBodyFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getRigidBodyFlags_0');
var _emscripten_bind_PxRigidBody_setMinCCDAdvanceCoefficient_1 = Module['_emscripten_bind_PxRigidBody_setMinCCDAdvanceCoefficient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setMinCCDAdvanceCoefficient_1');
var _emscripten_bind_PxRigidBody_getMinCCDAdvanceCoefficient_0 = Module['_emscripten_bind_PxRigidBody_getMinCCDAdvanceCoefficient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getMinCCDAdvanceCoefficient_0');
var _emscripten_bind_PxRigidBody_setMaxDepenetrationVelocity_1 = Module['_emscripten_bind_PxRigidBody_setMaxDepenetrationVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setMaxDepenetrationVelocity_1');
var _emscripten_bind_PxRigidBody_getMaxDepenetrationVelocity_0 = Module['_emscripten_bind_PxRigidBody_getMaxDepenetrationVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getMaxDepenetrationVelocity_0');
var _emscripten_bind_PxRigidBody_setMaxContactImpulse_1 = Module['_emscripten_bind_PxRigidBody_setMaxContactImpulse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setMaxContactImpulse_1');
var _emscripten_bind_PxRigidBody_getMaxContactImpulse_0 = Module['_emscripten_bind_PxRigidBody_getMaxContactImpulse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getMaxContactImpulse_0');
var _emscripten_bind_PxRigidBody_setContactSlopCoefficient_1 = Module['_emscripten_bind_PxRigidBody_setContactSlopCoefficient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setContactSlopCoefficient_1');
var _emscripten_bind_PxRigidBody_getContactSlopCoefficient_0 = Module['_emscripten_bind_PxRigidBody_getContactSlopCoefficient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getContactSlopCoefficient_0');
var _emscripten_bind_PxRigidBody_getType_0 = Module['_emscripten_bind_PxRigidBody_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getType_0');
var _emscripten_bind_PxRigidBody_getScene_0 = Module['_emscripten_bind_PxRigidBody_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getScene_0');
var _emscripten_bind_PxRigidBody_setName_1 = Module['_emscripten_bind_PxRigidBody_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setName_1');
var _emscripten_bind_PxRigidBody_getName_0 = Module['_emscripten_bind_PxRigidBody_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getName_0');
var _emscripten_bind_PxRigidBody_getWorldBounds_0 = Module['_emscripten_bind_PxRigidBody_getWorldBounds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getWorldBounds_0');
var _emscripten_bind_PxRigidBody_getWorldBounds_1 = Module['_emscripten_bind_PxRigidBody_getWorldBounds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getWorldBounds_1');
var _emscripten_bind_PxRigidBody_setActorFlag_2 = Module['_emscripten_bind_PxRigidBody_setActorFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setActorFlag_2');
var _emscripten_bind_PxRigidBody_setActorFlags_1 = Module['_emscripten_bind_PxRigidBody_setActorFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setActorFlags_1');
var _emscripten_bind_PxRigidBody_getActorFlags_0 = Module['_emscripten_bind_PxRigidBody_getActorFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getActorFlags_0');
var _emscripten_bind_PxRigidBody_setDominanceGroup_1 = Module['_emscripten_bind_PxRigidBody_setDominanceGroup_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setDominanceGroup_1');
var _emscripten_bind_PxRigidBody_getDominanceGroup_0 = Module['_emscripten_bind_PxRigidBody_getDominanceGroup_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getDominanceGroup_0');
var _emscripten_bind_PxRigidBody_setOwnerClient_1 = Module['_emscripten_bind_PxRigidBody_setOwnerClient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setOwnerClient_1');
var _emscripten_bind_PxRigidBody_getOwnerClient_0 = Module['_emscripten_bind_PxRigidBody_getOwnerClient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getOwnerClient_0');
var _emscripten_bind_PxRigidBody_release_0 = Module['_emscripten_bind_PxRigidBody_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_release_0');
var _emscripten_bind_PxRigidBody_getConcreteTypeName_0 = Module['_emscripten_bind_PxRigidBody_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getConcreteTypeName_0');
var _emscripten_bind_PxRigidBody_getConcreteType_0 = Module['_emscripten_bind_PxRigidBody_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getConcreteType_0');
var _emscripten_bind_PxRigidBody_setBaseFlag_2 = Module['_emscripten_bind_PxRigidBody_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setBaseFlag_2');
var _emscripten_bind_PxRigidBody_setBaseFlags_1 = Module['_emscripten_bind_PxRigidBody_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setBaseFlags_1');
var _emscripten_bind_PxRigidBody_getBaseFlags_0 = Module['_emscripten_bind_PxRigidBody_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getBaseFlags_0');
var _emscripten_bind_PxRigidBody_isReleasable_0 = Module['_emscripten_bind_PxRigidBody_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_isReleasable_0');
var _emscripten_bind_PxRigidBody_getGlobalPose_0 = Module['_emscripten_bind_PxRigidBody_getGlobalPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getGlobalPose_0');
var _emscripten_bind_PxRigidBody_setGlobalPose_1 = Module['_emscripten_bind_PxRigidBody_setGlobalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setGlobalPose_1');
var _emscripten_bind_PxRigidBody_setGlobalPose_2 = Module['_emscripten_bind_PxRigidBody_setGlobalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_setGlobalPose_2');
var _emscripten_bind_PxRigidBody_attachShape_1 = Module['_emscripten_bind_PxRigidBody_attachShape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_attachShape_1');
var _emscripten_bind_PxRigidBody_detachShape_1 = Module['_emscripten_bind_PxRigidBody_detachShape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_detachShape_1');
var _emscripten_bind_PxRigidBody_detachShape_2 = Module['_emscripten_bind_PxRigidBody_detachShape_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_detachShape_2');
var _emscripten_bind_PxRigidBody_getNbShapes_0 = Module['_emscripten_bind_PxRigidBody_getNbShapes_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getNbShapes_0');
var _emscripten_bind_PxRigidBody_getShapes_3 = Module['_emscripten_bind_PxRigidBody_getShapes_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getShapes_3');
var _emscripten_bind_PxRigidBody_getNbConstraints_0 = Module['_emscripten_bind_PxRigidBody_getNbConstraints_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_getNbConstraints_0');
var _emscripten_bind_PxRigidBody_get_userData_0 = Module['_emscripten_bind_PxRigidBody_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_get_userData_0');
var _emscripten_bind_PxRigidBody_set_userData_1 = Module['_emscripten_bind_PxRigidBody_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBody_set_userData_1');
var _emscripten_bind_PxSceneSQSystem_setSceneQueryUpdateMode_1 = Module['_emscripten_bind_PxSceneSQSystem_setSceneQueryUpdateMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_setSceneQueryUpdateMode_1');
var _emscripten_bind_PxSceneSQSystem_getSceneQueryUpdateMode_0 = Module['_emscripten_bind_PxSceneSQSystem_getSceneQueryUpdateMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_getSceneQueryUpdateMode_0');
var _emscripten_bind_PxSceneSQSystem_getSceneQueryStaticTimestamp_0 = Module['_emscripten_bind_PxSceneSQSystem_getSceneQueryStaticTimestamp_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_getSceneQueryStaticTimestamp_0');
var _emscripten_bind_PxSceneSQSystem_flushQueryUpdates_0 = Module['_emscripten_bind_PxSceneSQSystem_flushQueryUpdates_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_flushQueryUpdates_0');
var _emscripten_bind_PxSceneSQSystem_forceDynamicTreeRebuild_2 = Module['_emscripten_bind_PxSceneSQSystem_forceDynamicTreeRebuild_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_forceDynamicTreeRebuild_2');
var _emscripten_bind_PxSceneSQSystem_getStaticStructure_0 = Module['_emscripten_bind_PxSceneSQSystem_getStaticStructure_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_getStaticStructure_0');
var _emscripten_bind_PxSceneSQSystem_getDynamicStructure_0 = Module['_emscripten_bind_PxSceneSQSystem_getDynamicStructure_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_getDynamicStructure_0');
var _emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_0 = Module['_emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_0');
var _emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_1 = Module['_emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_1');
var _emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_2 = Module['_emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_2');
var _emscripten_bind_PxSceneSQSystem_checkQueries_0 = Module['_emscripten_bind_PxSceneSQSystem_checkQueries_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_checkQueries_0');
var _emscripten_bind_PxSceneSQSystem_checkQueries_1 = Module['_emscripten_bind_PxSceneSQSystem_checkQueries_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_checkQueries_1');
var _emscripten_bind_PxSceneSQSystem_fetchQueries_0 = Module['_emscripten_bind_PxSceneSQSystem_fetchQueries_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_fetchQueries_0');
var _emscripten_bind_PxSceneSQSystem_fetchQueries_1 = Module['_emscripten_bind_PxSceneSQSystem_fetchQueries_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_fetchQueries_1');
var _emscripten_bind_PxSceneSQSystem_setDynamicTreeRebuildRateHint_1 = Module['_emscripten_bind_PxSceneSQSystem_setDynamicTreeRebuildRateHint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_setDynamicTreeRebuildRateHint_1');
var _emscripten_bind_PxSceneSQSystem_getDynamicTreeRebuildRateHint_0 = Module['_emscripten_bind_PxSceneSQSystem_getDynamicTreeRebuildRateHint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_getDynamicTreeRebuildRateHint_0');
var _emscripten_bind_PxSceneSQSystem_forceRebuildDynamicTree_1 = Module['_emscripten_bind_PxSceneSQSystem_forceRebuildDynamicTree_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_forceRebuildDynamicTree_1');
var _emscripten_bind_PxSceneSQSystem_setUpdateMode_1 = Module['_emscripten_bind_PxSceneSQSystem_setUpdateMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_setUpdateMode_1');
var _emscripten_bind_PxSceneSQSystem_getUpdateMode_0 = Module['_emscripten_bind_PxSceneSQSystem_getUpdateMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_getUpdateMode_0');
var _emscripten_bind_PxSceneSQSystem_getStaticTimestamp_0 = Module['_emscripten_bind_PxSceneSQSystem_getStaticTimestamp_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_getStaticTimestamp_0');
var _emscripten_bind_PxSceneSQSystem_flushUpdates_0 = Module['_emscripten_bind_PxSceneSQSystem_flushUpdates_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_flushUpdates_0');
var _emscripten_bind_PxSceneSQSystem_raycast_4 = Module['_emscripten_bind_PxSceneSQSystem_raycast_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_raycast_4');
var _emscripten_bind_PxSceneSQSystem_raycast_5 = Module['_emscripten_bind_PxSceneSQSystem_raycast_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_raycast_5');
var _emscripten_bind_PxSceneSQSystem_raycast_6 = Module['_emscripten_bind_PxSceneSQSystem_raycast_6'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_raycast_6');
var _emscripten_bind_PxSceneSQSystem_sweep_5 = Module['_emscripten_bind_PxSceneSQSystem_sweep_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_sweep_5');
var _emscripten_bind_PxSceneSQSystem_sweep_6 = Module['_emscripten_bind_PxSceneSQSystem_sweep_6'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_sweep_6');
var _emscripten_bind_PxSceneSQSystem_sweep_7 = Module['_emscripten_bind_PxSceneSQSystem_sweep_7'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_sweep_7');
var _emscripten_bind_PxSceneSQSystem_overlap_3 = Module['_emscripten_bind_PxSceneSQSystem_overlap_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_overlap_3');
var _emscripten_bind_PxSceneSQSystem_overlap_4 = Module['_emscripten_bind_PxSceneSQSystem_overlap_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneSQSystem_overlap_4');
var _emscripten_bind_PxSimpleTriangleMesh_PxSimpleTriangleMesh_0 = Module['_emscripten_bind_PxSimpleTriangleMesh_PxSimpleTriangleMesh_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimpleTriangleMesh_PxSimpleTriangleMesh_0');
var _emscripten_bind_PxSimpleTriangleMesh_setToDefault_0 = Module['_emscripten_bind_PxSimpleTriangleMesh_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimpleTriangleMesh_setToDefault_0');
var _emscripten_bind_PxSimpleTriangleMesh_isValid_0 = Module['_emscripten_bind_PxSimpleTriangleMesh_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimpleTriangleMesh_isValid_0');
var _emscripten_bind_PxSimpleTriangleMesh_get_points_0 = Module['_emscripten_bind_PxSimpleTriangleMesh_get_points_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimpleTriangleMesh_get_points_0');
var _emscripten_bind_PxSimpleTriangleMesh_set_points_1 = Module['_emscripten_bind_PxSimpleTriangleMesh_set_points_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimpleTriangleMesh_set_points_1');
var _emscripten_bind_PxSimpleTriangleMesh_get_triangles_0 = Module['_emscripten_bind_PxSimpleTriangleMesh_get_triangles_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimpleTriangleMesh_get_triangles_0');
var _emscripten_bind_PxSimpleTriangleMesh_set_triangles_1 = Module['_emscripten_bind_PxSimpleTriangleMesh_set_triangles_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimpleTriangleMesh_set_triangles_1');
var _emscripten_bind_PxSimpleTriangleMesh_get_flags_0 = Module['_emscripten_bind_PxSimpleTriangleMesh_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimpleTriangleMesh_get_flags_0');
var _emscripten_bind_PxSimpleTriangleMesh_set_flags_1 = Module['_emscripten_bind_PxSimpleTriangleMesh_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimpleTriangleMesh_set_flags_1');
var _emscripten_bind_PxSimpleTriangleMesh___destroy___0 = Module['_emscripten_bind_PxSimpleTriangleMesh___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimpleTriangleMesh___destroy___0');
var _emscripten_bind_PxSpring_PxSpring_2 = Module['_emscripten_bind_PxSpring_PxSpring_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpring_PxSpring_2');
var _emscripten_bind_PxSpring_get_stiffness_0 = Module['_emscripten_bind_PxSpring_get_stiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpring_get_stiffness_0');
var _emscripten_bind_PxSpring_set_stiffness_1 = Module['_emscripten_bind_PxSpring_set_stiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpring_set_stiffness_1');
var _emscripten_bind_PxSpring_get_damping_0 = Module['_emscripten_bind_PxSpring_get_damping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpring_get_damping_0');
var _emscripten_bind_PxSpring_set_damping_1 = Module['_emscripten_bind_PxSpring_set_damping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpring_set_damping_1');
var _emscripten_bind_PxSpring___destroy___0 = Module['_emscripten_bind_PxSpring___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpring___destroy___0');
var _emscripten_bind_PxStridedData_get_stride_0 = Module['_emscripten_bind_PxStridedData_get_stride_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxStridedData_get_stride_0');
var _emscripten_bind_PxStridedData_set_stride_1 = Module['_emscripten_bind_PxStridedData_set_stride_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxStridedData_set_stride_1');
var _emscripten_bind_PxStridedData_get_data_0 = Module['_emscripten_bind_PxStridedData_get_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxStridedData_get_data_0');
var _emscripten_bind_PxStridedData_set_data_1 = Module['_emscripten_bind_PxStridedData_set_data_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxStridedData_set_data_1');
var _emscripten_bind_PxStridedData___destroy___0 = Module['_emscripten_bind_PxStridedData___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxStridedData___destroy___0');
var _emscripten_bind_PxSweepCallback_hasAnyHits_0 = Module['_emscripten_bind_PxSweepCallback_hasAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepCallback_hasAnyHits_0');
var _emscripten_bind_PxSweepCallback___destroy___0 = Module['_emscripten_bind_PxSweepCallback___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepCallback___destroy___0');
var _emscripten_bind_PxU16ConstPtr___destroy___0 = Module['_emscripten_bind_PxU16ConstPtr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxU16ConstPtr___destroy___0');
var _emscripten_bind_PxU32ConstPtr___destroy___0 = Module['_emscripten_bind_PxU32ConstPtr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxU32ConstPtr___destroy___0');
var _emscripten_bind_PxU8ConstPtr___destroy___0 = Module['_emscripten_bind_PxU8ConstPtr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxU8ConstPtr___destroy___0');
var _emscripten_bind_PxUserControllerHitReport_onShapeHit_1 = Module['_emscripten_bind_PxUserControllerHitReport_onShapeHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxUserControllerHitReport_onShapeHit_1');
var _emscripten_bind_PxUserControllerHitReport_onControllerHit_1 = Module['_emscripten_bind_PxUserControllerHitReport_onControllerHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxUserControllerHitReport_onControllerHit_1');
var _emscripten_bind_PxUserControllerHitReport_onObstacleHit_1 = Module['_emscripten_bind_PxUserControllerHitReport_onObstacleHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxUserControllerHitReport_onObstacleHit_1');
var _emscripten_bind_PxVehicleCommandResponseParams_PxVehicleCommandResponseParams_0 = Module['_emscripten_bind_PxVehicleCommandResponseParams_PxVehicleCommandResponseParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandResponseParams_PxVehicleCommandResponseParams_0');
var _emscripten_bind_PxVehicleCommandResponseParams_get_nonlinearResponse_0 = Module['_emscripten_bind_PxVehicleCommandResponseParams_get_nonlinearResponse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandResponseParams_get_nonlinearResponse_0');
var _emscripten_bind_PxVehicleCommandResponseParams_set_nonlinearResponse_1 = Module['_emscripten_bind_PxVehicleCommandResponseParams_set_nonlinearResponse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandResponseParams_set_nonlinearResponse_1');
var _emscripten_bind_PxVehicleCommandResponseParams_get_wheelResponseMultipliers_1 = Module['_emscripten_bind_PxVehicleCommandResponseParams_get_wheelResponseMultipliers_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandResponseParams_get_wheelResponseMultipliers_1');
var _emscripten_bind_PxVehicleCommandResponseParams_set_wheelResponseMultipliers_2 = Module['_emscripten_bind_PxVehicleCommandResponseParams_set_wheelResponseMultipliers_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandResponseParams_set_wheelResponseMultipliers_2');
var _emscripten_bind_PxVehicleCommandResponseParams_get_maxResponse_0 = Module['_emscripten_bind_PxVehicleCommandResponseParams_get_maxResponse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandResponseParams_get_maxResponse_0');
var _emscripten_bind_PxVehicleCommandResponseParams_set_maxResponse_1 = Module['_emscripten_bind_PxVehicleCommandResponseParams_set_maxResponse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandResponseParams_set_maxResponse_1');
var _emscripten_bind_PxVehicleCommandResponseParams___destroy___0 = Module['_emscripten_bind_PxVehicleCommandResponseParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandResponseParams___destroy___0');
var _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_PxVehicleEngineDriveTransmissionCommandState_0 = Module['_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_PxVehicleEngineDriveTransmissionCommandState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_PxVehicleEngineDriveTransmissionCommandState_0');
var _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_setToDefault_0 = Module['_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_setToDefault_0');
var _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_clutch_0 = Module['_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_clutch_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_clutch_0');
var _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_clutch_1 = Module['_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_clutch_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_clutch_1');
var _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_targetGear_0 = Module['_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_targetGear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_targetGear_0');
var _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_targetGear_1 = Module['_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_targetGear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_targetGear_1');
var _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState___destroy___0 = Module['_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState___destroy___0');
var _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_PxVehicleMultiWheelDriveDifferentialParams_0 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_PxVehicleMultiWheelDriveDifferentialParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_PxVehicleMultiWheelDriveDifferentialParams_0');
var _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_setToDefault_0 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_setToDefault_0');
var _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_transformAndScale_4');
var _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_isValid_1 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_isValid_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_isValid_1');
var _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_torqueRatios_1 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_torqueRatios_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_torqueRatios_1');
var _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_torqueRatios_2 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_torqueRatios_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_torqueRatios_2');
var _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1');
var _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2');
var _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams___destroy___0 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams___destroy___0');
var _emscripten_bind_PxVehicleSimulationContext_PxVehicleSimulationContext_0 = Module['_emscripten_bind_PxVehicleSimulationContext_PxVehicleSimulationContext_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_PxVehicleSimulationContext_0');
var _emscripten_bind_PxVehicleSimulationContext_getType_0 = Module['_emscripten_bind_PxVehicleSimulationContext_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_getType_0');
var _emscripten_bind_PxVehicleSimulationContext_setToDefault_0 = Module['_emscripten_bind_PxVehicleSimulationContext_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_setToDefault_0');
var _emscripten_bind_PxVehicleSimulationContext_transformAndScale_4 = Module['_emscripten_bind_PxVehicleSimulationContext_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_transformAndScale_4');
var _emscripten_bind_PxVehicleSimulationContext_get_gravity_0 = Module['_emscripten_bind_PxVehicleSimulationContext_get_gravity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_get_gravity_0');
var _emscripten_bind_PxVehicleSimulationContext_set_gravity_1 = Module['_emscripten_bind_PxVehicleSimulationContext_set_gravity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_set_gravity_1');
var _emscripten_bind_PxVehicleSimulationContext_get_frame_0 = Module['_emscripten_bind_PxVehicleSimulationContext_get_frame_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_get_frame_0');
var _emscripten_bind_PxVehicleSimulationContext_set_frame_1 = Module['_emscripten_bind_PxVehicleSimulationContext_set_frame_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_set_frame_1');
var _emscripten_bind_PxVehicleSimulationContext_get_scale_0 = Module['_emscripten_bind_PxVehicleSimulationContext_get_scale_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_get_scale_0');
var _emscripten_bind_PxVehicleSimulationContext_set_scale_1 = Module['_emscripten_bind_PxVehicleSimulationContext_set_scale_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_set_scale_1');
var _emscripten_bind_PxVehicleSimulationContext_get_tireSlipParams_0 = Module['_emscripten_bind_PxVehicleSimulationContext_get_tireSlipParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_get_tireSlipParams_0');
var _emscripten_bind_PxVehicleSimulationContext_set_tireSlipParams_1 = Module['_emscripten_bind_PxVehicleSimulationContext_set_tireSlipParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_set_tireSlipParams_1');
var _emscripten_bind_PxVehicleSimulationContext_get_tireStickyParams_0 = Module['_emscripten_bind_PxVehicleSimulationContext_get_tireStickyParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_get_tireStickyParams_0');
var _emscripten_bind_PxVehicleSimulationContext_set_tireStickyParams_1 = Module['_emscripten_bind_PxVehicleSimulationContext_set_tireStickyParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_set_tireStickyParams_1');
var _emscripten_bind_PxVehicleSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0 = Module['_emscripten_bind_PxVehicleSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0');
var _emscripten_bind_PxVehicleSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1 = Module['_emscripten_bind_PxVehicleSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1');
var _emscripten_bind_PxVehicleSimulationContext_get_pvdContext_0 = Module['_emscripten_bind_PxVehicleSimulationContext_get_pvdContext_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_get_pvdContext_0');
var _emscripten_bind_PxVehicleSimulationContext_set_pvdContext_1 = Module['_emscripten_bind_PxVehicleSimulationContext_set_pvdContext_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext_set_pvdContext_1');
var _emscripten_bind_PxVehicleSimulationContext___destroy___0 = Module['_emscripten_bind_PxVehicleSimulationContext___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSimulationContext___destroy___0');
var _emscripten_bind_SimpleControllerBehaviorCallback_getShapeBehaviorFlags_2 = Module['_emscripten_bind_SimpleControllerBehaviorCallback_getShapeBehaviorFlags_2'] = makeInvalidEarlyAccess('_emscripten_bind_SimpleControllerBehaviorCallback_getShapeBehaviorFlags_2');
var _emscripten_bind_SimpleControllerBehaviorCallback_getControllerBehaviorFlags_1 = Module['_emscripten_bind_SimpleControllerBehaviorCallback_getControllerBehaviorFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_SimpleControllerBehaviorCallback_getControllerBehaviorFlags_1');
var _emscripten_bind_SimpleControllerBehaviorCallback_getObstacleBehaviorFlags_1 = Module['_emscripten_bind_SimpleControllerBehaviorCallback_getObstacleBehaviorFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_SimpleControllerBehaviorCallback_getObstacleBehaviorFlags_1');
var _emscripten_bind_SimpleControllerBehaviorCallback___destroy___0 = Module['_emscripten_bind_SimpleControllerBehaviorCallback___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_SimpleControllerBehaviorCallback___destroy___0');
var _emscripten_bind_SimplePvdTransport_send_2 = Module['_emscripten_bind_SimplePvdTransport_send_2'] = makeInvalidEarlyAccess('_emscripten_bind_SimplePvdTransport_send_2');
var _emscripten_bind_SimplePvdTransport_connect_0 = Module['_emscripten_bind_SimplePvdTransport_connect_0'] = makeInvalidEarlyAccess('_emscripten_bind_SimplePvdTransport_connect_0');
var _emscripten_bind_SimplePvdTransport_isConnected_0 = Module['_emscripten_bind_SimplePvdTransport_isConnected_0'] = makeInvalidEarlyAccess('_emscripten_bind_SimplePvdTransport_isConnected_0');
var _emscripten_bind_SimplePvdTransport_disconnect_0 = Module['_emscripten_bind_SimplePvdTransport_disconnect_0'] = makeInvalidEarlyAccess('_emscripten_bind_SimplePvdTransport_disconnect_0');
var _emscripten_bind_SimplePvdTransport_release_0 = Module['_emscripten_bind_SimplePvdTransport_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_SimplePvdTransport_release_0');
var _emscripten_bind_SimplePvdTransport_flush_0 = Module['_emscripten_bind_SimplePvdTransport_flush_0'] = makeInvalidEarlyAccess('_emscripten_bind_SimplePvdTransport_flush_0');
var _emscripten_bind_SimplePvdTransport___destroy___0 = Module['_emscripten_bind_SimplePvdTransport___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_SimplePvdTransport___destroy___0');
var _emscripten_bind_SimpleQueryFilterCallback_simplePreFilter_4 = Module['_emscripten_bind_SimpleQueryFilterCallback_simplePreFilter_4'] = makeInvalidEarlyAccess('_emscripten_bind_SimpleQueryFilterCallback_simplePreFilter_4');
var _emscripten_bind_SimpleQueryFilterCallback_simplePostFilter_4 = Module['_emscripten_bind_SimpleQueryFilterCallback_simplePostFilter_4'] = makeInvalidEarlyAccess('_emscripten_bind_SimpleQueryFilterCallback_simplePostFilter_4');
var _emscripten_bind_SimpleQueryFilterCallback___destroy___0 = Module['_emscripten_bind_SimpleQueryFilterCallback___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_SimpleQueryFilterCallback___destroy___0');
var _emscripten_bind_SimpleSimulationEventCallback_onConstraintBreak_2 = Module['_emscripten_bind_SimpleSimulationEventCallback_onConstraintBreak_2'] = makeInvalidEarlyAccess('_emscripten_bind_SimpleSimulationEventCallback_onConstraintBreak_2');
var _emscripten_bind_SimpleSimulationEventCallback_onWake_2 = Module['_emscripten_bind_SimpleSimulationEventCallback_onWake_2'] = makeInvalidEarlyAccess('_emscripten_bind_SimpleSimulationEventCallback_onWake_2');
var _emscripten_bind_SimpleSimulationEventCallback_onSleep_2 = Module['_emscripten_bind_SimpleSimulationEventCallback_onSleep_2'] = makeInvalidEarlyAccess('_emscripten_bind_SimpleSimulationEventCallback_onSleep_2');
var _emscripten_bind_SimpleSimulationEventCallback_onContact_3 = Module['_emscripten_bind_SimpleSimulationEventCallback_onContact_3'] = makeInvalidEarlyAccess('_emscripten_bind_SimpleSimulationEventCallback_onContact_3');
var _emscripten_bind_SimpleSimulationEventCallback_onTrigger_2 = Module['_emscripten_bind_SimpleSimulationEventCallback_onTrigger_2'] = makeInvalidEarlyAccess('_emscripten_bind_SimpleSimulationEventCallback_onTrigger_2');
var _emscripten_bind_SimpleSimulationEventCallback___destroy___0 = Module['_emscripten_bind_SimpleSimulationEventCallback___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_SimpleSimulationEventCallback___destroy___0');
var _emscripten_bind_VoidPtr___destroy___0 = Module['_emscripten_bind_VoidPtr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_VoidPtr___destroy___0');
var _emscripten_bind_BaseVehicleParams_BaseVehicleParams_0 = Module['_emscripten_bind_BaseVehicleParams_BaseVehicleParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_BaseVehicleParams_0');
var _emscripten_bind_BaseVehicleParams_transformAndScale_4 = Module['_emscripten_bind_BaseVehicleParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_transformAndScale_4');
var _emscripten_bind_BaseVehicleParams_isValid_0 = Module['_emscripten_bind_BaseVehicleParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_isValid_0');
var _emscripten_bind_BaseVehicleParams_get_axleDescription_0 = Module['_emscripten_bind_BaseVehicleParams_get_axleDescription_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_axleDescription_0');
var _emscripten_bind_BaseVehicleParams_set_axleDescription_1 = Module['_emscripten_bind_BaseVehicleParams_set_axleDescription_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_axleDescription_1');
var _emscripten_bind_BaseVehicleParams_get_frame_0 = Module['_emscripten_bind_BaseVehicleParams_get_frame_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_frame_0');
var _emscripten_bind_BaseVehicleParams_set_frame_1 = Module['_emscripten_bind_BaseVehicleParams_set_frame_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_frame_1');
var _emscripten_bind_BaseVehicleParams_get_scale_0 = Module['_emscripten_bind_BaseVehicleParams_get_scale_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_scale_0');
var _emscripten_bind_BaseVehicleParams_set_scale_1 = Module['_emscripten_bind_BaseVehicleParams_set_scale_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_scale_1');
var _emscripten_bind_BaseVehicleParams_get_suspensionStateCalculationParams_0 = Module['_emscripten_bind_BaseVehicleParams_get_suspensionStateCalculationParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_suspensionStateCalculationParams_0');
var _emscripten_bind_BaseVehicleParams_set_suspensionStateCalculationParams_1 = Module['_emscripten_bind_BaseVehicleParams_set_suspensionStateCalculationParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_suspensionStateCalculationParams_1');
var _emscripten_bind_BaseVehicleParams_get_brakeResponseParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_brakeResponseParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_brakeResponseParams_1');
var _emscripten_bind_BaseVehicleParams_set_brakeResponseParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_brakeResponseParams_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_brakeResponseParams_2');
var _emscripten_bind_BaseVehicleParams_get_steerResponseParams_0 = Module['_emscripten_bind_BaseVehicleParams_get_steerResponseParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_steerResponseParams_0');
var _emscripten_bind_BaseVehicleParams_set_steerResponseParams_1 = Module['_emscripten_bind_BaseVehicleParams_set_steerResponseParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_steerResponseParams_1');
var _emscripten_bind_BaseVehicleParams_get_ackermannParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_ackermannParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_ackermannParams_1');
var _emscripten_bind_BaseVehicleParams_set_ackermannParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_ackermannParams_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_ackermannParams_2');
var _emscripten_bind_BaseVehicleParams_get_suspensionParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_suspensionParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_suspensionParams_1');
var _emscripten_bind_BaseVehicleParams_set_suspensionParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_suspensionParams_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_suspensionParams_2');
var _emscripten_bind_BaseVehicleParams_get_suspensionComplianceParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_suspensionComplianceParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_suspensionComplianceParams_1');
var _emscripten_bind_BaseVehicleParams_set_suspensionComplianceParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_suspensionComplianceParams_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_suspensionComplianceParams_2');
var _emscripten_bind_BaseVehicleParams_get_suspensionForceParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_suspensionForceParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_suspensionForceParams_1');
var _emscripten_bind_BaseVehicleParams_set_suspensionForceParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_suspensionForceParams_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_suspensionForceParams_2');
var _emscripten_bind_BaseVehicleParams_get_antiRollForceParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_antiRollForceParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_antiRollForceParams_1');
var _emscripten_bind_BaseVehicleParams_set_antiRollForceParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_antiRollForceParams_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_antiRollForceParams_2');
var _emscripten_bind_BaseVehicleParams_get_nbAntiRollForceParams_0 = Module['_emscripten_bind_BaseVehicleParams_get_nbAntiRollForceParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_nbAntiRollForceParams_0');
var _emscripten_bind_BaseVehicleParams_set_nbAntiRollForceParams_1 = Module['_emscripten_bind_BaseVehicleParams_set_nbAntiRollForceParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_nbAntiRollForceParams_1');
var _emscripten_bind_BaseVehicleParams_get_tireForceParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_tireForceParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_tireForceParams_1');
var _emscripten_bind_BaseVehicleParams_set_tireForceParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_tireForceParams_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_tireForceParams_2');
var _emscripten_bind_BaseVehicleParams_get_wheelParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_wheelParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_wheelParams_1');
var _emscripten_bind_BaseVehicleParams_set_wheelParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_wheelParams_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_wheelParams_2');
var _emscripten_bind_BaseVehicleParams_get_rigidBodyParams_0 = Module['_emscripten_bind_BaseVehicleParams_get_rigidBodyParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_get_rigidBodyParams_0');
var _emscripten_bind_BaseVehicleParams_set_rigidBodyParams_1 = Module['_emscripten_bind_BaseVehicleParams_set_rigidBodyParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams_set_rigidBodyParams_1');
var _emscripten_bind_BaseVehicleParams___destroy___0 = Module['_emscripten_bind_BaseVehicleParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleParams___destroy___0');
var _emscripten_bind_BaseVehicleState_BaseVehicleState_0 = Module['_emscripten_bind_BaseVehicleState_BaseVehicleState_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_BaseVehicleState_0');
var _emscripten_bind_BaseVehicleState_setToDefault_0 = Module['_emscripten_bind_BaseVehicleState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_setToDefault_0');
var _emscripten_bind_BaseVehicleState_get_brakeCommandResponseStates_1 = Module['_emscripten_bind_BaseVehicleState_get_brakeCommandResponseStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_brakeCommandResponseStates_1');
var _emscripten_bind_BaseVehicleState_set_brakeCommandResponseStates_2 = Module['_emscripten_bind_BaseVehicleState_set_brakeCommandResponseStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_brakeCommandResponseStates_2');
var _emscripten_bind_BaseVehicleState_get_steerCommandResponseStates_1 = Module['_emscripten_bind_BaseVehicleState_get_steerCommandResponseStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_steerCommandResponseStates_1');
var _emscripten_bind_BaseVehicleState_set_steerCommandResponseStates_2 = Module['_emscripten_bind_BaseVehicleState_set_steerCommandResponseStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_steerCommandResponseStates_2');
var _emscripten_bind_BaseVehicleState_get_actuationStates_1 = Module['_emscripten_bind_BaseVehicleState_get_actuationStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_actuationStates_1');
var _emscripten_bind_BaseVehicleState_set_actuationStates_2 = Module['_emscripten_bind_BaseVehicleState_set_actuationStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_actuationStates_2');
var _emscripten_bind_BaseVehicleState_get_roadGeomStates_1 = Module['_emscripten_bind_BaseVehicleState_get_roadGeomStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_roadGeomStates_1');
var _emscripten_bind_BaseVehicleState_set_roadGeomStates_2 = Module['_emscripten_bind_BaseVehicleState_set_roadGeomStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_roadGeomStates_2');
var _emscripten_bind_BaseVehicleState_get_suspensionStates_1 = Module['_emscripten_bind_BaseVehicleState_get_suspensionStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_suspensionStates_1');
var _emscripten_bind_BaseVehicleState_set_suspensionStates_2 = Module['_emscripten_bind_BaseVehicleState_set_suspensionStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_suspensionStates_2');
var _emscripten_bind_BaseVehicleState_get_suspensionComplianceStates_1 = Module['_emscripten_bind_BaseVehicleState_get_suspensionComplianceStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_suspensionComplianceStates_1');
var _emscripten_bind_BaseVehicleState_set_suspensionComplianceStates_2 = Module['_emscripten_bind_BaseVehicleState_set_suspensionComplianceStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_suspensionComplianceStates_2');
var _emscripten_bind_BaseVehicleState_get_suspensionForces_1 = Module['_emscripten_bind_BaseVehicleState_get_suspensionForces_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_suspensionForces_1');
var _emscripten_bind_BaseVehicleState_set_suspensionForces_2 = Module['_emscripten_bind_BaseVehicleState_set_suspensionForces_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_suspensionForces_2');
var _emscripten_bind_BaseVehicleState_get_antiRollTorque_0 = Module['_emscripten_bind_BaseVehicleState_get_antiRollTorque_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_antiRollTorque_0');
var _emscripten_bind_BaseVehicleState_set_antiRollTorque_1 = Module['_emscripten_bind_BaseVehicleState_set_antiRollTorque_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_antiRollTorque_1');
var _emscripten_bind_BaseVehicleState_get_tireGripStates_1 = Module['_emscripten_bind_BaseVehicleState_get_tireGripStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_tireGripStates_1');
var _emscripten_bind_BaseVehicleState_set_tireGripStates_2 = Module['_emscripten_bind_BaseVehicleState_set_tireGripStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_tireGripStates_2');
var _emscripten_bind_BaseVehicleState_get_tireDirectionStates_1 = Module['_emscripten_bind_BaseVehicleState_get_tireDirectionStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_tireDirectionStates_1');
var _emscripten_bind_BaseVehicleState_set_tireDirectionStates_2 = Module['_emscripten_bind_BaseVehicleState_set_tireDirectionStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_tireDirectionStates_2');
var _emscripten_bind_BaseVehicleState_get_tireSpeedStates_1 = Module['_emscripten_bind_BaseVehicleState_get_tireSpeedStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_tireSpeedStates_1');
var _emscripten_bind_BaseVehicleState_set_tireSpeedStates_2 = Module['_emscripten_bind_BaseVehicleState_set_tireSpeedStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_tireSpeedStates_2');
var _emscripten_bind_BaseVehicleState_get_tireSlipStates_1 = Module['_emscripten_bind_BaseVehicleState_get_tireSlipStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_tireSlipStates_1');
var _emscripten_bind_BaseVehicleState_set_tireSlipStates_2 = Module['_emscripten_bind_BaseVehicleState_set_tireSlipStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_tireSlipStates_2');
var _emscripten_bind_BaseVehicleState_get_tireCamberAngleStates_1 = Module['_emscripten_bind_BaseVehicleState_get_tireCamberAngleStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_tireCamberAngleStates_1');
var _emscripten_bind_BaseVehicleState_set_tireCamberAngleStates_2 = Module['_emscripten_bind_BaseVehicleState_set_tireCamberAngleStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_tireCamberAngleStates_2');
var _emscripten_bind_BaseVehicleState_get_tireStickyStates_1 = Module['_emscripten_bind_BaseVehicleState_get_tireStickyStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_tireStickyStates_1');
var _emscripten_bind_BaseVehicleState_set_tireStickyStates_2 = Module['_emscripten_bind_BaseVehicleState_set_tireStickyStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_tireStickyStates_2');
var _emscripten_bind_BaseVehicleState_get_tireForces_1 = Module['_emscripten_bind_BaseVehicleState_get_tireForces_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_tireForces_1');
var _emscripten_bind_BaseVehicleState_set_tireForces_2 = Module['_emscripten_bind_BaseVehicleState_set_tireForces_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_tireForces_2');
var _emscripten_bind_BaseVehicleState_get_wheelRigidBody1dStates_1 = Module['_emscripten_bind_BaseVehicleState_get_wheelRigidBody1dStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_wheelRigidBody1dStates_1');
var _emscripten_bind_BaseVehicleState_set_wheelRigidBody1dStates_2 = Module['_emscripten_bind_BaseVehicleState_set_wheelRigidBody1dStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_wheelRigidBody1dStates_2');
var _emscripten_bind_BaseVehicleState_get_wheelLocalPoses_1 = Module['_emscripten_bind_BaseVehicleState_get_wheelLocalPoses_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_wheelLocalPoses_1');
var _emscripten_bind_BaseVehicleState_set_wheelLocalPoses_2 = Module['_emscripten_bind_BaseVehicleState_set_wheelLocalPoses_2'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_wheelLocalPoses_2');
var _emscripten_bind_BaseVehicleState_get_rigidBodyState_0 = Module['_emscripten_bind_BaseVehicleState_get_rigidBodyState_0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_get_rigidBodyState_0');
var _emscripten_bind_BaseVehicleState_set_rigidBodyState_1 = Module['_emscripten_bind_BaseVehicleState_set_rigidBodyState_1'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState_set_rigidBodyState_1');
var _emscripten_bind_BaseVehicleState___destroy___0 = Module['_emscripten_bind_BaseVehicleState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_BaseVehicleState___destroy___0');
var _emscripten_bind_BoxSupport_BoxSupport_1 = Module['_emscripten_bind_BoxSupport_BoxSupport_1'] = makeInvalidEarlyAccess('_emscripten_bind_BoxSupport_BoxSupport_1');
var _emscripten_bind_BoxSupport_BoxSupport_2 = Module['_emscripten_bind_BoxSupport_BoxSupport_2'] = makeInvalidEarlyAccess('_emscripten_bind_BoxSupport_BoxSupport_2');
var _emscripten_bind_BoxSupport_getMargin_0 = Module['_emscripten_bind_BoxSupport_getMargin_0'] = makeInvalidEarlyAccess('_emscripten_bind_BoxSupport_getMargin_0');
var _emscripten_bind_BoxSupport_supportLocal_1 = Module['_emscripten_bind_BoxSupport_supportLocal_1'] = makeInvalidEarlyAccess('_emscripten_bind_BoxSupport_supportLocal_1');
var _emscripten_bind_BoxSupport_get_halfExtents_0 = Module['_emscripten_bind_BoxSupport_get_halfExtents_0'] = makeInvalidEarlyAccess('_emscripten_bind_BoxSupport_get_halfExtents_0');
var _emscripten_bind_BoxSupport_set_halfExtents_1 = Module['_emscripten_bind_BoxSupport_set_halfExtents_1'] = makeInvalidEarlyAccess('_emscripten_bind_BoxSupport_set_halfExtents_1');
var _emscripten_bind_BoxSupport_get_margin_0 = Module['_emscripten_bind_BoxSupport_get_margin_0'] = makeInvalidEarlyAccess('_emscripten_bind_BoxSupport_get_margin_0');
var _emscripten_bind_BoxSupport_set_margin_1 = Module['_emscripten_bind_BoxSupport_set_margin_1'] = makeInvalidEarlyAccess('_emscripten_bind_BoxSupport_set_margin_1');
var _emscripten_bind_BoxSupport___destroy___0 = Module['_emscripten_bind_BoxSupport___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_BoxSupport___destroy___0');
var _emscripten_bind_CapsuleSupport_CapsuleSupport_2 = Module['_emscripten_bind_CapsuleSupport_CapsuleSupport_2'] = makeInvalidEarlyAccess('_emscripten_bind_CapsuleSupport_CapsuleSupport_2');
var _emscripten_bind_CapsuleSupport_getMargin_0 = Module['_emscripten_bind_CapsuleSupport_getMargin_0'] = makeInvalidEarlyAccess('_emscripten_bind_CapsuleSupport_getMargin_0');
var _emscripten_bind_CapsuleSupport_supportLocal_1 = Module['_emscripten_bind_CapsuleSupport_supportLocal_1'] = makeInvalidEarlyAccess('_emscripten_bind_CapsuleSupport_supportLocal_1');
var _emscripten_bind_CapsuleSupport_get_radius_0 = Module['_emscripten_bind_CapsuleSupport_get_radius_0'] = makeInvalidEarlyAccess('_emscripten_bind_CapsuleSupport_get_radius_0');
var _emscripten_bind_CapsuleSupport_set_radius_1 = Module['_emscripten_bind_CapsuleSupport_set_radius_1'] = makeInvalidEarlyAccess('_emscripten_bind_CapsuleSupport_set_radius_1');
var _emscripten_bind_CapsuleSupport_get_halfHeight_0 = Module['_emscripten_bind_CapsuleSupport_get_halfHeight_0'] = makeInvalidEarlyAccess('_emscripten_bind_CapsuleSupport_get_halfHeight_0');
var _emscripten_bind_CapsuleSupport_set_halfHeight_1 = Module['_emscripten_bind_CapsuleSupport_set_halfHeight_1'] = makeInvalidEarlyAccess('_emscripten_bind_CapsuleSupport_set_halfHeight_1');
var _emscripten_bind_CapsuleSupport___destroy___0 = Module['_emscripten_bind_CapsuleSupport___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_CapsuleSupport___destroy___0');
var _emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_0 = Module['_emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_0'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_0');
var _emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_1 = Module['_emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_1'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_1');
var _emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_2 = Module['_emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_2'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_2');
var _emscripten_bind_ConvexGeomSupport_getMargin_0 = Module['_emscripten_bind_ConvexGeomSupport_getMargin_0'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexGeomSupport_getMargin_0');
var _emscripten_bind_ConvexGeomSupport_supportLocal_1 = Module['_emscripten_bind_ConvexGeomSupport_supportLocal_1'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexGeomSupport_supportLocal_1');
var _emscripten_bind_ConvexGeomSupport___destroy___0 = Module['_emscripten_bind_ConvexGeomSupport___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexGeomSupport___destroy___0');
var _emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_1 = Module['_emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_1'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_1');
var _emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_2 = Module['_emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_2'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_2');
var _emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_3 = Module['_emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_3'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_3');
var _emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_4 = Module['_emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_4'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_4');
var _emscripten_bind_ConvexMeshSupport_getMargin_0 = Module['_emscripten_bind_ConvexMeshSupport_getMargin_0'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexMeshSupport_getMargin_0');
var _emscripten_bind_ConvexMeshSupport_supportLocal_1 = Module['_emscripten_bind_ConvexMeshSupport_supportLocal_1'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexMeshSupport_supportLocal_1');
var _emscripten_bind_ConvexMeshSupport_get_scale_0 = Module['_emscripten_bind_ConvexMeshSupport_get_scale_0'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexMeshSupport_get_scale_0');
var _emscripten_bind_ConvexMeshSupport_set_scale_1 = Module['_emscripten_bind_ConvexMeshSupport_set_scale_1'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexMeshSupport_set_scale_1');
var _emscripten_bind_ConvexMeshSupport_get_scaleRotation_0 = Module['_emscripten_bind_ConvexMeshSupport_get_scaleRotation_0'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexMeshSupport_get_scaleRotation_0');
var _emscripten_bind_ConvexMeshSupport_set_scaleRotation_1 = Module['_emscripten_bind_ConvexMeshSupport_set_scaleRotation_1'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexMeshSupport_set_scaleRotation_1');
var _emscripten_bind_ConvexMeshSupport_get_margin_0 = Module['_emscripten_bind_ConvexMeshSupport_get_margin_0'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexMeshSupport_get_margin_0');
var _emscripten_bind_ConvexMeshSupport_set_margin_1 = Module['_emscripten_bind_ConvexMeshSupport_set_margin_1'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexMeshSupport_set_margin_1');
var _emscripten_bind_ConvexMeshSupport___destroy___0 = Module['_emscripten_bind_ConvexMeshSupport___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_ConvexMeshSupport___destroy___0');
var _emscripten_bind_CustomSupportImpl_CustomSupportImpl_0 = Module['_emscripten_bind_CustomSupportImpl_CustomSupportImpl_0'] = makeInvalidEarlyAccess('_emscripten_bind_CustomSupportImpl_CustomSupportImpl_0');
var _emscripten_bind_CustomSupportImpl_getCustomMargin_0 = Module['_emscripten_bind_CustomSupportImpl_getCustomMargin_0'] = makeInvalidEarlyAccess('_emscripten_bind_CustomSupportImpl_getCustomMargin_0');
var _emscripten_bind_CustomSupportImpl_getCustomSupportLocal_2 = Module['_emscripten_bind_CustomSupportImpl_getCustomSupportLocal_2'] = makeInvalidEarlyAccess('_emscripten_bind_CustomSupportImpl_getCustomSupportLocal_2');
var _emscripten_bind_CustomSupportImpl___destroy___0 = Module['_emscripten_bind_CustomSupportImpl___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_CustomSupportImpl___destroy___0');
var _emscripten_bind_DirectDriveVehicle_DirectDriveVehicle_0 = Module['_emscripten_bind_DirectDriveVehicle_DirectDriveVehicle_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_DirectDriveVehicle_0');
var _emscripten_bind_DirectDriveVehicle_initialize_3 = Module['_emscripten_bind_DirectDriveVehicle_initialize_3'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_initialize_3');
var _emscripten_bind_DirectDriveVehicle_initialize_4 = Module['_emscripten_bind_DirectDriveVehicle_initialize_4'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_initialize_4');
var _emscripten_bind_DirectDriveVehicle_initComponentSequence_1 = Module['_emscripten_bind_DirectDriveVehicle_initComponentSequence_1'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_initComponentSequence_1');
var _emscripten_bind_DirectDriveVehicle_destroyState_0 = Module['_emscripten_bind_DirectDriveVehicle_destroyState_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_destroyState_0');
var _emscripten_bind_DirectDriveVehicle_step_2 = Module['_emscripten_bind_DirectDriveVehicle_step_2'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_step_2');
var _emscripten_bind_DirectDriveVehicle_get_directDriveParams_0 = Module['_emscripten_bind_DirectDriveVehicle_get_directDriveParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_get_directDriveParams_0');
var _emscripten_bind_DirectDriveVehicle_set_directDriveParams_1 = Module['_emscripten_bind_DirectDriveVehicle_set_directDriveParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_set_directDriveParams_1');
var _emscripten_bind_DirectDriveVehicle_get_directDriveState_0 = Module['_emscripten_bind_DirectDriveVehicle_get_directDriveState_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_get_directDriveState_0');
var _emscripten_bind_DirectDriveVehicle_set_directDriveState_1 = Module['_emscripten_bind_DirectDriveVehicle_set_directDriveState_1'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_set_directDriveState_1');
var _emscripten_bind_DirectDriveVehicle_get_transmissionCommandState_0 = Module['_emscripten_bind_DirectDriveVehicle_get_transmissionCommandState_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_get_transmissionCommandState_0');
var _emscripten_bind_DirectDriveVehicle_set_transmissionCommandState_1 = Module['_emscripten_bind_DirectDriveVehicle_set_transmissionCommandState_1'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_set_transmissionCommandState_1');
var _emscripten_bind_DirectDriveVehicle_get_baseParams_0 = Module['_emscripten_bind_DirectDriveVehicle_get_baseParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_get_baseParams_0');
var _emscripten_bind_DirectDriveVehicle_set_baseParams_1 = Module['_emscripten_bind_DirectDriveVehicle_set_baseParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_set_baseParams_1');
var _emscripten_bind_DirectDriveVehicle_get_baseState_0 = Module['_emscripten_bind_DirectDriveVehicle_get_baseState_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_get_baseState_0');
var _emscripten_bind_DirectDriveVehicle_set_baseState_1 = Module['_emscripten_bind_DirectDriveVehicle_set_baseState_1'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_set_baseState_1');
var _emscripten_bind_DirectDriveVehicle_get_componentSequence_0 = Module['_emscripten_bind_DirectDriveVehicle_get_componentSequence_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_get_componentSequence_0');
var _emscripten_bind_DirectDriveVehicle_set_componentSequence_1 = Module['_emscripten_bind_DirectDriveVehicle_set_componentSequence_1'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_set_componentSequence_1');
var _emscripten_bind_DirectDriveVehicle_get_componentSequenceSubstepGroupHandle_0 = Module['_emscripten_bind_DirectDriveVehicle_get_componentSequenceSubstepGroupHandle_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_get_componentSequenceSubstepGroupHandle_0');
var _emscripten_bind_DirectDriveVehicle_set_componentSequenceSubstepGroupHandle_1 = Module['_emscripten_bind_DirectDriveVehicle_set_componentSequenceSubstepGroupHandle_1'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_set_componentSequenceSubstepGroupHandle_1');
var _emscripten_bind_DirectDriveVehicle_get_physXParams_0 = Module['_emscripten_bind_DirectDriveVehicle_get_physXParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_get_physXParams_0');
var _emscripten_bind_DirectDriveVehicle_set_physXParams_1 = Module['_emscripten_bind_DirectDriveVehicle_set_physXParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_set_physXParams_1');
var _emscripten_bind_DirectDriveVehicle_get_physXState_0 = Module['_emscripten_bind_DirectDriveVehicle_get_physXState_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_get_physXState_0');
var _emscripten_bind_DirectDriveVehicle_set_physXState_1 = Module['_emscripten_bind_DirectDriveVehicle_set_physXState_1'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_set_physXState_1');
var _emscripten_bind_DirectDriveVehicle_get_commandState_0 = Module['_emscripten_bind_DirectDriveVehicle_get_commandState_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_get_commandState_0');
var _emscripten_bind_DirectDriveVehicle_set_commandState_1 = Module['_emscripten_bind_DirectDriveVehicle_set_commandState_1'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle_set_commandState_1');
var _emscripten_bind_DirectDriveVehicle___destroy___0 = Module['_emscripten_bind_DirectDriveVehicle___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDriveVehicle___destroy___0');
var _emscripten_bind_DirectDrivetrainParams_DirectDrivetrainParams_0 = Module['_emscripten_bind_DirectDrivetrainParams_DirectDrivetrainParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDrivetrainParams_DirectDrivetrainParams_0');
var _emscripten_bind_DirectDrivetrainParams_transformAndScale_4 = Module['_emscripten_bind_DirectDrivetrainParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDrivetrainParams_transformAndScale_4');
var _emscripten_bind_DirectDrivetrainParams_isValid_1 = Module['_emscripten_bind_DirectDrivetrainParams_isValid_1'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDrivetrainParams_isValid_1');
var _emscripten_bind_DirectDrivetrainParams_get_directDriveThrottleResponseParams_0 = Module['_emscripten_bind_DirectDrivetrainParams_get_directDriveThrottleResponseParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDrivetrainParams_get_directDriveThrottleResponseParams_0');
var _emscripten_bind_DirectDrivetrainParams_set_directDriveThrottleResponseParams_1 = Module['_emscripten_bind_DirectDrivetrainParams_set_directDriveThrottleResponseParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDrivetrainParams_set_directDriveThrottleResponseParams_1');
var _emscripten_bind_DirectDrivetrainParams___destroy___0 = Module['_emscripten_bind_DirectDrivetrainParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDrivetrainParams___destroy___0');
var _emscripten_bind_DirectDrivetrainState_DirectDrivetrainState_0 = Module['_emscripten_bind_DirectDrivetrainState_DirectDrivetrainState_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDrivetrainState_DirectDrivetrainState_0');
var _emscripten_bind_DirectDrivetrainState_setToDefault_0 = Module['_emscripten_bind_DirectDrivetrainState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDrivetrainState_setToDefault_0');
var _emscripten_bind_DirectDrivetrainState_get_directDriveThrottleResponseStates_1 = Module['_emscripten_bind_DirectDrivetrainState_get_directDriveThrottleResponseStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDrivetrainState_get_directDriveThrottleResponseStates_1');
var _emscripten_bind_DirectDrivetrainState_set_directDriveThrottleResponseStates_2 = Module['_emscripten_bind_DirectDrivetrainState_set_directDriveThrottleResponseStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDrivetrainState_set_directDriveThrottleResponseStates_2');
var _emscripten_bind_DirectDrivetrainState___destroy___0 = Module['_emscripten_bind_DirectDrivetrainState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_DirectDrivetrainState___destroy___0');
var _emscripten_bind_EngineDriveVehicle_EngineDriveVehicle_0 = Module['_emscripten_bind_EngineDriveVehicle_EngineDriveVehicle_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_EngineDriveVehicle_0');
var _emscripten_bind_EngineDriveVehicle_initialize_4 = Module['_emscripten_bind_EngineDriveVehicle_initialize_4'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_initialize_4');
var _emscripten_bind_EngineDriveVehicle_initialize_5 = Module['_emscripten_bind_EngineDriveVehicle_initialize_5'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_initialize_5');
var _emscripten_bind_EngineDriveVehicle_initComponentSequence_1 = Module['_emscripten_bind_EngineDriveVehicle_initComponentSequence_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_initComponentSequence_1');
var _emscripten_bind_EngineDriveVehicle_destroyState_0 = Module['_emscripten_bind_EngineDriveVehicle_destroyState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_destroyState_0');
var _emscripten_bind_EngineDriveVehicle_step_2 = Module['_emscripten_bind_EngineDriveVehicle_step_2'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_step_2');
var _emscripten_bind_EngineDriveVehicle_get_engineDriveParams_0 = Module['_emscripten_bind_EngineDriveVehicle_get_engineDriveParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_get_engineDriveParams_0');
var _emscripten_bind_EngineDriveVehicle_set_engineDriveParams_1 = Module['_emscripten_bind_EngineDriveVehicle_set_engineDriveParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_set_engineDriveParams_1');
var _emscripten_bind_EngineDriveVehicle_get_engineDriveState_0 = Module['_emscripten_bind_EngineDriveVehicle_get_engineDriveState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_get_engineDriveState_0');
var _emscripten_bind_EngineDriveVehicle_set_engineDriveState_1 = Module['_emscripten_bind_EngineDriveVehicle_set_engineDriveState_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_set_engineDriveState_1');
var _emscripten_bind_EngineDriveVehicle_get_transmissionCommandState_0 = Module['_emscripten_bind_EngineDriveVehicle_get_transmissionCommandState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_get_transmissionCommandState_0');
var _emscripten_bind_EngineDriveVehicle_set_transmissionCommandState_1 = Module['_emscripten_bind_EngineDriveVehicle_set_transmissionCommandState_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_set_transmissionCommandState_1');
var _emscripten_bind_EngineDriveVehicle_get_tankDriveTransmissionCommandState_0 = Module['_emscripten_bind_EngineDriveVehicle_get_tankDriveTransmissionCommandState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_get_tankDriveTransmissionCommandState_0');
var _emscripten_bind_EngineDriveVehicle_set_tankDriveTransmissionCommandState_1 = Module['_emscripten_bind_EngineDriveVehicle_set_tankDriveTransmissionCommandState_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_set_tankDriveTransmissionCommandState_1');
var _emscripten_bind_EngineDriveVehicle_get_differentialType_0 = Module['_emscripten_bind_EngineDriveVehicle_get_differentialType_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_get_differentialType_0');
var _emscripten_bind_EngineDriveVehicle_set_differentialType_1 = Module['_emscripten_bind_EngineDriveVehicle_set_differentialType_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_set_differentialType_1');
var _emscripten_bind_EngineDriveVehicle_get_baseParams_0 = Module['_emscripten_bind_EngineDriveVehicle_get_baseParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_get_baseParams_0');
var _emscripten_bind_EngineDriveVehicle_set_baseParams_1 = Module['_emscripten_bind_EngineDriveVehicle_set_baseParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_set_baseParams_1');
var _emscripten_bind_EngineDriveVehicle_get_baseState_0 = Module['_emscripten_bind_EngineDriveVehicle_get_baseState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_get_baseState_0');
var _emscripten_bind_EngineDriveVehicle_set_baseState_1 = Module['_emscripten_bind_EngineDriveVehicle_set_baseState_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_set_baseState_1');
var _emscripten_bind_EngineDriveVehicle_get_componentSequence_0 = Module['_emscripten_bind_EngineDriveVehicle_get_componentSequence_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_get_componentSequence_0');
var _emscripten_bind_EngineDriveVehicle_set_componentSequence_1 = Module['_emscripten_bind_EngineDriveVehicle_set_componentSequence_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_set_componentSequence_1');
var _emscripten_bind_EngineDriveVehicle_get_componentSequenceSubstepGroupHandle_0 = Module['_emscripten_bind_EngineDriveVehicle_get_componentSequenceSubstepGroupHandle_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_get_componentSequenceSubstepGroupHandle_0');
var _emscripten_bind_EngineDriveVehicle_set_componentSequenceSubstepGroupHandle_1 = Module['_emscripten_bind_EngineDriveVehicle_set_componentSequenceSubstepGroupHandle_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_set_componentSequenceSubstepGroupHandle_1');
var _emscripten_bind_EngineDriveVehicle_get_physXParams_0 = Module['_emscripten_bind_EngineDriveVehicle_get_physXParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_get_physXParams_0');
var _emscripten_bind_EngineDriveVehicle_set_physXParams_1 = Module['_emscripten_bind_EngineDriveVehicle_set_physXParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_set_physXParams_1');
var _emscripten_bind_EngineDriveVehicle_get_physXState_0 = Module['_emscripten_bind_EngineDriveVehicle_get_physXState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_get_physXState_0');
var _emscripten_bind_EngineDriveVehicle_set_physXState_1 = Module['_emscripten_bind_EngineDriveVehicle_set_physXState_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_set_physXState_1');
var _emscripten_bind_EngineDriveVehicle_get_commandState_0 = Module['_emscripten_bind_EngineDriveVehicle_get_commandState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_get_commandState_0');
var _emscripten_bind_EngineDriveVehicle_set_commandState_1 = Module['_emscripten_bind_EngineDriveVehicle_set_commandState_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle_set_commandState_1');
var _emscripten_bind_EngineDriveVehicle___destroy___0 = Module['_emscripten_bind_EngineDriveVehicle___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDriveVehicle___destroy___0');
var _emscripten_bind_EngineDrivetrainParams_EngineDrivetrainParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_EngineDrivetrainParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_EngineDrivetrainParams_0');
var _emscripten_bind_EngineDrivetrainParams_transformAndScale_4 = Module['_emscripten_bind_EngineDrivetrainParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_transformAndScale_4');
var _emscripten_bind_EngineDrivetrainParams_isValid_1 = Module['_emscripten_bind_EngineDrivetrainParams_isValid_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_isValid_1');
var _emscripten_bind_EngineDrivetrainParams_get_autoboxParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_autoboxParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_get_autoboxParams_0');
var _emscripten_bind_EngineDrivetrainParams_set_autoboxParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_autoboxParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_set_autoboxParams_1');
var _emscripten_bind_EngineDrivetrainParams_get_clutchCommandResponseParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_clutchCommandResponseParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_get_clutchCommandResponseParams_0');
var _emscripten_bind_EngineDrivetrainParams_set_clutchCommandResponseParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_clutchCommandResponseParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_set_clutchCommandResponseParams_1');
var _emscripten_bind_EngineDrivetrainParams_get_engineParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_engineParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_get_engineParams_0');
var _emscripten_bind_EngineDrivetrainParams_set_engineParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_engineParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_set_engineParams_1');
var _emscripten_bind_EngineDrivetrainParams_get_gearBoxParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_gearBoxParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_get_gearBoxParams_0');
var _emscripten_bind_EngineDrivetrainParams_set_gearBoxParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_gearBoxParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_set_gearBoxParams_1');
var _emscripten_bind_EngineDrivetrainParams_get_multiWheelDifferentialParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_multiWheelDifferentialParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_get_multiWheelDifferentialParams_0');
var _emscripten_bind_EngineDrivetrainParams_set_multiWheelDifferentialParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_multiWheelDifferentialParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_set_multiWheelDifferentialParams_1');
var _emscripten_bind_EngineDrivetrainParams_get_fourWheelDifferentialParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_fourWheelDifferentialParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_get_fourWheelDifferentialParams_0');
var _emscripten_bind_EngineDrivetrainParams_set_fourWheelDifferentialParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_fourWheelDifferentialParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_set_fourWheelDifferentialParams_1');
var _emscripten_bind_EngineDrivetrainParams_get_tankDifferentialParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_tankDifferentialParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_get_tankDifferentialParams_0');
var _emscripten_bind_EngineDrivetrainParams_set_tankDifferentialParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_tankDifferentialParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_set_tankDifferentialParams_1');
var _emscripten_bind_EngineDrivetrainParams_get_clutchParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_clutchParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_get_clutchParams_0');
var _emscripten_bind_EngineDrivetrainParams_set_clutchParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_clutchParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams_set_clutchParams_1');
var _emscripten_bind_EngineDrivetrainParams___destroy___0 = Module['_emscripten_bind_EngineDrivetrainParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainParams___destroy___0');
var _emscripten_bind_EngineDrivetrainState_EngineDrivetrainState_0 = Module['_emscripten_bind_EngineDrivetrainState_EngineDrivetrainState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_EngineDrivetrainState_0');
var _emscripten_bind_EngineDrivetrainState_setToDefault_0 = Module['_emscripten_bind_EngineDrivetrainState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_setToDefault_0');
var _emscripten_bind_EngineDrivetrainState_get_throttleCommandResponseState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_throttleCommandResponseState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_get_throttleCommandResponseState_0');
var _emscripten_bind_EngineDrivetrainState_set_throttleCommandResponseState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_throttleCommandResponseState_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_set_throttleCommandResponseState_1');
var _emscripten_bind_EngineDrivetrainState_get_autoboxState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_autoboxState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_get_autoboxState_0');
var _emscripten_bind_EngineDrivetrainState_set_autoboxState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_autoboxState_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_set_autoboxState_1');
var _emscripten_bind_EngineDrivetrainState_get_clutchCommandResponseState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_clutchCommandResponseState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_get_clutchCommandResponseState_0');
var _emscripten_bind_EngineDrivetrainState_set_clutchCommandResponseState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_clutchCommandResponseState_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_set_clutchCommandResponseState_1');
var _emscripten_bind_EngineDrivetrainState_get_differentialState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_differentialState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_get_differentialState_0');
var _emscripten_bind_EngineDrivetrainState_set_differentialState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_differentialState_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_set_differentialState_1');
var _emscripten_bind_EngineDrivetrainState_get_wheelConstraintGroupState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_wheelConstraintGroupState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_get_wheelConstraintGroupState_0');
var _emscripten_bind_EngineDrivetrainState_set_wheelConstraintGroupState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_wheelConstraintGroupState_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_set_wheelConstraintGroupState_1');
var _emscripten_bind_EngineDrivetrainState_get_engineState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_engineState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_get_engineState_0');
var _emscripten_bind_EngineDrivetrainState_set_engineState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_engineState_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_set_engineState_1');
var _emscripten_bind_EngineDrivetrainState_get_gearboxState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_gearboxState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_get_gearboxState_0');
var _emscripten_bind_EngineDrivetrainState_set_gearboxState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_gearboxState_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_set_gearboxState_1');
var _emscripten_bind_EngineDrivetrainState_get_clutchState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_clutchState_0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_get_clutchState_0');
var _emscripten_bind_EngineDrivetrainState_set_clutchState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_clutchState_1'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState_set_clutchState_1');
var _emscripten_bind_EngineDrivetrainState___destroy___0 = Module['_emscripten_bind_EngineDrivetrainState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_EngineDrivetrainState___destroy___0');
var _emscripten_bind_NativeArrayHelpers_getU8At_2 = Module['_emscripten_bind_NativeArrayHelpers_getU8At_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getU8At_2');
var _emscripten_bind_NativeArrayHelpers_getU16At_2 = Module['_emscripten_bind_NativeArrayHelpers_getU16At_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getU16At_2');
var _emscripten_bind_NativeArrayHelpers_getU32At_2 = Module['_emscripten_bind_NativeArrayHelpers_getU32At_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getU32At_2');
var _emscripten_bind_NativeArrayHelpers_getRealAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getRealAt_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getRealAt_2');
var _emscripten_bind_NativeArrayHelpers_setU8At_3 = Module['_emscripten_bind_NativeArrayHelpers_setU8At_3'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_setU8At_3');
var _emscripten_bind_NativeArrayHelpers_setU16At_3 = Module['_emscripten_bind_NativeArrayHelpers_setU16At_3'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_setU16At_3');
var _emscripten_bind_NativeArrayHelpers_setU32At_3 = Module['_emscripten_bind_NativeArrayHelpers_setU32At_3'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_setU32At_3');
var _emscripten_bind_NativeArrayHelpers_setRealAt_3 = Module['_emscripten_bind_NativeArrayHelpers_setRealAt_3'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_setRealAt_3');
var _emscripten_bind_NativeArrayHelpers_voidToU8Ptr_1 = Module['_emscripten_bind_NativeArrayHelpers_voidToU8Ptr_1'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_voidToU8Ptr_1');
var _emscripten_bind_NativeArrayHelpers_voidToU16Ptr_1 = Module['_emscripten_bind_NativeArrayHelpers_voidToU16Ptr_1'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_voidToU16Ptr_1');
var _emscripten_bind_NativeArrayHelpers_voidToU32Ptr_1 = Module['_emscripten_bind_NativeArrayHelpers_voidToU32Ptr_1'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_voidToU32Ptr_1');
var _emscripten_bind_NativeArrayHelpers_voidToI32Ptr_1 = Module['_emscripten_bind_NativeArrayHelpers_voidToI32Ptr_1'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_voidToI32Ptr_1');
var _emscripten_bind_NativeArrayHelpers_voidToRealPtr_1 = Module['_emscripten_bind_NativeArrayHelpers_voidToRealPtr_1'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_voidToRealPtr_1');
var _emscripten_bind_NativeArrayHelpers_getActorAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getActorAt_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getActorAt_2');
var _emscripten_bind_NativeArrayHelpers_getBounds3At_2 = Module['_emscripten_bind_NativeArrayHelpers_getBounds3At_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getBounds3At_2');
var _emscripten_bind_NativeArrayHelpers_getContactPairAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getContactPairAt_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getContactPairAt_2');
var _emscripten_bind_NativeArrayHelpers_getContactPairHeaderAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getContactPairHeaderAt_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getContactPairHeaderAt_2');
var _emscripten_bind_NativeArrayHelpers_getControllerAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getControllerAt_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getControllerAt_2');
var _emscripten_bind_NativeArrayHelpers_getControllerShapeHitAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getControllerShapeHitAt_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getControllerShapeHitAt_2');
var _emscripten_bind_NativeArrayHelpers_getControllersHitAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getControllersHitAt_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getControllersHitAt_2');
var _emscripten_bind_NativeArrayHelpers_getControllerObstacleHitAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getControllerObstacleHitAt_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getControllerObstacleHitAt_2');
var _emscripten_bind_NativeArrayHelpers_getDebugPointAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getDebugPointAt_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getDebugPointAt_2');
var _emscripten_bind_NativeArrayHelpers_getDebugLineAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getDebugLineAt_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getDebugLineAt_2');
var _emscripten_bind_NativeArrayHelpers_getDebugTriangleAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getDebugTriangleAt_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getDebugTriangleAt_2');
var _emscripten_bind_NativeArrayHelpers_getObstacleAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getObstacleAt_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getObstacleAt_2');
var _emscripten_bind_NativeArrayHelpers_getShapeAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getShapeAt_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getShapeAt_2');
var _emscripten_bind_NativeArrayHelpers_getTriggerPairAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getTriggerPairAt_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getTriggerPairAt_2');
var _emscripten_bind_NativeArrayHelpers_getVec3At_2 = Module['_emscripten_bind_NativeArrayHelpers_getVec3At_2'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers_getVec3At_2');
var _emscripten_bind_NativeArrayHelpers___destroy___0 = Module['_emscripten_bind_NativeArrayHelpers___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_NativeArrayHelpers___destroy___0');
var _emscripten_bind_PassThroughFilterShaderImpl_PassThroughFilterShaderImpl_0 = Module['_emscripten_bind_PassThroughFilterShaderImpl_PassThroughFilterShaderImpl_0'] = makeInvalidEarlyAccess('_emscripten_bind_PassThroughFilterShaderImpl_PassThroughFilterShaderImpl_0');
var _emscripten_bind_PassThroughFilterShaderImpl_filterShader_10 = Module['_emscripten_bind_PassThroughFilterShaderImpl_filterShader_10'] = makeInvalidEarlyAccess('_emscripten_bind_PassThroughFilterShaderImpl_filterShader_10');
var _emscripten_bind_PassThroughFilterShaderImpl___destroy___0 = Module['_emscripten_bind_PassThroughFilterShaderImpl___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PassThroughFilterShaderImpl___destroy___0');
var _emscripten_bind_PhysXIntegrationParams_PhysXIntegrationParams_0 = Module['_emscripten_bind_PhysXIntegrationParams_PhysXIntegrationParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_PhysXIntegrationParams_0');
var _emscripten_bind_PhysXIntegrationParams_transformAndScale_4 = Module['_emscripten_bind_PhysXIntegrationParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_transformAndScale_4');
var _emscripten_bind_PhysXIntegrationParams_isValid_1 = Module['_emscripten_bind_PhysXIntegrationParams_isValid_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_isValid_1');
var _emscripten_bind_PhysXIntegrationParams_create_10 = Module['_emscripten_bind_PhysXIntegrationParams_create_10'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_create_10');
var _emscripten_bind_PhysXIntegrationParams_get_physxRoadGeometryQueryParams_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxRoadGeometryQueryParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_get_physxRoadGeometryQueryParams_0');
var _emscripten_bind_PhysXIntegrationParams_set_physxRoadGeometryQueryParams_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxRoadGeometryQueryParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_set_physxRoadGeometryQueryParams_1');
var _emscripten_bind_PhysXIntegrationParams_get_physxMaterialFrictionParams_1 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxMaterialFrictionParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_get_physxMaterialFrictionParams_1');
var _emscripten_bind_PhysXIntegrationParams_set_physxMaterialFrictionParams_2 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxMaterialFrictionParams_2'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_set_physxMaterialFrictionParams_2');
var _emscripten_bind_PhysXIntegrationParams_get_physxSuspensionLimitConstraintParams_1 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxSuspensionLimitConstraintParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_get_physxSuspensionLimitConstraintParams_1');
var _emscripten_bind_PhysXIntegrationParams_set_physxSuspensionLimitConstraintParams_2 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxSuspensionLimitConstraintParams_2'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_set_physxSuspensionLimitConstraintParams_2');
var _emscripten_bind_PhysXIntegrationParams_get_physxActorCMassLocalPose_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorCMassLocalPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_get_physxActorCMassLocalPose_0');
var _emscripten_bind_PhysXIntegrationParams_set_physxActorCMassLocalPose_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorCMassLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_set_physxActorCMassLocalPose_1');
var _emscripten_bind_PhysXIntegrationParams_get_physxActorGeometry_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorGeometry_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_get_physxActorGeometry_0');
var _emscripten_bind_PhysXIntegrationParams_set_physxActorGeometry_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorGeometry_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_set_physxActorGeometry_1');
var _emscripten_bind_PhysXIntegrationParams_get_physxActorBoxShapeLocalPose_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorBoxShapeLocalPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_get_physxActorBoxShapeLocalPose_0');
var _emscripten_bind_PhysXIntegrationParams_set_physxActorBoxShapeLocalPose_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorBoxShapeLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_set_physxActorBoxShapeLocalPose_1');
var _emscripten_bind_PhysXIntegrationParams_get_physxWheelShapeLocalPoses_1 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxWheelShapeLocalPoses_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_get_physxWheelShapeLocalPoses_1');
var _emscripten_bind_PhysXIntegrationParams_set_physxWheelShapeLocalPoses_2 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxWheelShapeLocalPoses_2'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_set_physxWheelShapeLocalPoses_2');
var _emscripten_bind_PhysXIntegrationParams_get_physxActorShapeFlags_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorShapeFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_get_physxActorShapeFlags_0');
var _emscripten_bind_PhysXIntegrationParams_set_physxActorShapeFlags_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorShapeFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_set_physxActorShapeFlags_1');
var _emscripten_bind_PhysXIntegrationParams_get_physxActorSimulationFilterData_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorSimulationFilterData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_get_physxActorSimulationFilterData_0');
var _emscripten_bind_PhysXIntegrationParams_set_physxActorSimulationFilterData_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorSimulationFilterData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_set_physxActorSimulationFilterData_1');
var _emscripten_bind_PhysXIntegrationParams_get_physxActorQueryFilterData_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorQueryFilterData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_get_physxActorQueryFilterData_0');
var _emscripten_bind_PhysXIntegrationParams_set_physxActorQueryFilterData_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorQueryFilterData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_set_physxActorQueryFilterData_1');
var _emscripten_bind_PhysXIntegrationParams_get_physxActorWheelShapeFlags_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorWheelShapeFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_get_physxActorWheelShapeFlags_0');
var _emscripten_bind_PhysXIntegrationParams_set_physxActorWheelShapeFlags_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorWheelShapeFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_set_physxActorWheelShapeFlags_1');
var _emscripten_bind_PhysXIntegrationParams_get_physxActorWheelSimulationFilterData_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorWheelSimulationFilterData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_get_physxActorWheelSimulationFilterData_0');
var _emscripten_bind_PhysXIntegrationParams_set_physxActorWheelSimulationFilterData_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorWheelSimulationFilterData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_set_physxActorWheelSimulationFilterData_1');
var _emscripten_bind_PhysXIntegrationParams_get_physxActorWheelQueryFilterData_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorWheelQueryFilterData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_get_physxActorWheelQueryFilterData_0');
var _emscripten_bind_PhysXIntegrationParams_set_physxActorWheelQueryFilterData_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorWheelQueryFilterData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams_set_physxActorWheelQueryFilterData_1');
var _emscripten_bind_PhysXIntegrationParams___destroy___0 = Module['_emscripten_bind_PhysXIntegrationParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationParams___destroy___0');
var _emscripten_bind_PhysXIntegrationState_PhysXIntegrationState_0 = Module['_emscripten_bind_PhysXIntegrationState_PhysXIntegrationState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationState_PhysXIntegrationState_0');
var _emscripten_bind_PhysXIntegrationState_destroyState_0 = Module['_emscripten_bind_PhysXIntegrationState_destroyState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationState_destroyState_0');
var _emscripten_bind_PhysXIntegrationState_setToDefault_0 = Module['_emscripten_bind_PhysXIntegrationState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationState_setToDefault_0');
var _emscripten_bind_PhysXIntegrationState_create_5 = Module['_emscripten_bind_PhysXIntegrationState_create_5'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationState_create_5');
var _emscripten_bind_PhysXIntegrationState_get_physxActor_0 = Module['_emscripten_bind_PhysXIntegrationState_get_physxActor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationState_get_physxActor_0');
var _emscripten_bind_PhysXIntegrationState_set_physxActor_1 = Module['_emscripten_bind_PhysXIntegrationState_set_physxActor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationState_set_physxActor_1');
var _emscripten_bind_PhysXIntegrationState_get_physxSteerState_0 = Module['_emscripten_bind_PhysXIntegrationState_get_physxSteerState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationState_get_physxSteerState_0');
var _emscripten_bind_PhysXIntegrationState_set_physxSteerState_1 = Module['_emscripten_bind_PhysXIntegrationState_set_physxSteerState_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationState_set_physxSteerState_1');
var _emscripten_bind_PhysXIntegrationState_get_physxConstraints_0 = Module['_emscripten_bind_PhysXIntegrationState_get_physxConstraints_0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationState_get_physxConstraints_0');
var _emscripten_bind_PhysXIntegrationState_set_physxConstraints_1 = Module['_emscripten_bind_PhysXIntegrationState_set_physxConstraints_1'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationState_set_physxConstraints_1');
var _emscripten_bind_PhysXIntegrationState___destroy___0 = Module['_emscripten_bind_PhysXIntegrationState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PhysXIntegrationState___destroy___0');
var _emscripten_bind_PxActorFlags_PxActorFlags_1 = Module['_emscripten_bind_PxActorFlags_PxActorFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActorFlags_PxActorFlags_1');
var _emscripten_bind_PxActorFlags_isSet_1 = Module['_emscripten_bind_PxActorFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActorFlags_isSet_1');
var _emscripten_bind_PxActorFlags_raise_1 = Module['_emscripten_bind_PxActorFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActorFlags_raise_1');
var _emscripten_bind_PxActorFlags_clear_1 = Module['_emscripten_bind_PxActorFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActorFlags_clear_1');
var _emscripten_bind_PxActorFlags___destroy___0 = Module['_emscripten_bind_PxActorFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActorFlags___destroy___0');
var _emscripten_bind_PxActorPtr___destroy___0 = Module['_emscripten_bind_PxActorPtr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActorPtr___destroy___0');
var _emscripten_bind_PxActorTypeFlags_PxActorTypeFlags_1 = Module['_emscripten_bind_PxActorTypeFlags_PxActorTypeFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActorTypeFlags_PxActorTypeFlags_1');
var _emscripten_bind_PxActorTypeFlags_isSet_1 = Module['_emscripten_bind_PxActorTypeFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActorTypeFlags_isSet_1');
var _emscripten_bind_PxActorTypeFlags_raise_1 = Module['_emscripten_bind_PxActorTypeFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActorTypeFlags_raise_1');
var _emscripten_bind_PxActorTypeFlags_clear_1 = Module['_emscripten_bind_PxActorTypeFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxActorTypeFlags_clear_1');
var _emscripten_bind_PxActorTypeFlags___destroy___0 = Module['_emscripten_bind_PxActorTypeFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxActorTypeFlags___destroy___0');
var _emscripten_bind_PxAggregate_addActor_1 = Module['_emscripten_bind_PxAggregate_addActor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_addActor_1');
var _emscripten_bind_PxAggregate_addActor_2 = Module['_emscripten_bind_PxAggregate_addActor_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_addActor_2');
var _emscripten_bind_PxAggregate_removeActor_1 = Module['_emscripten_bind_PxAggregate_removeActor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_removeActor_1');
var _emscripten_bind_PxAggregate_addArticulation_1 = Module['_emscripten_bind_PxAggregate_addArticulation_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_addArticulation_1');
var _emscripten_bind_PxAggregate_removeArticulation_1 = Module['_emscripten_bind_PxAggregate_removeArticulation_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_removeArticulation_1');
var _emscripten_bind_PxAggregate_getNbActors_0 = Module['_emscripten_bind_PxAggregate_getNbActors_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_getNbActors_0');
var _emscripten_bind_PxAggregate_getMaxNbActors_0 = Module['_emscripten_bind_PxAggregate_getMaxNbActors_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_getMaxNbActors_0');
var _emscripten_bind_PxAggregate_getMaxNbShapes_0 = Module['_emscripten_bind_PxAggregate_getMaxNbShapes_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_getMaxNbShapes_0');
var _emscripten_bind_PxAggregate_getScene_0 = Module['_emscripten_bind_PxAggregate_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_getScene_0');
var _emscripten_bind_PxAggregate_getSelfCollision_0 = Module['_emscripten_bind_PxAggregate_getSelfCollision_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_getSelfCollision_0');
var _emscripten_bind_PxAggregate_release_0 = Module['_emscripten_bind_PxAggregate_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_release_0');
var _emscripten_bind_PxAggregate_getConcreteTypeName_0 = Module['_emscripten_bind_PxAggregate_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_getConcreteTypeName_0');
var _emscripten_bind_PxAggregate_getConcreteType_0 = Module['_emscripten_bind_PxAggregate_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_getConcreteType_0');
var _emscripten_bind_PxAggregate_setBaseFlag_2 = Module['_emscripten_bind_PxAggregate_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_setBaseFlag_2');
var _emscripten_bind_PxAggregate_setBaseFlags_1 = Module['_emscripten_bind_PxAggregate_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_setBaseFlags_1');
var _emscripten_bind_PxAggregate_getBaseFlags_0 = Module['_emscripten_bind_PxAggregate_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_getBaseFlags_0');
var _emscripten_bind_PxAggregate_isReleasable_0 = Module['_emscripten_bind_PxAggregate_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxAggregate_isReleasable_0');
var _emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_0 = Module['_emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_0');
var _emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_1 = Module['_emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_1');
var _emscripten_bind_PxArray_PxActorPtr_get_1 = Module['_emscripten_bind_PxArray_PxActorPtr_get_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxActorPtr_get_1');
var _emscripten_bind_PxArray_PxActorPtr_set_2 = Module['_emscripten_bind_PxArray_PxActorPtr_set_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxActorPtr_set_2');
var _emscripten_bind_PxArray_PxActorPtr_begin_0 = Module['_emscripten_bind_PxArray_PxActorPtr_begin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxActorPtr_begin_0');
var _emscripten_bind_PxArray_PxActorPtr_size_0 = Module['_emscripten_bind_PxArray_PxActorPtr_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxActorPtr_size_0');
var _emscripten_bind_PxArray_PxActorPtr_pushBack_1 = Module['_emscripten_bind_PxArray_PxActorPtr_pushBack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxActorPtr_pushBack_1');
var _emscripten_bind_PxArray_PxActorPtr_clear_0 = Module['_emscripten_bind_PxArray_PxActorPtr_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxActorPtr_clear_0');
var _emscripten_bind_PxArray_PxActorPtr___destroy___0 = Module['_emscripten_bind_PxArray_PxActorPtr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxActorPtr___destroy___0');
var _emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_0 = Module['_emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_0');
var _emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_1 = Module['_emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_1');
var _emscripten_bind_PxArray_PxContactPairPoint_get_1 = Module['_emscripten_bind_PxArray_PxContactPairPoint_get_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxContactPairPoint_get_1');
var _emscripten_bind_PxArray_PxContactPairPoint_set_2 = Module['_emscripten_bind_PxArray_PxContactPairPoint_set_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxContactPairPoint_set_2');
var _emscripten_bind_PxArray_PxContactPairPoint_begin_0 = Module['_emscripten_bind_PxArray_PxContactPairPoint_begin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxContactPairPoint_begin_0');
var _emscripten_bind_PxArray_PxContactPairPoint_size_0 = Module['_emscripten_bind_PxArray_PxContactPairPoint_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxContactPairPoint_size_0');
var _emscripten_bind_PxArray_PxContactPairPoint_pushBack_1 = Module['_emscripten_bind_PxArray_PxContactPairPoint_pushBack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxContactPairPoint_pushBack_1');
var _emscripten_bind_PxArray_PxContactPairPoint_clear_0 = Module['_emscripten_bind_PxArray_PxContactPairPoint_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxContactPairPoint_clear_0');
var _emscripten_bind_PxArray_PxContactPairPoint___destroy___0 = Module['_emscripten_bind_PxArray_PxContactPairPoint___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxContactPairPoint___destroy___0');
var _emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_0 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_0');
var _emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_1 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_1');
var _emscripten_bind_PxArray_PxHeightFieldSample_get_1 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_get_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxHeightFieldSample_get_1');
var _emscripten_bind_PxArray_PxHeightFieldSample_set_2 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_set_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxHeightFieldSample_set_2');
var _emscripten_bind_PxArray_PxHeightFieldSample_begin_0 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_begin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxHeightFieldSample_begin_0');
var _emscripten_bind_PxArray_PxHeightFieldSample_size_0 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxHeightFieldSample_size_0');
var _emscripten_bind_PxArray_PxHeightFieldSample_pushBack_1 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_pushBack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxHeightFieldSample_pushBack_1');
var _emscripten_bind_PxArray_PxHeightFieldSample_clear_0 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxHeightFieldSample_clear_0');
var _emscripten_bind_PxArray_PxHeightFieldSample___destroy___0 = Module['_emscripten_bind_PxArray_PxHeightFieldSample___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxHeightFieldSample___destroy___0');
var _emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_0 = Module['_emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_0');
var _emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_1 = Module['_emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_1');
var _emscripten_bind_PxArray_PxMaterialConst_get_1 = Module['_emscripten_bind_PxArray_PxMaterialConst_get_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxMaterialConst_get_1');
var _emscripten_bind_PxArray_PxMaterialConst_set_2 = Module['_emscripten_bind_PxArray_PxMaterialConst_set_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxMaterialConst_set_2');
var _emscripten_bind_PxArray_PxMaterialConst_begin_0 = Module['_emscripten_bind_PxArray_PxMaterialConst_begin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxMaterialConst_begin_0');
var _emscripten_bind_PxArray_PxMaterialConst_size_0 = Module['_emscripten_bind_PxArray_PxMaterialConst_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxMaterialConst_size_0');
var _emscripten_bind_PxArray_PxMaterialConst_pushBack_1 = Module['_emscripten_bind_PxArray_PxMaterialConst_pushBack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxMaterialConst_pushBack_1');
var _emscripten_bind_PxArray_PxMaterialConst_clear_0 = Module['_emscripten_bind_PxArray_PxMaterialConst_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxMaterialConst_clear_0');
var _emscripten_bind_PxArray_PxMaterialConst___destroy___0 = Module['_emscripten_bind_PxArray_PxMaterialConst___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxMaterialConst___destroy___0');
var _emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_0 = Module['_emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_0');
var _emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_1 = Module['_emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_1');
var _emscripten_bind_PxArray_PxRaycastHit_get_1 = Module['_emscripten_bind_PxArray_PxRaycastHit_get_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxRaycastHit_get_1');
var _emscripten_bind_PxArray_PxRaycastHit_set_2 = Module['_emscripten_bind_PxArray_PxRaycastHit_set_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxRaycastHit_set_2');
var _emscripten_bind_PxArray_PxRaycastHit_begin_0 = Module['_emscripten_bind_PxArray_PxRaycastHit_begin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxRaycastHit_begin_0');
var _emscripten_bind_PxArray_PxRaycastHit_size_0 = Module['_emscripten_bind_PxArray_PxRaycastHit_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxRaycastHit_size_0');
var _emscripten_bind_PxArray_PxRaycastHit_pushBack_1 = Module['_emscripten_bind_PxArray_PxRaycastHit_pushBack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxRaycastHit_pushBack_1');
var _emscripten_bind_PxArray_PxRaycastHit_clear_0 = Module['_emscripten_bind_PxArray_PxRaycastHit_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxRaycastHit_clear_0');
var _emscripten_bind_PxArray_PxRaycastHit___destroy___0 = Module['_emscripten_bind_PxArray_PxRaycastHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxRaycastHit___destroy___0');
var _emscripten_bind_PxArray_PxReal_PxArray_PxReal_0 = Module['_emscripten_bind_PxArray_PxReal_PxArray_PxReal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxReal_PxArray_PxReal_0');
var _emscripten_bind_PxArray_PxReal_PxArray_PxReal_1 = Module['_emscripten_bind_PxArray_PxReal_PxArray_PxReal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxReal_PxArray_PxReal_1');
var _emscripten_bind_PxArray_PxReal_get_1 = Module['_emscripten_bind_PxArray_PxReal_get_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxReal_get_1');
var _emscripten_bind_PxArray_PxReal_set_2 = Module['_emscripten_bind_PxArray_PxReal_set_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxReal_set_2');
var _emscripten_bind_PxArray_PxReal_begin_0 = Module['_emscripten_bind_PxArray_PxReal_begin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxReal_begin_0');
var _emscripten_bind_PxArray_PxReal_size_0 = Module['_emscripten_bind_PxArray_PxReal_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxReal_size_0');
var _emscripten_bind_PxArray_PxReal_pushBack_1 = Module['_emscripten_bind_PxArray_PxReal_pushBack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxReal_pushBack_1');
var _emscripten_bind_PxArray_PxReal_clear_0 = Module['_emscripten_bind_PxArray_PxReal_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxReal_clear_0');
var _emscripten_bind_PxArray_PxReal___destroy___0 = Module['_emscripten_bind_PxArray_PxReal___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxReal___destroy___0');
var _emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_0 = Module['_emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_0');
var _emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_1 = Module['_emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_1');
var _emscripten_bind_PxArray_PxShapePtr_get_1 = Module['_emscripten_bind_PxArray_PxShapePtr_get_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxShapePtr_get_1');
var _emscripten_bind_PxArray_PxShapePtr_set_2 = Module['_emscripten_bind_PxArray_PxShapePtr_set_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxShapePtr_set_2');
var _emscripten_bind_PxArray_PxShapePtr_begin_0 = Module['_emscripten_bind_PxArray_PxShapePtr_begin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxShapePtr_begin_0');
var _emscripten_bind_PxArray_PxShapePtr_size_0 = Module['_emscripten_bind_PxArray_PxShapePtr_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxShapePtr_size_0');
var _emscripten_bind_PxArray_PxShapePtr_pushBack_1 = Module['_emscripten_bind_PxArray_PxShapePtr_pushBack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxShapePtr_pushBack_1');
var _emscripten_bind_PxArray_PxShapePtr_clear_0 = Module['_emscripten_bind_PxArray_PxShapePtr_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxShapePtr_clear_0');
var _emscripten_bind_PxArray_PxShapePtr___destroy___0 = Module['_emscripten_bind_PxArray_PxShapePtr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxShapePtr___destroy___0');
var _emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_0 = Module['_emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_0');
var _emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_1 = Module['_emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_1');
var _emscripten_bind_PxArray_PxSweepHit_get_1 = Module['_emscripten_bind_PxArray_PxSweepHit_get_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxSweepHit_get_1');
var _emscripten_bind_PxArray_PxSweepHit_set_2 = Module['_emscripten_bind_PxArray_PxSweepHit_set_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxSweepHit_set_2');
var _emscripten_bind_PxArray_PxSweepHit_begin_0 = Module['_emscripten_bind_PxArray_PxSweepHit_begin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxSweepHit_begin_0');
var _emscripten_bind_PxArray_PxSweepHit_size_0 = Module['_emscripten_bind_PxArray_PxSweepHit_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxSweepHit_size_0');
var _emscripten_bind_PxArray_PxSweepHit_pushBack_1 = Module['_emscripten_bind_PxArray_PxSweepHit_pushBack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxSweepHit_pushBack_1');
var _emscripten_bind_PxArray_PxSweepHit_clear_0 = Module['_emscripten_bind_PxArray_PxSweepHit_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxSweepHit_clear_0');
var _emscripten_bind_PxArray_PxSweepHit___destroy___0 = Module['_emscripten_bind_PxArray_PxSweepHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxSweepHit___destroy___0');
var _emscripten_bind_PxArray_PxU16_PxArray_PxU16_0 = Module['_emscripten_bind_PxArray_PxU16_PxArray_PxU16_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU16_PxArray_PxU16_0');
var _emscripten_bind_PxArray_PxU16_PxArray_PxU16_1 = Module['_emscripten_bind_PxArray_PxU16_PxArray_PxU16_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU16_PxArray_PxU16_1');
var _emscripten_bind_PxArray_PxU16_get_1 = Module['_emscripten_bind_PxArray_PxU16_get_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU16_get_1');
var _emscripten_bind_PxArray_PxU16_set_2 = Module['_emscripten_bind_PxArray_PxU16_set_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU16_set_2');
var _emscripten_bind_PxArray_PxU16_begin_0 = Module['_emscripten_bind_PxArray_PxU16_begin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU16_begin_0');
var _emscripten_bind_PxArray_PxU16_size_0 = Module['_emscripten_bind_PxArray_PxU16_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU16_size_0');
var _emscripten_bind_PxArray_PxU16_pushBack_1 = Module['_emscripten_bind_PxArray_PxU16_pushBack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU16_pushBack_1');
var _emscripten_bind_PxArray_PxU16_clear_0 = Module['_emscripten_bind_PxArray_PxU16_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU16_clear_0');
var _emscripten_bind_PxArray_PxU16___destroy___0 = Module['_emscripten_bind_PxArray_PxU16___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU16___destroy___0');
var _emscripten_bind_PxArray_PxU32_PxArray_PxU32_0 = Module['_emscripten_bind_PxArray_PxU32_PxArray_PxU32_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU32_PxArray_PxU32_0');
var _emscripten_bind_PxArray_PxU32_PxArray_PxU32_1 = Module['_emscripten_bind_PxArray_PxU32_PxArray_PxU32_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU32_PxArray_PxU32_1');
var _emscripten_bind_PxArray_PxU32_get_1 = Module['_emscripten_bind_PxArray_PxU32_get_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU32_get_1');
var _emscripten_bind_PxArray_PxU32_set_2 = Module['_emscripten_bind_PxArray_PxU32_set_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU32_set_2');
var _emscripten_bind_PxArray_PxU32_begin_0 = Module['_emscripten_bind_PxArray_PxU32_begin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU32_begin_0');
var _emscripten_bind_PxArray_PxU32_size_0 = Module['_emscripten_bind_PxArray_PxU32_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU32_size_0');
var _emscripten_bind_PxArray_PxU32_pushBack_1 = Module['_emscripten_bind_PxArray_PxU32_pushBack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU32_pushBack_1');
var _emscripten_bind_PxArray_PxU32_clear_0 = Module['_emscripten_bind_PxArray_PxU32_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU32_clear_0');
var _emscripten_bind_PxArray_PxU32___destroy___0 = Module['_emscripten_bind_PxArray_PxU32___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU32___destroy___0');
var _emscripten_bind_PxArray_PxU8_PxArray_PxU8_0 = Module['_emscripten_bind_PxArray_PxU8_PxArray_PxU8_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU8_PxArray_PxU8_0');
var _emscripten_bind_PxArray_PxU8_PxArray_PxU8_1 = Module['_emscripten_bind_PxArray_PxU8_PxArray_PxU8_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU8_PxArray_PxU8_1');
var _emscripten_bind_PxArray_PxU8_get_1 = Module['_emscripten_bind_PxArray_PxU8_get_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU8_get_1');
var _emscripten_bind_PxArray_PxU8_set_2 = Module['_emscripten_bind_PxArray_PxU8_set_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU8_set_2');
var _emscripten_bind_PxArray_PxU8_begin_0 = Module['_emscripten_bind_PxArray_PxU8_begin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU8_begin_0');
var _emscripten_bind_PxArray_PxU8_size_0 = Module['_emscripten_bind_PxArray_PxU8_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU8_size_0');
var _emscripten_bind_PxArray_PxU8_pushBack_1 = Module['_emscripten_bind_PxArray_PxU8_pushBack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU8_pushBack_1');
var _emscripten_bind_PxArray_PxU8_setFromBuffer_2 = Module['_emscripten_bind_PxArray_PxU8_setFromBuffer_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU8_setFromBuffer_2');
var _emscripten_bind_PxArray_PxU8_clear_0 = Module['_emscripten_bind_PxArray_PxU8_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU8_clear_0');
var _emscripten_bind_PxArray_PxU8___destroy___0 = Module['_emscripten_bind_PxArray_PxU8___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxU8___destroy___0');
var _emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_0 = Module['_emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_0');
var _emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_1 = Module['_emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_1');
var _emscripten_bind_PxArray_PxVec3_get_1 = Module['_emscripten_bind_PxArray_PxVec3_get_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec3_get_1');
var _emscripten_bind_PxArray_PxVec3_set_2 = Module['_emscripten_bind_PxArray_PxVec3_set_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec3_set_2');
var _emscripten_bind_PxArray_PxVec3_begin_0 = Module['_emscripten_bind_PxArray_PxVec3_begin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec3_begin_0');
var _emscripten_bind_PxArray_PxVec3_size_0 = Module['_emscripten_bind_PxArray_PxVec3_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec3_size_0');
var _emscripten_bind_PxArray_PxVec3_pushBack_1 = Module['_emscripten_bind_PxArray_PxVec3_pushBack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec3_pushBack_1');
var _emscripten_bind_PxArray_PxVec3_clear_0 = Module['_emscripten_bind_PxArray_PxVec3_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec3_clear_0');
var _emscripten_bind_PxArray_PxVec3___destroy___0 = Module['_emscripten_bind_PxArray_PxVec3___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec3___destroy___0');
var _emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_0 = Module['_emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_0');
var _emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_1 = Module['_emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_1');
var _emscripten_bind_PxArray_PxVec4_get_1 = Module['_emscripten_bind_PxArray_PxVec4_get_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec4_get_1');
var _emscripten_bind_PxArray_PxVec4_set_2 = Module['_emscripten_bind_PxArray_PxVec4_set_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec4_set_2');
var _emscripten_bind_PxArray_PxVec4_begin_0 = Module['_emscripten_bind_PxArray_PxVec4_begin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec4_begin_0');
var _emscripten_bind_PxArray_PxVec4_size_0 = Module['_emscripten_bind_PxArray_PxVec4_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec4_size_0');
var _emscripten_bind_PxArray_PxVec4_pushBack_1 = Module['_emscripten_bind_PxArray_PxVec4_pushBack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec4_pushBack_1');
var _emscripten_bind_PxArray_PxVec4_clear_0 = Module['_emscripten_bind_PxArray_PxVec4_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec4_clear_0');
var _emscripten_bind_PxArray_PxVec4___destroy___0 = Module['_emscripten_bind_PxArray_PxVec4___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArray_PxVec4___destroy___0');
var _emscripten_bind_PxArticulationAttachment_setRestLength_1 = Module['_emscripten_bind_PxArticulationAttachment_setRestLength_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_setRestLength_1');
var _emscripten_bind_PxArticulationAttachment_getRestLength_0 = Module['_emscripten_bind_PxArticulationAttachment_getRestLength_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_getRestLength_0');
var _emscripten_bind_PxArticulationAttachment_setLimitParameters_1 = Module['_emscripten_bind_PxArticulationAttachment_setLimitParameters_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_setLimitParameters_1');
var _emscripten_bind_PxArticulationAttachment_getLimitParameters_0 = Module['_emscripten_bind_PxArticulationAttachment_getLimitParameters_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_getLimitParameters_0');
var _emscripten_bind_PxArticulationAttachment_setRelativeOffset_1 = Module['_emscripten_bind_PxArticulationAttachment_setRelativeOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_setRelativeOffset_1');
var _emscripten_bind_PxArticulationAttachment_getRelativeOffset_0 = Module['_emscripten_bind_PxArticulationAttachment_getRelativeOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_getRelativeOffset_0');
var _emscripten_bind_PxArticulationAttachment_setCoefficient_1 = Module['_emscripten_bind_PxArticulationAttachment_setCoefficient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_setCoefficient_1');
var _emscripten_bind_PxArticulationAttachment_getCoefficient_0 = Module['_emscripten_bind_PxArticulationAttachment_getCoefficient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_getCoefficient_0');
var _emscripten_bind_PxArticulationAttachment_getLink_0 = Module['_emscripten_bind_PxArticulationAttachment_getLink_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_getLink_0');
var _emscripten_bind_PxArticulationAttachment_getParent_0 = Module['_emscripten_bind_PxArticulationAttachment_getParent_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_getParent_0');
var _emscripten_bind_PxArticulationAttachment_isLeaf_0 = Module['_emscripten_bind_PxArticulationAttachment_isLeaf_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_isLeaf_0');
var _emscripten_bind_PxArticulationAttachment_getTendon_0 = Module['_emscripten_bind_PxArticulationAttachment_getTendon_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_getTendon_0');
var _emscripten_bind_PxArticulationAttachment_release_0 = Module['_emscripten_bind_PxArticulationAttachment_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_release_0');
var _emscripten_bind_PxArticulationAttachment_get_userData_0 = Module['_emscripten_bind_PxArticulationAttachment_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_get_userData_0');
var _emscripten_bind_PxArticulationAttachment_set_userData_1 = Module['_emscripten_bind_PxArticulationAttachment_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment_set_userData_1');
var _emscripten_bind_PxArticulationAttachment___destroy___0 = Module['_emscripten_bind_PxArticulationAttachment___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationAttachment___destroy___0');
var _emscripten_bind_PxArticulationCache_release_0 = Module['_emscripten_bind_PxArticulationCache_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_release_0');
var _emscripten_bind_PxArticulationCache_get_externalForces_0 = Module['_emscripten_bind_PxArticulationCache_get_externalForces_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_externalForces_0');
var _emscripten_bind_PxArticulationCache_set_externalForces_1 = Module['_emscripten_bind_PxArticulationCache_set_externalForces_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_externalForces_1');
var _emscripten_bind_PxArticulationCache_get_denseJacobian_0 = Module['_emscripten_bind_PxArticulationCache_get_denseJacobian_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_denseJacobian_0');
var _emscripten_bind_PxArticulationCache_set_denseJacobian_1 = Module['_emscripten_bind_PxArticulationCache_set_denseJacobian_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_denseJacobian_1');
var _emscripten_bind_PxArticulationCache_get_massMatrix_0 = Module['_emscripten_bind_PxArticulationCache_get_massMatrix_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_massMatrix_0');
var _emscripten_bind_PxArticulationCache_set_massMatrix_1 = Module['_emscripten_bind_PxArticulationCache_set_massMatrix_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_massMatrix_1');
var _emscripten_bind_PxArticulationCache_get_jointVelocity_0 = Module['_emscripten_bind_PxArticulationCache_get_jointVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_jointVelocity_0');
var _emscripten_bind_PxArticulationCache_set_jointVelocity_1 = Module['_emscripten_bind_PxArticulationCache_set_jointVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_jointVelocity_1');
var _emscripten_bind_PxArticulationCache_get_jointAcceleration_0 = Module['_emscripten_bind_PxArticulationCache_get_jointAcceleration_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_jointAcceleration_0');
var _emscripten_bind_PxArticulationCache_set_jointAcceleration_1 = Module['_emscripten_bind_PxArticulationCache_set_jointAcceleration_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_jointAcceleration_1');
var _emscripten_bind_PxArticulationCache_get_jointPosition_0 = Module['_emscripten_bind_PxArticulationCache_get_jointPosition_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_jointPosition_0');
var _emscripten_bind_PxArticulationCache_set_jointPosition_1 = Module['_emscripten_bind_PxArticulationCache_set_jointPosition_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_jointPosition_1');
var _emscripten_bind_PxArticulationCache_get_jointForce_0 = Module['_emscripten_bind_PxArticulationCache_get_jointForce_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_jointForce_0');
var _emscripten_bind_PxArticulationCache_set_jointForce_1 = Module['_emscripten_bind_PxArticulationCache_set_jointForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_jointForce_1');
var _emscripten_bind_PxArticulationCache_get_linkVelocity_0 = Module['_emscripten_bind_PxArticulationCache_get_linkVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_linkVelocity_0');
var _emscripten_bind_PxArticulationCache_set_linkVelocity_1 = Module['_emscripten_bind_PxArticulationCache_set_linkVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_linkVelocity_1');
var _emscripten_bind_PxArticulationCache_get_linkAcceleration_0 = Module['_emscripten_bind_PxArticulationCache_get_linkAcceleration_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_linkAcceleration_0');
var _emscripten_bind_PxArticulationCache_set_linkAcceleration_1 = Module['_emscripten_bind_PxArticulationCache_set_linkAcceleration_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_linkAcceleration_1');
var _emscripten_bind_PxArticulationCache_get_linkIncomingJointForce_0 = Module['_emscripten_bind_PxArticulationCache_get_linkIncomingJointForce_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_linkIncomingJointForce_0');
var _emscripten_bind_PxArticulationCache_set_linkIncomingJointForce_1 = Module['_emscripten_bind_PxArticulationCache_set_linkIncomingJointForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_linkIncomingJointForce_1');
var _emscripten_bind_PxArticulationCache_get_rootLinkData_0 = Module['_emscripten_bind_PxArticulationCache_get_rootLinkData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_rootLinkData_0');
var _emscripten_bind_PxArticulationCache_set_rootLinkData_1 = Module['_emscripten_bind_PxArticulationCache_set_rootLinkData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_rootLinkData_1');
var _emscripten_bind_PxArticulationCache_get_coefficientMatrix_0 = Module['_emscripten_bind_PxArticulationCache_get_coefficientMatrix_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_coefficientMatrix_0');
var _emscripten_bind_PxArticulationCache_set_coefficientMatrix_1 = Module['_emscripten_bind_PxArticulationCache_set_coefficientMatrix_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_coefficientMatrix_1');
var _emscripten_bind_PxArticulationCache_get_lambda_0 = Module['_emscripten_bind_PxArticulationCache_get_lambda_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_lambda_0');
var _emscripten_bind_PxArticulationCache_set_lambda_1 = Module['_emscripten_bind_PxArticulationCache_set_lambda_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_lambda_1');
var _emscripten_bind_PxArticulationCache_get_scratchMemory_0 = Module['_emscripten_bind_PxArticulationCache_get_scratchMemory_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_scratchMemory_0');
var _emscripten_bind_PxArticulationCache_set_scratchMemory_1 = Module['_emscripten_bind_PxArticulationCache_set_scratchMemory_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_scratchMemory_1');
var _emscripten_bind_PxArticulationCache_get_scratchAllocator_0 = Module['_emscripten_bind_PxArticulationCache_get_scratchAllocator_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_scratchAllocator_0');
var _emscripten_bind_PxArticulationCache_set_scratchAllocator_1 = Module['_emscripten_bind_PxArticulationCache_set_scratchAllocator_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_scratchAllocator_1');
var _emscripten_bind_PxArticulationCache_get_version_0 = Module['_emscripten_bind_PxArticulationCache_get_version_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_get_version_0');
var _emscripten_bind_PxArticulationCache_set_version_1 = Module['_emscripten_bind_PxArticulationCache_set_version_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache_set_version_1');
var _emscripten_bind_PxArticulationCache___destroy___0 = Module['_emscripten_bind_PxArticulationCache___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCache___destroy___0');
var _emscripten_bind_PxArticulationCacheFlags_PxArticulationCacheFlags_1 = Module['_emscripten_bind_PxArticulationCacheFlags_PxArticulationCacheFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCacheFlags_PxArticulationCacheFlags_1');
var _emscripten_bind_PxArticulationCacheFlags_isSet_1 = Module['_emscripten_bind_PxArticulationCacheFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCacheFlags_isSet_1');
var _emscripten_bind_PxArticulationCacheFlags_raise_1 = Module['_emscripten_bind_PxArticulationCacheFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCacheFlags_raise_1');
var _emscripten_bind_PxArticulationCacheFlags_clear_1 = Module['_emscripten_bind_PxArticulationCacheFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCacheFlags_clear_1');
var _emscripten_bind_PxArticulationCacheFlags___destroy___0 = Module['_emscripten_bind_PxArticulationCacheFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationCacheFlags___destroy___0');
var _emscripten_bind_PxArticulationDrive_PxArticulationDrive_0 = Module['_emscripten_bind_PxArticulationDrive_PxArticulationDrive_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationDrive_PxArticulationDrive_0');
var _emscripten_bind_PxArticulationDrive_PxArticulationDrive_4 = Module['_emscripten_bind_PxArticulationDrive_PxArticulationDrive_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationDrive_PxArticulationDrive_4');
var _emscripten_bind_PxArticulationDrive_get_stiffness_0 = Module['_emscripten_bind_PxArticulationDrive_get_stiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationDrive_get_stiffness_0');
var _emscripten_bind_PxArticulationDrive_set_stiffness_1 = Module['_emscripten_bind_PxArticulationDrive_set_stiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationDrive_set_stiffness_1');
var _emscripten_bind_PxArticulationDrive_get_damping_0 = Module['_emscripten_bind_PxArticulationDrive_get_damping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationDrive_get_damping_0');
var _emscripten_bind_PxArticulationDrive_set_damping_1 = Module['_emscripten_bind_PxArticulationDrive_set_damping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationDrive_set_damping_1');
var _emscripten_bind_PxArticulationDrive_get_maxForce_0 = Module['_emscripten_bind_PxArticulationDrive_get_maxForce_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationDrive_get_maxForce_0');
var _emscripten_bind_PxArticulationDrive_set_maxForce_1 = Module['_emscripten_bind_PxArticulationDrive_set_maxForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationDrive_set_maxForce_1');
var _emscripten_bind_PxArticulationDrive_get_driveType_0 = Module['_emscripten_bind_PxArticulationDrive_get_driveType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationDrive_get_driveType_0');
var _emscripten_bind_PxArticulationDrive_set_driveType_1 = Module['_emscripten_bind_PxArticulationDrive_set_driveType_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationDrive_set_driveType_1');
var _emscripten_bind_PxArticulationDrive___destroy___0 = Module['_emscripten_bind_PxArticulationDrive___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationDrive___destroy___0');
var _emscripten_bind_PxArticulationFixedTendon_createTendonJoint_5 = Module['_emscripten_bind_PxArticulationFixedTendon_createTendonJoint_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_createTendonJoint_5');
var _emscripten_bind_PxArticulationFixedTendon_getNbTendonJoints_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getNbTendonJoints_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_getNbTendonJoints_0');
var _emscripten_bind_PxArticulationFixedTendon_setRestLength_1 = Module['_emscripten_bind_PxArticulationFixedTendon_setRestLength_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_setRestLength_1');
var _emscripten_bind_PxArticulationFixedTendon_getRestLength_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getRestLength_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_getRestLength_0');
var _emscripten_bind_PxArticulationFixedTendon_setLimitParameters_1 = Module['_emscripten_bind_PxArticulationFixedTendon_setLimitParameters_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_setLimitParameters_1');
var _emscripten_bind_PxArticulationFixedTendon_getLimitParameters_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getLimitParameters_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_getLimitParameters_0');
var _emscripten_bind_PxArticulationFixedTendon_setStiffness_1 = Module['_emscripten_bind_PxArticulationFixedTendon_setStiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_setStiffness_1');
var _emscripten_bind_PxArticulationFixedTendon_getStiffness_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getStiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_getStiffness_0');
var _emscripten_bind_PxArticulationFixedTendon_setDamping_1 = Module['_emscripten_bind_PxArticulationFixedTendon_setDamping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_setDamping_1');
var _emscripten_bind_PxArticulationFixedTendon_getDamping_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getDamping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_getDamping_0');
var _emscripten_bind_PxArticulationFixedTendon_setLimitStiffness_1 = Module['_emscripten_bind_PxArticulationFixedTendon_setLimitStiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_setLimitStiffness_1');
var _emscripten_bind_PxArticulationFixedTendon_getLimitStiffness_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getLimitStiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_getLimitStiffness_0');
var _emscripten_bind_PxArticulationFixedTendon_setOffset_1 = Module['_emscripten_bind_PxArticulationFixedTendon_setOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_setOffset_1');
var _emscripten_bind_PxArticulationFixedTendon_setOffset_2 = Module['_emscripten_bind_PxArticulationFixedTendon_setOffset_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_setOffset_2');
var _emscripten_bind_PxArticulationFixedTendon_getOffset_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_getOffset_0');
var _emscripten_bind_PxArticulationFixedTendon_getArticulation_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getArticulation_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_getArticulation_0');
var _emscripten_bind_PxArticulationFixedTendon_release_0 = Module['_emscripten_bind_PxArticulationFixedTendon_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_release_0');
var _emscripten_bind_PxArticulationFixedTendon_getConcreteTypeName_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_getConcreteTypeName_0');
var _emscripten_bind_PxArticulationFixedTendon_getConcreteType_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_getConcreteType_0');
var _emscripten_bind_PxArticulationFixedTendon_setBaseFlag_2 = Module['_emscripten_bind_PxArticulationFixedTendon_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_setBaseFlag_2');
var _emscripten_bind_PxArticulationFixedTendon_setBaseFlags_1 = Module['_emscripten_bind_PxArticulationFixedTendon_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_setBaseFlags_1');
var _emscripten_bind_PxArticulationFixedTendon_getBaseFlags_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_getBaseFlags_0');
var _emscripten_bind_PxArticulationFixedTendon_isReleasable_0 = Module['_emscripten_bind_PxArticulationFixedTendon_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon_isReleasable_0');
var _emscripten_bind_PxArticulationFixedTendon___destroy___0 = Module['_emscripten_bind_PxArticulationFixedTendon___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFixedTendon___destroy___0');
var _emscripten_bind_PxArticulationFlags_PxArticulationFlags_1 = Module['_emscripten_bind_PxArticulationFlags_PxArticulationFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFlags_PxArticulationFlags_1');
var _emscripten_bind_PxArticulationFlags_isSet_1 = Module['_emscripten_bind_PxArticulationFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFlags_isSet_1');
var _emscripten_bind_PxArticulationFlags_raise_1 = Module['_emscripten_bind_PxArticulationFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFlags_raise_1');
var _emscripten_bind_PxArticulationFlags_clear_1 = Module['_emscripten_bind_PxArticulationFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFlags_clear_1');
var _emscripten_bind_PxArticulationFlags___destroy___0 = Module['_emscripten_bind_PxArticulationFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationFlags___destroy___0');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getParentArticulationLink_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getParentArticulationLink_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getParentArticulationLink_0');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setParentPose_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setParentPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setParentPose_1');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getParentPose_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getParentPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getParentPose_0');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getChildArticulationLink_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getChildArticulationLink_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getChildArticulationLink_0');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setChildPose_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setChildPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setChildPose_1');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getChildPose_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getChildPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getChildPose_0');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setJointType_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setJointType_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setJointType_1');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getJointType_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getJointType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getJointType_0');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setMotion_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setMotion_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setMotion_2');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getMotion_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getMotion_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getMotion_1');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setLimitParams_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setLimitParams_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setLimitParams_2');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getLimitParams_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getLimitParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getLimitParams_1');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveParams_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveParams_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveParams_2');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_2');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_3 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_3');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getDriveTarget_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getDriveTarget_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getDriveTarget_1');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_2');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_3 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_3');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getDriveVelocity_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getDriveVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getDriveVelocity_1');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setArmature_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setArmature_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setArmature_2');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getArmature_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getArmature_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getArmature_1');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setFrictionCoefficient_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setFrictionCoefficient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setFrictionCoefficient_1');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getFrictionCoefficient_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getFrictionCoefficient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getFrictionCoefficient_0');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setMaxJointVelocity_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setMaxJointVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setMaxJointVelocity_1');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getMaxJointVelocity_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getMaxJointVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getMaxJointVelocity_0');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setJointPosition_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setJointPosition_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setJointPosition_2');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getJointPosition_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getJointPosition_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getJointPosition_1');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setJointVelocity_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setJointVelocity_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setJointVelocity_2');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getJointVelocity_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getJointVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getJointVelocity_1');
var _emscripten_bind_PxArticulationJointReducedCoordinate_release_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_release_0');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteTypeName_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteTypeName_0');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteType_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteType_0');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlag_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlag_2');
var _emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlags_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlags_1');
var _emscripten_bind_PxArticulationJointReducedCoordinate_getBaseFlags_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_getBaseFlags_0');
var _emscripten_bind_PxArticulationJointReducedCoordinate_isReleasable_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate_isReleasable_0');
var _emscripten_bind_PxArticulationJointReducedCoordinate___destroy___0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationJointReducedCoordinate___destroy___0');
var _emscripten_bind_PxArticulationKinematicFlags_PxArticulationKinematicFlags_1 = Module['_emscripten_bind_PxArticulationKinematicFlags_PxArticulationKinematicFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationKinematicFlags_PxArticulationKinematicFlags_1');
var _emscripten_bind_PxArticulationKinematicFlags_isSet_1 = Module['_emscripten_bind_PxArticulationKinematicFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationKinematicFlags_isSet_1');
var _emscripten_bind_PxArticulationKinematicFlags_raise_1 = Module['_emscripten_bind_PxArticulationKinematicFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationKinematicFlags_raise_1');
var _emscripten_bind_PxArticulationKinematicFlags_clear_1 = Module['_emscripten_bind_PxArticulationKinematicFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationKinematicFlags_clear_1');
var _emscripten_bind_PxArticulationKinematicFlags___destroy___0 = Module['_emscripten_bind_PxArticulationKinematicFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationKinematicFlags___destroy___0');
var _emscripten_bind_PxArticulationLimit_PxArticulationLimit_0 = Module['_emscripten_bind_PxArticulationLimit_PxArticulationLimit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLimit_PxArticulationLimit_0');
var _emscripten_bind_PxArticulationLimit_PxArticulationLimit_2 = Module['_emscripten_bind_PxArticulationLimit_PxArticulationLimit_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLimit_PxArticulationLimit_2');
var _emscripten_bind_PxArticulationLimit_get_low_0 = Module['_emscripten_bind_PxArticulationLimit_get_low_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLimit_get_low_0');
var _emscripten_bind_PxArticulationLimit_set_low_1 = Module['_emscripten_bind_PxArticulationLimit_set_low_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLimit_set_low_1');
var _emscripten_bind_PxArticulationLimit_get_high_0 = Module['_emscripten_bind_PxArticulationLimit_get_high_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLimit_get_high_0');
var _emscripten_bind_PxArticulationLimit_set_high_1 = Module['_emscripten_bind_PxArticulationLimit_set_high_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLimit_set_high_1');
var _emscripten_bind_PxArticulationLimit___destroy___0 = Module['_emscripten_bind_PxArticulationLimit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLimit___destroy___0');
var _emscripten_bind_PxArticulationLink_getArticulation_0 = Module['_emscripten_bind_PxArticulationLink_getArticulation_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getArticulation_0');
var _emscripten_bind_PxArticulationLink_getInboundJoint_0 = Module['_emscripten_bind_PxArticulationLink_getInboundJoint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getInboundJoint_0');
var _emscripten_bind_PxArticulationLink_getInboundJointDof_0 = Module['_emscripten_bind_PxArticulationLink_getInboundJointDof_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getInboundJointDof_0');
var _emscripten_bind_PxArticulationLink_getNbChildren_0 = Module['_emscripten_bind_PxArticulationLink_getNbChildren_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getNbChildren_0');
var _emscripten_bind_PxArticulationLink_getLinkIndex_0 = Module['_emscripten_bind_PxArticulationLink_getLinkIndex_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getLinkIndex_0');
var _emscripten_bind_PxArticulationLink_setCfmScale_1 = Module['_emscripten_bind_PxArticulationLink_setCfmScale_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setCfmScale_1');
var _emscripten_bind_PxArticulationLink_getCfmScale_0 = Module['_emscripten_bind_PxArticulationLink_getCfmScale_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getCfmScale_0');
var _emscripten_bind_PxArticulationLink_getType_0 = Module['_emscripten_bind_PxArticulationLink_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getType_0');
var _emscripten_bind_PxArticulationLink_getScene_0 = Module['_emscripten_bind_PxArticulationLink_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getScene_0');
var _emscripten_bind_PxArticulationLink_setName_1 = Module['_emscripten_bind_PxArticulationLink_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setName_1');
var _emscripten_bind_PxArticulationLink_getName_0 = Module['_emscripten_bind_PxArticulationLink_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getName_0');
var _emscripten_bind_PxArticulationLink_getWorldBounds_0 = Module['_emscripten_bind_PxArticulationLink_getWorldBounds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getWorldBounds_0');
var _emscripten_bind_PxArticulationLink_getWorldBounds_1 = Module['_emscripten_bind_PxArticulationLink_getWorldBounds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getWorldBounds_1');
var _emscripten_bind_PxArticulationLink_setActorFlag_2 = Module['_emscripten_bind_PxArticulationLink_setActorFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setActorFlag_2');
var _emscripten_bind_PxArticulationLink_setActorFlags_1 = Module['_emscripten_bind_PxArticulationLink_setActorFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setActorFlags_1');
var _emscripten_bind_PxArticulationLink_getActorFlags_0 = Module['_emscripten_bind_PxArticulationLink_getActorFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getActorFlags_0');
var _emscripten_bind_PxArticulationLink_setDominanceGroup_1 = Module['_emscripten_bind_PxArticulationLink_setDominanceGroup_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setDominanceGroup_1');
var _emscripten_bind_PxArticulationLink_getDominanceGroup_0 = Module['_emscripten_bind_PxArticulationLink_getDominanceGroup_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getDominanceGroup_0');
var _emscripten_bind_PxArticulationLink_setOwnerClient_1 = Module['_emscripten_bind_PxArticulationLink_setOwnerClient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setOwnerClient_1');
var _emscripten_bind_PxArticulationLink_getOwnerClient_0 = Module['_emscripten_bind_PxArticulationLink_getOwnerClient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getOwnerClient_0');
var _emscripten_bind_PxArticulationLink_release_0 = Module['_emscripten_bind_PxArticulationLink_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_release_0');
var _emscripten_bind_PxArticulationLink_getConcreteTypeName_0 = Module['_emscripten_bind_PxArticulationLink_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getConcreteTypeName_0');
var _emscripten_bind_PxArticulationLink_getConcreteType_0 = Module['_emscripten_bind_PxArticulationLink_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getConcreteType_0');
var _emscripten_bind_PxArticulationLink_setBaseFlag_2 = Module['_emscripten_bind_PxArticulationLink_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setBaseFlag_2');
var _emscripten_bind_PxArticulationLink_setBaseFlags_1 = Module['_emscripten_bind_PxArticulationLink_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setBaseFlags_1');
var _emscripten_bind_PxArticulationLink_getBaseFlags_0 = Module['_emscripten_bind_PxArticulationLink_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getBaseFlags_0');
var _emscripten_bind_PxArticulationLink_isReleasable_0 = Module['_emscripten_bind_PxArticulationLink_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_isReleasable_0');
var _emscripten_bind_PxArticulationLink_getGlobalPose_0 = Module['_emscripten_bind_PxArticulationLink_getGlobalPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getGlobalPose_0');
var _emscripten_bind_PxArticulationLink_setGlobalPose_1 = Module['_emscripten_bind_PxArticulationLink_setGlobalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setGlobalPose_1');
var _emscripten_bind_PxArticulationLink_setGlobalPose_2 = Module['_emscripten_bind_PxArticulationLink_setGlobalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setGlobalPose_2');
var _emscripten_bind_PxArticulationLink_attachShape_1 = Module['_emscripten_bind_PxArticulationLink_attachShape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_attachShape_1');
var _emscripten_bind_PxArticulationLink_detachShape_1 = Module['_emscripten_bind_PxArticulationLink_detachShape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_detachShape_1');
var _emscripten_bind_PxArticulationLink_detachShape_2 = Module['_emscripten_bind_PxArticulationLink_detachShape_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_detachShape_2');
var _emscripten_bind_PxArticulationLink_getNbShapes_0 = Module['_emscripten_bind_PxArticulationLink_getNbShapes_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getNbShapes_0');
var _emscripten_bind_PxArticulationLink_getShapes_3 = Module['_emscripten_bind_PxArticulationLink_getShapes_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getShapes_3');
var _emscripten_bind_PxArticulationLink_getNbConstraints_0 = Module['_emscripten_bind_PxArticulationLink_getNbConstraints_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getNbConstraints_0');
var _emscripten_bind_PxArticulationLink_setCMassLocalPose_1 = Module['_emscripten_bind_PxArticulationLink_setCMassLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setCMassLocalPose_1');
var _emscripten_bind_PxArticulationLink_getCMassLocalPose_0 = Module['_emscripten_bind_PxArticulationLink_getCMassLocalPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getCMassLocalPose_0');
var _emscripten_bind_PxArticulationLink_setMass_1 = Module['_emscripten_bind_PxArticulationLink_setMass_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setMass_1');
var _emscripten_bind_PxArticulationLink_getMass_0 = Module['_emscripten_bind_PxArticulationLink_getMass_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getMass_0');
var _emscripten_bind_PxArticulationLink_getInvMass_0 = Module['_emscripten_bind_PxArticulationLink_getInvMass_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getInvMass_0');
var _emscripten_bind_PxArticulationLink_setMassSpaceInertiaTensor_1 = Module['_emscripten_bind_PxArticulationLink_setMassSpaceInertiaTensor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setMassSpaceInertiaTensor_1');
var _emscripten_bind_PxArticulationLink_getMassSpaceInertiaTensor_0 = Module['_emscripten_bind_PxArticulationLink_getMassSpaceInertiaTensor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getMassSpaceInertiaTensor_0');
var _emscripten_bind_PxArticulationLink_getMassSpaceInvInertiaTensor_0 = Module['_emscripten_bind_PxArticulationLink_getMassSpaceInvInertiaTensor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getMassSpaceInvInertiaTensor_0');
var _emscripten_bind_PxArticulationLink_setLinearDamping_1 = Module['_emscripten_bind_PxArticulationLink_setLinearDamping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setLinearDamping_1');
var _emscripten_bind_PxArticulationLink_getLinearDamping_0 = Module['_emscripten_bind_PxArticulationLink_getLinearDamping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getLinearDamping_0');
var _emscripten_bind_PxArticulationLink_setAngularDamping_1 = Module['_emscripten_bind_PxArticulationLink_setAngularDamping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setAngularDamping_1');
var _emscripten_bind_PxArticulationLink_getAngularDamping_0 = Module['_emscripten_bind_PxArticulationLink_getAngularDamping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getAngularDamping_0');
var _emscripten_bind_PxArticulationLink_getLinearVelocity_0 = Module['_emscripten_bind_PxArticulationLink_getLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getLinearVelocity_0');
var _emscripten_bind_PxArticulationLink_getAngularVelocity_0 = Module['_emscripten_bind_PxArticulationLink_getAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getAngularVelocity_0');
var _emscripten_bind_PxArticulationLink_setMaxLinearVelocity_1 = Module['_emscripten_bind_PxArticulationLink_setMaxLinearVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setMaxLinearVelocity_1');
var _emscripten_bind_PxArticulationLink_getMaxLinearVelocity_0 = Module['_emscripten_bind_PxArticulationLink_getMaxLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getMaxLinearVelocity_0');
var _emscripten_bind_PxArticulationLink_setMaxAngularVelocity_1 = Module['_emscripten_bind_PxArticulationLink_setMaxAngularVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setMaxAngularVelocity_1');
var _emscripten_bind_PxArticulationLink_getMaxAngularVelocity_0 = Module['_emscripten_bind_PxArticulationLink_getMaxAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getMaxAngularVelocity_0');
var _emscripten_bind_PxArticulationLink_addForce_1 = Module['_emscripten_bind_PxArticulationLink_addForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_addForce_1');
var _emscripten_bind_PxArticulationLink_addForce_2 = Module['_emscripten_bind_PxArticulationLink_addForce_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_addForce_2');
var _emscripten_bind_PxArticulationLink_addForce_3 = Module['_emscripten_bind_PxArticulationLink_addForce_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_addForce_3');
var _emscripten_bind_PxArticulationLink_addTorque_1 = Module['_emscripten_bind_PxArticulationLink_addTorque_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_addTorque_1');
var _emscripten_bind_PxArticulationLink_addTorque_2 = Module['_emscripten_bind_PxArticulationLink_addTorque_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_addTorque_2');
var _emscripten_bind_PxArticulationLink_addTorque_3 = Module['_emscripten_bind_PxArticulationLink_addTorque_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_addTorque_3');
var _emscripten_bind_PxArticulationLink_clearForce_1 = Module['_emscripten_bind_PxArticulationLink_clearForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_clearForce_1');
var _emscripten_bind_PxArticulationLink_clearTorque_1 = Module['_emscripten_bind_PxArticulationLink_clearTorque_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_clearTorque_1');
var _emscripten_bind_PxArticulationLink_setForceAndTorque_2 = Module['_emscripten_bind_PxArticulationLink_setForceAndTorque_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setForceAndTorque_2');
var _emscripten_bind_PxArticulationLink_setForceAndTorque_3 = Module['_emscripten_bind_PxArticulationLink_setForceAndTorque_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setForceAndTorque_3');
var _emscripten_bind_PxArticulationLink_setRigidBodyFlag_2 = Module['_emscripten_bind_PxArticulationLink_setRigidBodyFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setRigidBodyFlag_2');
var _emscripten_bind_PxArticulationLink_setRigidBodyFlags_1 = Module['_emscripten_bind_PxArticulationLink_setRigidBodyFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setRigidBodyFlags_1');
var _emscripten_bind_PxArticulationLink_getRigidBodyFlags_0 = Module['_emscripten_bind_PxArticulationLink_getRigidBodyFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getRigidBodyFlags_0');
var _emscripten_bind_PxArticulationLink_setMinCCDAdvanceCoefficient_1 = Module['_emscripten_bind_PxArticulationLink_setMinCCDAdvanceCoefficient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setMinCCDAdvanceCoefficient_1');
var _emscripten_bind_PxArticulationLink_getMinCCDAdvanceCoefficient_0 = Module['_emscripten_bind_PxArticulationLink_getMinCCDAdvanceCoefficient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getMinCCDAdvanceCoefficient_0');
var _emscripten_bind_PxArticulationLink_setMaxDepenetrationVelocity_1 = Module['_emscripten_bind_PxArticulationLink_setMaxDepenetrationVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setMaxDepenetrationVelocity_1');
var _emscripten_bind_PxArticulationLink_getMaxDepenetrationVelocity_0 = Module['_emscripten_bind_PxArticulationLink_getMaxDepenetrationVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getMaxDepenetrationVelocity_0');
var _emscripten_bind_PxArticulationLink_setMaxContactImpulse_1 = Module['_emscripten_bind_PxArticulationLink_setMaxContactImpulse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setMaxContactImpulse_1');
var _emscripten_bind_PxArticulationLink_getMaxContactImpulse_0 = Module['_emscripten_bind_PxArticulationLink_getMaxContactImpulse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getMaxContactImpulse_0');
var _emscripten_bind_PxArticulationLink_setContactSlopCoefficient_1 = Module['_emscripten_bind_PxArticulationLink_setContactSlopCoefficient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_setContactSlopCoefficient_1');
var _emscripten_bind_PxArticulationLink_getContactSlopCoefficient_0 = Module['_emscripten_bind_PxArticulationLink_getContactSlopCoefficient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_getContactSlopCoefficient_0');
var _emscripten_bind_PxArticulationLink_get_userData_0 = Module['_emscripten_bind_PxArticulationLink_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_get_userData_0');
var _emscripten_bind_PxArticulationLink_set_userData_1 = Module['_emscripten_bind_PxArticulationLink_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationLink_set_userData_1');
var _emscripten_bind_PxArticulationReducedCoordinate_getScene_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getScene_0');
var _emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_1');
var _emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_2');
var _emscripten_bind_PxArticulationReducedCoordinate_isSleeping_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_isSleeping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_isSleeping_0');
var _emscripten_bind_PxArticulationReducedCoordinate_setSleepThreshold_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setSleepThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setSleepThreshold_1');
var _emscripten_bind_PxArticulationReducedCoordinate_getSleepThreshold_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getSleepThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getSleepThreshold_0');
var _emscripten_bind_PxArticulationReducedCoordinate_setStabilizationThreshold_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setStabilizationThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setStabilizationThreshold_1');
var _emscripten_bind_PxArticulationReducedCoordinate_getStabilizationThreshold_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getStabilizationThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getStabilizationThreshold_0');
var _emscripten_bind_PxArticulationReducedCoordinate_setWakeCounter_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setWakeCounter_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setWakeCounter_1');
var _emscripten_bind_PxArticulationReducedCoordinate_getWakeCounter_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getWakeCounter_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getWakeCounter_0');
var _emscripten_bind_PxArticulationReducedCoordinate_wakeUp_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_wakeUp_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_wakeUp_0');
var _emscripten_bind_PxArticulationReducedCoordinate_putToSleep_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_putToSleep_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_putToSleep_0');
var _emscripten_bind_PxArticulationReducedCoordinate_createLink_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_createLink_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_createLink_2');
var _emscripten_bind_PxArticulationReducedCoordinate_getNbLinks_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getNbLinks_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getNbLinks_0');
var _emscripten_bind_PxArticulationReducedCoordinate_getNbShapes_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getNbShapes_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getNbShapes_0');
var _emscripten_bind_PxArticulationReducedCoordinate_setName_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setName_1');
var _emscripten_bind_PxArticulationReducedCoordinate_getName_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getName_0');
var _emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_0');
var _emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_1');
var _emscripten_bind_PxArticulationReducedCoordinate_getAggregate_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getAggregate_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getAggregate_0');
var _emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlags_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlags_1');
var _emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlag_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlag_2');
var _emscripten_bind_PxArticulationReducedCoordinate_getArticulationFlags_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getArticulationFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getArticulationFlags_0');
var _emscripten_bind_PxArticulationReducedCoordinate_getDofs_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getDofs_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getDofs_0');
var _emscripten_bind_PxArticulationReducedCoordinate_createCache_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_createCache_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_createCache_0');
var _emscripten_bind_PxArticulationReducedCoordinate_getCacheDataSize_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getCacheDataSize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getCacheDataSize_0');
var _emscripten_bind_PxArticulationReducedCoordinate_zeroCache_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_zeroCache_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_zeroCache_1');
var _emscripten_bind_PxArticulationReducedCoordinate_applyCache_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_applyCache_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_applyCache_2');
var _emscripten_bind_PxArticulationReducedCoordinate_applyCache_3 = Module['_emscripten_bind_PxArticulationReducedCoordinate_applyCache_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_applyCache_3');
var _emscripten_bind_PxArticulationReducedCoordinate_copyInternalStateToCache_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_copyInternalStateToCache_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_copyInternalStateToCache_2');
var _emscripten_bind_PxArticulationReducedCoordinate_commonInit_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_commonInit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_commonInit_0');
var _emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedGravityForce_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedGravityForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedGravityForce_1');
var _emscripten_bind_PxArticulationReducedCoordinate_computeGravityCompensation_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeGravityCompensation_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_computeGravityCompensation_1');
var _emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisAndCentrifugalForce_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisAndCentrifugalForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisAndCentrifugalForce_1');
var _emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisCompensation_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisCompensation_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisCompensation_1');
var _emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedExternalForce_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedExternalForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedExternalForce_1');
var _emscripten_bind_PxArticulationReducedCoordinate_computeJointAcceleration_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeJointAcceleration_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_computeJointAcceleration_1');
var _emscripten_bind_PxArticulationReducedCoordinate_computeJointForce_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeJointForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_computeJointForce_1');
var _emscripten_bind_PxArticulationReducedCoordinate_computeCoefficientMatrix_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeCoefficientMatrix_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_computeCoefficientMatrix_1');
var _emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedMassMatrix_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedMassMatrix_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedMassMatrix_1');
var _emscripten_bind_PxArticulationReducedCoordinate_computeMassMatrix_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeMassMatrix_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_computeMassMatrix_1');
var _emscripten_bind_PxArticulationReducedCoordinate_computeArticulationCOM_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeArticulationCOM_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_computeArticulationCOM_1');
var _emscripten_bind_PxArticulationReducedCoordinate_computeCentroidalMomentumMatrix_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeCentroidalMomentumMatrix_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_computeCentroidalMomentumMatrix_1');
var _emscripten_bind_PxArticulationReducedCoordinate_addLoopJoint_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_addLoopJoint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_addLoopJoint_1');
var _emscripten_bind_PxArticulationReducedCoordinate_removeLoopJoint_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_removeLoopJoint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_removeLoopJoint_1');
var _emscripten_bind_PxArticulationReducedCoordinate_getNbLoopJoints_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getNbLoopJoints_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getNbLoopJoints_0');
var _emscripten_bind_PxArticulationReducedCoordinate_getCoefficientMatrixSize_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getCoefficientMatrixSize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getCoefficientMatrixSize_0');
var _emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_1');
var _emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_2');
var _emscripten_bind_PxArticulationReducedCoordinate_getRootGlobalPose_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getRootGlobalPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getRootGlobalPose_0');
var _emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_1');
var _emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_2');
var _emscripten_bind_PxArticulationReducedCoordinate_getRootLinearVelocity_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getRootLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getRootLinearVelocity_0');
var _emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_1');
var _emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_2');
var _emscripten_bind_PxArticulationReducedCoordinate_getRootAngularVelocity_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getRootAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getRootAngularVelocity_0');
var _emscripten_bind_PxArticulationReducedCoordinate_getLinkAcceleration_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getLinkAcceleration_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getLinkAcceleration_1');
var _emscripten_bind_PxArticulationReducedCoordinate_getGPUIndex_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getGPUIndex_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getGPUIndex_0');
var _emscripten_bind_PxArticulationReducedCoordinate_createSpatialTendon_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_createSpatialTendon_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_createSpatialTendon_0');
var _emscripten_bind_PxArticulationReducedCoordinate_createFixedTendon_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_createFixedTendon_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_createFixedTendon_0');
var _emscripten_bind_PxArticulationReducedCoordinate_getNbSpatialTendons_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getNbSpatialTendons_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getNbSpatialTendons_0');
var _emscripten_bind_PxArticulationReducedCoordinate_getNbFixedTendons_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getNbFixedTendons_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getNbFixedTendons_0');
var _emscripten_bind_PxArticulationReducedCoordinate_updateKinematic_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_updateKinematic_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_updateKinematic_1');
var _emscripten_bind_PxArticulationReducedCoordinate_release_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_release_0');
var _emscripten_bind_PxArticulationReducedCoordinate_getConcreteTypeName_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getConcreteTypeName_0');
var _emscripten_bind_PxArticulationReducedCoordinate_getConcreteType_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getConcreteType_0');
var _emscripten_bind_PxArticulationReducedCoordinate_setBaseFlag_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setBaseFlag_2');
var _emscripten_bind_PxArticulationReducedCoordinate_setBaseFlags_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_setBaseFlags_1');
var _emscripten_bind_PxArticulationReducedCoordinate_getBaseFlags_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_getBaseFlags_0');
var _emscripten_bind_PxArticulationReducedCoordinate_isReleasable_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate_isReleasable_0');
var _emscripten_bind_PxArticulationReducedCoordinate___destroy___0 = Module['_emscripten_bind_PxArticulationReducedCoordinate___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationReducedCoordinate___destroy___0');
var _emscripten_bind_PxArticulationRootLinkData_PxArticulationRootLinkData_0 = Module['_emscripten_bind_PxArticulationRootLinkData_PxArticulationRootLinkData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationRootLinkData_PxArticulationRootLinkData_0');
var _emscripten_bind_PxArticulationRootLinkData_get_transform_0 = Module['_emscripten_bind_PxArticulationRootLinkData_get_transform_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationRootLinkData_get_transform_0');
var _emscripten_bind_PxArticulationRootLinkData_set_transform_1 = Module['_emscripten_bind_PxArticulationRootLinkData_set_transform_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationRootLinkData_set_transform_1');
var _emscripten_bind_PxArticulationRootLinkData_get_worldLinVel_0 = Module['_emscripten_bind_PxArticulationRootLinkData_get_worldLinVel_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationRootLinkData_get_worldLinVel_0');
var _emscripten_bind_PxArticulationRootLinkData_set_worldLinVel_1 = Module['_emscripten_bind_PxArticulationRootLinkData_set_worldLinVel_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationRootLinkData_set_worldLinVel_1');
var _emscripten_bind_PxArticulationRootLinkData_get_worldAngVel_0 = Module['_emscripten_bind_PxArticulationRootLinkData_get_worldAngVel_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationRootLinkData_get_worldAngVel_0');
var _emscripten_bind_PxArticulationRootLinkData_set_worldAngVel_1 = Module['_emscripten_bind_PxArticulationRootLinkData_set_worldAngVel_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationRootLinkData_set_worldAngVel_1');
var _emscripten_bind_PxArticulationRootLinkData_get_worldLinAccel_0 = Module['_emscripten_bind_PxArticulationRootLinkData_get_worldLinAccel_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationRootLinkData_get_worldLinAccel_0');
var _emscripten_bind_PxArticulationRootLinkData_set_worldLinAccel_1 = Module['_emscripten_bind_PxArticulationRootLinkData_set_worldLinAccel_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationRootLinkData_set_worldLinAccel_1');
var _emscripten_bind_PxArticulationRootLinkData_get_worldAngAccel_0 = Module['_emscripten_bind_PxArticulationRootLinkData_get_worldAngAccel_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationRootLinkData_get_worldAngAccel_0');
var _emscripten_bind_PxArticulationRootLinkData_set_worldAngAccel_1 = Module['_emscripten_bind_PxArticulationRootLinkData_set_worldAngAccel_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationRootLinkData_set_worldAngAccel_1');
var _emscripten_bind_PxArticulationRootLinkData___destroy___0 = Module['_emscripten_bind_PxArticulationRootLinkData___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationRootLinkData___destroy___0');
var _emscripten_bind_PxArticulationSpatialTendon_createAttachment_4 = Module['_emscripten_bind_PxArticulationSpatialTendon_createAttachment_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_createAttachment_4');
var _emscripten_bind_PxArticulationSpatialTendon_getNbAttachments_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getNbAttachments_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_getNbAttachments_0');
var _emscripten_bind_PxArticulationSpatialTendon_setStiffness_1 = Module['_emscripten_bind_PxArticulationSpatialTendon_setStiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_setStiffness_1');
var _emscripten_bind_PxArticulationSpatialTendon_getStiffness_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getStiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_getStiffness_0');
var _emscripten_bind_PxArticulationSpatialTendon_setDamping_1 = Module['_emscripten_bind_PxArticulationSpatialTendon_setDamping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_setDamping_1');
var _emscripten_bind_PxArticulationSpatialTendon_getDamping_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getDamping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_getDamping_0');
var _emscripten_bind_PxArticulationSpatialTendon_setLimitStiffness_1 = Module['_emscripten_bind_PxArticulationSpatialTendon_setLimitStiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_setLimitStiffness_1');
var _emscripten_bind_PxArticulationSpatialTendon_getLimitStiffness_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getLimitStiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_getLimitStiffness_0');
var _emscripten_bind_PxArticulationSpatialTendon_setOffset_1 = Module['_emscripten_bind_PxArticulationSpatialTendon_setOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_setOffset_1');
var _emscripten_bind_PxArticulationSpatialTendon_setOffset_2 = Module['_emscripten_bind_PxArticulationSpatialTendon_setOffset_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_setOffset_2');
var _emscripten_bind_PxArticulationSpatialTendon_getOffset_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_getOffset_0');
var _emscripten_bind_PxArticulationSpatialTendon_getArticulation_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getArticulation_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_getArticulation_0');
var _emscripten_bind_PxArticulationSpatialTendon_release_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_release_0');
var _emscripten_bind_PxArticulationSpatialTendon_getConcreteTypeName_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_getConcreteTypeName_0');
var _emscripten_bind_PxArticulationSpatialTendon_getConcreteType_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_getConcreteType_0');
var _emscripten_bind_PxArticulationSpatialTendon_setBaseFlag_2 = Module['_emscripten_bind_PxArticulationSpatialTendon_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_setBaseFlag_2');
var _emscripten_bind_PxArticulationSpatialTendon_setBaseFlags_1 = Module['_emscripten_bind_PxArticulationSpatialTendon_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_setBaseFlags_1');
var _emscripten_bind_PxArticulationSpatialTendon_getBaseFlags_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_getBaseFlags_0');
var _emscripten_bind_PxArticulationSpatialTendon_isReleasable_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon_isReleasable_0');
var _emscripten_bind_PxArticulationSpatialTendon___destroy___0 = Module['_emscripten_bind_PxArticulationSpatialTendon___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationSpatialTendon___destroy___0');
var _emscripten_bind_PxArticulationTendonJoint_setCoefficient_3 = Module['_emscripten_bind_PxArticulationTendonJoint_setCoefficient_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendonJoint_setCoefficient_3');
var _emscripten_bind_PxArticulationTendonJoint_getLink_0 = Module['_emscripten_bind_PxArticulationTendonJoint_getLink_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendonJoint_getLink_0');
var _emscripten_bind_PxArticulationTendonJoint_getParent_0 = Module['_emscripten_bind_PxArticulationTendonJoint_getParent_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendonJoint_getParent_0');
var _emscripten_bind_PxArticulationTendonJoint_getTendon_0 = Module['_emscripten_bind_PxArticulationTendonJoint_getTendon_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendonJoint_getTendon_0');
var _emscripten_bind_PxArticulationTendonJoint_release_0 = Module['_emscripten_bind_PxArticulationTendonJoint_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendonJoint_release_0');
var _emscripten_bind_PxArticulationTendonJoint_get_userData_0 = Module['_emscripten_bind_PxArticulationTendonJoint_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendonJoint_get_userData_0');
var _emscripten_bind_PxArticulationTendonJoint_set_userData_1 = Module['_emscripten_bind_PxArticulationTendonJoint_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendonJoint_set_userData_1');
var _emscripten_bind_PxArticulationTendonJoint___destroy___0 = Module['_emscripten_bind_PxArticulationTendonJoint___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendonJoint___destroy___0');
var _emscripten_bind_PxArticulationTendonLimit_get_lowLimit_0 = Module['_emscripten_bind_PxArticulationTendonLimit_get_lowLimit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendonLimit_get_lowLimit_0');
var _emscripten_bind_PxArticulationTendonLimit_set_lowLimit_1 = Module['_emscripten_bind_PxArticulationTendonLimit_set_lowLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendonLimit_set_lowLimit_1');
var _emscripten_bind_PxArticulationTendonLimit_get_highLimit_0 = Module['_emscripten_bind_PxArticulationTendonLimit_get_highLimit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendonLimit_get_highLimit_0');
var _emscripten_bind_PxArticulationTendonLimit_set_highLimit_1 = Module['_emscripten_bind_PxArticulationTendonLimit_set_highLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendonLimit_set_highLimit_1');
var _emscripten_bind_PxArticulationTendonLimit___destroy___0 = Module['_emscripten_bind_PxArticulationTendonLimit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxArticulationTendonLimit___destroy___0');
var _emscripten_bind_PxBVH_release_0 = Module['_emscripten_bind_PxBVH_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH_release_0');
var _emscripten_bind_PxBVH_getConcreteTypeName_0 = Module['_emscripten_bind_PxBVH_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH_getConcreteTypeName_0');
var _emscripten_bind_PxBVH_getConcreteType_0 = Module['_emscripten_bind_PxBVH_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH_getConcreteType_0');
var _emscripten_bind_PxBVH_setBaseFlag_2 = Module['_emscripten_bind_PxBVH_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH_setBaseFlag_2');
var _emscripten_bind_PxBVH_setBaseFlags_1 = Module['_emscripten_bind_PxBVH_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH_setBaseFlags_1');
var _emscripten_bind_PxBVH_getBaseFlags_0 = Module['_emscripten_bind_PxBVH_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH_getBaseFlags_0');
var _emscripten_bind_PxBVH_isReleasable_0 = Module['_emscripten_bind_PxBVH_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH_isReleasable_0');
var _emscripten_bind_PxBVH33MidphaseDesc_setToDefault_0 = Module['_emscripten_bind_PxBVH33MidphaseDesc_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH33MidphaseDesc_setToDefault_0');
var _emscripten_bind_PxBVH33MidphaseDesc_isValid_0 = Module['_emscripten_bind_PxBVH33MidphaseDesc_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH33MidphaseDesc_isValid_0');
var _emscripten_bind_PxBVH33MidphaseDesc_get_meshSizePerformanceTradeOff_0 = Module['_emscripten_bind_PxBVH33MidphaseDesc_get_meshSizePerformanceTradeOff_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH33MidphaseDesc_get_meshSizePerformanceTradeOff_0');
var _emscripten_bind_PxBVH33MidphaseDesc_set_meshSizePerformanceTradeOff_1 = Module['_emscripten_bind_PxBVH33MidphaseDesc_set_meshSizePerformanceTradeOff_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH33MidphaseDesc_set_meshSizePerformanceTradeOff_1');
var _emscripten_bind_PxBVH33MidphaseDesc_get_meshCookingHint_0 = Module['_emscripten_bind_PxBVH33MidphaseDesc_get_meshCookingHint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH33MidphaseDesc_get_meshCookingHint_0');
var _emscripten_bind_PxBVH33MidphaseDesc_set_meshCookingHint_1 = Module['_emscripten_bind_PxBVH33MidphaseDesc_set_meshCookingHint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH33MidphaseDesc_set_meshCookingHint_1');
var _emscripten_bind_PxBVH33MidphaseDesc___destroy___0 = Module['_emscripten_bind_PxBVH33MidphaseDesc___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH33MidphaseDesc___destroy___0');
var _emscripten_bind_PxBVH34MidphaseDesc_setToDefault_0 = Module['_emscripten_bind_PxBVH34MidphaseDesc_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH34MidphaseDesc_setToDefault_0');
var _emscripten_bind_PxBVH34MidphaseDesc_isValid_0 = Module['_emscripten_bind_PxBVH34MidphaseDesc_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH34MidphaseDesc_isValid_0');
var _emscripten_bind_PxBVH34MidphaseDesc_get_numPrimsPerLeaf_0 = Module['_emscripten_bind_PxBVH34MidphaseDesc_get_numPrimsPerLeaf_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH34MidphaseDesc_get_numPrimsPerLeaf_0');
var _emscripten_bind_PxBVH34MidphaseDesc_set_numPrimsPerLeaf_1 = Module['_emscripten_bind_PxBVH34MidphaseDesc_set_numPrimsPerLeaf_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH34MidphaseDesc_set_numPrimsPerLeaf_1');
var _emscripten_bind_PxBVH34MidphaseDesc___destroy___0 = Module['_emscripten_bind_PxBVH34MidphaseDesc___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBVH34MidphaseDesc___destroy___0');
var _emscripten_bind_PxBaseFlags_PxBaseFlags_1 = Module['_emscripten_bind_PxBaseFlags_PxBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseFlags_PxBaseFlags_1');
var _emscripten_bind_PxBaseFlags_isSet_1 = Module['_emscripten_bind_PxBaseFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseFlags_isSet_1');
var _emscripten_bind_PxBaseFlags_raise_1 = Module['_emscripten_bind_PxBaseFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseFlags_raise_1');
var _emscripten_bind_PxBaseFlags_clear_1 = Module['_emscripten_bind_PxBaseFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseFlags_clear_1');
var _emscripten_bind_PxBaseFlags___destroy___0 = Module['_emscripten_bind_PxBaseFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseFlags___destroy___0');
var _emscripten_bind_PxBaseTask___destroy___0 = Module['_emscripten_bind_PxBaseTask___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBaseTask___destroy___0');
var _emscripten_bind_PxBoundedData_PxBoundedData_0 = Module['_emscripten_bind_PxBoundedData_PxBoundedData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoundedData_PxBoundedData_0');
var _emscripten_bind_PxBoundedData_get_count_0 = Module['_emscripten_bind_PxBoundedData_get_count_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoundedData_get_count_0');
var _emscripten_bind_PxBoundedData_set_count_1 = Module['_emscripten_bind_PxBoundedData_set_count_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoundedData_set_count_1');
var _emscripten_bind_PxBoundedData_get_stride_0 = Module['_emscripten_bind_PxBoundedData_get_stride_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoundedData_get_stride_0');
var _emscripten_bind_PxBoundedData_set_stride_1 = Module['_emscripten_bind_PxBoundedData_set_stride_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoundedData_set_stride_1');
var _emscripten_bind_PxBoundedData_get_data_0 = Module['_emscripten_bind_PxBoundedData_get_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoundedData_get_data_0');
var _emscripten_bind_PxBoundedData_set_data_1 = Module['_emscripten_bind_PxBoundedData_set_data_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoundedData_set_data_1');
var _emscripten_bind_PxBoundedData___destroy___0 = Module['_emscripten_bind_PxBoundedData___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoundedData___destroy___0');
var _emscripten_bind_PxBounds3_PxBounds3_0 = Module['_emscripten_bind_PxBounds3_PxBounds3_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_PxBounds3_0');
var _emscripten_bind_PxBounds3_PxBounds3_2 = Module['_emscripten_bind_PxBounds3_PxBounds3_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_PxBounds3_2');
var _emscripten_bind_PxBounds3_setEmpty_0 = Module['_emscripten_bind_PxBounds3_setEmpty_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_setEmpty_0');
var _emscripten_bind_PxBounds3_setMaximal_0 = Module['_emscripten_bind_PxBounds3_setMaximal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_setMaximal_0');
var _emscripten_bind_PxBounds3_include_1 = Module['_emscripten_bind_PxBounds3_include_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_include_1');
var _emscripten_bind_PxBounds3_isEmpty_0 = Module['_emscripten_bind_PxBounds3_isEmpty_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_isEmpty_0');
var _emscripten_bind_PxBounds3_intersects_1 = Module['_emscripten_bind_PxBounds3_intersects_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_intersects_1');
var _emscripten_bind_PxBounds3_intersects1D_2 = Module['_emscripten_bind_PxBounds3_intersects1D_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_intersects1D_2');
var _emscripten_bind_PxBounds3_contains_1 = Module['_emscripten_bind_PxBounds3_contains_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_contains_1');
var _emscripten_bind_PxBounds3_isInside_1 = Module['_emscripten_bind_PxBounds3_isInside_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_isInside_1');
var _emscripten_bind_PxBounds3_getCenter_0 = Module['_emscripten_bind_PxBounds3_getCenter_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_getCenter_0');
var _emscripten_bind_PxBounds3_getDimensions_0 = Module['_emscripten_bind_PxBounds3_getDimensions_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_getDimensions_0');
var _emscripten_bind_PxBounds3_getExtents_0 = Module['_emscripten_bind_PxBounds3_getExtents_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_getExtents_0');
var _emscripten_bind_PxBounds3_scaleSafe_1 = Module['_emscripten_bind_PxBounds3_scaleSafe_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_scaleSafe_1');
var _emscripten_bind_PxBounds3_scaleFast_1 = Module['_emscripten_bind_PxBounds3_scaleFast_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_scaleFast_1');
var _emscripten_bind_PxBounds3_fattenSafe_1 = Module['_emscripten_bind_PxBounds3_fattenSafe_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_fattenSafe_1');
var _emscripten_bind_PxBounds3_fattenFast_1 = Module['_emscripten_bind_PxBounds3_fattenFast_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_fattenFast_1');
var _emscripten_bind_PxBounds3_isFinite_0 = Module['_emscripten_bind_PxBounds3_isFinite_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_isFinite_0');
var _emscripten_bind_PxBounds3_isValid_0 = Module['_emscripten_bind_PxBounds3_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_isValid_0');
var _emscripten_bind_PxBounds3_get_minimum_0 = Module['_emscripten_bind_PxBounds3_get_minimum_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_get_minimum_0');
var _emscripten_bind_PxBounds3_set_minimum_1 = Module['_emscripten_bind_PxBounds3_set_minimum_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_set_minimum_1');
var _emscripten_bind_PxBounds3_get_maximum_0 = Module['_emscripten_bind_PxBounds3_get_maximum_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_get_maximum_0');
var _emscripten_bind_PxBounds3_set_maximum_1 = Module['_emscripten_bind_PxBounds3_set_maximum_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3_set_maximum_1');
var _emscripten_bind_PxBounds3___destroy___0 = Module['_emscripten_bind_PxBounds3___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBounds3___destroy___0');
var _emscripten_bind_PxBoxController_getHalfHeight_0 = Module['_emscripten_bind_PxBoxController_getHalfHeight_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getHalfHeight_0');
var _emscripten_bind_PxBoxController_getHalfSideExtent_0 = Module['_emscripten_bind_PxBoxController_getHalfSideExtent_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getHalfSideExtent_0');
var _emscripten_bind_PxBoxController_getHalfForwardExtent_0 = Module['_emscripten_bind_PxBoxController_getHalfForwardExtent_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getHalfForwardExtent_0');
var _emscripten_bind_PxBoxController_setHalfHeight_1 = Module['_emscripten_bind_PxBoxController_setHalfHeight_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_setHalfHeight_1');
var _emscripten_bind_PxBoxController_setHalfSideExtent_1 = Module['_emscripten_bind_PxBoxController_setHalfSideExtent_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_setHalfSideExtent_1');
var _emscripten_bind_PxBoxController_setHalfForwardExtent_1 = Module['_emscripten_bind_PxBoxController_setHalfForwardExtent_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_setHalfForwardExtent_1');
var _emscripten_bind_PxBoxController_getType_0 = Module['_emscripten_bind_PxBoxController_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getType_0');
var _emscripten_bind_PxBoxController_release_0 = Module['_emscripten_bind_PxBoxController_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_release_0');
var _emscripten_bind_PxBoxController_move_4 = Module['_emscripten_bind_PxBoxController_move_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_move_4');
var _emscripten_bind_PxBoxController_move_5 = Module['_emscripten_bind_PxBoxController_move_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_move_5');
var _emscripten_bind_PxBoxController_setPosition_1 = Module['_emscripten_bind_PxBoxController_setPosition_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_setPosition_1');
var _emscripten_bind_PxBoxController_getPosition_0 = Module['_emscripten_bind_PxBoxController_getPosition_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getPosition_0');
var _emscripten_bind_PxBoxController_setFootPosition_1 = Module['_emscripten_bind_PxBoxController_setFootPosition_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_setFootPosition_1');
var _emscripten_bind_PxBoxController_getFootPosition_0 = Module['_emscripten_bind_PxBoxController_getFootPosition_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getFootPosition_0');
var _emscripten_bind_PxBoxController_getActor_0 = Module['_emscripten_bind_PxBoxController_getActor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getActor_0');
var _emscripten_bind_PxBoxController_setStepOffset_1 = Module['_emscripten_bind_PxBoxController_setStepOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_setStepOffset_1');
var _emscripten_bind_PxBoxController_getStepOffset_0 = Module['_emscripten_bind_PxBoxController_getStepOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getStepOffset_0');
var _emscripten_bind_PxBoxController_setNonWalkableMode_1 = Module['_emscripten_bind_PxBoxController_setNonWalkableMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_setNonWalkableMode_1');
var _emscripten_bind_PxBoxController_getNonWalkableMode_0 = Module['_emscripten_bind_PxBoxController_getNonWalkableMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getNonWalkableMode_0');
var _emscripten_bind_PxBoxController_getContactOffset_0 = Module['_emscripten_bind_PxBoxController_getContactOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getContactOffset_0');
var _emscripten_bind_PxBoxController_setContactOffset_1 = Module['_emscripten_bind_PxBoxController_setContactOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_setContactOffset_1');
var _emscripten_bind_PxBoxController_getUpDirection_0 = Module['_emscripten_bind_PxBoxController_getUpDirection_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getUpDirection_0');
var _emscripten_bind_PxBoxController_setUpDirection_1 = Module['_emscripten_bind_PxBoxController_setUpDirection_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_setUpDirection_1');
var _emscripten_bind_PxBoxController_getSlopeLimit_0 = Module['_emscripten_bind_PxBoxController_getSlopeLimit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getSlopeLimit_0');
var _emscripten_bind_PxBoxController_setSlopeLimit_1 = Module['_emscripten_bind_PxBoxController_setSlopeLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_setSlopeLimit_1');
var _emscripten_bind_PxBoxController_invalidateCache_0 = Module['_emscripten_bind_PxBoxController_invalidateCache_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_invalidateCache_0');
var _emscripten_bind_PxBoxController_getScene_0 = Module['_emscripten_bind_PxBoxController_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getScene_0');
var _emscripten_bind_PxBoxController_getUserData_0 = Module['_emscripten_bind_PxBoxController_getUserData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getUserData_0');
var _emscripten_bind_PxBoxController_setUserData_1 = Module['_emscripten_bind_PxBoxController_setUserData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_setUserData_1');
var _emscripten_bind_PxBoxController_getState_1 = Module['_emscripten_bind_PxBoxController_getState_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getState_1');
var _emscripten_bind_PxBoxController_getStats_1 = Module['_emscripten_bind_PxBoxController_getStats_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_getStats_1');
var _emscripten_bind_PxBoxController_resize_1 = Module['_emscripten_bind_PxBoxController_resize_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxController_resize_1');
var _emscripten_bind_PxBoxControllerDesc_PxBoxControllerDesc_0 = Module['_emscripten_bind_PxBoxControllerDesc_PxBoxControllerDesc_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_PxBoxControllerDesc_0');
var _emscripten_bind_PxBoxControllerDesc_setToDefault_0 = Module['_emscripten_bind_PxBoxControllerDesc_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_setToDefault_0');
var _emscripten_bind_PxBoxControllerDesc_isValid_0 = Module['_emscripten_bind_PxBoxControllerDesc_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_isValid_0');
var _emscripten_bind_PxBoxControllerDesc_getType_0 = Module['_emscripten_bind_PxBoxControllerDesc_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_getType_0');
var _emscripten_bind_PxBoxControllerDesc_get_halfHeight_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_halfHeight_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_halfHeight_0');
var _emscripten_bind_PxBoxControllerDesc_set_halfHeight_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_halfHeight_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_halfHeight_1');
var _emscripten_bind_PxBoxControllerDesc_get_halfSideExtent_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_halfSideExtent_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_halfSideExtent_0');
var _emscripten_bind_PxBoxControllerDesc_set_halfSideExtent_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_halfSideExtent_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_halfSideExtent_1');
var _emscripten_bind_PxBoxControllerDesc_get_halfForwardExtent_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_halfForwardExtent_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_halfForwardExtent_0');
var _emscripten_bind_PxBoxControllerDesc_set_halfForwardExtent_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_halfForwardExtent_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_halfForwardExtent_1');
var _emscripten_bind_PxBoxControllerDesc_get_position_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_position_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_position_0');
var _emscripten_bind_PxBoxControllerDesc_set_position_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_position_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_position_1');
var _emscripten_bind_PxBoxControllerDesc_get_upDirection_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_upDirection_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_upDirection_0');
var _emscripten_bind_PxBoxControllerDesc_set_upDirection_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_upDirection_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_upDirection_1');
var _emscripten_bind_PxBoxControllerDesc_get_slopeLimit_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_slopeLimit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_slopeLimit_0');
var _emscripten_bind_PxBoxControllerDesc_set_slopeLimit_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_slopeLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_slopeLimit_1');
var _emscripten_bind_PxBoxControllerDesc_get_invisibleWallHeight_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_invisibleWallHeight_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_invisibleWallHeight_0');
var _emscripten_bind_PxBoxControllerDesc_set_invisibleWallHeight_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_invisibleWallHeight_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_invisibleWallHeight_1');
var _emscripten_bind_PxBoxControllerDesc_get_maxJumpHeight_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_maxJumpHeight_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_maxJumpHeight_0');
var _emscripten_bind_PxBoxControllerDesc_set_maxJumpHeight_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_maxJumpHeight_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_maxJumpHeight_1');
var _emscripten_bind_PxBoxControllerDesc_get_contactOffset_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_contactOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_contactOffset_0');
var _emscripten_bind_PxBoxControllerDesc_set_contactOffset_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_contactOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_contactOffset_1');
var _emscripten_bind_PxBoxControllerDesc_get_stepOffset_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_stepOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_stepOffset_0');
var _emscripten_bind_PxBoxControllerDesc_set_stepOffset_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_stepOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_stepOffset_1');
var _emscripten_bind_PxBoxControllerDesc_get_density_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_density_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_density_0');
var _emscripten_bind_PxBoxControllerDesc_set_density_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_density_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_density_1');
var _emscripten_bind_PxBoxControllerDesc_get_scaleCoeff_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_scaleCoeff_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_scaleCoeff_0');
var _emscripten_bind_PxBoxControllerDesc_set_scaleCoeff_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_scaleCoeff_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_scaleCoeff_1');
var _emscripten_bind_PxBoxControllerDesc_get_volumeGrowth_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_volumeGrowth_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_volumeGrowth_0');
var _emscripten_bind_PxBoxControllerDesc_set_volumeGrowth_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_volumeGrowth_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_volumeGrowth_1');
var _emscripten_bind_PxBoxControllerDesc_get_reportCallback_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_reportCallback_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_reportCallback_0');
var _emscripten_bind_PxBoxControllerDesc_set_reportCallback_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_reportCallback_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_reportCallback_1');
var _emscripten_bind_PxBoxControllerDesc_get_behaviorCallback_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_behaviorCallback_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_behaviorCallback_0');
var _emscripten_bind_PxBoxControllerDesc_set_behaviorCallback_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_behaviorCallback_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_behaviorCallback_1');
var _emscripten_bind_PxBoxControllerDesc_get_nonWalkableMode_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_nonWalkableMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_nonWalkableMode_0');
var _emscripten_bind_PxBoxControllerDesc_set_nonWalkableMode_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_nonWalkableMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_nonWalkableMode_1');
var _emscripten_bind_PxBoxControllerDesc_get_material_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_material_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_material_0');
var _emscripten_bind_PxBoxControllerDesc_set_material_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_material_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_material_1');
var _emscripten_bind_PxBoxControllerDesc_get_registerDeletionListener_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_registerDeletionListener_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_registerDeletionListener_0');
var _emscripten_bind_PxBoxControllerDesc_set_registerDeletionListener_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_registerDeletionListener_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_registerDeletionListener_1');
var _emscripten_bind_PxBoxControllerDesc_get_userData_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_get_userData_0');
var _emscripten_bind_PxBoxControllerDesc_set_userData_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc_set_userData_1');
var _emscripten_bind_PxBoxControllerDesc___destroy___0 = Module['_emscripten_bind_PxBoxControllerDesc___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxControllerDesc___destroy___0');
var _emscripten_bind_PxBoxGeometry_PxBoxGeometry_3 = Module['_emscripten_bind_PxBoxGeometry_PxBoxGeometry_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxGeometry_PxBoxGeometry_3');
var _emscripten_bind_PxBoxGeometry_getType_0 = Module['_emscripten_bind_PxBoxGeometry_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxGeometry_getType_0');
var _emscripten_bind_PxBoxGeometry_get_halfExtents_0 = Module['_emscripten_bind_PxBoxGeometry_get_halfExtents_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxGeometry_get_halfExtents_0');
var _emscripten_bind_PxBoxGeometry_set_halfExtents_1 = Module['_emscripten_bind_PxBoxGeometry_set_halfExtents_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxGeometry_set_halfExtents_1');
var _emscripten_bind_PxBoxGeometry___destroy___0 = Module['_emscripten_bind_PxBoxGeometry___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxGeometry___destroy___0');
var _emscripten_bind_PxBoxObstacle_PxBoxObstacle_0 = Module['_emscripten_bind_PxBoxObstacle_PxBoxObstacle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxObstacle_PxBoxObstacle_0');
var _emscripten_bind_PxBoxObstacle_getType_0 = Module['_emscripten_bind_PxBoxObstacle_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxObstacle_getType_0');
var _emscripten_bind_PxBoxObstacle_get_mHalfExtents_0 = Module['_emscripten_bind_PxBoxObstacle_get_mHalfExtents_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxObstacle_get_mHalfExtents_0');
var _emscripten_bind_PxBoxObstacle_set_mHalfExtents_1 = Module['_emscripten_bind_PxBoxObstacle_set_mHalfExtents_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxObstacle_set_mHalfExtents_1');
var _emscripten_bind_PxBoxObstacle_get_mUserData_0 = Module['_emscripten_bind_PxBoxObstacle_get_mUserData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxObstacle_get_mUserData_0');
var _emscripten_bind_PxBoxObstacle_set_mUserData_1 = Module['_emscripten_bind_PxBoxObstacle_set_mUserData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxObstacle_set_mUserData_1');
var _emscripten_bind_PxBoxObstacle_get_mPos_0 = Module['_emscripten_bind_PxBoxObstacle_get_mPos_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxObstacle_get_mPos_0');
var _emscripten_bind_PxBoxObstacle_set_mPos_1 = Module['_emscripten_bind_PxBoxObstacle_set_mPos_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxObstacle_set_mPos_1');
var _emscripten_bind_PxBoxObstacle_get_mRot_0 = Module['_emscripten_bind_PxBoxObstacle_get_mRot_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxObstacle_get_mRot_0');
var _emscripten_bind_PxBoxObstacle_set_mRot_1 = Module['_emscripten_bind_PxBoxObstacle_set_mRot_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxObstacle_set_mRot_1');
var _emscripten_bind_PxBoxObstacle___destroy___0 = Module['_emscripten_bind_PxBoxObstacle___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBoxObstacle___destroy___0');
var _emscripten_bind_PxBroadPhaseCaps_PxBroadPhaseCaps_0 = Module['_emscripten_bind_PxBroadPhaseCaps_PxBroadPhaseCaps_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseCaps_PxBroadPhaseCaps_0');
var _emscripten_bind_PxBroadPhaseCaps_get_mMaxNbRegions_0 = Module['_emscripten_bind_PxBroadPhaseCaps_get_mMaxNbRegions_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseCaps_get_mMaxNbRegions_0');
var _emscripten_bind_PxBroadPhaseCaps_set_mMaxNbRegions_1 = Module['_emscripten_bind_PxBroadPhaseCaps_set_mMaxNbRegions_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseCaps_set_mMaxNbRegions_1');
var _emscripten_bind_PxBroadPhaseCaps___destroy___0 = Module['_emscripten_bind_PxBroadPhaseCaps___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseCaps___destroy___0');
var _emscripten_bind_PxBroadPhaseRegion_PxBroadPhaseRegion_0 = Module['_emscripten_bind_PxBroadPhaseRegion_PxBroadPhaseRegion_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegion_PxBroadPhaseRegion_0');
var _emscripten_bind_PxBroadPhaseRegion_get_mBounds_0 = Module['_emscripten_bind_PxBroadPhaseRegion_get_mBounds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegion_get_mBounds_0');
var _emscripten_bind_PxBroadPhaseRegion_set_mBounds_1 = Module['_emscripten_bind_PxBroadPhaseRegion_set_mBounds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegion_set_mBounds_1');
var _emscripten_bind_PxBroadPhaseRegion_get_mUserData_0 = Module['_emscripten_bind_PxBroadPhaseRegion_get_mUserData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegion_get_mUserData_0');
var _emscripten_bind_PxBroadPhaseRegion_set_mUserData_1 = Module['_emscripten_bind_PxBroadPhaseRegion_set_mUserData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegion_set_mUserData_1');
var _emscripten_bind_PxBroadPhaseRegion___destroy___0 = Module['_emscripten_bind_PxBroadPhaseRegion___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegion___destroy___0');
var _emscripten_bind_PxBroadPhaseRegionInfo_PxBroadPhaseRegionInfo_0 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_PxBroadPhaseRegionInfo_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegionInfo_PxBroadPhaseRegionInfo_0');
var _emscripten_bind_PxBroadPhaseRegionInfo_get_mRegion_0 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_get_mRegion_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegionInfo_get_mRegion_0');
var _emscripten_bind_PxBroadPhaseRegionInfo_set_mRegion_1 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_set_mRegion_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegionInfo_set_mRegion_1');
var _emscripten_bind_PxBroadPhaseRegionInfo_get_mNbStaticObjects_0 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_get_mNbStaticObjects_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegionInfo_get_mNbStaticObjects_0');
var _emscripten_bind_PxBroadPhaseRegionInfo_set_mNbStaticObjects_1 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_set_mNbStaticObjects_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegionInfo_set_mNbStaticObjects_1');
var _emscripten_bind_PxBroadPhaseRegionInfo_get_mNbDynamicObjects_0 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_get_mNbDynamicObjects_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegionInfo_get_mNbDynamicObjects_0');
var _emscripten_bind_PxBroadPhaseRegionInfo_set_mNbDynamicObjects_1 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_set_mNbDynamicObjects_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegionInfo_set_mNbDynamicObjects_1');
var _emscripten_bind_PxBroadPhaseRegionInfo_get_mActive_0 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_get_mActive_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegionInfo_get_mActive_0');
var _emscripten_bind_PxBroadPhaseRegionInfo_set_mActive_1 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_set_mActive_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegionInfo_set_mActive_1');
var _emscripten_bind_PxBroadPhaseRegionInfo_get_mOverlap_0 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_get_mOverlap_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegionInfo_get_mOverlap_0');
var _emscripten_bind_PxBroadPhaseRegionInfo_set_mOverlap_1 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_set_mOverlap_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegionInfo_set_mOverlap_1');
var _emscripten_bind_PxBroadPhaseRegionInfo___destroy___0 = Module['_emscripten_bind_PxBroadPhaseRegionInfo___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxBroadPhaseRegionInfo___destroy___0');
var _emscripten_bind_PxCapsuleController_getRadius_0 = Module['_emscripten_bind_PxCapsuleController_getRadius_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getRadius_0');
var _emscripten_bind_PxCapsuleController_setRadius_1 = Module['_emscripten_bind_PxCapsuleController_setRadius_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_setRadius_1');
var _emscripten_bind_PxCapsuleController_getHeight_0 = Module['_emscripten_bind_PxCapsuleController_getHeight_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getHeight_0');
var _emscripten_bind_PxCapsuleController_setHeight_1 = Module['_emscripten_bind_PxCapsuleController_setHeight_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_setHeight_1');
var _emscripten_bind_PxCapsuleController_getClimbingMode_0 = Module['_emscripten_bind_PxCapsuleController_getClimbingMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getClimbingMode_0');
var _emscripten_bind_PxCapsuleController_setClimbingMode_1 = Module['_emscripten_bind_PxCapsuleController_setClimbingMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_setClimbingMode_1');
var _emscripten_bind_PxCapsuleController_getType_0 = Module['_emscripten_bind_PxCapsuleController_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getType_0');
var _emscripten_bind_PxCapsuleController_release_0 = Module['_emscripten_bind_PxCapsuleController_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_release_0');
var _emscripten_bind_PxCapsuleController_move_4 = Module['_emscripten_bind_PxCapsuleController_move_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_move_4');
var _emscripten_bind_PxCapsuleController_move_5 = Module['_emscripten_bind_PxCapsuleController_move_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_move_5');
var _emscripten_bind_PxCapsuleController_setPosition_1 = Module['_emscripten_bind_PxCapsuleController_setPosition_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_setPosition_1');
var _emscripten_bind_PxCapsuleController_getPosition_0 = Module['_emscripten_bind_PxCapsuleController_getPosition_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getPosition_0');
var _emscripten_bind_PxCapsuleController_setFootPosition_1 = Module['_emscripten_bind_PxCapsuleController_setFootPosition_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_setFootPosition_1');
var _emscripten_bind_PxCapsuleController_getFootPosition_0 = Module['_emscripten_bind_PxCapsuleController_getFootPosition_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getFootPosition_0');
var _emscripten_bind_PxCapsuleController_getActor_0 = Module['_emscripten_bind_PxCapsuleController_getActor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getActor_0');
var _emscripten_bind_PxCapsuleController_setStepOffset_1 = Module['_emscripten_bind_PxCapsuleController_setStepOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_setStepOffset_1');
var _emscripten_bind_PxCapsuleController_getStepOffset_0 = Module['_emscripten_bind_PxCapsuleController_getStepOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getStepOffset_0');
var _emscripten_bind_PxCapsuleController_setNonWalkableMode_1 = Module['_emscripten_bind_PxCapsuleController_setNonWalkableMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_setNonWalkableMode_1');
var _emscripten_bind_PxCapsuleController_getNonWalkableMode_0 = Module['_emscripten_bind_PxCapsuleController_getNonWalkableMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getNonWalkableMode_0');
var _emscripten_bind_PxCapsuleController_getContactOffset_0 = Module['_emscripten_bind_PxCapsuleController_getContactOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getContactOffset_0');
var _emscripten_bind_PxCapsuleController_setContactOffset_1 = Module['_emscripten_bind_PxCapsuleController_setContactOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_setContactOffset_1');
var _emscripten_bind_PxCapsuleController_getUpDirection_0 = Module['_emscripten_bind_PxCapsuleController_getUpDirection_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getUpDirection_0');
var _emscripten_bind_PxCapsuleController_setUpDirection_1 = Module['_emscripten_bind_PxCapsuleController_setUpDirection_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_setUpDirection_1');
var _emscripten_bind_PxCapsuleController_getSlopeLimit_0 = Module['_emscripten_bind_PxCapsuleController_getSlopeLimit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getSlopeLimit_0');
var _emscripten_bind_PxCapsuleController_setSlopeLimit_1 = Module['_emscripten_bind_PxCapsuleController_setSlopeLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_setSlopeLimit_1');
var _emscripten_bind_PxCapsuleController_invalidateCache_0 = Module['_emscripten_bind_PxCapsuleController_invalidateCache_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_invalidateCache_0');
var _emscripten_bind_PxCapsuleController_getScene_0 = Module['_emscripten_bind_PxCapsuleController_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getScene_0');
var _emscripten_bind_PxCapsuleController_getUserData_0 = Module['_emscripten_bind_PxCapsuleController_getUserData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getUserData_0');
var _emscripten_bind_PxCapsuleController_setUserData_1 = Module['_emscripten_bind_PxCapsuleController_setUserData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_setUserData_1');
var _emscripten_bind_PxCapsuleController_getState_1 = Module['_emscripten_bind_PxCapsuleController_getState_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getState_1');
var _emscripten_bind_PxCapsuleController_getStats_1 = Module['_emscripten_bind_PxCapsuleController_getStats_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_getStats_1');
var _emscripten_bind_PxCapsuleController_resize_1 = Module['_emscripten_bind_PxCapsuleController_resize_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleController_resize_1');
var _emscripten_bind_PxCapsuleControllerDesc_PxCapsuleControllerDesc_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_PxCapsuleControllerDesc_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_PxCapsuleControllerDesc_0');
var _emscripten_bind_PxCapsuleControllerDesc_setToDefault_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_setToDefault_0');
var _emscripten_bind_PxCapsuleControllerDesc_isValid_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_isValid_0');
var _emscripten_bind_PxCapsuleControllerDesc_getType_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_getType_0');
var _emscripten_bind_PxCapsuleControllerDesc_get_radius_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_radius_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_radius_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_radius_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_radius_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_radius_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_height_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_height_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_height_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_height_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_height_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_height_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_climbingMode_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_climbingMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_climbingMode_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_climbingMode_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_climbingMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_climbingMode_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_position_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_position_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_position_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_position_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_position_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_position_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_upDirection_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_upDirection_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_upDirection_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_upDirection_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_upDirection_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_upDirection_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_slopeLimit_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_slopeLimit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_slopeLimit_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_slopeLimit_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_slopeLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_slopeLimit_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_invisibleWallHeight_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_invisibleWallHeight_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_invisibleWallHeight_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_invisibleWallHeight_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_invisibleWallHeight_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_invisibleWallHeight_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_maxJumpHeight_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_maxJumpHeight_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_maxJumpHeight_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_maxJumpHeight_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_maxJumpHeight_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_maxJumpHeight_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_contactOffset_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_contactOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_contactOffset_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_contactOffset_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_contactOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_contactOffset_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_stepOffset_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_stepOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_stepOffset_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_stepOffset_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_stepOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_stepOffset_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_density_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_density_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_density_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_density_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_density_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_density_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_scaleCoeff_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_scaleCoeff_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_scaleCoeff_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_scaleCoeff_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_scaleCoeff_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_scaleCoeff_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_volumeGrowth_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_volumeGrowth_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_volumeGrowth_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_volumeGrowth_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_volumeGrowth_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_volumeGrowth_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_reportCallback_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_reportCallback_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_reportCallback_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_reportCallback_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_reportCallback_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_reportCallback_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_behaviorCallback_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_behaviorCallback_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_behaviorCallback_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_behaviorCallback_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_behaviorCallback_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_behaviorCallback_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_nonWalkableMode_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_nonWalkableMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_nonWalkableMode_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_nonWalkableMode_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_nonWalkableMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_nonWalkableMode_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_material_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_material_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_material_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_material_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_material_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_material_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_registerDeletionListener_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_registerDeletionListener_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_registerDeletionListener_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_registerDeletionListener_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_registerDeletionListener_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_registerDeletionListener_1');
var _emscripten_bind_PxCapsuleControllerDesc_get_userData_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_get_userData_0');
var _emscripten_bind_PxCapsuleControllerDesc_set_userData_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc_set_userData_1');
var _emscripten_bind_PxCapsuleControllerDesc___destroy___0 = Module['_emscripten_bind_PxCapsuleControllerDesc___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleControllerDesc___destroy___0');
var _emscripten_bind_PxCapsuleGeometry_PxCapsuleGeometry_2 = Module['_emscripten_bind_PxCapsuleGeometry_PxCapsuleGeometry_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleGeometry_PxCapsuleGeometry_2');
var _emscripten_bind_PxCapsuleGeometry_getType_0 = Module['_emscripten_bind_PxCapsuleGeometry_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleGeometry_getType_0');
var _emscripten_bind_PxCapsuleGeometry_get_radius_0 = Module['_emscripten_bind_PxCapsuleGeometry_get_radius_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleGeometry_get_radius_0');
var _emscripten_bind_PxCapsuleGeometry_set_radius_1 = Module['_emscripten_bind_PxCapsuleGeometry_set_radius_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleGeometry_set_radius_1');
var _emscripten_bind_PxCapsuleGeometry_get_halfHeight_0 = Module['_emscripten_bind_PxCapsuleGeometry_get_halfHeight_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleGeometry_get_halfHeight_0');
var _emscripten_bind_PxCapsuleGeometry_set_halfHeight_1 = Module['_emscripten_bind_PxCapsuleGeometry_set_halfHeight_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleGeometry_set_halfHeight_1');
var _emscripten_bind_PxCapsuleGeometry___destroy___0 = Module['_emscripten_bind_PxCapsuleGeometry___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleGeometry___destroy___0');
var _emscripten_bind_PxCapsuleObstacle_PxCapsuleObstacle_0 = Module['_emscripten_bind_PxCapsuleObstacle_PxCapsuleObstacle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleObstacle_PxCapsuleObstacle_0');
var _emscripten_bind_PxCapsuleObstacle_getType_0 = Module['_emscripten_bind_PxCapsuleObstacle_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleObstacle_getType_0');
var _emscripten_bind_PxCapsuleObstacle_get_mHalfHeight_0 = Module['_emscripten_bind_PxCapsuleObstacle_get_mHalfHeight_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleObstacle_get_mHalfHeight_0');
var _emscripten_bind_PxCapsuleObstacle_set_mHalfHeight_1 = Module['_emscripten_bind_PxCapsuleObstacle_set_mHalfHeight_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleObstacle_set_mHalfHeight_1');
var _emscripten_bind_PxCapsuleObstacle_get_mRadius_0 = Module['_emscripten_bind_PxCapsuleObstacle_get_mRadius_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleObstacle_get_mRadius_0');
var _emscripten_bind_PxCapsuleObstacle_set_mRadius_1 = Module['_emscripten_bind_PxCapsuleObstacle_set_mRadius_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleObstacle_set_mRadius_1');
var _emscripten_bind_PxCapsuleObstacle_get_mUserData_0 = Module['_emscripten_bind_PxCapsuleObstacle_get_mUserData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleObstacle_get_mUserData_0');
var _emscripten_bind_PxCapsuleObstacle_set_mUserData_1 = Module['_emscripten_bind_PxCapsuleObstacle_set_mUserData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleObstacle_set_mUserData_1');
var _emscripten_bind_PxCapsuleObstacle_get_mPos_0 = Module['_emscripten_bind_PxCapsuleObstacle_get_mPos_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleObstacle_get_mPos_0');
var _emscripten_bind_PxCapsuleObstacle_set_mPos_1 = Module['_emscripten_bind_PxCapsuleObstacle_set_mPos_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleObstacle_set_mPos_1');
var _emscripten_bind_PxCapsuleObstacle_get_mRot_0 = Module['_emscripten_bind_PxCapsuleObstacle_get_mRot_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleObstacle_get_mRot_0');
var _emscripten_bind_PxCapsuleObstacle_set_mRot_1 = Module['_emscripten_bind_PxCapsuleObstacle_set_mRot_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleObstacle_set_mRot_1');
var _emscripten_bind_PxCapsuleObstacle___destroy___0 = Module['_emscripten_bind_PxCapsuleObstacle___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCapsuleObstacle___destroy___0');
var _emscripten_bind_PxCollection_add_1 = Module['_emscripten_bind_PxCollection_add_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollection_add_1');
var _emscripten_bind_PxCollection_add_2 = Module['_emscripten_bind_PxCollection_add_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollection_add_2');
var _emscripten_bind_PxCollection_remove_1 = Module['_emscripten_bind_PxCollection_remove_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollection_remove_1');
var _emscripten_bind_PxCollection_contains_1 = Module['_emscripten_bind_PxCollection_contains_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollection_contains_1');
var _emscripten_bind_PxCollection_addId_2 = Module['_emscripten_bind_PxCollection_addId_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollection_addId_2');
var _emscripten_bind_PxCollection_removeId_1 = Module['_emscripten_bind_PxCollection_removeId_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollection_removeId_1');
var _emscripten_bind_PxCollection_getNbObjects_0 = Module['_emscripten_bind_PxCollection_getNbObjects_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollection_getNbObjects_0');
var _emscripten_bind_PxCollection_getObject_1 = Module['_emscripten_bind_PxCollection_getObject_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollection_getObject_1');
var _emscripten_bind_PxCollection_find_1 = Module['_emscripten_bind_PxCollection_find_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollection_find_1');
var _emscripten_bind_PxCollection_getNbIds_0 = Module['_emscripten_bind_PxCollection_getNbIds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollection_getNbIds_0');
var _emscripten_bind_PxCollection_getId_1 = Module['_emscripten_bind_PxCollection_getId_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollection_getId_1');
var _emscripten_bind_PxCollection_release_0 = Module['_emscripten_bind_PxCollection_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollection_release_0');
var _emscripten_bind_PxCollectionExt_releaseObjects_1 = Module['_emscripten_bind_PxCollectionExt_releaseObjects_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollectionExt_releaseObjects_1');
var _emscripten_bind_PxCollectionExt_releaseObjects_2 = Module['_emscripten_bind_PxCollectionExt_releaseObjects_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollectionExt_releaseObjects_2');
var _emscripten_bind_PxCollectionExt_remove_2 = Module['_emscripten_bind_PxCollectionExt_remove_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollectionExt_remove_2');
var _emscripten_bind_PxCollectionExt_remove_3 = Module['_emscripten_bind_PxCollectionExt_remove_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollectionExt_remove_3');
var _emscripten_bind_PxCollectionExt_createCollection_1 = Module['_emscripten_bind_PxCollectionExt_createCollection_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollectionExt_createCollection_1');
var _emscripten_bind_PxCollectionExt___destroy___0 = Module['_emscripten_bind_PxCollectionExt___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCollectionExt___destroy___0');
var _emscripten_bind_PxConstraint_getScene_0 = Module['_emscripten_bind_PxConstraint_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_getScene_0');
var _emscripten_bind_PxConstraint_setActors_2 = Module['_emscripten_bind_PxConstraint_setActors_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_setActors_2');
var _emscripten_bind_PxConstraint_markDirty_0 = Module['_emscripten_bind_PxConstraint_markDirty_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_markDirty_0');
var _emscripten_bind_PxConstraint_setFlags_1 = Module['_emscripten_bind_PxConstraint_setFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_setFlags_1');
var _emscripten_bind_PxConstraint_getFlags_0 = Module['_emscripten_bind_PxConstraint_getFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_getFlags_0');
var _emscripten_bind_PxConstraint_setFlag_2 = Module['_emscripten_bind_PxConstraint_setFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_setFlag_2');
var _emscripten_bind_PxConstraint_getForce_2 = Module['_emscripten_bind_PxConstraint_getForce_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_getForce_2');
var _emscripten_bind_PxConstraint_isValid_0 = Module['_emscripten_bind_PxConstraint_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_isValid_0');
var _emscripten_bind_PxConstraint_setBreakForce_2 = Module['_emscripten_bind_PxConstraint_setBreakForce_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_setBreakForce_2');
var _emscripten_bind_PxConstraint_setMinResponseThreshold_1 = Module['_emscripten_bind_PxConstraint_setMinResponseThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_setMinResponseThreshold_1');
var _emscripten_bind_PxConstraint_getMinResponseThreshold_0 = Module['_emscripten_bind_PxConstraint_getMinResponseThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_getMinResponseThreshold_0');
var _emscripten_bind_PxConstraint_release_0 = Module['_emscripten_bind_PxConstraint_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_release_0');
var _emscripten_bind_PxConstraint_getConcreteTypeName_0 = Module['_emscripten_bind_PxConstraint_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_getConcreteTypeName_0');
var _emscripten_bind_PxConstraint_getConcreteType_0 = Module['_emscripten_bind_PxConstraint_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_getConcreteType_0');
var _emscripten_bind_PxConstraint_setBaseFlag_2 = Module['_emscripten_bind_PxConstraint_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_setBaseFlag_2');
var _emscripten_bind_PxConstraint_setBaseFlags_1 = Module['_emscripten_bind_PxConstraint_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_setBaseFlags_1');
var _emscripten_bind_PxConstraint_getBaseFlags_0 = Module['_emscripten_bind_PxConstraint_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_getBaseFlags_0');
var _emscripten_bind_PxConstraint_isReleasable_0 = Module['_emscripten_bind_PxConstraint_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraint_isReleasable_0');
var _emscripten_bind_PxConstraintFlags_PxConstraintFlags_1 = Module['_emscripten_bind_PxConstraintFlags_PxConstraintFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintFlags_PxConstraintFlags_1');
var _emscripten_bind_PxConstraintFlags_isSet_1 = Module['_emscripten_bind_PxConstraintFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintFlags_isSet_1');
var _emscripten_bind_PxConstraintFlags_raise_1 = Module['_emscripten_bind_PxConstraintFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintFlags_raise_1');
var _emscripten_bind_PxConstraintFlags_clear_1 = Module['_emscripten_bind_PxConstraintFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintFlags_clear_1');
var _emscripten_bind_PxConstraintFlags___destroy___0 = Module['_emscripten_bind_PxConstraintFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintFlags___destroy___0');
var _emscripten_bind_PxConstraintInfo_get_constraint_0 = Module['_emscripten_bind_PxConstraintInfo_get_constraint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintInfo_get_constraint_0');
var _emscripten_bind_PxConstraintInfo_set_constraint_1 = Module['_emscripten_bind_PxConstraintInfo_set_constraint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintInfo_set_constraint_1');
var _emscripten_bind_PxConstraintInfo_get_externalReference_0 = Module['_emscripten_bind_PxConstraintInfo_get_externalReference_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintInfo_get_externalReference_0');
var _emscripten_bind_PxConstraintInfo_set_externalReference_1 = Module['_emscripten_bind_PxConstraintInfo_set_externalReference_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintInfo_set_externalReference_1');
var _emscripten_bind_PxConstraintInfo_get_type_0 = Module['_emscripten_bind_PxConstraintInfo_get_type_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintInfo_get_type_0');
var _emscripten_bind_PxConstraintInfo_set_type_1 = Module['_emscripten_bind_PxConstraintInfo_set_type_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintInfo_set_type_1');
var _emscripten_bind_PxConstraintInfo___destroy___0 = Module['_emscripten_bind_PxConstraintInfo___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintInfo___destroy___0');
var _emscripten_bind_PxConstraintSolverPrep___destroy___0 = Module['_emscripten_bind_PxConstraintSolverPrep___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConstraintSolverPrep___destroy___0');
var _emscripten_bind_PxContactBuffer_reset_0 = Module['_emscripten_bind_PxContactBuffer_reset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactBuffer_reset_0');
var _emscripten_bind_PxContactBuffer_contact_1 = Module['_emscripten_bind_PxContactBuffer_contact_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactBuffer_contact_1');
var _emscripten_bind_PxContactBuffer_contact_3 = Module['_emscripten_bind_PxContactBuffer_contact_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactBuffer_contact_3');
var _emscripten_bind_PxContactBuffer_contact_4 = Module['_emscripten_bind_PxContactBuffer_contact_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactBuffer_contact_4');
var _emscripten_bind_PxContactBuffer_get_contacts_1 = Module['_emscripten_bind_PxContactBuffer_get_contacts_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactBuffer_get_contacts_1');
var _emscripten_bind_PxContactBuffer_set_contacts_2 = Module['_emscripten_bind_PxContactBuffer_set_contacts_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactBuffer_set_contacts_2');
var _emscripten_bind_PxContactBuffer_get_count_0 = Module['_emscripten_bind_PxContactBuffer_get_count_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactBuffer_get_count_0');
var _emscripten_bind_PxContactBuffer_set_count_1 = Module['_emscripten_bind_PxContactBuffer_set_count_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactBuffer_set_count_1');
var _emscripten_bind_PxContactBuffer_get_pad_0 = Module['_emscripten_bind_PxContactBuffer_get_pad_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactBuffer_get_pad_0');
var _emscripten_bind_PxContactBuffer_set_pad_1 = Module['_emscripten_bind_PxContactBuffer_set_pad_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactBuffer_set_pad_1');
var _emscripten_bind_PxContactBuffer_get_MAX_CONTACTS_0 = Module['_emscripten_bind_PxContactBuffer_get_MAX_CONTACTS_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactBuffer_get_MAX_CONTACTS_0');
var _emscripten_bind_PxContactBuffer___destroy___0 = Module['_emscripten_bind_PxContactBuffer___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactBuffer___destroy___0');
var _emscripten_bind_PxContactPair_extractContacts_2 = Module['_emscripten_bind_PxContactPair_extractContacts_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPair_extractContacts_2');
var _emscripten_bind_PxContactPair_get_shapes_1 = Module['_emscripten_bind_PxContactPair_get_shapes_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPair_get_shapes_1');
var _emscripten_bind_PxContactPair_set_shapes_2 = Module['_emscripten_bind_PxContactPair_set_shapes_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPair_set_shapes_2');
var _emscripten_bind_PxContactPair_get_contactCount_0 = Module['_emscripten_bind_PxContactPair_get_contactCount_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPair_get_contactCount_0');
var _emscripten_bind_PxContactPair_set_contactCount_1 = Module['_emscripten_bind_PxContactPair_set_contactCount_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPair_set_contactCount_1');
var _emscripten_bind_PxContactPair_get_patchCount_0 = Module['_emscripten_bind_PxContactPair_get_patchCount_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPair_get_patchCount_0');
var _emscripten_bind_PxContactPair_set_patchCount_1 = Module['_emscripten_bind_PxContactPair_set_patchCount_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPair_set_patchCount_1');
var _emscripten_bind_PxContactPair_get_flags_0 = Module['_emscripten_bind_PxContactPair_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPair_get_flags_0');
var _emscripten_bind_PxContactPair_set_flags_1 = Module['_emscripten_bind_PxContactPair_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPair_set_flags_1');
var _emscripten_bind_PxContactPair_get_events_0 = Module['_emscripten_bind_PxContactPair_get_events_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPair_get_events_0');
var _emscripten_bind_PxContactPair_set_events_1 = Module['_emscripten_bind_PxContactPair_set_events_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPair_set_events_1');
var _emscripten_bind_PxContactPair___destroy___0 = Module['_emscripten_bind_PxContactPair___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPair___destroy___0');
var _emscripten_bind_PxContactPairFlags_PxContactPairFlags_1 = Module['_emscripten_bind_PxContactPairFlags_PxContactPairFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairFlags_PxContactPairFlags_1');
var _emscripten_bind_PxContactPairFlags_isSet_1 = Module['_emscripten_bind_PxContactPairFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairFlags_isSet_1');
var _emscripten_bind_PxContactPairFlags_raise_1 = Module['_emscripten_bind_PxContactPairFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairFlags_raise_1');
var _emscripten_bind_PxContactPairFlags_clear_1 = Module['_emscripten_bind_PxContactPairFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairFlags_clear_1');
var _emscripten_bind_PxContactPairFlags___destroy___0 = Module['_emscripten_bind_PxContactPairFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairFlags___destroy___0');
var _emscripten_bind_PxContactPairHeader_get_actors_1 = Module['_emscripten_bind_PxContactPairHeader_get_actors_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairHeader_get_actors_1');
var _emscripten_bind_PxContactPairHeader_set_actors_2 = Module['_emscripten_bind_PxContactPairHeader_set_actors_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairHeader_set_actors_2');
var _emscripten_bind_PxContactPairHeader_get_flags_0 = Module['_emscripten_bind_PxContactPairHeader_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairHeader_get_flags_0');
var _emscripten_bind_PxContactPairHeader_set_flags_1 = Module['_emscripten_bind_PxContactPairHeader_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairHeader_set_flags_1');
var _emscripten_bind_PxContactPairHeader_get_pairs_0 = Module['_emscripten_bind_PxContactPairHeader_get_pairs_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairHeader_get_pairs_0');
var _emscripten_bind_PxContactPairHeader_set_pairs_1 = Module['_emscripten_bind_PxContactPairHeader_set_pairs_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairHeader_set_pairs_1');
var _emscripten_bind_PxContactPairHeader_get_nbPairs_0 = Module['_emscripten_bind_PxContactPairHeader_get_nbPairs_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairHeader_get_nbPairs_0');
var _emscripten_bind_PxContactPairHeader_set_nbPairs_1 = Module['_emscripten_bind_PxContactPairHeader_set_nbPairs_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairHeader_set_nbPairs_1');
var _emscripten_bind_PxContactPairHeader___destroy___0 = Module['_emscripten_bind_PxContactPairHeader___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairHeader___destroy___0');
var _emscripten_bind_PxContactPairHeaderFlags_PxContactPairHeaderFlags_1 = Module['_emscripten_bind_PxContactPairHeaderFlags_PxContactPairHeaderFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairHeaderFlags_PxContactPairHeaderFlags_1');
var _emscripten_bind_PxContactPairHeaderFlags_isSet_1 = Module['_emscripten_bind_PxContactPairHeaderFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairHeaderFlags_isSet_1');
var _emscripten_bind_PxContactPairHeaderFlags_raise_1 = Module['_emscripten_bind_PxContactPairHeaderFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairHeaderFlags_raise_1');
var _emscripten_bind_PxContactPairHeaderFlags_clear_1 = Module['_emscripten_bind_PxContactPairHeaderFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairHeaderFlags_clear_1');
var _emscripten_bind_PxContactPairHeaderFlags___destroy___0 = Module['_emscripten_bind_PxContactPairHeaderFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairHeaderFlags___destroy___0');
var _emscripten_bind_PxContactPairPoint_get_position_0 = Module['_emscripten_bind_PxContactPairPoint_get_position_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairPoint_get_position_0');
var _emscripten_bind_PxContactPairPoint_set_position_1 = Module['_emscripten_bind_PxContactPairPoint_set_position_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairPoint_set_position_1');
var _emscripten_bind_PxContactPairPoint_get_separation_0 = Module['_emscripten_bind_PxContactPairPoint_get_separation_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairPoint_get_separation_0');
var _emscripten_bind_PxContactPairPoint_set_separation_1 = Module['_emscripten_bind_PxContactPairPoint_set_separation_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairPoint_set_separation_1');
var _emscripten_bind_PxContactPairPoint_get_normal_0 = Module['_emscripten_bind_PxContactPairPoint_get_normal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairPoint_get_normal_0');
var _emscripten_bind_PxContactPairPoint_set_normal_1 = Module['_emscripten_bind_PxContactPairPoint_set_normal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairPoint_set_normal_1');
var _emscripten_bind_PxContactPairPoint_get_internalFaceIndex0_0 = Module['_emscripten_bind_PxContactPairPoint_get_internalFaceIndex0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairPoint_get_internalFaceIndex0_0');
var _emscripten_bind_PxContactPairPoint_set_internalFaceIndex0_1 = Module['_emscripten_bind_PxContactPairPoint_set_internalFaceIndex0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairPoint_set_internalFaceIndex0_1');
var _emscripten_bind_PxContactPairPoint_get_impulse_0 = Module['_emscripten_bind_PxContactPairPoint_get_impulse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairPoint_get_impulse_0');
var _emscripten_bind_PxContactPairPoint_set_impulse_1 = Module['_emscripten_bind_PxContactPairPoint_set_impulse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairPoint_set_impulse_1');
var _emscripten_bind_PxContactPairPoint_get_internalFaceIndex1_0 = Module['_emscripten_bind_PxContactPairPoint_get_internalFaceIndex1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairPoint_get_internalFaceIndex1_0');
var _emscripten_bind_PxContactPairPoint_set_internalFaceIndex1_1 = Module['_emscripten_bind_PxContactPairPoint_set_internalFaceIndex1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairPoint_set_internalFaceIndex1_1');
var _emscripten_bind_PxContactPairPoint___destroy___0 = Module['_emscripten_bind_PxContactPairPoint___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPairPoint___destroy___0');
var _emscripten_bind_PxContactPoint_PxContactPoint_0 = Module['_emscripten_bind_PxContactPoint_PxContactPoint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_PxContactPoint_0');
var _emscripten_bind_PxContactPoint_get_normal_0 = Module['_emscripten_bind_PxContactPoint_get_normal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_get_normal_0');
var _emscripten_bind_PxContactPoint_set_normal_1 = Module['_emscripten_bind_PxContactPoint_set_normal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_set_normal_1');
var _emscripten_bind_PxContactPoint_get_point_0 = Module['_emscripten_bind_PxContactPoint_get_point_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_get_point_0');
var _emscripten_bind_PxContactPoint_set_point_1 = Module['_emscripten_bind_PxContactPoint_set_point_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_set_point_1');
var _emscripten_bind_PxContactPoint_get_targetVel_0 = Module['_emscripten_bind_PxContactPoint_get_targetVel_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_get_targetVel_0');
var _emscripten_bind_PxContactPoint_set_targetVel_1 = Module['_emscripten_bind_PxContactPoint_set_targetVel_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_set_targetVel_1');
var _emscripten_bind_PxContactPoint_get_separation_0 = Module['_emscripten_bind_PxContactPoint_get_separation_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_get_separation_0');
var _emscripten_bind_PxContactPoint_set_separation_1 = Module['_emscripten_bind_PxContactPoint_set_separation_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_set_separation_1');
var _emscripten_bind_PxContactPoint_get_maxImpulse_0 = Module['_emscripten_bind_PxContactPoint_get_maxImpulse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_get_maxImpulse_0');
var _emscripten_bind_PxContactPoint_set_maxImpulse_1 = Module['_emscripten_bind_PxContactPoint_set_maxImpulse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_set_maxImpulse_1');
var _emscripten_bind_PxContactPoint_get_staticFriction_0 = Module['_emscripten_bind_PxContactPoint_get_staticFriction_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_get_staticFriction_0');
var _emscripten_bind_PxContactPoint_set_staticFriction_1 = Module['_emscripten_bind_PxContactPoint_set_staticFriction_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_set_staticFriction_1');
var _emscripten_bind_PxContactPoint_get_materialFlags_0 = Module['_emscripten_bind_PxContactPoint_get_materialFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_get_materialFlags_0');
var _emscripten_bind_PxContactPoint_set_materialFlags_1 = Module['_emscripten_bind_PxContactPoint_set_materialFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_set_materialFlags_1');
var _emscripten_bind_PxContactPoint_get_internalFaceIndex1_0 = Module['_emscripten_bind_PxContactPoint_get_internalFaceIndex1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_get_internalFaceIndex1_0');
var _emscripten_bind_PxContactPoint_set_internalFaceIndex1_1 = Module['_emscripten_bind_PxContactPoint_set_internalFaceIndex1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_set_internalFaceIndex1_1');
var _emscripten_bind_PxContactPoint_get_dynamicFriction_0 = Module['_emscripten_bind_PxContactPoint_get_dynamicFriction_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_get_dynamicFriction_0');
var _emscripten_bind_PxContactPoint_set_dynamicFriction_1 = Module['_emscripten_bind_PxContactPoint_set_dynamicFriction_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_set_dynamicFriction_1');
var _emscripten_bind_PxContactPoint_get_restitution_0 = Module['_emscripten_bind_PxContactPoint_get_restitution_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_get_restitution_0');
var _emscripten_bind_PxContactPoint_set_restitution_1 = Module['_emscripten_bind_PxContactPoint_set_restitution_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_set_restitution_1');
var _emscripten_bind_PxContactPoint_get_damping_0 = Module['_emscripten_bind_PxContactPoint_get_damping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_get_damping_0');
var _emscripten_bind_PxContactPoint_set_damping_1 = Module['_emscripten_bind_PxContactPoint_set_damping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint_set_damping_1');
var _emscripten_bind_PxContactPoint___destroy___0 = Module['_emscripten_bind_PxContactPoint___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxContactPoint___destroy___0');
var _emscripten_bind_PxControllerBehaviorCallbackImpl_PxControllerBehaviorCallbackImpl_0 = Module['_emscripten_bind_PxControllerBehaviorCallbackImpl_PxControllerBehaviorCallbackImpl_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerBehaviorCallbackImpl_PxControllerBehaviorCallbackImpl_0');
var _emscripten_bind_PxControllerBehaviorCallbackImpl_getShapeBehaviorFlags_2 = Module['_emscripten_bind_PxControllerBehaviorCallbackImpl_getShapeBehaviorFlags_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerBehaviorCallbackImpl_getShapeBehaviorFlags_2');
var _emscripten_bind_PxControllerBehaviorCallbackImpl_getControllerBehaviorFlags_1 = Module['_emscripten_bind_PxControllerBehaviorCallbackImpl_getControllerBehaviorFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerBehaviorCallbackImpl_getControllerBehaviorFlags_1');
var _emscripten_bind_PxControllerBehaviorCallbackImpl_getObstacleBehaviorFlags_1 = Module['_emscripten_bind_PxControllerBehaviorCallbackImpl_getObstacleBehaviorFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerBehaviorCallbackImpl_getObstacleBehaviorFlags_1');
var _emscripten_bind_PxControllerBehaviorCallbackImpl___destroy___0 = Module['_emscripten_bind_PxControllerBehaviorCallbackImpl___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerBehaviorCallbackImpl___destroy___0');
var _emscripten_bind_PxControllerBehaviorFlags_PxControllerBehaviorFlags_1 = Module['_emscripten_bind_PxControllerBehaviorFlags_PxControllerBehaviorFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerBehaviorFlags_PxControllerBehaviorFlags_1');
var _emscripten_bind_PxControllerBehaviorFlags_isSet_1 = Module['_emscripten_bind_PxControllerBehaviorFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerBehaviorFlags_isSet_1');
var _emscripten_bind_PxControllerBehaviorFlags_raise_1 = Module['_emscripten_bind_PxControllerBehaviorFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerBehaviorFlags_raise_1');
var _emscripten_bind_PxControllerBehaviorFlags_clear_1 = Module['_emscripten_bind_PxControllerBehaviorFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerBehaviorFlags_clear_1');
var _emscripten_bind_PxControllerBehaviorFlags___destroy___0 = Module['_emscripten_bind_PxControllerBehaviorFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerBehaviorFlags___destroy___0');
var _emscripten_bind_PxControllerCollisionFlags_PxControllerCollisionFlags_1 = Module['_emscripten_bind_PxControllerCollisionFlags_PxControllerCollisionFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerCollisionFlags_PxControllerCollisionFlags_1');
var _emscripten_bind_PxControllerCollisionFlags_isSet_1 = Module['_emscripten_bind_PxControllerCollisionFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerCollisionFlags_isSet_1');
var _emscripten_bind_PxControllerCollisionFlags_raise_1 = Module['_emscripten_bind_PxControllerCollisionFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerCollisionFlags_raise_1');
var _emscripten_bind_PxControllerCollisionFlags_clear_1 = Module['_emscripten_bind_PxControllerCollisionFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerCollisionFlags_clear_1');
var _emscripten_bind_PxControllerCollisionFlags___destroy___0 = Module['_emscripten_bind_PxControllerCollisionFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerCollisionFlags___destroy___0');
var _emscripten_bind_PxControllerFilterCallbackImpl_PxControllerFilterCallbackImpl_0 = Module['_emscripten_bind_PxControllerFilterCallbackImpl_PxControllerFilterCallbackImpl_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilterCallbackImpl_PxControllerFilterCallbackImpl_0');
var _emscripten_bind_PxControllerFilterCallbackImpl_filter_2 = Module['_emscripten_bind_PxControllerFilterCallbackImpl_filter_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilterCallbackImpl_filter_2');
var _emscripten_bind_PxControllerFilterCallbackImpl___destroy___0 = Module['_emscripten_bind_PxControllerFilterCallbackImpl___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilterCallbackImpl___destroy___0');
var _emscripten_bind_PxControllerFilters_PxControllerFilters_0 = Module['_emscripten_bind_PxControllerFilters_PxControllerFilters_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilters_PxControllerFilters_0');
var _emscripten_bind_PxControllerFilters_PxControllerFilters_1 = Module['_emscripten_bind_PxControllerFilters_PxControllerFilters_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilters_PxControllerFilters_1');
var _emscripten_bind_PxControllerFilters_get_mFilterData_0 = Module['_emscripten_bind_PxControllerFilters_get_mFilterData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilters_get_mFilterData_0');
var _emscripten_bind_PxControllerFilters_set_mFilterData_1 = Module['_emscripten_bind_PxControllerFilters_set_mFilterData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilters_set_mFilterData_1');
var _emscripten_bind_PxControllerFilters_get_mFilterCallback_0 = Module['_emscripten_bind_PxControllerFilters_get_mFilterCallback_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilters_get_mFilterCallback_0');
var _emscripten_bind_PxControllerFilters_set_mFilterCallback_1 = Module['_emscripten_bind_PxControllerFilters_set_mFilterCallback_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilters_set_mFilterCallback_1');
var _emscripten_bind_PxControllerFilters_get_mFilterFlags_0 = Module['_emscripten_bind_PxControllerFilters_get_mFilterFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilters_get_mFilterFlags_0');
var _emscripten_bind_PxControllerFilters_set_mFilterFlags_1 = Module['_emscripten_bind_PxControllerFilters_set_mFilterFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilters_set_mFilterFlags_1');
var _emscripten_bind_PxControllerFilters_get_mCCTFilterCallback_0 = Module['_emscripten_bind_PxControllerFilters_get_mCCTFilterCallback_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilters_get_mCCTFilterCallback_0');
var _emscripten_bind_PxControllerFilters_set_mCCTFilterCallback_1 = Module['_emscripten_bind_PxControllerFilters_set_mCCTFilterCallback_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilters_set_mCCTFilterCallback_1');
var _emscripten_bind_PxControllerFilters___destroy___0 = Module['_emscripten_bind_PxControllerFilters___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerFilters___destroy___0');
var _emscripten_bind_PxControllerManager_release_0 = Module['_emscripten_bind_PxControllerManager_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_release_0');
var _emscripten_bind_PxControllerManager_getScene_0 = Module['_emscripten_bind_PxControllerManager_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_getScene_0');
var _emscripten_bind_PxControllerManager_getNbControllers_0 = Module['_emscripten_bind_PxControllerManager_getNbControllers_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_getNbControllers_0');
var _emscripten_bind_PxControllerManager_getController_1 = Module['_emscripten_bind_PxControllerManager_getController_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_getController_1');
var _emscripten_bind_PxControllerManager_createController_1 = Module['_emscripten_bind_PxControllerManager_createController_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_createController_1');
var _emscripten_bind_PxControllerManager_purgeControllers_0 = Module['_emscripten_bind_PxControllerManager_purgeControllers_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_purgeControllers_0');
var _emscripten_bind_PxControllerManager_getNbObstacleContexts_0 = Module['_emscripten_bind_PxControllerManager_getNbObstacleContexts_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_getNbObstacleContexts_0');
var _emscripten_bind_PxControllerManager_getObstacleContext_1 = Module['_emscripten_bind_PxControllerManager_getObstacleContext_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_getObstacleContext_1');
var _emscripten_bind_PxControllerManager_createObstacleContext_0 = Module['_emscripten_bind_PxControllerManager_createObstacleContext_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_createObstacleContext_0');
var _emscripten_bind_PxControllerManager_computeInteractions_1 = Module['_emscripten_bind_PxControllerManager_computeInteractions_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_computeInteractions_1');
var _emscripten_bind_PxControllerManager_setTessellation_2 = Module['_emscripten_bind_PxControllerManager_setTessellation_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_setTessellation_2');
var _emscripten_bind_PxControllerManager_setOverlapRecoveryModule_1 = Module['_emscripten_bind_PxControllerManager_setOverlapRecoveryModule_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_setOverlapRecoveryModule_1');
var _emscripten_bind_PxControllerManager_setPreciseSweeps_1 = Module['_emscripten_bind_PxControllerManager_setPreciseSweeps_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_setPreciseSweeps_1');
var _emscripten_bind_PxControllerManager_setPreventVerticalSlidingAgainstCeiling_1 = Module['_emscripten_bind_PxControllerManager_setPreventVerticalSlidingAgainstCeiling_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_setPreventVerticalSlidingAgainstCeiling_1');
var _emscripten_bind_PxControllerManager_shiftOrigin_1 = Module['_emscripten_bind_PxControllerManager_shiftOrigin_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerManager_shiftOrigin_1');
var _emscripten_bind_PxControllerObstacleHit_get_userData_0 = Module['_emscripten_bind_PxControllerObstacleHit_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerObstacleHit_get_userData_0');
var _emscripten_bind_PxControllerObstacleHit_set_userData_1 = Module['_emscripten_bind_PxControllerObstacleHit_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerObstacleHit_set_userData_1');
var _emscripten_bind_PxControllerObstacleHit_get_controller_0 = Module['_emscripten_bind_PxControllerObstacleHit_get_controller_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerObstacleHit_get_controller_0');
var _emscripten_bind_PxControllerObstacleHit_set_controller_1 = Module['_emscripten_bind_PxControllerObstacleHit_set_controller_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerObstacleHit_set_controller_1');
var _emscripten_bind_PxControllerObstacleHit_get_worldPos_0 = Module['_emscripten_bind_PxControllerObstacleHit_get_worldPos_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerObstacleHit_get_worldPos_0');
var _emscripten_bind_PxControllerObstacleHit_set_worldPos_1 = Module['_emscripten_bind_PxControllerObstacleHit_set_worldPos_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerObstacleHit_set_worldPos_1');
var _emscripten_bind_PxControllerObstacleHit_get_worldNormal_0 = Module['_emscripten_bind_PxControllerObstacleHit_get_worldNormal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerObstacleHit_get_worldNormal_0');
var _emscripten_bind_PxControllerObstacleHit_set_worldNormal_1 = Module['_emscripten_bind_PxControllerObstacleHit_set_worldNormal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerObstacleHit_set_worldNormal_1');
var _emscripten_bind_PxControllerObstacleHit_get_dir_0 = Module['_emscripten_bind_PxControllerObstacleHit_get_dir_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerObstacleHit_get_dir_0');
var _emscripten_bind_PxControllerObstacleHit_set_dir_1 = Module['_emscripten_bind_PxControllerObstacleHit_set_dir_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerObstacleHit_set_dir_1');
var _emscripten_bind_PxControllerObstacleHit_get_length_0 = Module['_emscripten_bind_PxControllerObstacleHit_get_length_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerObstacleHit_get_length_0');
var _emscripten_bind_PxControllerObstacleHit_set_length_1 = Module['_emscripten_bind_PxControllerObstacleHit_set_length_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerObstacleHit_set_length_1');
var _emscripten_bind_PxControllerObstacleHit___destroy___0 = Module['_emscripten_bind_PxControllerObstacleHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerObstacleHit___destroy___0');
var _emscripten_bind_PxControllerShapeHit_get_shape_0 = Module['_emscripten_bind_PxControllerShapeHit_get_shape_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_get_shape_0');
var _emscripten_bind_PxControllerShapeHit_set_shape_1 = Module['_emscripten_bind_PxControllerShapeHit_set_shape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_set_shape_1');
var _emscripten_bind_PxControllerShapeHit_get_actor_0 = Module['_emscripten_bind_PxControllerShapeHit_get_actor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_get_actor_0');
var _emscripten_bind_PxControllerShapeHit_set_actor_1 = Module['_emscripten_bind_PxControllerShapeHit_set_actor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_set_actor_1');
var _emscripten_bind_PxControllerShapeHit_get_triangleIndex_0 = Module['_emscripten_bind_PxControllerShapeHit_get_triangleIndex_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_get_triangleIndex_0');
var _emscripten_bind_PxControllerShapeHit_set_triangleIndex_1 = Module['_emscripten_bind_PxControllerShapeHit_set_triangleIndex_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_set_triangleIndex_1');
var _emscripten_bind_PxControllerShapeHit_get_controller_0 = Module['_emscripten_bind_PxControllerShapeHit_get_controller_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_get_controller_0');
var _emscripten_bind_PxControllerShapeHit_set_controller_1 = Module['_emscripten_bind_PxControllerShapeHit_set_controller_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_set_controller_1');
var _emscripten_bind_PxControllerShapeHit_get_worldPos_0 = Module['_emscripten_bind_PxControllerShapeHit_get_worldPos_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_get_worldPos_0');
var _emscripten_bind_PxControllerShapeHit_set_worldPos_1 = Module['_emscripten_bind_PxControllerShapeHit_set_worldPos_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_set_worldPos_1');
var _emscripten_bind_PxControllerShapeHit_get_worldNormal_0 = Module['_emscripten_bind_PxControllerShapeHit_get_worldNormal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_get_worldNormal_0');
var _emscripten_bind_PxControllerShapeHit_set_worldNormal_1 = Module['_emscripten_bind_PxControllerShapeHit_set_worldNormal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_set_worldNormal_1');
var _emscripten_bind_PxControllerShapeHit_get_dir_0 = Module['_emscripten_bind_PxControllerShapeHit_get_dir_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_get_dir_0');
var _emscripten_bind_PxControllerShapeHit_set_dir_1 = Module['_emscripten_bind_PxControllerShapeHit_set_dir_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_set_dir_1');
var _emscripten_bind_PxControllerShapeHit_get_length_0 = Module['_emscripten_bind_PxControllerShapeHit_get_length_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_get_length_0');
var _emscripten_bind_PxControllerShapeHit_set_length_1 = Module['_emscripten_bind_PxControllerShapeHit_set_length_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit_set_length_1');
var _emscripten_bind_PxControllerShapeHit___destroy___0 = Module['_emscripten_bind_PxControllerShapeHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerShapeHit___destroy___0');
var _emscripten_bind_PxControllerState_PxControllerState_0 = Module['_emscripten_bind_PxControllerState_PxControllerState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_PxControllerState_0');
var _emscripten_bind_PxControllerState_get_deltaXP_0 = Module['_emscripten_bind_PxControllerState_get_deltaXP_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_get_deltaXP_0');
var _emscripten_bind_PxControllerState_set_deltaXP_1 = Module['_emscripten_bind_PxControllerState_set_deltaXP_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_set_deltaXP_1');
var _emscripten_bind_PxControllerState_get_touchedShape_0 = Module['_emscripten_bind_PxControllerState_get_touchedShape_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_get_touchedShape_0');
var _emscripten_bind_PxControllerState_set_touchedShape_1 = Module['_emscripten_bind_PxControllerState_set_touchedShape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_set_touchedShape_1');
var _emscripten_bind_PxControllerState_get_touchedActor_0 = Module['_emscripten_bind_PxControllerState_get_touchedActor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_get_touchedActor_0');
var _emscripten_bind_PxControllerState_set_touchedActor_1 = Module['_emscripten_bind_PxControllerState_set_touchedActor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_set_touchedActor_1');
var _emscripten_bind_PxControllerState_get_touchedObstacleHandle_0 = Module['_emscripten_bind_PxControllerState_get_touchedObstacleHandle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_get_touchedObstacleHandle_0');
var _emscripten_bind_PxControllerState_set_touchedObstacleHandle_1 = Module['_emscripten_bind_PxControllerState_set_touchedObstacleHandle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_set_touchedObstacleHandle_1');
var _emscripten_bind_PxControllerState_get_collisionFlags_0 = Module['_emscripten_bind_PxControllerState_get_collisionFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_get_collisionFlags_0');
var _emscripten_bind_PxControllerState_set_collisionFlags_1 = Module['_emscripten_bind_PxControllerState_set_collisionFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_set_collisionFlags_1');
var _emscripten_bind_PxControllerState_get_standOnAnotherCCT_0 = Module['_emscripten_bind_PxControllerState_get_standOnAnotherCCT_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_get_standOnAnotherCCT_0');
var _emscripten_bind_PxControllerState_set_standOnAnotherCCT_1 = Module['_emscripten_bind_PxControllerState_set_standOnAnotherCCT_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_set_standOnAnotherCCT_1');
var _emscripten_bind_PxControllerState_get_standOnObstacle_0 = Module['_emscripten_bind_PxControllerState_get_standOnObstacle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_get_standOnObstacle_0');
var _emscripten_bind_PxControllerState_set_standOnObstacle_1 = Module['_emscripten_bind_PxControllerState_set_standOnObstacle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_set_standOnObstacle_1');
var _emscripten_bind_PxControllerState_get_isMovingUp_0 = Module['_emscripten_bind_PxControllerState_get_isMovingUp_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_get_isMovingUp_0');
var _emscripten_bind_PxControllerState_set_isMovingUp_1 = Module['_emscripten_bind_PxControllerState_set_isMovingUp_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState_set_isMovingUp_1');
var _emscripten_bind_PxControllerState___destroy___0 = Module['_emscripten_bind_PxControllerState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerState___destroy___0');
var _emscripten_bind_PxControllerStats_get_nbIterations_0 = Module['_emscripten_bind_PxControllerStats_get_nbIterations_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerStats_get_nbIterations_0');
var _emscripten_bind_PxControllerStats_set_nbIterations_1 = Module['_emscripten_bind_PxControllerStats_set_nbIterations_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerStats_set_nbIterations_1');
var _emscripten_bind_PxControllerStats_get_nbFullUpdates_0 = Module['_emscripten_bind_PxControllerStats_get_nbFullUpdates_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerStats_get_nbFullUpdates_0');
var _emscripten_bind_PxControllerStats_set_nbFullUpdates_1 = Module['_emscripten_bind_PxControllerStats_set_nbFullUpdates_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerStats_set_nbFullUpdates_1');
var _emscripten_bind_PxControllerStats_get_nbPartialUpdates_0 = Module['_emscripten_bind_PxControllerStats_get_nbPartialUpdates_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerStats_get_nbPartialUpdates_0');
var _emscripten_bind_PxControllerStats_set_nbPartialUpdates_1 = Module['_emscripten_bind_PxControllerStats_set_nbPartialUpdates_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerStats_set_nbPartialUpdates_1');
var _emscripten_bind_PxControllerStats_get_nbTessellation_0 = Module['_emscripten_bind_PxControllerStats_get_nbTessellation_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerStats_get_nbTessellation_0');
var _emscripten_bind_PxControllerStats_set_nbTessellation_1 = Module['_emscripten_bind_PxControllerStats_set_nbTessellation_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerStats_set_nbTessellation_1');
var _emscripten_bind_PxControllerStats___destroy___0 = Module['_emscripten_bind_PxControllerStats___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllerStats___destroy___0');
var _emscripten_bind_PxControllersHit_get_other_0 = Module['_emscripten_bind_PxControllersHit_get_other_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllersHit_get_other_0');
var _emscripten_bind_PxControllersHit_set_other_1 = Module['_emscripten_bind_PxControllersHit_set_other_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllersHit_set_other_1');
var _emscripten_bind_PxControllersHit_get_controller_0 = Module['_emscripten_bind_PxControllersHit_get_controller_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllersHit_get_controller_0');
var _emscripten_bind_PxControllersHit_set_controller_1 = Module['_emscripten_bind_PxControllersHit_set_controller_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllersHit_set_controller_1');
var _emscripten_bind_PxControllersHit_get_worldPos_0 = Module['_emscripten_bind_PxControllersHit_get_worldPos_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllersHit_get_worldPos_0');
var _emscripten_bind_PxControllersHit_set_worldPos_1 = Module['_emscripten_bind_PxControllersHit_set_worldPos_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllersHit_set_worldPos_1');
var _emscripten_bind_PxControllersHit_get_worldNormal_0 = Module['_emscripten_bind_PxControllersHit_get_worldNormal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllersHit_get_worldNormal_0');
var _emscripten_bind_PxControllersHit_set_worldNormal_1 = Module['_emscripten_bind_PxControllersHit_set_worldNormal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllersHit_set_worldNormal_1');
var _emscripten_bind_PxControllersHit_get_dir_0 = Module['_emscripten_bind_PxControllersHit_get_dir_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllersHit_get_dir_0');
var _emscripten_bind_PxControllersHit_set_dir_1 = Module['_emscripten_bind_PxControllersHit_set_dir_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllersHit_set_dir_1');
var _emscripten_bind_PxControllersHit_get_length_0 = Module['_emscripten_bind_PxControllersHit_get_length_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllersHit_get_length_0');
var _emscripten_bind_PxControllersHit_set_length_1 = Module['_emscripten_bind_PxControllersHit_set_length_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllersHit_set_length_1');
var _emscripten_bind_PxControllersHit___destroy___0 = Module['_emscripten_bind_PxControllersHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxControllersHit___destroy___0');
var _emscripten_bind_PxConvexCoreBox_PxConvexCoreBox_3 = Module['_emscripten_bind_PxConvexCoreBox_PxConvexCoreBox_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreBox_PxConvexCoreBox_3');
var _emscripten_bind_PxConvexCoreBox_get_extents_0 = Module['_emscripten_bind_PxConvexCoreBox_get_extents_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreBox_get_extents_0');
var _emscripten_bind_PxConvexCoreBox_set_extents_1 = Module['_emscripten_bind_PxConvexCoreBox_set_extents_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreBox_set_extents_1');
var _emscripten_bind_PxConvexCoreBox___destroy___0 = Module['_emscripten_bind_PxConvexCoreBox___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreBox___destroy___0');
var _emscripten_bind_PxConvexCoreCone_PxConvexCoreCone_2 = Module['_emscripten_bind_PxConvexCoreCone_PxConvexCoreCone_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreCone_PxConvexCoreCone_2');
var _emscripten_bind_PxConvexCoreCone_get_height_0 = Module['_emscripten_bind_PxConvexCoreCone_get_height_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreCone_get_height_0');
var _emscripten_bind_PxConvexCoreCone_set_height_1 = Module['_emscripten_bind_PxConvexCoreCone_set_height_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreCone_set_height_1');
var _emscripten_bind_PxConvexCoreCone_get_radius_0 = Module['_emscripten_bind_PxConvexCoreCone_get_radius_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreCone_get_radius_0');
var _emscripten_bind_PxConvexCoreCone_set_radius_1 = Module['_emscripten_bind_PxConvexCoreCone_set_radius_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreCone_set_radius_1');
var _emscripten_bind_PxConvexCoreCone___destroy___0 = Module['_emscripten_bind_PxConvexCoreCone___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreCone___destroy___0');
var _emscripten_bind_PxConvexCoreCylinder_PxConvexCoreCylinder_2 = Module['_emscripten_bind_PxConvexCoreCylinder_PxConvexCoreCylinder_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreCylinder_PxConvexCoreCylinder_2');
var _emscripten_bind_PxConvexCoreCylinder_get_height_0 = Module['_emscripten_bind_PxConvexCoreCylinder_get_height_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreCylinder_get_height_0');
var _emscripten_bind_PxConvexCoreCylinder_set_height_1 = Module['_emscripten_bind_PxConvexCoreCylinder_set_height_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreCylinder_set_height_1');
var _emscripten_bind_PxConvexCoreCylinder_get_radius_0 = Module['_emscripten_bind_PxConvexCoreCylinder_get_radius_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreCylinder_get_radius_0');
var _emscripten_bind_PxConvexCoreCylinder_set_radius_1 = Module['_emscripten_bind_PxConvexCoreCylinder_set_radius_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreCylinder_set_radius_1');
var _emscripten_bind_PxConvexCoreCylinder___destroy___0 = Module['_emscripten_bind_PxConvexCoreCylinder___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreCylinder___destroy___0');
var _emscripten_bind_PxConvexCoreEllipsoid_PxConvexCoreEllipsoid_3 = Module['_emscripten_bind_PxConvexCoreEllipsoid_PxConvexCoreEllipsoid_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreEllipsoid_PxConvexCoreEllipsoid_3');
var _emscripten_bind_PxConvexCoreEllipsoid_get_radii_0 = Module['_emscripten_bind_PxConvexCoreEllipsoid_get_radii_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreEllipsoid_get_radii_0');
var _emscripten_bind_PxConvexCoreEllipsoid_set_radii_1 = Module['_emscripten_bind_PxConvexCoreEllipsoid_set_radii_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreEllipsoid_set_radii_1');
var _emscripten_bind_PxConvexCoreEllipsoid___destroy___0 = Module['_emscripten_bind_PxConvexCoreEllipsoid___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreEllipsoid___destroy___0');
var _emscripten_bind_PxConvexCoreGeometry_getCoreType_0 = Module['_emscripten_bind_PxConvexCoreGeometry_getCoreType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreGeometry_getCoreType_0');
var _emscripten_bind_PxConvexCoreGeometry_getCoreData_0 = Module['_emscripten_bind_PxConvexCoreGeometry_getCoreData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreGeometry_getCoreData_0');
var _emscripten_bind_PxConvexCoreGeometry_getMargin_0 = Module['_emscripten_bind_PxConvexCoreGeometry_getMargin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreGeometry_getMargin_0');
var _emscripten_bind_PxConvexCoreGeometry_isValid_0 = Module['_emscripten_bind_PxConvexCoreGeometry_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreGeometry_isValid_0');
var _emscripten_bind_PxConvexCoreGeometry_getType_0 = Module['_emscripten_bind_PxConvexCoreGeometry_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreGeometry_getType_0');
var _emscripten_bind_PxConvexCoreGeometry___destroy___0 = Module['_emscripten_bind_PxConvexCoreGeometry___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreGeometry___destroy___0');
var _emscripten_bind_PxConvexCoreGeometryFactory_createFromBox_2 = Module['_emscripten_bind_PxConvexCoreGeometryFactory_createFromBox_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreGeometryFactory_createFromBox_2');
var _emscripten_bind_PxConvexCoreGeometryFactory_createFromCone_2 = Module['_emscripten_bind_PxConvexCoreGeometryFactory_createFromCone_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreGeometryFactory_createFromCone_2');
var _emscripten_bind_PxConvexCoreGeometryFactory_createFromCylinder_2 = Module['_emscripten_bind_PxConvexCoreGeometryFactory_createFromCylinder_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreGeometryFactory_createFromCylinder_2');
var _emscripten_bind_PxConvexCoreGeometryFactory_createFromEllipsoid_2 = Module['_emscripten_bind_PxConvexCoreGeometryFactory_createFromEllipsoid_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreGeometryFactory_createFromEllipsoid_2');
var _emscripten_bind_PxConvexCoreGeometryFactory_createFromPoint_2 = Module['_emscripten_bind_PxConvexCoreGeometryFactory_createFromPoint_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreGeometryFactory_createFromPoint_2');
var _emscripten_bind_PxConvexCoreGeometryFactory_createFromSegment_2 = Module['_emscripten_bind_PxConvexCoreGeometryFactory_createFromSegment_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreGeometryFactory_createFromSegment_2');
var _emscripten_bind_PxConvexCoreGeometryFactory___destroy___0 = Module['_emscripten_bind_PxConvexCoreGeometryFactory___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreGeometryFactory___destroy___0');
var _emscripten_bind_PxConvexCorePoint_PxConvexCorePoint_0 = Module['_emscripten_bind_PxConvexCorePoint_PxConvexCorePoint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCorePoint_PxConvexCorePoint_0');
var _emscripten_bind_PxConvexCorePoint___destroy___0 = Module['_emscripten_bind_PxConvexCorePoint___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCorePoint___destroy___0');
var _emscripten_bind_PxConvexCoreSegment_PxConvexCoreSegment_1 = Module['_emscripten_bind_PxConvexCoreSegment_PxConvexCoreSegment_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreSegment_PxConvexCoreSegment_1');
var _emscripten_bind_PxConvexCoreSegment_get_length_0 = Module['_emscripten_bind_PxConvexCoreSegment_get_length_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreSegment_get_length_0');
var _emscripten_bind_PxConvexCoreSegment_set_length_1 = Module['_emscripten_bind_PxConvexCoreSegment_set_length_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreSegment_set_length_1');
var _emscripten_bind_PxConvexCoreSegment___destroy___0 = Module['_emscripten_bind_PxConvexCoreSegment___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexCoreSegment___destroy___0');
var _emscripten_bind_PxConvexFlags_PxConvexFlags_1 = Module['_emscripten_bind_PxConvexFlags_PxConvexFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexFlags_PxConvexFlags_1');
var _emscripten_bind_PxConvexFlags_isSet_1 = Module['_emscripten_bind_PxConvexFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexFlags_isSet_1');
var _emscripten_bind_PxConvexFlags_raise_1 = Module['_emscripten_bind_PxConvexFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexFlags_raise_1');
var _emscripten_bind_PxConvexFlags_clear_1 = Module['_emscripten_bind_PxConvexFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexFlags_clear_1');
var _emscripten_bind_PxConvexFlags___destroy___0 = Module['_emscripten_bind_PxConvexFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexFlags___destroy___0');
var _emscripten_bind_PxConvexMesh_getNbVertices_0 = Module['_emscripten_bind_PxConvexMesh_getNbVertices_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_getNbVertices_0');
var _emscripten_bind_PxConvexMesh_getVertices_0 = Module['_emscripten_bind_PxConvexMesh_getVertices_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_getVertices_0');
var _emscripten_bind_PxConvexMesh_getIndexBuffer_0 = Module['_emscripten_bind_PxConvexMesh_getIndexBuffer_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_getIndexBuffer_0');
var _emscripten_bind_PxConvexMesh_getNbPolygons_0 = Module['_emscripten_bind_PxConvexMesh_getNbPolygons_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_getNbPolygons_0');
var _emscripten_bind_PxConvexMesh_getPolygonData_2 = Module['_emscripten_bind_PxConvexMesh_getPolygonData_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_getPolygonData_2');
var _emscripten_bind_PxConvexMesh_getLocalBounds_0 = Module['_emscripten_bind_PxConvexMesh_getLocalBounds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_getLocalBounds_0');
var _emscripten_bind_PxConvexMesh_isGpuCompatible_0 = Module['_emscripten_bind_PxConvexMesh_isGpuCompatible_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_isGpuCompatible_0');
var _emscripten_bind_PxConvexMesh_release_0 = Module['_emscripten_bind_PxConvexMesh_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_release_0');
var _emscripten_bind_PxConvexMesh_getConcreteTypeName_0 = Module['_emscripten_bind_PxConvexMesh_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_getConcreteTypeName_0');
var _emscripten_bind_PxConvexMesh_getConcreteType_0 = Module['_emscripten_bind_PxConvexMesh_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_getConcreteType_0');
var _emscripten_bind_PxConvexMesh_setBaseFlag_2 = Module['_emscripten_bind_PxConvexMesh_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_setBaseFlag_2');
var _emscripten_bind_PxConvexMesh_setBaseFlags_1 = Module['_emscripten_bind_PxConvexMesh_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_setBaseFlags_1');
var _emscripten_bind_PxConvexMesh_getBaseFlags_0 = Module['_emscripten_bind_PxConvexMesh_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_getBaseFlags_0');
var _emscripten_bind_PxConvexMesh_isReleasable_0 = Module['_emscripten_bind_PxConvexMesh_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_isReleasable_0');
var _emscripten_bind_PxConvexMesh_getReferenceCount_0 = Module['_emscripten_bind_PxConvexMesh_getReferenceCount_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_getReferenceCount_0');
var _emscripten_bind_PxConvexMesh_acquireReference_0 = Module['_emscripten_bind_PxConvexMesh_acquireReference_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMesh_acquireReference_0');
var _emscripten_bind_PxConvexMeshDesc_PxConvexMeshDesc_0 = Module['_emscripten_bind_PxConvexMeshDesc_PxConvexMeshDesc_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshDesc_PxConvexMeshDesc_0');
var _emscripten_bind_PxConvexMeshDesc_get_points_0 = Module['_emscripten_bind_PxConvexMeshDesc_get_points_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshDesc_get_points_0');
var _emscripten_bind_PxConvexMeshDesc_set_points_1 = Module['_emscripten_bind_PxConvexMeshDesc_set_points_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshDesc_set_points_1');
var _emscripten_bind_PxConvexMeshDesc_get_flags_0 = Module['_emscripten_bind_PxConvexMeshDesc_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshDesc_get_flags_0');
var _emscripten_bind_PxConvexMeshDesc_set_flags_1 = Module['_emscripten_bind_PxConvexMeshDesc_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshDesc_set_flags_1');
var _emscripten_bind_PxConvexMeshDesc___destroy___0 = Module['_emscripten_bind_PxConvexMeshDesc___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshDesc___destroy___0');
var _emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_1 = Module['_emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_1');
var _emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_2 = Module['_emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_2');
var _emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_3 = Module['_emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_3');
var _emscripten_bind_PxConvexMeshGeometry_getType_0 = Module['_emscripten_bind_PxConvexMeshGeometry_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometry_getType_0');
var _emscripten_bind_PxConvexMeshGeometry_get_scale_0 = Module['_emscripten_bind_PxConvexMeshGeometry_get_scale_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometry_get_scale_0');
var _emscripten_bind_PxConvexMeshGeometry_set_scale_1 = Module['_emscripten_bind_PxConvexMeshGeometry_set_scale_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometry_set_scale_1');
var _emscripten_bind_PxConvexMeshGeometry_get_convexMesh_0 = Module['_emscripten_bind_PxConvexMeshGeometry_get_convexMesh_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometry_get_convexMesh_0');
var _emscripten_bind_PxConvexMeshGeometry_set_convexMesh_1 = Module['_emscripten_bind_PxConvexMeshGeometry_set_convexMesh_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometry_set_convexMesh_1');
var _emscripten_bind_PxConvexMeshGeometry_get_meshFlags_0 = Module['_emscripten_bind_PxConvexMeshGeometry_get_meshFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometry_get_meshFlags_0');
var _emscripten_bind_PxConvexMeshGeometry_set_meshFlags_1 = Module['_emscripten_bind_PxConvexMeshGeometry_set_meshFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometry_set_meshFlags_1');
var _emscripten_bind_PxConvexMeshGeometry___destroy___0 = Module['_emscripten_bind_PxConvexMeshGeometry___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometry___destroy___0');
var _emscripten_bind_PxConvexMeshGeometryFlags_PxConvexMeshGeometryFlags_1 = Module['_emscripten_bind_PxConvexMeshGeometryFlags_PxConvexMeshGeometryFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometryFlags_PxConvexMeshGeometryFlags_1');
var _emscripten_bind_PxConvexMeshGeometryFlags_isSet_1 = Module['_emscripten_bind_PxConvexMeshGeometryFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometryFlags_isSet_1');
var _emscripten_bind_PxConvexMeshGeometryFlags_raise_1 = Module['_emscripten_bind_PxConvexMeshGeometryFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometryFlags_raise_1');
var _emscripten_bind_PxConvexMeshGeometryFlags_clear_1 = Module['_emscripten_bind_PxConvexMeshGeometryFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometryFlags_clear_1');
var _emscripten_bind_PxConvexMeshGeometryFlags___destroy___0 = Module['_emscripten_bind_PxConvexMeshGeometryFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxConvexMeshGeometryFlags___destroy___0');
var _emscripten_bind_PxCookingParams_PxCookingParams_1 = Module['_emscripten_bind_PxCookingParams_PxCookingParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_PxCookingParams_1');
var _emscripten_bind_PxCookingParams_get_areaTestEpsilon_0 = Module['_emscripten_bind_PxCookingParams_get_areaTestEpsilon_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_get_areaTestEpsilon_0');
var _emscripten_bind_PxCookingParams_set_areaTestEpsilon_1 = Module['_emscripten_bind_PxCookingParams_set_areaTestEpsilon_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_set_areaTestEpsilon_1');
var _emscripten_bind_PxCookingParams_get_planeTolerance_0 = Module['_emscripten_bind_PxCookingParams_get_planeTolerance_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_get_planeTolerance_0');
var _emscripten_bind_PxCookingParams_set_planeTolerance_1 = Module['_emscripten_bind_PxCookingParams_set_planeTolerance_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_set_planeTolerance_1');
var _emscripten_bind_PxCookingParams_get_convexMeshCookingType_0 = Module['_emscripten_bind_PxCookingParams_get_convexMeshCookingType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_get_convexMeshCookingType_0');
var _emscripten_bind_PxCookingParams_set_convexMeshCookingType_1 = Module['_emscripten_bind_PxCookingParams_set_convexMeshCookingType_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_set_convexMeshCookingType_1');
var _emscripten_bind_PxCookingParams_get_suppressTriangleMeshRemapTable_0 = Module['_emscripten_bind_PxCookingParams_get_suppressTriangleMeshRemapTable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_get_suppressTriangleMeshRemapTable_0');
var _emscripten_bind_PxCookingParams_set_suppressTriangleMeshRemapTable_1 = Module['_emscripten_bind_PxCookingParams_set_suppressTriangleMeshRemapTable_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_set_suppressTriangleMeshRemapTable_1');
var _emscripten_bind_PxCookingParams_get_buildTriangleAdjacencies_0 = Module['_emscripten_bind_PxCookingParams_get_buildTriangleAdjacencies_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_get_buildTriangleAdjacencies_0');
var _emscripten_bind_PxCookingParams_set_buildTriangleAdjacencies_1 = Module['_emscripten_bind_PxCookingParams_set_buildTriangleAdjacencies_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_set_buildTriangleAdjacencies_1');
var _emscripten_bind_PxCookingParams_get_buildGPUData_0 = Module['_emscripten_bind_PxCookingParams_get_buildGPUData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_get_buildGPUData_0');
var _emscripten_bind_PxCookingParams_set_buildGPUData_1 = Module['_emscripten_bind_PxCookingParams_set_buildGPUData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_set_buildGPUData_1');
var _emscripten_bind_PxCookingParams_get_scale_0 = Module['_emscripten_bind_PxCookingParams_get_scale_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_get_scale_0');
var _emscripten_bind_PxCookingParams_set_scale_1 = Module['_emscripten_bind_PxCookingParams_set_scale_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_set_scale_1');
var _emscripten_bind_PxCookingParams_get_meshPreprocessParams_0 = Module['_emscripten_bind_PxCookingParams_get_meshPreprocessParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_get_meshPreprocessParams_0');
var _emscripten_bind_PxCookingParams_set_meshPreprocessParams_1 = Module['_emscripten_bind_PxCookingParams_set_meshPreprocessParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_set_meshPreprocessParams_1');
var _emscripten_bind_PxCookingParams_get_meshWeldTolerance_0 = Module['_emscripten_bind_PxCookingParams_get_meshWeldTolerance_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_get_meshWeldTolerance_0');
var _emscripten_bind_PxCookingParams_set_meshWeldTolerance_1 = Module['_emscripten_bind_PxCookingParams_set_meshWeldTolerance_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_set_meshWeldTolerance_1');
var _emscripten_bind_PxCookingParams_get_midphaseDesc_0 = Module['_emscripten_bind_PxCookingParams_get_midphaseDesc_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_get_midphaseDesc_0');
var _emscripten_bind_PxCookingParams_set_midphaseDesc_1 = Module['_emscripten_bind_PxCookingParams_set_midphaseDesc_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_set_midphaseDesc_1');
var _emscripten_bind_PxCookingParams_get_gaussMapLimit_0 = Module['_emscripten_bind_PxCookingParams_get_gaussMapLimit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_get_gaussMapLimit_0');
var _emscripten_bind_PxCookingParams_set_gaussMapLimit_1 = Module['_emscripten_bind_PxCookingParams_set_gaussMapLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams_set_gaussMapLimit_1');
var _emscripten_bind_PxCookingParams___destroy___0 = Module['_emscripten_bind_PxCookingParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxCookingParams___destroy___0');
var _emscripten_bind_PxD6Joint_setMotion_2 = Module['_emscripten_bind_PxD6Joint_setMotion_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setMotion_2');
var _emscripten_bind_PxD6Joint_getMotion_1 = Module['_emscripten_bind_PxD6Joint_getMotion_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getMotion_1');
var _emscripten_bind_PxD6Joint_getTwistAngle_0 = Module['_emscripten_bind_PxD6Joint_getTwistAngle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getTwistAngle_0');
var _emscripten_bind_PxD6Joint_getSwingYAngle_0 = Module['_emscripten_bind_PxD6Joint_getSwingYAngle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getSwingYAngle_0');
var _emscripten_bind_PxD6Joint_getSwingZAngle_0 = Module['_emscripten_bind_PxD6Joint_getSwingZAngle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getSwingZAngle_0');
var _emscripten_bind_PxD6Joint_setDistanceLimit_1 = Module['_emscripten_bind_PxD6Joint_setDistanceLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setDistanceLimit_1');
var _emscripten_bind_PxD6Joint_setLinearLimit_2 = Module['_emscripten_bind_PxD6Joint_setLinearLimit_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setLinearLimit_2');
var _emscripten_bind_PxD6Joint_setTwistLimit_1 = Module['_emscripten_bind_PxD6Joint_setTwistLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setTwistLimit_1');
var _emscripten_bind_PxD6Joint_setSwingLimit_1 = Module['_emscripten_bind_PxD6Joint_setSwingLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setSwingLimit_1');
var _emscripten_bind_PxD6Joint_setPyramidSwingLimit_1 = Module['_emscripten_bind_PxD6Joint_setPyramidSwingLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setPyramidSwingLimit_1');
var _emscripten_bind_PxD6Joint_setDrive_2 = Module['_emscripten_bind_PxD6Joint_setDrive_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setDrive_2');
var _emscripten_bind_PxD6Joint_getDrive_1 = Module['_emscripten_bind_PxD6Joint_getDrive_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getDrive_1');
var _emscripten_bind_PxD6Joint_setDrivePosition_1 = Module['_emscripten_bind_PxD6Joint_setDrivePosition_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setDrivePosition_1');
var _emscripten_bind_PxD6Joint_setDrivePosition_2 = Module['_emscripten_bind_PxD6Joint_setDrivePosition_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setDrivePosition_2');
var _emscripten_bind_PxD6Joint_getDrivePosition_0 = Module['_emscripten_bind_PxD6Joint_getDrivePosition_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getDrivePosition_0');
var _emscripten_bind_PxD6Joint_setDriveVelocity_2 = Module['_emscripten_bind_PxD6Joint_setDriveVelocity_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setDriveVelocity_2');
var _emscripten_bind_PxD6Joint_getDriveVelocity_2 = Module['_emscripten_bind_PxD6Joint_getDriveVelocity_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getDriveVelocity_2');
var _emscripten_bind_PxD6Joint_setAngularDriveConfig_1 = Module['_emscripten_bind_PxD6Joint_setAngularDriveConfig_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setAngularDriveConfig_1');
var _emscripten_bind_PxD6Joint_getAngularDriveConfig_0 = Module['_emscripten_bind_PxD6Joint_getAngularDriveConfig_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getAngularDriveConfig_0');
var _emscripten_bind_PxD6Joint_release_0 = Module['_emscripten_bind_PxD6Joint_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_release_0');
var _emscripten_bind_PxD6Joint_getConcreteTypeName_0 = Module['_emscripten_bind_PxD6Joint_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getConcreteTypeName_0');
var _emscripten_bind_PxD6Joint_getConcreteType_0 = Module['_emscripten_bind_PxD6Joint_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getConcreteType_0');
var _emscripten_bind_PxD6Joint_setBaseFlag_2 = Module['_emscripten_bind_PxD6Joint_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setBaseFlag_2');
var _emscripten_bind_PxD6Joint_setBaseFlags_1 = Module['_emscripten_bind_PxD6Joint_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setBaseFlags_1');
var _emscripten_bind_PxD6Joint_getBaseFlags_0 = Module['_emscripten_bind_PxD6Joint_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getBaseFlags_0');
var _emscripten_bind_PxD6Joint_isReleasable_0 = Module['_emscripten_bind_PxD6Joint_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_isReleasable_0');
var _emscripten_bind_PxD6Joint_setActors_2 = Module['_emscripten_bind_PxD6Joint_setActors_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setActors_2');
var _emscripten_bind_PxD6Joint_setLocalPose_2 = Module['_emscripten_bind_PxD6Joint_setLocalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setLocalPose_2');
var _emscripten_bind_PxD6Joint_getLocalPose_1 = Module['_emscripten_bind_PxD6Joint_getLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getLocalPose_1');
var _emscripten_bind_PxD6Joint_getRelativeTransform_0 = Module['_emscripten_bind_PxD6Joint_getRelativeTransform_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getRelativeTransform_0');
var _emscripten_bind_PxD6Joint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxD6Joint_getRelativeLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getRelativeLinearVelocity_0');
var _emscripten_bind_PxD6Joint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxD6Joint_getRelativeAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getRelativeAngularVelocity_0');
var _emscripten_bind_PxD6Joint_setBreakForce_2 = Module['_emscripten_bind_PxD6Joint_setBreakForce_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setBreakForce_2');
var _emscripten_bind_PxD6Joint_setConstraintFlags_1 = Module['_emscripten_bind_PxD6Joint_setConstraintFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setConstraintFlags_1');
var _emscripten_bind_PxD6Joint_setConstraintFlag_2 = Module['_emscripten_bind_PxD6Joint_setConstraintFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setConstraintFlag_2');
var _emscripten_bind_PxD6Joint_getConstraintFlags_0 = Module['_emscripten_bind_PxD6Joint_getConstraintFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getConstraintFlags_0');
var _emscripten_bind_PxD6Joint_setInvMassScale0_1 = Module['_emscripten_bind_PxD6Joint_setInvMassScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setInvMassScale0_1');
var _emscripten_bind_PxD6Joint_getInvMassScale0_0 = Module['_emscripten_bind_PxD6Joint_getInvMassScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getInvMassScale0_0');
var _emscripten_bind_PxD6Joint_setInvMassScale1_1 = Module['_emscripten_bind_PxD6Joint_setInvMassScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setInvMassScale1_1');
var _emscripten_bind_PxD6Joint_getInvMassScale1_0 = Module['_emscripten_bind_PxD6Joint_getInvMassScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getInvMassScale1_0');
var _emscripten_bind_PxD6Joint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxD6Joint_setInvInertiaScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setInvInertiaScale0_1');
var _emscripten_bind_PxD6Joint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxD6Joint_getInvInertiaScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getInvInertiaScale0_0');
var _emscripten_bind_PxD6Joint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxD6Joint_setInvInertiaScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setInvInertiaScale1_1');
var _emscripten_bind_PxD6Joint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxD6Joint_getInvInertiaScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getInvInertiaScale1_0');
var _emscripten_bind_PxD6Joint_getConstraint_0 = Module['_emscripten_bind_PxD6Joint_getConstraint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getConstraint_0');
var _emscripten_bind_PxD6Joint_setName_1 = Module['_emscripten_bind_PxD6Joint_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_setName_1');
var _emscripten_bind_PxD6Joint_getName_0 = Module['_emscripten_bind_PxD6Joint_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getName_0');
var _emscripten_bind_PxD6Joint_getScene_0 = Module['_emscripten_bind_PxD6Joint_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_getScene_0');
var _emscripten_bind_PxD6Joint_get_userData_0 = Module['_emscripten_bind_PxD6Joint_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_get_userData_0');
var _emscripten_bind_PxD6Joint_set_userData_1 = Module['_emscripten_bind_PxD6Joint_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint_set_userData_1');
var _emscripten_bind_PxD6Joint___destroy___0 = Module['_emscripten_bind_PxD6Joint___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6Joint___destroy___0');
var _emscripten_bind_PxD6JointDrive_PxD6JointDrive_0 = Module['_emscripten_bind_PxD6JointDrive_PxD6JointDrive_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDrive_PxD6JointDrive_0');
var _emscripten_bind_PxD6JointDrive_PxD6JointDrive_3 = Module['_emscripten_bind_PxD6JointDrive_PxD6JointDrive_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDrive_PxD6JointDrive_3');
var _emscripten_bind_PxD6JointDrive_PxD6JointDrive_4 = Module['_emscripten_bind_PxD6JointDrive_PxD6JointDrive_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDrive_PxD6JointDrive_4');
var _emscripten_bind_PxD6JointDrive_get_forceLimit_0 = Module['_emscripten_bind_PxD6JointDrive_get_forceLimit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDrive_get_forceLimit_0');
var _emscripten_bind_PxD6JointDrive_set_forceLimit_1 = Module['_emscripten_bind_PxD6JointDrive_set_forceLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDrive_set_forceLimit_1');
var _emscripten_bind_PxD6JointDrive_get_flags_0 = Module['_emscripten_bind_PxD6JointDrive_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDrive_get_flags_0');
var _emscripten_bind_PxD6JointDrive_set_flags_1 = Module['_emscripten_bind_PxD6JointDrive_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDrive_set_flags_1');
var _emscripten_bind_PxD6JointDrive_get_stiffness_0 = Module['_emscripten_bind_PxD6JointDrive_get_stiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDrive_get_stiffness_0');
var _emscripten_bind_PxD6JointDrive_set_stiffness_1 = Module['_emscripten_bind_PxD6JointDrive_set_stiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDrive_set_stiffness_1');
var _emscripten_bind_PxD6JointDrive_get_damping_0 = Module['_emscripten_bind_PxD6JointDrive_get_damping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDrive_get_damping_0');
var _emscripten_bind_PxD6JointDrive_set_damping_1 = Module['_emscripten_bind_PxD6JointDrive_set_damping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDrive_set_damping_1');
var _emscripten_bind_PxD6JointDrive___destroy___0 = Module['_emscripten_bind_PxD6JointDrive___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDrive___destroy___0');
var _emscripten_bind_PxD6JointDriveFlags_PxD6JointDriveFlags_1 = Module['_emscripten_bind_PxD6JointDriveFlags_PxD6JointDriveFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDriveFlags_PxD6JointDriveFlags_1');
var _emscripten_bind_PxD6JointDriveFlags_isSet_1 = Module['_emscripten_bind_PxD6JointDriveFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDriveFlags_isSet_1');
var _emscripten_bind_PxD6JointDriveFlags_raise_1 = Module['_emscripten_bind_PxD6JointDriveFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDriveFlags_raise_1');
var _emscripten_bind_PxD6JointDriveFlags_clear_1 = Module['_emscripten_bind_PxD6JointDriveFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDriveFlags_clear_1');
var _emscripten_bind_PxD6JointDriveFlags___destroy___0 = Module['_emscripten_bind_PxD6JointDriveFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxD6JointDriveFlags___destroy___0');
var _emscripten_bind_PxDebugLine_get_pos0_0 = Module['_emscripten_bind_PxDebugLine_get_pos0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugLine_get_pos0_0');
var _emscripten_bind_PxDebugLine_set_pos0_1 = Module['_emscripten_bind_PxDebugLine_set_pos0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugLine_set_pos0_1');
var _emscripten_bind_PxDebugLine_get_color0_0 = Module['_emscripten_bind_PxDebugLine_get_color0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugLine_get_color0_0');
var _emscripten_bind_PxDebugLine_set_color0_1 = Module['_emscripten_bind_PxDebugLine_set_color0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugLine_set_color0_1');
var _emscripten_bind_PxDebugLine_get_pos1_0 = Module['_emscripten_bind_PxDebugLine_get_pos1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugLine_get_pos1_0');
var _emscripten_bind_PxDebugLine_set_pos1_1 = Module['_emscripten_bind_PxDebugLine_set_pos1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugLine_set_pos1_1');
var _emscripten_bind_PxDebugLine_get_color1_0 = Module['_emscripten_bind_PxDebugLine_get_color1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugLine_get_color1_0');
var _emscripten_bind_PxDebugLine_set_color1_1 = Module['_emscripten_bind_PxDebugLine_set_color1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugLine_set_color1_1');
var _emscripten_bind_PxDebugPoint_get_pos_0 = Module['_emscripten_bind_PxDebugPoint_get_pos_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugPoint_get_pos_0');
var _emscripten_bind_PxDebugPoint_set_pos_1 = Module['_emscripten_bind_PxDebugPoint_set_pos_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugPoint_set_pos_1');
var _emscripten_bind_PxDebugPoint_get_color_0 = Module['_emscripten_bind_PxDebugPoint_get_color_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugPoint_get_color_0');
var _emscripten_bind_PxDebugPoint_set_color_1 = Module['_emscripten_bind_PxDebugPoint_set_color_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugPoint_set_color_1');
var _emscripten_bind_PxDebugTriangle_get_pos0_0 = Module['_emscripten_bind_PxDebugTriangle_get_pos0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugTriangle_get_pos0_0');
var _emscripten_bind_PxDebugTriangle_set_pos0_1 = Module['_emscripten_bind_PxDebugTriangle_set_pos0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugTriangle_set_pos0_1');
var _emscripten_bind_PxDebugTriangle_get_color0_0 = Module['_emscripten_bind_PxDebugTriangle_get_color0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugTriangle_get_color0_0');
var _emscripten_bind_PxDebugTriangle_set_color0_1 = Module['_emscripten_bind_PxDebugTriangle_set_color0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugTriangle_set_color0_1');
var _emscripten_bind_PxDebugTriangle_get_pos1_0 = Module['_emscripten_bind_PxDebugTriangle_get_pos1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugTriangle_get_pos1_0');
var _emscripten_bind_PxDebugTriangle_set_pos1_1 = Module['_emscripten_bind_PxDebugTriangle_set_pos1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugTriangle_set_pos1_1');
var _emscripten_bind_PxDebugTriangle_get_color1_0 = Module['_emscripten_bind_PxDebugTriangle_get_color1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugTriangle_get_color1_0');
var _emscripten_bind_PxDebugTriangle_set_color1_1 = Module['_emscripten_bind_PxDebugTriangle_set_color1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugTriangle_set_color1_1');
var _emscripten_bind_PxDebugTriangle_get_pos2_0 = Module['_emscripten_bind_PxDebugTriangle_get_pos2_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugTriangle_get_pos2_0');
var _emscripten_bind_PxDebugTriangle_set_pos2_1 = Module['_emscripten_bind_PxDebugTriangle_set_pos2_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugTriangle_set_pos2_1');
var _emscripten_bind_PxDebugTriangle_get_color2_0 = Module['_emscripten_bind_PxDebugTriangle_get_color2_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugTriangle_get_color2_0');
var _emscripten_bind_PxDebugTriangle_set_color2_1 = Module['_emscripten_bind_PxDebugTriangle_set_color2_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDebugTriangle_set_color2_1');
var _emscripten_bind_PxDefaultAllocator_PxDefaultAllocator_0 = Module['_emscripten_bind_PxDefaultAllocator_PxDefaultAllocator_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultAllocator_PxDefaultAllocator_0');
var _emscripten_bind_PxDefaultAllocator___destroy___0 = Module['_emscripten_bind_PxDefaultAllocator___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultAllocator___destroy___0');
var _emscripten_bind_PxDefaultCpuDispatcher___destroy___0 = Module['_emscripten_bind_PxDefaultCpuDispatcher___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultCpuDispatcher___destroy___0');
var _emscripten_bind_PxDefaultErrorCallback_PxDefaultErrorCallback_0 = Module['_emscripten_bind_PxDefaultErrorCallback_PxDefaultErrorCallback_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultErrorCallback_PxDefaultErrorCallback_0');
var _emscripten_bind_PxDefaultErrorCallback_reportError_4 = Module['_emscripten_bind_PxDefaultErrorCallback_reportError_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultErrorCallback_reportError_4');
var _emscripten_bind_PxDefaultErrorCallback___destroy___0 = Module['_emscripten_bind_PxDefaultErrorCallback___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultErrorCallback___destroy___0');
var _emscripten_bind_PxDefaultMemoryInputData_PxDefaultMemoryInputData_2 = Module['_emscripten_bind_PxDefaultMemoryInputData_PxDefaultMemoryInputData_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultMemoryInputData_PxDefaultMemoryInputData_2');
var _emscripten_bind_PxDefaultMemoryInputData_read_2 = Module['_emscripten_bind_PxDefaultMemoryInputData_read_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultMemoryInputData_read_2');
var _emscripten_bind_PxDefaultMemoryInputData_getLength_0 = Module['_emscripten_bind_PxDefaultMemoryInputData_getLength_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultMemoryInputData_getLength_0');
var _emscripten_bind_PxDefaultMemoryInputData_seek_1 = Module['_emscripten_bind_PxDefaultMemoryInputData_seek_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultMemoryInputData_seek_1');
var _emscripten_bind_PxDefaultMemoryInputData_tell_0 = Module['_emscripten_bind_PxDefaultMemoryInputData_tell_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultMemoryInputData_tell_0');
var _emscripten_bind_PxDefaultMemoryInputData___destroy___0 = Module['_emscripten_bind_PxDefaultMemoryInputData___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultMemoryInputData___destroy___0');
var _emscripten_bind_PxDefaultMemoryOutputStream_PxDefaultMemoryOutputStream_0 = Module['_emscripten_bind_PxDefaultMemoryOutputStream_PxDefaultMemoryOutputStream_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultMemoryOutputStream_PxDefaultMemoryOutputStream_0');
var _emscripten_bind_PxDefaultMemoryOutputStream_write_2 = Module['_emscripten_bind_PxDefaultMemoryOutputStream_write_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultMemoryOutputStream_write_2');
var _emscripten_bind_PxDefaultMemoryOutputStream_getSize_0 = Module['_emscripten_bind_PxDefaultMemoryOutputStream_getSize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultMemoryOutputStream_getSize_0');
var _emscripten_bind_PxDefaultMemoryOutputStream_getData_0 = Module['_emscripten_bind_PxDefaultMemoryOutputStream_getData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultMemoryOutputStream_getData_0');
var _emscripten_bind_PxDefaultMemoryOutputStream___destroy___0 = Module['_emscripten_bind_PxDefaultMemoryOutputStream___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDefaultMemoryOutputStream___destroy___0');
var _emscripten_bind_PxDim3_PxDim3_0 = Module['_emscripten_bind_PxDim3_PxDim3_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDim3_PxDim3_0');
var _emscripten_bind_PxDim3_get_x_0 = Module['_emscripten_bind_PxDim3_get_x_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDim3_get_x_0');
var _emscripten_bind_PxDim3_set_x_1 = Module['_emscripten_bind_PxDim3_set_x_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDim3_set_x_1');
var _emscripten_bind_PxDim3_get_y_0 = Module['_emscripten_bind_PxDim3_get_y_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDim3_get_y_0');
var _emscripten_bind_PxDim3_set_y_1 = Module['_emscripten_bind_PxDim3_set_y_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDim3_set_y_1');
var _emscripten_bind_PxDim3_get_z_0 = Module['_emscripten_bind_PxDim3_get_z_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDim3_get_z_0');
var _emscripten_bind_PxDim3_set_z_1 = Module['_emscripten_bind_PxDim3_set_z_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDim3_set_z_1');
var _emscripten_bind_PxDim3___destroy___0 = Module['_emscripten_bind_PxDim3___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDim3___destroy___0');
var _emscripten_bind_PxDistanceJoint_getDistance_0 = Module['_emscripten_bind_PxDistanceJoint_getDistance_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getDistance_0');
var _emscripten_bind_PxDistanceJoint_setMinDistance_1 = Module['_emscripten_bind_PxDistanceJoint_setMinDistance_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setMinDistance_1');
var _emscripten_bind_PxDistanceJoint_getMinDistance_0 = Module['_emscripten_bind_PxDistanceJoint_getMinDistance_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getMinDistance_0');
var _emscripten_bind_PxDistanceJoint_setMaxDistance_1 = Module['_emscripten_bind_PxDistanceJoint_setMaxDistance_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setMaxDistance_1');
var _emscripten_bind_PxDistanceJoint_getMaxDistance_0 = Module['_emscripten_bind_PxDistanceJoint_getMaxDistance_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getMaxDistance_0');
var _emscripten_bind_PxDistanceJoint_setTolerance_1 = Module['_emscripten_bind_PxDistanceJoint_setTolerance_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setTolerance_1');
var _emscripten_bind_PxDistanceJoint_getTolerance_0 = Module['_emscripten_bind_PxDistanceJoint_getTolerance_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getTolerance_0');
var _emscripten_bind_PxDistanceJoint_setStiffness_1 = Module['_emscripten_bind_PxDistanceJoint_setStiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setStiffness_1');
var _emscripten_bind_PxDistanceJoint_getStiffness_0 = Module['_emscripten_bind_PxDistanceJoint_getStiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getStiffness_0');
var _emscripten_bind_PxDistanceJoint_setDamping_1 = Module['_emscripten_bind_PxDistanceJoint_setDamping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setDamping_1');
var _emscripten_bind_PxDistanceJoint_getDamping_0 = Module['_emscripten_bind_PxDistanceJoint_getDamping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getDamping_0');
var _emscripten_bind_PxDistanceJoint_setDistanceJointFlags_1 = Module['_emscripten_bind_PxDistanceJoint_setDistanceJointFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setDistanceJointFlags_1');
var _emscripten_bind_PxDistanceJoint_setDistanceJointFlag_2 = Module['_emscripten_bind_PxDistanceJoint_setDistanceJointFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setDistanceJointFlag_2');
var _emscripten_bind_PxDistanceJoint_getDistanceJointFlags_0 = Module['_emscripten_bind_PxDistanceJoint_getDistanceJointFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getDistanceJointFlags_0');
var _emscripten_bind_PxDistanceJoint_release_0 = Module['_emscripten_bind_PxDistanceJoint_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_release_0');
var _emscripten_bind_PxDistanceJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxDistanceJoint_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getConcreteTypeName_0');
var _emscripten_bind_PxDistanceJoint_getConcreteType_0 = Module['_emscripten_bind_PxDistanceJoint_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getConcreteType_0');
var _emscripten_bind_PxDistanceJoint_setBaseFlag_2 = Module['_emscripten_bind_PxDistanceJoint_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setBaseFlag_2');
var _emscripten_bind_PxDistanceJoint_setBaseFlags_1 = Module['_emscripten_bind_PxDistanceJoint_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setBaseFlags_1');
var _emscripten_bind_PxDistanceJoint_getBaseFlags_0 = Module['_emscripten_bind_PxDistanceJoint_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getBaseFlags_0');
var _emscripten_bind_PxDistanceJoint_isReleasable_0 = Module['_emscripten_bind_PxDistanceJoint_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_isReleasable_0');
var _emscripten_bind_PxDistanceJoint_setActors_2 = Module['_emscripten_bind_PxDistanceJoint_setActors_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setActors_2');
var _emscripten_bind_PxDistanceJoint_setLocalPose_2 = Module['_emscripten_bind_PxDistanceJoint_setLocalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setLocalPose_2');
var _emscripten_bind_PxDistanceJoint_getLocalPose_1 = Module['_emscripten_bind_PxDistanceJoint_getLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getLocalPose_1');
var _emscripten_bind_PxDistanceJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxDistanceJoint_getRelativeTransform_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getRelativeTransform_0');
var _emscripten_bind_PxDistanceJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxDistanceJoint_getRelativeLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getRelativeLinearVelocity_0');
var _emscripten_bind_PxDistanceJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxDistanceJoint_getRelativeAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getRelativeAngularVelocity_0');
var _emscripten_bind_PxDistanceJoint_setBreakForce_2 = Module['_emscripten_bind_PxDistanceJoint_setBreakForce_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setBreakForce_2');
var _emscripten_bind_PxDistanceJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxDistanceJoint_setConstraintFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setConstraintFlags_1');
var _emscripten_bind_PxDistanceJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxDistanceJoint_setConstraintFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setConstraintFlag_2');
var _emscripten_bind_PxDistanceJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxDistanceJoint_getConstraintFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getConstraintFlags_0');
var _emscripten_bind_PxDistanceJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxDistanceJoint_setInvMassScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setInvMassScale0_1');
var _emscripten_bind_PxDistanceJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxDistanceJoint_getInvMassScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getInvMassScale0_0');
var _emscripten_bind_PxDistanceJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxDistanceJoint_setInvMassScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setInvMassScale1_1');
var _emscripten_bind_PxDistanceJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxDistanceJoint_getInvMassScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getInvMassScale1_0');
var _emscripten_bind_PxDistanceJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxDistanceJoint_setInvInertiaScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setInvInertiaScale0_1');
var _emscripten_bind_PxDistanceJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxDistanceJoint_getInvInertiaScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getInvInertiaScale0_0');
var _emscripten_bind_PxDistanceJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxDistanceJoint_setInvInertiaScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setInvInertiaScale1_1');
var _emscripten_bind_PxDistanceJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxDistanceJoint_getInvInertiaScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getInvInertiaScale1_0');
var _emscripten_bind_PxDistanceJoint_getConstraint_0 = Module['_emscripten_bind_PxDistanceJoint_getConstraint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getConstraint_0');
var _emscripten_bind_PxDistanceJoint_setName_1 = Module['_emscripten_bind_PxDistanceJoint_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_setName_1');
var _emscripten_bind_PxDistanceJoint_getName_0 = Module['_emscripten_bind_PxDistanceJoint_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getName_0');
var _emscripten_bind_PxDistanceJoint_getScene_0 = Module['_emscripten_bind_PxDistanceJoint_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_getScene_0');
var _emscripten_bind_PxDistanceJoint_get_userData_0 = Module['_emscripten_bind_PxDistanceJoint_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_get_userData_0');
var _emscripten_bind_PxDistanceJoint_set_userData_1 = Module['_emscripten_bind_PxDistanceJoint_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint_set_userData_1');
var _emscripten_bind_PxDistanceJoint___destroy___0 = Module['_emscripten_bind_PxDistanceJoint___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJoint___destroy___0');
var _emscripten_bind_PxDistanceJointFlags_PxDistanceJointFlags_1 = Module['_emscripten_bind_PxDistanceJointFlags_PxDistanceJointFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJointFlags_PxDistanceJointFlags_1');
var _emscripten_bind_PxDistanceJointFlags_isSet_1 = Module['_emscripten_bind_PxDistanceJointFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJointFlags_isSet_1');
var _emscripten_bind_PxDistanceJointFlags_raise_1 = Module['_emscripten_bind_PxDistanceJointFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJointFlags_raise_1');
var _emscripten_bind_PxDistanceJointFlags_clear_1 = Module['_emscripten_bind_PxDistanceJointFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJointFlags_clear_1');
var _emscripten_bind_PxDistanceJointFlags___destroy___0 = Module['_emscripten_bind_PxDistanceJointFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDistanceJointFlags___destroy___0');
var _emscripten_bind_PxDominanceGroupPair_PxDominanceGroupPair_2 = Module['_emscripten_bind_PxDominanceGroupPair_PxDominanceGroupPair_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxDominanceGroupPair_PxDominanceGroupPair_2');
var _emscripten_bind_PxDominanceGroupPair_get_dominance0_0 = Module['_emscripten_bind_PxDominanceGroupPair_get_dominance0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDominanceGroupPair_get_dominance0_0');
var _emscripten_bind_PxDominanceGroupPair_set_dominance0_1 = Module['_emscripten_bind_PxDominanceGroupPair_set_dominance0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDominanceGroupPair_set_dominance0_1');
var _emscripten_bind_PxDominanceGroupPair_get_dominance1_0 = Module['_emscripten_bind_PxDominanceGroupPair_get_dominance1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDominanceGroupPair_get_dominance1_0');
var _emscripten_bind_PxDominanceGroupPair_set_dominance1_1 = Module['_emscripten_bind_PxDominanceGroupPair_set_dominance1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxDominanceGroupPair_set_dominance1_1');
var _emscripten_bind_PxDominanceGroupPair___destroy___0 = Module['_emscripten_bind_PxDominanceGroupPair___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxDominanceGroupPair___destroy___0');
var _emscripten_bind_PxErrorCallbackImpl_PxErrorCallbackImpl_0 = Module['_emscripten_bind_PxErrorCallbackImpl_PxErrorCallbackImpl_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxErrorCallbackImpl_PxErrorCallbackImpl_0');
var _emscripten_bind_PxErrorCallbackImpl_reportError_4 = Module['_emscripten_bind_PxErrorCallbackImpl_reportError_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxErrorCallbackImpl_reportError_4');
var _emscripten_bind_PxErrorCallbackImpl___destroy___0 = Module['_emscripten_bind_PxErrorCallbackImpl___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxErrorCallbackImpl___destroy___0');
var _emscripten_bind_PxExtendedVec3_PxExtendedVec3_0 = Module['_emscripten_bind_PxExtendedVec3_PxExtendedVec3_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxExtendedVec3_PxExtendedVec3_0');
var _emscripten_bind_PxExtendedVec3_PxExtendedVec3_3 = Module['_emscripten_bind_PxExtendedVec3_PxExtendedVec3_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxExtendedVec3_PxExtendedVec3_3');
var _emscripten_bind_PxExtendedVec3_get_x_0 = Module['_emscripten_bind_PxExtendedVec3_get_x_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxExtendedVec3_get_x_0');
var _emscripten_bind_PxExtendedVec3_set_x_1 = Module['_emscripten_bind_PxExtendedVec3_set_x_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxExtendedVec3_set_x_1');
var _emscripten_bind_PxExtendedVec3_get_y_0 = Module['_emscripten_bind_PxExtendedVec3_get_y_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxExtendedVec3_get_y_0');
var _emscripten_bind_PxExtendedVec3_set_y_1 = Module['_emscripten_bind_PxExtendedVec3_set_y_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxExtendedVec3_set_y_1');
var _emscripten_bind_PxExtendedVec3_get_z_0 = Module['_emscripten_bind_PxExtendedVec3_get_z_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxExtendedVec3_get_z_0');
var _emscripten_bind_PxExtendedVec3_set_z_1 = Module['_emscripten_bind_PxExtendedVec3_set_z_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxExtendedVec3_set_z_1');
var _emscripten_bind_PxExtendedVec3___destroy___0 = Module['_emscripten_bind_PxExtendedVec3___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxExtendedVec3___destroy___0');
var _emscripten_bind_PxExtensionTopLevelFunctions_CreatePlane_4 = Module['_emscripten_bind_PxExtensionTopLevelFunctions_CreatePlane_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxExtensionTopLevelFunctions_CreatePlane_4');
var _emscripten_bind_PxFilterData_PxFilterData_0 = Module['_emscripten_bind_PxFilterData_PxFilterData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFilterData_PxFilterData_0');
var _emscripten_bind_PxFilterData_PxFilterData_4 = Module['_emscripten_bind_PxFilterData_PxFilterData_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxFilterData_PxFilterData_4');
var _emscripten_bind_PxFilterData_get_word0_0 = Module['_emscripten_bind_PxFilterData_get_word0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFilterData_get_word0_0');
var _emscripten_bind_PxFilterData_set_word0_1 = Module['_emscripten_bind_PxFilterData_set_word0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxFilterData_set_word0_1');
var _emscripten_bind_PxFilterData_get_word1_0 = Module['_emscripten_bind_PxFilterData_get_word1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFilterData_get_word1_0');
var _emscripten_bind_PxFilterData_set_word1_1 = Module['_emscripten_bind_PxFilterData_set_word1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxFilterData_set_word1_1');
var _emscripten_bind_PxFilterData_get_word2_0 = Module['_emscripten_bind_PxFilterData_get_word2_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFilterData_get_word2_0');
var _emscripten_bind_PxFilterData_set_word2_1 = Module['_emscripten_bind_PxFilterData_set_word2_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxFilterData_set_word2_1');
var _emscripten_bind_PxFilterData_get_word3_0 = Module['_emscripten_bind_PxFilterData_get_word3_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFilterData_get_word3_0');
var _emscripten_bind_PxFilterData_set_word3_1 = Module['_emscripten_bind_PxFilterData_set_word3_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxFilterData_set_word3_1');
var _emscripten_bind_PxFilterData___destroy___0 = Module['_emscripten_bind_PxFilterData___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFilterData___destroy___0');
var _emscripten_bind_PxFixedJoint_release_0 = Module['_emscripten_bind_PxFixedJoint_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_release_0');
var _emscripten_bind_PxFixedJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxFixedJoint_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getConcreteTypeName_0');
var _emscripten_bind_PxFixedJoint_getConcreteType_0 = Module['_emscripten_bind_PxFixedJoint_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getConcreteType_0');
var _emscripten_bind_PxFixedJoint_setBaseFlag_2 = Module['_emscripten_bind_PxFixedJoint_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_setBaseFlag_2');
var _emscripten_bind_PxFixedJoint_setBaseFlags_1 = Module['_emscripten_bind_PxFixedJoint_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_setBaseFlags_1');
var _emscripten_bind_PxFixedJoint_getBaseFlags_0 = Module['_emscripten_bind_PxFixedJoint_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getBaseFlags_0');
var _emscripten_bind_PxFixedJoint_isReleasable_0 = Module['_emscripten_bind_PxFixedJoint_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_isReleasable_0');
var _emscripten_bind_PxFixedJoint_setActors_2 = Module['_emscripten_bind_PxFixedJoint_setActors_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_setActors_2');
var _emscripten_bind_PxFixedJoint_setLocalPose_2 = Module['_emscripten_bind_PxFixedJoint_setLocalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_setLocalPose_2');
var _emscripten_bind_PxFixedJoint_getLocalPose_1 = Module['_emscripten_bind_PxFixedJoint_getLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getLocalPose_1');
var _emscripten_bind_PxFixedJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxFixedJoint_getRelativeTransform_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getRelativeTransform_0');
var _emscripten_bind_PxFixedJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxFixedJoint_getRelativeLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getRelativeLinearVelocity_0');
var _emscripten_bind_PxFixedJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxFixedJoint_getRelativeAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getRelativeAngularVelocity_0');
var _emscripten_bind_PxFixedJoint_setBreakForce_2 = Module['_emscripten_bind_PxFixedJoint_setBreakForce_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_setBreakForce_2');
var _emscripten_bind_PxFixedJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxFixedJoint_setConstraintFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_setConstraintFlags_1');
var _emscripten_bind_PxFixedJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxFixedJoint_setConstraintFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_setConstraintFlag_2');
var _emscripten_bind_PxFixedJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxFixedJoint_getConstraintFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getConstraintFlags_0');
var _emscripten_bind_PxFixedJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxFixedJoint_setInvMassScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_setInvMassScale0_1');
var _emscripten_bind_PxFixedJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxFixedJoint_getInvMassScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getInvMassScale0_0');
var _emscripten_bind_PxFixedJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxFixedJoint_setInvMassScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_setInvMassScale1_1');
var _emscripten_bind_PxFixedJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxFixedJoint_getInvMassScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getInvMassScale1_0');
var _emscripten_bind_PxFixedJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxFixedJoint_setInvInertiaScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_setInvInertiaScale0_1');
var _emscripten_bind_PxFixedJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxFixedJoint_getInvInertiaScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getInvInertiaScale0_0');
var _emscripten_bind_PxFixedJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxFixedJoint_setInvInertiaScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_setInvInertiaScale1_1');
var _emscripten_bind_PxFixedJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxFixedJoint_getInvInertiaScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getInvInertiaScale1_0');
var _emscripten_bind_PxFixedJoint_getConstraint_0 = Module['_emscripten_bind_PxFixedJoint_getConstraint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getConstraint_0');
var _emscripten_bind_PxFixedJoint_setName_1 = Module['_emscripten_bind_PxFixedJoint_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_setName_1');
var _emscripten_bind_PxFixedJoint_getName_0 = Module['_emscripten_bind_PxFixedJoint_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getName_0');
var _emscripten_bind_PxFixedJoint_getScene_0 = Module['_emscripten_bind_PxFixedJoint_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_getScene_0');
var _emscripten_bind_PxFixedJoint_get_userData_0 = Module['_emscripten_bind_PxFixedJoint_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_get_userData_0');
var _emscripten_bind_PxFixedJoint_set_userData_1 = Module['_emscripten_bind_PxFixedJoint_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint_set_userData_1');
var _emscripten_bind_PxFixedJoint___destroy___0 = Module['_emscripten_bind_PxFixedJoint___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFixedJoint___destroy___0');
var _emscripten_bind_PxFoundation_release_0 = Module['_emscripten_bind_PxFoundation_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxFoundation_release_0');
var _emscripten_bind_PxGearJoint_setHinges_2 = Module['_emscripten_bind_PxGearJoint_setHinges_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_setHinges_2');
var _emscripten_bind_PxGearJoint_setGearRatio_1 = Module['_emscripten_bind_PxGearJoint_setGearRatio_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_setGearRatio_1');
var _emscripten_bind_PxGearJoint_getGearRatio_0 = Module['_emscripten_bind_PxGearJoint_getGearRatio_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getGearRatio_0');
var _emscripten_bind_PxGearJoint_release_0 = Module['_emscripten_bind_PxGearJoint_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_release_0');
var _emscripten_bind_PxGearJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxGearJoint_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getConcreteTypeName_0');
var _emscripten_bind_PxGearJoint_getConcreteType_0 = Module['_emscripten_bind_PxGearJoint_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getConcreteType_0');
var _emscripten_bind_PxGearJoint_setBaseFlag_2 = Module['_emscripten_bind_PxGearJoint_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_setBaseFlag_2');
var _emscripten_bind_PxGearJoint_setBaseFlags_1 = Module['_emscripten_bind_PxGearJoint_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_setBaseFlags_1');
var _emscripten_bind_PxGearJoint_getBaseFlags_0 = Module['_emscripten_bind_PxGearJoint_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getBaseFlags_0');
var _emscripten_bind_PxGearJoint_isReleasable_0 = Module['_emscripten_bind_PxGearJoint_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_isReleasable_0');
var _emscripten_bind_PxGearJoint_setActors_2 = Module['_emscripten_bind_PxGearJoint_setActors_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_setActors_2');
var _emscripten_bind_PxGearJoint_setLocalPose_2 = Module['_emscripten_bind_PxGearJoint_setLocalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_setLocalPose_2');
var _emscripten_bind_PxGearJoint_getLocalPose_1 = Module['_emscripten_bind_PxGearJoint_getLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getLocalPose_1');
var _emscripten_bind_PxGearJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxGearJoint_getRelativeTransform_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getRelativeTransform_0');
var _emscripten_bind_PxGearJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxGearJoint_getRelativeLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getRelativeLinearVelocity_0');
var _emscripten_bind_PxGearJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxGearJoint_getRelativeAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getRelativeAngularVelocity_0');
var _emscripten_bind_PxGearJoint_setBreakForce_2 = Module['_emscripten_bind_PxGearJoint_setBreakForce_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_setBreakForce_2');
var _emscripten_bind_PxGearJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxGearJoint_setConstraintFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_setConstraintFlags_1');
var _emscripten_bind_PxGearJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxGearJoint_setConstraintFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_setConstraintFlag_2');
var _emscripten_bind_PxGearJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxGearJoint_getConstraintFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getConstraintFlags_0');
var _emscripten_bind_PxGearJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxGearJoint_setInvMassScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_setInvMassScale0_1');
var _emscripten_bind_PxGearJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxGearJoint_getInvMassScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getInvMassScale0_0');
var _emscripten_bind_PxGearJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxGearJoint_setInvMassScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_setInvMassScale1_1');
var _emscripten_bind_PxGearJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxGearJoint_getInvMassScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getInvMassScale1_0');
var _emscripten_bind_PxGearJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxGearJoint_setInvInertiaScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_setInvInertiaScale0_1');
var _emscripten_bind_PxGearJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxGearJoint_getInvInertiaScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getInvInertiaScale0_0');
var _emscripten_bind_PxGearJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxGearJoint_setInvInertiaScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_setInvInertiaScale1_1');
var _emscripten_bind_PxGearJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxGearJoint_getInvInertiaScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getInvInertiaScale1_0');
var _emscripten_bind_PxGearJoint_getConstraint_0 = Module['_emscripten_bind_PxGearJoint_getConstraint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getConstraint_0');
var _emscripten_bind_PxGearJoint_setName_1 = Module['_emscripten_bind_PxGearJoint_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_setName_1');
var _emscripten_bind_PxGearJoint_getName_0 = Module['_emscripten_bind_PxGearJoint_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getName_0');
var _emscripten_bind_PxGearJoint_getScene_0 = Module['_emscripten_bind_PxGearJoint_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_getScene_0');
var _emscripten_bind_PxGearJoint_get_userData_0 = Module['_emscripten_bind_PxGearJoint_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_get_userData_0');
var _emscripten_bind_PxGearJoint_set_userData_1 = Module['_emscripten_bind_PxGearJoint_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint_set_userData_1');
var _emscripten_bind_PxGearJoint___destroy___0 = Module['_emscripten_bind_PxGearJoint___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGearJoint___destroy___0');
var _emscripten_bind_PxGeometryHolder_PxGeometryHolder_0 = Module['_emscripten_bind_PxGeometryHolder_PxGeometryHolder_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryHolder_PxGeometryHolder_0');
var _emscripten_bind_PxGeometryHolder_PxGeometryHolder_1 = Module['_emscripten_bind_PxGeometryHolder_PxGeometryHolder_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryHolder_PxGeometryHolder_1');
var _emscripten_bind_PxGeometryHolder_getType_0 = Module['_emscripten_bind_PxGeometryHolder_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryHolder_getType_0');
var _emscripten_bind_PxGeometryHolder_sphere_0 = Module['_emscripten_bind_PxGeometryHolder_sphere_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryHolder_sphere_0');
var _emscripten_bind_PxGeometryHolder_plane_0 = Module['_emscripten_bind_PxGeometryHolder_plane_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryHolder_plane_0');
var _emscripten_bind_PxGeometryHolder_capsule_0 = Module['_emscripten_bind_PxGeometryHolder_capsule_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryHolder_capsule_0');
var _emscripten_bind_PxGeometryHolder_box_0 = Module['_emscripten_bind_PxGeometryHolder_box_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryHolder_box_0');
var _emscripten_bind_PxGeometryHolder_convexMesh_0 = Module['_emscripten_bind_PxGeometryHolder_convexMesh_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryHolder_convexMesh_0');
var _emscripten_bind_PxGeometryHolder_triangleMesh_0 = Module['_emscripten_bind_PxGeometryHolder_triangleMesh_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryHolder_triangleMesh_0');
var _emscripten_bind_PxGeometryHolder_heightField_0 = Module['_emscripten_bind_PxGeometryHolder_heightField_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryHolder_heightField_0');
var _emscripten_bind_PxGeometryHolder_storeAny_1 = Module['_emscripten_bind_PxGeometryHolder_storeAny_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryHolder_storeAny_1');
var _emscripten_bind_PxGeometryHolder___destroy___0 = Module['_emscripten_bind_PxGeometryHolder___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryHolder___destroy___0');
var _emscripten_bind_PxGeometryQuery_sweep_7 = Module['_emscripten_bind_PxGeometryQuery_sweep_7'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryQuery_sweep_7');
var _emscripten_bind_PxGeometryQuery_sweep_8 = Module['_emscripten_bind_PxGeometryQuery_sweep_8'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryQuery_sweep_8');
var _emscripten_bind_PxGeometryQuery_sweep_9 = Module['_emscripten_bind_PxGeometryQuery_sweep_9'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryQuery_sweep_9');
var _emscripten_bind_PxGeometryQuery_overlap_4 = Module['_emscripten_bind_PxGeometryQuery_overlap_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryQuery_overlap_4');
var _emscripten_bind_PxGeometryQuery_raycast_8 = Module['_emscripten_bind_PxGeometryQuery_raycast_8'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryQuery_raycast_8');
var _emscripten_bind_PxGeometryQuery_pointDistance_3 = Module['_emscripten_bind_PxGeometryQuery_pointDistance_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryQuery_pointDistance_3');
var _emscripten_bind_PxGeometryQuery_pointDistance_4 = Module['_emscripten_bind_PxGeometryQuery_pointDistance_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryQuery_pointDistance_4');
var _emscripten_bind_PxGeometryQuery_computeGeomBounds_3 = Module['_emscripten_bind_PxGeometryQuery_computeGeomBounds_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryQuery_computeGeomBounds_3');
var _emscripten_bind_PxGeometryQuery_computeGeomBounds_4 = Module['_emscripten_bind_PxGeometryQuery_computeGeomBounds_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryQuery_computeGeomBounds_4');
var _emscripten_bind_PxGeometryQuery_isValid_1 = Module['_emscripten_bind_PxGeometryQuery_isValid_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryQuery_isValid_1');
var _emscripten_bind_PxGeometryQuery___destroy___0 = Module['_emscripten_bind_PxGeometryQuery___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGeometryQuery___destroy___0');
var _emscripten_bind_PxGjkQuery_proximityInfo_7 = Module['_emscripten_bind_PxGjkQuery_proximityInfo_7'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuery_proximityInfo_7');
var _emscripten_bind_PxGjkQuery_raycast_6 = Module['_emscripten_bind_PxGjkQuery_raycast_6'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuery_raycast_6');
var _emscripten_bind_PxGjkQuery_overlap_4 = Module['_emscripten_bind_PxGjkQuery_overlap_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuery_overlap_4');
var _emscripten_bind_PxGjkQuery_sweep_7 = Module['_emscripten_bind_PxGjkQuery_sweep_7'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuery_sweep_7');
var _emscripten_bind_PxGjkQuery___destroy___0 = Module['_emscripten_bind_PxGjkQuery___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuery___destroy___0');
var _emscripten_bind_PxGjkQueryExt_generateContacts_7 = Module['_emscripten_bind_PxGjkQueryExt_generateContacts_7'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryExt_generateContacts_7');
var _emscripten_bind_PxGjkQueryExt___destroy___0 = Module['_emscripten_bind_PxGjkQueryExt___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryExt___destroy___0');
var _emscripten_bind_PxGjkQueryProximityInfoResult_PxGjkQueryProximityInfoResult_0 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_PxGjkQueryProximityInfoResult_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryProximityInfoResult_PxGjkQueryProximityInfoResult_0');
var _emscripten_bind_PxGjkQueryProximityInfoResult_get_success_0 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_get_success_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryProximityInfoResult_get_success_0');
var _emscripten_bind_PxGjkQueryProximityInfoResult_set_success_1 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_set_success_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryProximityInfoResult_set_success_1');
var _emscripten_bind_PxGjkQueryProximityInfoResult_get_pointA_0 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_get_pointA_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryProximityInfoResult_get_pointA_0');
var _emscripten_bind_PxGjkQueryProximityInfoResult_set_pointA_1 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_set_pointA_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryProximityInfoResult_set_pointA_1');
var _emscripten_bind_PxGjkQueryProximityInfoResult_get_pointB_0 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_get_pointB_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryProximityInfoResult_get_pointB_0');
var _emscripten_bind_PxGjkQueryProximityInfoResult_set_pointB_1 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_set_pointB_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryProximityInfoResult_set_pointB_1');
var _emscripten_bind_PxGjkQueryProximityInfoResult_get_separatingAxis_0 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_get_separatingAxis_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryProximityInfoResult_get_separatingAxis_0');
var _emscripten_bind_PxGjkQueryProximityInfoResult_set_separatingAxis_1 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_set_separatingAxis_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryProximityInfoResult_set_separatingAxis_1');
var _emscripten_bind_PxGjkQueryProximityInfoResult_get_separation_0 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_get_separation_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryProximityInfoResult_get_separation_0');
var _emscripten_bind_PxGjkQueryProximityInfoResult_set_separation_1 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_set_separation_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryProximityInfoResult_set_separation_1');
var _emscripten_bind_PxGjkQueryProximityInfoResult___destroy___0 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryProximityInfoResult___destroy___0');
var _emscripten_bind_PxGjkQueryRaycastResult_PxGjkQueryRaycastResult_0 = Module['_emscripten_bind_PxGjkQueryRaycastResult_PxGjkQueryRaycastResult_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryRaycastResult_PxGjkQueryRaycastResult_0');
var _emscripten_bind_PxGjkQueryRaycastResult_get_success_0 = Module['_emscripten_bind_PxGjkQueryRaycastResult_get_success_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryRaycastResult_get_success_0');
var _emscripten_bind_PxGjkQueryRaycastResult_set_success_1 = Module['_emscripten_bind_PxGjkQueryRaycastResult_set_success_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryRaycastResult_set_success_1');
var _emscripten_bind_PxGjkQueryRaycastResult_get_t_0 = Module['_emscripten_bind_PxGjkQueryRaycastResult_get_t_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryRaycastResult_get_t_0');
var _emscripten_bind_PxGjkQueryRaycastResult_set_t_1 = Module['_emscripten_bind_PxGjkQueryRaycastResult_set_t_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryRaycastResult_set_t_1');
var _emscripten_bind_PxGjkQueryRaycastResult_get_n_0 = Module['_emscripten_bind_PxGjkQueryRaycastResult_get_n_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryRaycastResult_get_n_0');
var _emscripten_bind_PxGjkQueryRaycastResult_set_n_1 = Module['_emscripten_bind_PxGjkQueryRaycastResult_set_n_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryRaycastResult_set_n_1');
var _emscripten_bind_PxGjkQueryRaycastResult_get_p_0 = Module['_emscripten_bind_PxGjkQueryRaycastResult_get_p_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryRaycastResult_get_p_0');
var _emscripten_bind_PxGjkQueryRaycastResult_set_p_1 = Module['_emscripten_bind_PxGjkQueryRaycastResult_set_p_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryRaycastResult_set_p_1');
var _emscripten_bind_PxGjkQueryRaycastResult___destroy___0 = Module['_emscripten_bind_PxGjkQueryRaycastResult___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQueryRaycastResult___destroy___0');
var _emscripten_bind_PxGjkQuerySweepResult_PxGjkQuerySweepResult_0 = Module['_emscripten_bind_PxGjkQuerySweepResult_PxGjkQuerySweepResult_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuerySweepResult_PxGjkQuerySweepResult_0');
var _emscripten_bind_PxGjkQuerySweepResult_get_success_0 = Module['_emscripten_bind_PxGjkQuerySweepResult_get_success_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuerySweepResult_get_success_0');
var _emscripten_bind_PxGjkQuerySweepResult_set_success_1 = Module['_emscripten_bind_PxGjkQuerySweepResult_set_success_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuerySweepResult_set_success_1');
var _emscripten_bind_PxGjkQuerySweepResult_get_t_0 = Module['_emscripten_bind_PxGjkQuerySweepResult_get_t_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuerySweepResult_get_t_0');
var _emscripten_bind_PxGjkQuerySweepResult_set_t_1 = Module['_emscripten_bind_PxGjkQuerySweepResult_set_t_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuerySweepResult_set_t_1');
var _emscripten_bind_PxGjkQuerySweepResult_get_n_0 = Module['_emscripten_bind_PxGjkQuerySweepResult_get_n_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuerySweepResult_get_n_0');
var _emscripten_bind_PxGjkQuerySweepResult_set_n_1 = Module['_emscripten_bind_PxGjkQuerySweepResult_set_n_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuerySweepResult_set_n_1');
var _emscripten_bind_PxGjkQuerySweepResult_get_p_0 = Module['_emscripten_bind_PxGjkQuerySweepResult_get_p_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuerySweepResult_get_p_0');
var _emscripten_bind_PxGjkQuerySweepResult_set_p_1 = Module['_emscripten_bind_PxGjkQuerySweepResult_set_p_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuerySweepResult_set_p_1');
var _emscripten_bind_PxGjkQuerySweepResult___destroy___0 = Module['_emscripten_bind_PxGjkQuerySweepResult___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxGjkQuerySweepResult___destroy___0');
var _emscripten_bind_PxHeightField_saveCells_2 = Module['_emscripten_bind_PxHeightField_saveCells_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_saveCells_2');
var _emscripten_bind_PxHeightField_modifySamples_3 = Module['_emscripten_bind_PxHeightField_modifySamples_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_modifySamples_3');
var _emscripten_bind_PxHeightField_modifySamples_4 = Module['_emscripten_bind_PxHeightField_modifySamples_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_modifySamples_4');
var _emscripten_bind_PxHeightField_getNbRows_0 = Module['_emscripten_bind_PxHeightField_getNbRows_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getNbRows_0');
var _emscripten_bind_PxHeightField_getNbColumns_0 = Module['_emscripten_bind_PxHeightField_getNbColumns_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getNbColumns_0');
var _emscripten_bind_PxHeightField_getFormat_0 = Module['_emscripten_bind_PxHeightField_getFormat_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getFormat_0');
var _emscripten_bind_PxHeightField_getSampleStride_0 = Module['_emscripten_bind_PxHeightField_getSampleStride_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getSampleStride_0');
var _emscripten_bind_PxHeightField_getConvexEdgeThreshold_0 = Module['_emscripten_bind_PxHeightField_getConvexEdgeThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getConvexEdgeThreshold_0');
var _emscripten_bind_PxHeightField_getFlags_0 = Module['_emscripten_bind_PxHeightField_getFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getFlags_0');
var _emscripten_bind_PxHeightField_getHeight_2 = Module['_emscripten_bind_PxHeightField_getHeight_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getHeight_2');
var _emscripten_bind_PxHeightField_getTriangleMaterialIndex_1 = Module['_emscripten_bind_PxHeightField_getTriangleMaterialIndex_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getTriangleMaterialIndex_1');
var _emscripten_bind_PxHeightField_getTriangleNormal_1 = Module['_emscripten_bind_PxHeightField_getTriangleNormal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getTriangleNormal_1');
var _emscripten_bind_PxHeightField_getSample_2 = Module['_emscripten_bind_PxHeightField_getSample_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getSample_2');
var _emscripten_bind_PxHeightField_getTimestamp_0 = Module['_emscripten_bind_PxHeightField_getTimestamp_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getTimestamp_0');
var _emscripten_bind_PxHeightField_release_0 = Module['_emscripten_bind_PxHeightField_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_release_0');
var _emscripten_bind_PxHeightField_getConcreteTypeName_0 = Module['_emscripten_bind_PxHeightField_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getConcreteTypeName_0');
var _emscripten_bind_PxHeightField_getConcreteType_0 = Module['_emscripten_bind_PxHeightField_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getConcreteType_0');
var _emscripten_bind_PxHeightField_setBaseFlag_2 = Module['_emscripten_bind_PxHeightField_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_setBaseFlag_2');
var _emscripten_bind_PxHeightField_setBaseFlags_1 = Module['_emscripten_bind_PxHeightField_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_setBaseFlags_1');
var _emscripten_bind_PxHeightField_getBaseFlags_0 = Module['_emscripten_bind_PxHeightField_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getBaseFlags_0');
var _emscripten_bind_PxHeightField_isReleasable_0 = Module['_emscripten_bind_PxHeightField_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_isReleasable_0');
var _emscripten_bind_PxHeightField_getReferenceCount_0 = Module['_emscripten_bind_PxHeightField_getReferenceCount_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_getReferenceCount_0');
var _emscripten_bind_PxHeightField_acquireReference_0 = Module['_emscripten_bind_PxHeightField_acquireReference_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightField_acquireReference_0');
var _emscripten_bind_PxHeightFieldDesc_PxHeightFieldDesc_0 = Module['_emscripten_bind_PxHeightFieldDesc_PxHeightFieldDesc_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_PxHeightFieldDesc_0');
var _emscripten_bind_PxHeightFieldDesc_setToDefault_0 = Module['_emscripten_bind_PxHeightFieldDesc_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_setToDefault_0');
var _emscripten_bind_PxHeightFieldDesc_isValid_0 = Module['_emscripten_bind_PxHeightFieldDesc_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_isValid_0');
var _emscripten_bind_PxHeightFieldDesc_get_nbRows_0 = Module['_emscripten_bind_PxHeightFieldDesc_get_nbRows_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_get_nbRows_0');
var _emscripten_bind_PxHeightFieldDesc_set_nbRows_1 = Module['_emscripten_bind_PxHeightFieldDesc_set_nbRows_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_set_nbRows_1');
var _emscripten_bind_PxHeightFieldDesc_get_nbColumns_0 = Module['_emscripten_bind_PxHeightFieldDesc_get_nbColumns_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_get_nbColumns_0');
var _emscripten_bind_PxHeightFieldDesc_set_nbColumns_1 = Module['_emscripten_bind_PxHeightFieldDesc_set_nbColumns_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_set_nbColumns_1');
var _emscripten_bind_PxHeightFieldDesc_get_format_0 = Module['_emscripten_bind_PxHeightFieldDesc_get_format_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_get_format_0');
var _emscripten_bind_PxHeightFieldDesc_set_format_1 = Module['_emscripten_bind_PxHeightFieldDesc_set_format_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_set_format_1');
var _emscripten_bind_PxHeightFieldDesc_get_samples_0 = Module['_emscripten_bind_PxHeightFieldDesc_get_samples_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_get_samples_0');
var _emscripten_bind_PxHeightFieldDesc_set_samples_1 = Module['_emscripten_bind_PxHeightFieldDesc_set_samples_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_set_samples_1');
var _emscripten_bind_PxHeightFieldDesc_get_convexEdgeThreshold_0 = Module['_emscripten_bind_PxHeightFieldDesc_get_convexEdgeThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_get_convexEdgeThreshold_0');
var _emscripten_bind_PxHeightFieldDesc_set_convexEdgeThreshold_1 = Module['_emscripten_bind_PxHeightFieldDesc_set_convexEdgeThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_set_convexEdgeThreshold_1');
var _emscripten_bind_PxHeightFieldDesc_get_flags_0 = Module['_emscripten_bind_PxHeightFieldDesc_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_get_flags_0');
var _emscripten_bind_PxHeightFieldDesc_set_flags_1 = Module['_emscripten_bind_PxHeightFieldDesc_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc_set_flags_1');
var _emscripten_bind_PxHeightFieldDesc___destroy___0 = Module['_emscripten_bind_PxHeightFieldDesc___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldDesc___destroy___0');
var _emscripten_bind_PxHeightFieldFlags_PxHeightFieldFlags_1 = Module['_emscripten_bind_PxHeightFieldFlags_PxHeightFieldFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldFlags_PxHeightFieldFlags_1');
var _emscripten_bind_PxHeightFieldFlags_isSet_1 = Module['_emscripten_bind_PxHeightFieldFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldFlags_isSet_1');
var _emscripten_bind_PxHeightFieldFlags_raise_1 = Module['_emscripten_bind_PxHeightFieldFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldFlags_raise_1');
var _emscripten_bind_PxHeightFieldFlags_clear_1 = Module['_emscripten_bind_PxHeightFieldFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldFlags_clear_1');
var _emscripten_bind_PxHeightFieldFlags___destroy___0 = Module['_emscripten_bind_PxHeightFieldFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldFlags___destroy___0');
var _emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_0 = Module['_emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_0');
var _emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_5 = Module['_emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_5');
var _emscripten_bind_PxHeightFieldGeometry_isValid_0 = Module['_emscripten_bind_PxHeightFieldGeometry_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry_isValid_0');
var _emscripten_bind_PxHeightFieldGeometry_getType_0 = Module['_emscripten_bind_PxHeightFieldGeometry_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry_getType_0');
var _emscripten_bind_PxHeightFieldGeometry_get_heightField_0 = Module['_emscripten_bind_PxHeightFieldGeometry_get_heightField_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry_get_heightField_0');
var _emscripten_bind_PxHeightFieldGeometry_set_heightField_1 = Module['_emscripten_bind_PxHeightFieldGeometry_set_heightField_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry_set_heightField_1');
var _emscripten_bind_PxHeightFieldGeometry_get_heightScale_0 = Module['_emscripten_bind_PxHeightFieldGeometry_get_heightScale_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry_get_heightScale_0');
var _emscripten_bind_PxHeightFieldGeometry_set_heightScale_1 = Module['_emscripten_bind_PxHeightFieldGeometry_set_heightScale_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry_set_heightScale_1');
var _emscripten_bind_PxHeightFieldGeometry_get_rowScale_0 = Module['_emscripten_bind_PxHeightFieldGeometry_get_rowScale_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry_get_rowScale_0');
var _emscripten_bind_PxHeightFieldGeometry_set_rowScale_1 = Module['_emscripten_bind_PxHeightFieldGeometry_set_rowScale_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry_set_rowScale_1');
var _emscripten_bind_PxHeightFieldGeometry_get_columnScale_0 = Module['_emscripten_bind_PxHeightFieldGeometry_get_columnScale_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry_get_columnScale_0');
var _emscripten_bind_PxHeightFieldGeometry_set_columnScale_1 = Module['_emscripten_bind_PxHeightFieldGeometry_set_columnScale_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry_set_columnScale_1');
var _emscripten_bind_PxHeightFieldGeometry_get_heightFieldFlags_0 = Module['_emscripten_bind_PxHeightFieldGeometry_get_heightFieldFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry_get_heightFieldFlags_0');
var _emscripten_bind_PxHeightFieldGeometry_set_heightFieldFlags_1 = Module['_emscripten_bind_PxHeightFieldGeometry_set_heightFieldFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry_set_heightFieldFlags_1');
var _emscripten_bind_PxHeightFieldGeometry___destroy___0 = Module['_emscripten_bind_PxHeightFieldGeometry___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldGeometry___destroy___0');
var _emscripten_bind_PxHeightFieldSample_PxHeightFieldSample_0 = Module['_emscripten_bind_PxHeightFieldSample_PxHeightFieldSample_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldSample_PxHeightFieldSample_0');
var _emscripten_bind_PxHeightFieldSample_tessFlag_0 = Module['_emscripten_bind_PxHeightFieldSample_tessFlag_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldSample_tessFlag_0');
var _emscripten_bind_PxHeightFieldSample_clearTessFlag_0 = Module['_emscripten_bind_PxHeightFieldSample_clearTessFlag_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldSample_clearTessFlag_0');
var _emscripten_bind_PxHeightFieldSample_setTessFlag_0 = Module['_emscripten_bind_PxHeightFieldSample_setTessFlag_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldSample_setTessFlag_0');
var _emscripten_bind_PxHeightFieldSample_get_height_0 = Module['_emscripten_bind_PxHeightFieldSample_get_height_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldSample_get_height_0');
var _emscripten_bind_PxHeightFieldSample_set_height_1 = Module['_emscripten_bind_PxHeightFieldSample_set_height_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldSample_set_height_1');
var _emscripten_bind_PxHeightFieldSample_get_materialIndex0_0 = Module['_emscripten_bind_PxHeightFieldSample_get_materialIndex0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldSample_get_materialIndex0_0');
var _emscripten_bind_PxHeightFieldSample_set_materialIndex0_1 = Module['_emscripten_bind_PxHeightFieldSample_set_materialIndex0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldSample_set_materialIndex0_1');
var _emscripten_bind_PxHeightFieldSample_get_materialIndex1_0 = Module['_emscripten_bind_PxHeightFieldSample_get_materialIndex1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldSample_get_materialIndex1_0');
var _emscripten_bind_PxHeightFieldSample_set_materialIndex1_1 = Module['_emscripten_bind_PxHeightFieldSample_set_materialIndex1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldSample_set_materialIndex1_1');
var _emscripten_bind_PxHeightFieldSample___destroy___0 = Module['_emscripten_bind_PxHeightFieldSample___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHeightFieldSample___destroy___0');
var _emscripten_bind_PxHitFlags_PxHitFlags_1 = Module['_emscripten_bind_PxHitFlags_PxHitFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHitFlags_PxHitFlags_1');
var _emscripten_bind_PxHitFlags_isSet_1 = Module['_emscripten_bind_PxHitFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHitFlags_isSet_1');
var _emscripten_bind_PxHitFlags_raise_1 = Module['_emscripten_bind_PxHitFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHitFlags_raise_1');
var _emscripten_bind_PxHitFlags_clear_1 = Module['_emscripten_bind_PxHitFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHitFlags_clear_1');
var _emscripten_bind_PxHitFlags___destroy___0 = Module['_emscripten_bind_PxHitFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHitFlags___destroy___0');
var _emscripten_bind_PxHullPolygon_PxHullPolygon_0 = Module['_emscripten_bind_PxHullPolygon_PxHullPolygon_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHullPolygon_PxHullPolygon_0');
var _emscripten_bind_PxHullPolygon_get_mPlane_1 = Module['_emscripten_bind_PxHullPolygon_get_mPlane_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHullPolygon_get_mPlane_1');
var _emscripten_bind_PxHullPolygon_set_mPlane_2 = Module['_emscripten_bind_PxHullPolygon_set_mPlane_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxHullPolygon_set_mPlane_2');
var _emscripten_bind_PxHullPolygon_get_mNbVerts_0 = Module['_emscripten_bind_PxHullPolygon_get_mNbVerts_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHullPolygon_get_mNbVerts_0');
var _emscripten_bind_PxHullPolygon_set_mNbVerts_1 = Module['_emscripten_bind_PxHullPolygon_set_mNbVerts_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHullPolygon_set_mNbVerts_1');
var _emscripten_bind_PxHullPolygon_get_mIndexBase_0 = Module['_emscripten_bind_PxHullPolygon_get_mIndexBase_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHullPolygon_get_mIndexBase_0');
var _emscripten_bind_PxHullPolygon_set_mIndexBase_1 = Module['_emscripten_bind_PxHullPolygon_set_mIndexBase_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxHullPolygon_set_mIndexBase_1');
var _emscripten_bind_PxHullPolygon___destroy___0 = Module['_emscripten_bind_PxHullPolygon___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxHullPolygon___destroy___0');
var _emscripten_bind_PxI32Ptr___destroy___0 = Module['_emscripten_bind_PxI32Ptr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxI32Ptr___destroy___0');
var _emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_2 = Module['_emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_2');
var _emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_3 = Module['_emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_3');
var _emscripten_bind_PxJointAngularLimitPair_isValid_0 = Module['_emscripten_bind_PxJointAngularLimitPair_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_isValid_0');
var _emscripten_bind_PxJointAngularLimitPair_isSoft_0 = Module['_emscripten_bind_PxJointAngularLimitPair_isSoft_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_isSoft_0');
var _emscripten_bind_PxJointAngularLimitPair_get_upper_0 = Module['_emscripten_bind_PxJointAngularLimitPair_get_upper_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_get_upper_0');
var _emscripten_bind_PxJointAngularLimitPair_set_upper_1 = Module['_emscripten_bind_PxJointAngularLimitPair_set_upper_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_set_upper_1');
var _emscripten_bind_PxJointAngularLimitPair_get_lower_0 = Module['_emscripten_bind_PxJointAngularLimitPair_get_lower_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_get_lower_0');
var _emscripten_bind_PxJointAngularLimitPair_set_lower_1 = Module['_emscripten_bind_PxJointAngularLimitPair_set_lower_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_set_lower_1');
var _emscripten_bind_PxJointAngularLimitPair_get_restitution_0 = Module['_emscripten_bind_PxJointAngularLimitPair_get_restitution_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_get_restitution_0');
var _emscripten_bind_PxJointAngularLimitPair_set_restitution_1 = Module['_emscripten_bind_PxJointAngularLimitPair_set_restitution_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_set_restitution_1');
var _emscripten_bind_PxJointAngularLimitPair_get_bounceThreshold_0 = Module['_emscripten_bind_PxJointAngularLimitPair_get_bounceThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_get_bounceThreshold_0');
var _emscripten_bind_PxJointAngularLimitPair_set_bounceThreshold_1 = Module['_emscripten_bind_PxJointAngularLimitPair_set_bounceThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_set_bounceThreshold_1');
var _emscripten_bind_PxJointAngularLimitPair_get_stiffness_0 = Module['_emscripten_bind_PxJointAngularLimitPair_get_stiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_get_stiffness_0');
var _emscripten_bind_PxJointAngularLimitPair_set_stiffness_1 = Module['_emscripten_bind_PxJointAngularLimitPair_set_stiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_set_stiffness_1');
var _emscripten_bind_PxJointAngularLimitPair_get_damping_0 = Module['_emscripten_bind_PxJointAngularLimitPair_get_damping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_get_damping_0');
var _emscripten_bind_PxJointAngularLimitPair_set_damping_1 = Module['_emscripten_bind_PxJointAngularLimitPair_set_damping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair_set_damping_1');
var _emscripten_bind_PxJointAngularLimitPair___destroy___0 = Module['_emscripten_bind_PxJointAngularLimitPair___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointAngularLimitPair___destroy___0');
var _emscripten_bind_PxJointLimitCone_PxJointLimitCone_2 = Module['_emscripten_bind_PxJointLimitCone_PxJointLimitCone_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_PxJointLimitCone_2');
var _emscripten_bind_PxJointLimitCone_PxJointLimitCone_3 = Module['_emscripten_bind_PxJointLimitCone_PxJointLimitCone_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_PxJointLimitCone_3');
var _emscripten_bind_PxJointLimitCone_isValid_0 = Module['_emscripten_bind_PxJointLimitCone_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_isValid_0');
var _emscripten_bind_PxJointLimitCone_isSoft_0 = Module['_emscripten_bind_PxJointLimitCone_isSoft_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_isSoft_0');
var _emscripten_bind_PxJointLimitCone_get_yAngle_0 = Module['_emscripten_bind_PxJointLimitCone_get_yAngle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_get_yAngle_0');
var _emscripten_bind_PxJointLimitCone_set_yAngle_1 = Module['_emscripten_bind_PxJointLimitCone_set_yAngle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_set_yAngle_1');
var _emscripten_bind_PxJointLimitCone_get_zAngle_0 = Module['_emscripten_bind_PxJointLimitCone_get_zAngle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_get_zAngle_0');
var _emscripten_bind_PxJointLimitCone_set_zAngle_1 = Module['_emscripten_bind_PxJointLimitCone_set_zAngle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_set_zAngle_1');
var _emscripten_bind_PxJointLimitCone_get_restitution_0 = Module['_emscripten_bind_PxJointLimitCone_get_restitution_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_get_restitution_0');
var _emscripten_bind_PxJointLimitCone_set_restitution_1 = Module['_emscripten_bind_PxJointLimitCone_set_restitution_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_set_restitution_1');
var _emscripten_bind_PxJointLimitCone_get_bounceThreshold_0 = Module['_emscripten_bind_PxJointLimitCone_get_bounceThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_get_bounceThreshold_0');
var _emscripten_bind_PxJointLimitCone_set_bounceThreshold_1 = Module['_emscripten_bind_PxJointLimitCone_set_bounceThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_set_bounceThreshold_1');
var _emscripten_bind_PxJointLimitCone_get_stiffness_0 = Module['_emscripten_bind_PxJointLimitCone_get_stiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_get_stiffness_0');
var _emscripten_bind_PxJointLimitCone_set_stiffness_1 = Module['_emscripten_bind_PxJointLimitCone_set_stiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_set_stiffness_1');
var _emscripten_bind_PxJointLimitCone_get_damping_0 = Module['_emscripten_bind_PxJointLimitCone_get_damping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_get_damping_0');
var _emscripten_bind_PxJointLimitCone_set_damping_1 = Module['_emscripten_bind_PxJointLimitCone_set_damping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone_set_damping_1');
var _emscripten_bind_PxJointLimitCone___destroy___0 = Module['_emscripten_bind_PxJointLimitCone___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitCone___destroy___0');
var _emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_4 = Module['_emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_4');
var _emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_5 = Module['_emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_5');
var _emscripten_bind_PxJointLimitPyramid_isValid_0 = Module['_emscripten_bind_PxJointLimitPyramid_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_isValid_0');
var _emscripten_bind_PxJointLimitPyramid_isSoft_0 = Module['_emscripten_bind_PxJointLimitPyramid_isSoft_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_isSoft_0');
var _emscripten_bind_PxJointLimitPyramid_get_yAngleMin_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_yAngleMin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_get_yAngleMin_0');
var _emscripten_bind_PxJointLimitPyramid_set_yAngleMin_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_yAngleMin_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_set_yAngleMin_1');
var _emscripten_bind_PxJointLimitPyramid_get_yAngleMax_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_yAngleMax_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_get_yAngleMax_0');
var _emscripten_bind_PxJointLimitPyramid_set_yAngleMax_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_yAngleMax_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_set_yAngleMax_1');
var _emscripten_bind_PxJointLimitPyramid_get_zAngleMin_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_zAngleMin_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_get_zAngleMin_0');
var _emscripten_bind_PxJointLimitPyramid_set_zAngleMin_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_zAngleMin_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_set_zAngleMin_1');
var _emscripten_bind_PxJointLimitPyramid_get_zAngleMax_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_zAngleMax_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_get_zAngleMax_0');
var _emscripten_bind_PxJointLimitPyramid_set_zAngleMax_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_zAngleMax_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_set_zAngleMax_1');
var _emscripten_bind_PxJointLimitPyramid_get_restitution_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_restitution_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_get_restitution_0');
var _emscripten_bind_PxJointLimitPyramid_set_restitution_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_restitution_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_set_restitution_1');
var _emscripten_bind_PxJointLimitPyramid_get_bounceThreshold_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_bounceThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_get_bounceThreshold_0');
var _emscripten_bind_PxJointLimitPyramid_set_bounceThreshold_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_bounceThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_set_bounceThreshold_1');
var _emscripten_bind_PxJointLimitPyramid_get_stiffness_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_stiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_get_stiffness_0');
var _emscripten_bind_PxJointLimitPyramid_set_stiffness_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_stiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_set_stiffness_1');
var _emscripten_bind_PxJointLimitPyramid_get_damping_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_damping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_get_damping_0');
var _emscripten_bind_PxJointLimitPyramid_set_damping_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_damping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid_set_damping_1');
var _emscripten_bind_PxJointLimitPyramid___destroy___0 = Module['_emscripten_bind_PxJointLimitPyramid___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLimitPyramid___destroy___0');
var _emscripten_bind_PxJointLinearLimit_PxJointLinearLimit_2 = Module['_emscripten_bind_PxJointLinearLimit_PxJointLinearLimit_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimit_PxJointLinearLimit_2');
var _emscripten_bind_PxJointLinearLimit_isValid_0 = Module['_emscripten_bind_PxJointLinearLimit_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimit_isValid_0');
var _emscripten_bind_PxJointLinearLimit_isSoft_0 = Module['_emscripten_bind_PxJointLinearLimit_isSoft_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimit_isSoft_0');
var _emscripten_bind_PxJointLinearLimit_get_value_0 = Module['_emscripten_bind_PxJointLinearLimit_get_value_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimit_get_value_0');
var _emscripten_bind_PxJointLinearLimit_set_value_1 = Module['_emscripten_bind_PxJointLinearLimit_set_value_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimit_set_value_1');
var _emscripten_bind_PxJointLinearLimit_get_restitution_0 = Module['_emscripten_bind_PxJointLinearLimit_get_restitution_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimit_get_restitution_0');
var _emscripten_bind_PxJointLinearLimit_set_restitution_1 = Module['_emscripten_bind_PxJointLinearLimit_set_restitution_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimit_set_restitution_1');
var _emscripten_bind_PxJointLinearLimit_get_bounceThreshold_0 = Module['_emscripten_bind_PxJointLinearLimit_get_bounceThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimit_get_bounceThreshold_0');
var _emscripten_bind_PxJointLinearLimit_set_bounceThreshold_1 = Module['_emscripten_bind_PxJointLinearLimit_set_bounceThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimit_set_bounceThreshold_1');
var _emscripten_bind_PxJointLinearLimit_get_stiffness_0 = Module['_emscripten_bind_PxJointLinearLimit_get_stiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimit_get_stiffness_0');
var _emscripten_bind_PxJointLinearLimit_set_stiffness_1 = Module['_emscripten_bind_PxJointLinearLimit_set_stiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimit_set_stiffness_1');
var _emscripten_bind_PxJointLinearLimit_get_damping_0 = Module['_emscripten_bind_PxJointLinearLimit_get_damping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimit_get_damping_0');
var _emscripten_bind_PxJointLinearLimit_set_damping_1 = Module['_emscripten_bind_PxJointLinearLimit_set_damping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimit_set_damping_1');
var _emscripten_bind_PxJointLinearLimit___destroy___0 = Module['_emscripten_bind_PxJointLinearLimit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimit___destroy___0');
var _emscripten_bind_PxJointLinearLimitPair_PxJointLinearLimitPair_3 = Module['_emscripten_bind_PxJointLinearLimitPair_PxJointLinearLimitPair_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_PxJointLinearLimitPair_3');
var _emscripten_bind_PxJointLinearLimitPair_isValid_0 = Module['_emscripten_bind_PxJointLinearLimitPair_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_isValid_0');
var _emscripten_bind_PxJointLinearLimitPair_isSoft_0 = Module['_emscripten_bind_PxJointLinearLimitPair_isSoft_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_isSoft_0');
var _emscripten_bind_PxJointLinearLimitPair_get_upper_0 = Module['_emscripten_bind_PxJointLinearLimitPair_get_upper_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_get_upper_0');
var _emscripten_bind_PxJointLinearLimitPair_set_upper_1 = Module['_emscripten_bind_PxJointLinearLimitPair_set_upper_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_set_upper_1');
var _emscripten_bind_PxJointLinearLimitPair_get_lower_0 = Module['_emscripten_bind_PxJointLinearLimitPair_get_lower_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_get_lower_0');
var _emscripten_bind_PxJointLinearLimitPair_set_lower_1 = Module['_emscripten_bind_PxJointLinearLimitPair_set_lower_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_set_lower_1');
var _emscripten_bind_PxJointLinearLimitPair_get_restitution_0 = Module['_emscripten_bind_PxJointLinearLimitPair_get_restitution_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_get_restitution_0');
var _emscripten_bind_PxJointLinearLimitPair_set_restitution_1 = Module['_emscripten_bind_PxJointLinearLimitPair_set_restitution_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_set_restitution_1');
var _emscripten_bind_PxJointLinearLimitPair_get_bounceThreshold_0 = Module['_emscripten_bind_PxJointLinearLimitPair_get_bounceThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_get_bounceThreshold_0');
var _emscripten_bind_PxJointLinearLimitPair_set_bounceThreshold_1 = Module['_emscripten_bind_PxJointLinearLimitPair_set_bounceThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_set_bounceThreshold_1');
var _emscripten_bind_PxJointLinearLimitPair_get_stiffness_0 = Module['_emscripten_bind_PxJointLinearLimitPair_get_stiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_get_stiffness_0');
var _emscripten_bind_PxJointLinearLimitPair_set_stiffness_1 = Module['_emscripten_bind_PxJointLinearLimitPair_set_stiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_set_stiffness_1');
var _emscripten_bind_PxJointLinearLimitPair_get_damping_0 = Module['_emscripten_bind_PxJointLinearLimitPair_get_damping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_get_damping_0');
var _emscripten_bind_PxJointLinearLimitPair_set_damping_1 = Module['_emscripten_bind_PxJointLinearLimitPair_set_damping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair_set_damping_1');
var _emscripten_bind_PxJointLinearLimitPair___destroy___0 = Module['_emscripten_bind_PxJointLinearLimitPair___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxJointLinearLimitPair___destroy___0');
var _emscripten_bind_PxMassProperties_PxMassProperties_0 = Module['_emscripten_bind_PxMassProperties_PxMassProperties_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_PxMassProperties_0');
var _emscripten_bind_PxMassProperties_PxMassProperties_1 = Module['_emscripten_bind_PxMassProperties_PxMassProperties_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_PxMassProperties_1');
var _emscripten_bind_PxMassProperties_PxMassProperties_3 = Module['_emscripten_bind_PxMassProperties_PxMassProperties_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_PxMassProperties_3');
var _emscripten_bind_PxMassProperties_translate_1 = Module['_emscripten_bind_PxMassProperties_translate_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_translate_1');
var _emscripten_bind_PxMassProperties_getMassSpaceInertia_2 = Module['_emscripten_bind_PxMassProperties_getMassSpaceInertia_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_getMassSpaceInertia_2');
var _emscripten_bind_PxMassProperties_translateInertia_3 = Module['_emscripten_bind_PxMassProperties_translateInertia_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_translateInertia_3');
var _emscripten_bind_PxMassProperties_rotateInertia_2 = Module['_emscripten_bind_PxMassProperties_rotateInertia_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_rotateInertia_2');
var _emscripten_bind_PxMassProperties_scaleInertia_3 = Module['_emscripten_bind_PxMassProperties_scaleInertia_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_scaleInertia_3');
var _emscripten_bind_PxMassProperties_sum_3 = Module['_emscripten_bind_PxMassProperties_sum_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_sum_3');
var _emscripten_bind_PxMassProperties_get_inertiaTensor_0 = Module['_emscripten_bind_PxMassProperties_get_inertiaTensor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_get_inertiaTensor_0');
var _emscripten_bind_PxMassProperties_set_inertiaTensor_1 = Module['_emscripten_bind_PxMassProperties_set_inertiaTensor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_set_inertiaTensor_1');
var _emscripten_bind_PxMassProperties_get_centerOfMass_0 = Module['_emscripten_bind_PxMassProperties_get_centerOfMass_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_get_centerOfMass_0');
var _emscripten_bind_PxMassProperties_set_centerOfMass_1 = Module['_emscripten_bind_PxMassProperties_set_centerOfMass_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_set_centerOfMass_1');
var _emscripten_bind_PxMassProperties_get_mass_0 = Module['_emscripten_bind_PxMassProperties_get_mass_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_get_mass_0');
var _emscripten_bind_PxMassProperties_set_mass_1 = Module['_emscripten_bind_PxMassProperties_set_mass_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties_set_mass_1');
var _emscripten_bind_PxMassProperties___destroy___0 = Module['_emscripten_bind_PxMassProperties___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMassProperties___destroy___0');
var _emscripten_bind_PxMat33_PxMat33_0 = Module['_emscripten_bind_PxMat33_PxMat33_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33_PxMat33_0');
var _emscripten_bind_PxMat33_PxMat33_1 = Module['_emscripten_bind_PxMat33_PxMat33_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33_PxMat33_1');
var _emscripten_bind_PxMat33_PxMat33_3 = Module['_emscripten_bind_PxMat33_PxMat33_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33_PxMat33_3');
var _emscripten_bind_PxMat33_getTranspose_0 = Module['_emscripten_bind_PxMat33_getTranspose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33_getTranspose_0');
var _emscripten_bind_PxMat33_getInverse_0 = Module['_emscripten_bind_PxMat33_getInverse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33_getInverse_0');
var _emscripten_bind_PxMat33_getDeterminant_0 = Module['_emscripten_bind_PxMat33_getDeterminant_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33_getDeterminant_0');
var _emscripten_bind_PxMat33_transform_1 = Module['_emscripten_bind_PxMat33_transform_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33_transform_1');
var _emscripten_bind_PxMat33_transformTranspose_1 = Module['_emscripten_bind_PxMat33_transformTranspose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33_transformTranspose_1');
var _emscripten_bind_PxMat33_get_column0_0 = Module['_emscripten_bind_PxMat33_get_column0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33_get_column0_0');
var _emscripten_bind_PxMat33_set_column0_1 = Module['_emscripten_bind_PxMat33_set_column0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33_set_column0_1');
var _emscripten_bind_PxMat33_get_column1_0 = Module['_emscripten_bind_PxMat33_get_column1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33_get_column1_0');
var _emscripten_bind_PxMat33_set_column1_1 = Module['_emscripten_bind_PxMat33_set_column1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33_set_column1_1');
var _emscripten_bind_PxMat33_get_column2_0 = Module['_emscripten_bind_PxMat33_get_column2_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33_get_column2_0');
var _emscripten_bind_PxMat33_set_column2_1 = Module['_emscripten_bind_PxMat33_set_column2_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33_set_column2_1');
var _emscripten_bind_PxMat33___destroy___0 = Module['_emscripten_bind_PxMat33___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMat33___destroy___0');
var _emscripten_bind_PxMaterial_setDynamicFriction_1 = Module['_emscripten_bind_PxMaterial_setDynamicFriction_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_setDynamicFriction_1');
var _emscripten_bind_PxMaterial_getDynamicFriction_0 = Module['_emscripten_bind_PxMaterial_getDynamicFriction_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_getDynamicFriction_0');
var _emscripten_bind_PxMaterial_setStaticFriction_1 = Module['_emscripten_bind_PxMaterial_setStaticFriction_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_setStaticFriction_1');
var _emscripten_bind_PxMaterial_getStaticFriction_0 = Module['_emscripten_bind_PxMaterial_getStaticFriction_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_getStaticFriction_0');
var _emscripten_bind_PxMaterial_setRestitution_1 = Module['_emscripten_bind_PxMaterial_setRestitution_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_setRestitution_1');
var _emscripten_bind_PxMaterial_getRestitution_0 = Module['_emscripten_bind_PxMaterial_getRestitution_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_getRestitution_0');
var _emscripten_bind_PxMaterial_setFlag_2 = Module['_emscripten_bind_PxMaterial_setFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_setFlag_2');
var _emscripten_bind_PxMaterial_setFlags_1 = Module['_emscripten_bind_PxMaterial_setFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_setFlags_1');
var _emscripten_bind_PxMaterial_getFlags_0 = Module['_emscripten_bind_PxMaterial_getFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_getFlags_0');
var _emscripten_bind_PxMaterial_setFrictionCombineMode_1 = Module['_emscripten_bind_PxMaterial_setFrictionCombineMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_setFrictionCombineMode_1');
var _emscripten_bind_PxMaterial_getFrictionCombineMode_0 = Module['_emscripten_bind_PxMaterial_getFrictionCombineMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_getFrictionCombineMode_0');
var _emscripten_bind_PxMaterial_setRestitutionCombineMode_1 = Module['_emscripten_bind_PxMaterial_setRestitutionCombineMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_setRestitutionCombineMode_1');
var _emscripten_bind_PxMaterial_getRestitutionCombineMode_0 = Module['_emscripten_bind_PxMaterial_getRestitutionCombineMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_getRestitutionCombineMode_0');
var _emscripten_bind_PxMaterial_release_0 = Module['_emscripten_bind_PxMaterial_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_release_0');
var _emscripten_bind_PxMaterial_getConcreteTypeName_0 = Module['_emscripten_bind_PxMaterial_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_getConcreteTypeName_0');
var _emscripten_bind_PxMaterial_getConcreteType_0 = Module['_emscripten_bind_PxMaterial_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_getConcreteType_0');
var _emscripten_bind_PxMaterial_setBaseFlag_2 = Module['_emscripten_bind_PxMaterial_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_setBaseFlag_2');
var _emscripten_bind_PxMaterial_setBaseFlags_1 = Module['_emscripten_bind_PxMaterial_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_setBaseFlags_1');
var _emscripten_bind_PxMaterial_getBaseFlags_0 = Module['_emscripten_bind_PxMaterial_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_getBaseFlags_0');
var _emscripten_bind_PxMaterial_isReleasable_0 = Module['_emscripten_bind_PxMaterial_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_isReleasable_0');
var _emscripten_bind_PxMaterial_getReferenceCount_0 = Module['_emscripten_bind_PxMaterial_getReferenceCount_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_getReferenceCount_0');
var _emscripten_bind_PxMaterial_acquireReference_0 = Module['_emscripten_bind_PxMaterial_acquireReference_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_acquireReference_0');
var _emscripten_bind_PxMaterial_get_userData_0 = Module['_emscripten_bind_PxMaterial_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_get_userData_0');
var _emscripten_bind_PxMaterial_set_userData_1 = Module['_emscripten_bind_PxMaterial_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterial_set_userData_1');
var _emscripten_bind_PxMaterialConstPtr___destroy___0 = Module['_emscripten_bind_PxMaterialConstPtr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterialConstPtr___destroy___0');
var _emscripten_bind_PxMaterialFlags_PxMaterialFlags_1 = Module['_emscripten_bind_PxMaterialFlags_PxMaterialFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterialFlags_PxMaterialFlags_1');
var _emscripten_bind_PxMaterialFlags_isSet_1 = Module['_emscripten_bind_PxMaterialFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterialFlags_isSet_1');
var _emscripten_bind_PxMaterialFlags_raise_1 = Module['_emscripten_bind_PxMaterialFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterialFlags_raise_1');
var _emscripten_bind_PxMaterialFlags_clear_1 = Module['_emscripten_bind_PxMaterialFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterialFlags_clear_1');
var _emscripten_bind_PxMaterialFlags___destroy___0 = Module['_emscripten_bind_PxMaterialFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterialFlags___destroy___0');
var _emscripten_bind_PxMaterialPtr___destroy___0 = Module['_emscripten_bind_PxMaterialPtr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMaterialPtr___destroy___0');
var _emscripten_bind_PxMeshFlags_PxMeshFlags_1 = Module['_emscripten_bind_PxMeshFlags_PxMeshFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshFlags_PxMeshFlags_1');
var _emscripten_bind_PxMeshFlags_isSet_1 = Module['_emscripten_bind_PxMeshFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshFlags_isSet_1');
var _emscripten_bind_PxMeshFlags_raise_1 = Module['_emscripten_bind_PxMeshFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshFlags_raise_1');
var _emscripten_bind_PxMeshFlags_clear_1 = Module['_emscripten_bind_PxMeshFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshFlags_clear_1');
var _emscripten_bind_PxMeshFlags___destroy___0 = Module['_emscripten_bind_PxMeshFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshFlags___destroy___0');
var _emscripten_bind_PxMeshGeometryFlags_PxMeshGeometryFlags_1 = Module['_emscripten_bind_PxMeshGeometryFlags_PxMeshGeometryFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshGeometryFlags_PxMeshGeometryFlags_1');
var _emscripten_bind_PxMeshGeometryFlags_isSet_1 = Module['_emscripten_bind_PxMeshGeometryFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshGeometryFlags_isSet_1');
var _emscripten_bind_PxMeshGeometryFlags_raise_1 = Module['_emscripten_bind_PxMeshGeometryFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshGeometryFlags_raise_1');
var _emscripten_bind_PxMeshGeometryFlags_clear_1 = Module['_emscripten_bind_PxMeshGeometryFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshGeometryFlags_clear_1');
var _emscripten_bind_PxMeshGeometryFlags___destroy___0 = Module['_emscripten_bind_PxMeshGeometryFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshGeometryFlags___destroy___0');
var _emscripten_bind_PxMeshOverlapUtil_PxMeshOverlapUtil_0 = Module['_emscripten_bind_PxMeshOverlapUtil_PxMeshOverlapUtil_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshOverlapUtil_PxMeshOverlapUtil_0');
var _emscripten_bind_PxMeshOverlapUtil_findOverlap_4 = Module['_emscripten_bind_PxMeshOverlapUtil_findOverlap_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshOverlapUtil_findOverlap_4');
var _emscripten_bind_PxMeshOverlapUtil_getResults_0 = Module['_emscripten_bind_PxMeshOverlapUtil_getResults_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshOverlapUtil_getResults_0');
var _emscripten_bind_PxMeshOverlapUtil_getNbResults_0 = Module['_emscripten_bind_PxMeshOverlapUtil_getNbResults_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshOverlapUtil_getNbResults_0');
var _emscripten_bind_PxMeshOverlapUtil___destroy___0 = Module['_emscripten_bind_PxMeshOverlapUtil___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshOverlapUtil___destroy___0');
var _emscripten_bind_PxMeshPreprocessingFlags_PxMeshPreprocessingFlags_1 = Module['_emscripten_bind_PxMeshPreprocessingFlags_PxMeshPreprocessingFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshPreprocessingFlags_PxMeshPreprocessingFlags_1');
var _emscripten_bind_PxMeshPreprocessingFlags_isSet_1 = Module['_emscripten_bind_PxMeshPreprocessingFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshPreprocessingFlags_isSet_1');
var _emscripten_bind_PxMeshPreprocessingFlags_raise_1 = Module['_emscripten_bind_PxMeshPreprocessingFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshPreprocessingFlags_raise_1');
var _emscripten_bind_PxMeshPreprocessingFlags_clear_1 = Module['_emscripten_bind_PxMeshPreprocessingFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshPreprocessingFlags_clear_1');
var _emscripten_bind_PxMeshPreprocessingFlags___destroy___0 = Module['_emscripten_bind_PxMeshPreprocessingFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshPreprocessingFlags___destroy___0');
var _emscripten_bind_PxMeshScale_PxMeshScale_0 = Module['_emscripten_bind_PxMeshScale_PxMeshScale_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshScale_PxMeshScale_0');
var _emscripten_bind_PxMeshScale_PxMeshScale_1 = Module['_emscripten_bind_PxMeshScale_PxMeshScale_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshScale_PxMeshScale_1');
var _emscripten_bind_PxMeshScale_PxMeshScale_2 = Module['_emscripten_bind_PxMeshScale_PxMeshScale_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshScale_PxMeshScale_2');
var _emscripten_bind_PxMeshScale___destroy___0 = Module['_emscripten_bind_PxMeshScale___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMeshScale___destroy___0');
var _emscripten_bind_PxMidphaseDesc_PxMidphaseDesc_0 = Module['_emscripten_bind_PxMidphaseDesc_PxMidphaseDesc_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMidphaseDesc_PxMidphaseDesc_0');
var _emscripten_bind_PxMidphaseDesc_getType_0 = Module['_emscripten_bind_PxMidphaseDesc_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMidphaseDesc_getType_0');
var _emscripten_bind_PxMidphaseDesc_setToDefault_1 = Module['_emscripten_bind_PxMidphaseDesc_setToDefault_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMidphaseDesc_setToDefault_1');
var _emscripten_bind_PxMidphaseDesc_isValid_0 = Module['_emscripten_bind_PxMidphaseDesc_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMidphaseDesc_isValid_0');
var _emscripten_bind_PxMidphaseDesc_get_mBVH33Desc_0 = Module['_emscripten_bind_PxMidphaseDesc_get_mBVH33Desc_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMidphaseDesc_get_mBVH33Desc_0');
var _emscripten_bind_PxMidphaseDesc_set_mBVH33Desc_1 = Module['_emscripten_bind_PxMidphaseDesc_set_mBVH33Desc_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMidphaseDesc_set_mBVH33Desc_1');
var _emscripten_bind_PxMidphaseDesc_get_mBVH34Desc_0 = Module['_emscripten_bind_PxMidphaseDesc_get_mBVH34Desc_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMidphaseDesc_get_mBVH34Desc_0');
var _emscripten_bind_PxMidphaseDesc_set_mBVH34Desc_1 = Module['_emscripten_bind_PxMidphaseDesc_set_mBVH34Desc_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxMidphaseDesc_set_mBVH34Desc_1');
var _emscripten_bind_PxMidphaseDesc___destroy___0 = Module['_emscripten_bind_PxMidphaseDesc___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxMidphaseDesc___destroy___0');
var _emscripten_bind_PxObstacleContext_release_0 = Module['_emscripten_bind_PxObstacleContext_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacleContext_release_0');
var _emscripten_bind_PxObstacleContext_getControllerManager_0 = Module['_emscripten_bind_PxObstacleContext_getControllerManager_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacleContext_getControllerManager_0');
var _emscripten_bind_PxObstacleContext_addObstacle_1 = Module['_emscripten_bind_PxObstacleContext_addObstacle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacleContext_addObstacle_1');
var _emscripten_bind_PxObstacleContext_removeObstacle_1 = Module['_emscripten_bind_PxObstacleContext_removeObstacle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacleContext_removeObstacle_1');
var _emscripten_bind_PxObstacleContext_updateObstacle_2 = Module['_emscripten_bind_PxObstacleContext_updateObstacle_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacleContext_updateObstacle_2');
var _emscripten_bind_PxObstacleContext_getNbObstacles_0 = Module['_emscripten_bind_PxObstacleContext_getNbObstacles_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacleContext_getNbObstacles_0');
var _emscripten_bind_PxObstacleContext_getObstacle_1 = Module['_emscripten_bind_PxObstacleContext_getObstacle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacleContext_getObstacle_1');
var _emscripten_bind_PxObstacleContext_getObstacleByHandle_1 = Module['_emscripten_bind_PxObstacleContext_getObstacleByHandle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacleContext_getObstacleByHandle_1');
var _emscripten_bind_PxObstacleContext___destroy___0 = Module['_emscripten_bind_PxObstacleContext___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxObstacleContext___destroy___0');
var _emscripten_bind_PxOmniPvd_startSampling_0 = Module['_emscripten_bind_PxOmniPvd_startSampling_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOmniPvd_startSampling_0');
var _emscripten_bind_PxOmniPvd_release_0 = Module['_emscripten_bind_PxOmniPvd_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOmniPvd_release_0');
var _emscripten_bind_PxOmniPvd___destroy___0 = Module['_emscripten_bind_PxOmniPvd___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOmniPvd___destroy___0');
var _emscripten_bind_PxOverlapBuffer10_PxOverlapBuffer10_0 = Module['_emscripten_bind_PxOverlapBuffer10_PxOverlapBuffer10_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapBuffer10_PxOverlapBuffer10_0');
var _emscripten_bind_PxOverlapBuffer10_getNbAnyHits_0 = Module['_emscripten_bind_PxOverlapBuffer10_getNbAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapBuffer10_getNbAnyHits_0');
var _emscripten_bind_PxOverlapBuffer10_getAnyHit_1 = Module['_emscripten_bind_PxOverlapBuffer10_getAnyHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapBuffer10_getAnyHit_1');
var _emscripten_bind_PxOverlapBuffer10_getNbTouches_0 = Module['_emscripten_bind_PxOverlapBuffer10_getNbTouches_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapBuffer10_getNbTouches_0');
var _emscripten_bind_PxOverlapBuffer10_getTouches_0 = Module['_emscripten_bind_PxOverlapBuffer10_getTouches_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapBuffer10_getTouches_0');
var _emscripten_bind_PxOverlapBuffer10_getTouch_1 = Module['_emscripten_bind_PxOverlapBuffer10_getTouch_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapBuffer10_getTouch_1');
var _emscripten_bind_PxOverlapBuffer10_getMaxNbTouches_0 = Module['_emscripten_bind_PxOverlapBuffer10_getMaxNbTouches_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapBuffer10_getMaxNbTouches_0');
var _emscripten_bind_PxOverlapBuffer10_hasAnyHits_0 = Module['_emscripten_bind_PxOverlapBuffer10_hasAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapBuffer10_hasAnyHits_0');
var _emscripten_bind_PxOverlapBuffer10_get_block_0 = Module['_emscripten_bind_PxOverlapBuffer10_get_block_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapBuffer10_get_block_0');
var _emscripten_bind_PxOverlapBuffer10_set_block_1 = Module['_emscripten_bind_PxOverlapBuffer10_set_block_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapBuffer10_set_block_1');
var _emscripten_bind_PxOverlapBuffer10_get_hasBlock_0 = Module['_emscripten_bind_PxOverlapBuffer10_get_hasBlock_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapBuffer10_get_hasBlock_0');
var _emscripten_bind_PxOverlapBuffer10_set_hasBlock_1 = Module['_emscripten_bind_PxOverlapBuffer10_set_hasBlock_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapBuffer10_set_hasBlock_1');
var _emscripten_bind_PxOverlapBuffer10___destroy___0 = Module['_emscripten_bind_PxOverlapBuffer10___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapBuffer10___destroy___0');
var _emscripten_bind_PxOverlapHit_get_actor_0 = Module['_emscripten_bind_PxOverlapHit_get_actor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapHit_get_actor_0');
var _emscripten_bind_PxOverlapHit_set_actor_1 = Module['_emscripten_bind_PxOverlapHit_set_actor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapHit_set_actor_1');
var _emscripten_bind_PxOverlapHit_get_shape_0 = Module['_emscripten_bind_PxOverlapHit_get_shape_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapHit_get_shape_0');
var _emscripten_bind_PxOverlapHit_set_shape_1 = Module['_emscripten_bind_PxOverlapHit_set_shape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapHit_set_shape_1');
var _emscripten_bind_PxOverlapHit_get_faceIndex_0 = Module['_emscripten_bind_PxOverlapHit_get_faceIndex_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapHit_get_faceIndex_0');
var _emscripten_bind_PxOverlapHit_set_faceIndex_1 = Module['_emscripten_bind_PxOverlapHit_set_faceIndex_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapHit_set_faceIndex_1');
var _emscripten_bind_PxOverlapHit___destroy___0 = Module['_emscripten_bind_PxOverlapHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapHit___destroy___0');
var _emscripten_bind_PxOverlapResult_PxOverlapResult_0 = Module['_emscripten_bind_PxOverlapResult_PxOverlapResult_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapResult_PxOverlapResult_0');
var _emscripten_bind_PxOverlapResult_getNbAnyHits_0 = Module['_emscripten_bind_PxOverlapResult_getNbAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapResult_getNbAnyHits_0');
var _emscripten_bind_PxOverlapResult_getAnyHit_1 = Module['_emscripten_bind_PxOverlapResult_getAnyHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapResult_getAnyHit_1');
var _emscripten_bind_PxOverlapResult_getNbTouches_0 = Module['_emscripten_bind_PxOverlapResult_getNbTouches_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapResult_getNbTouches_0');
var _emscripten_bind_PxOverlapResult_getTouch_1 = Module['_emscripten_bind_PxOverlapResult_getTouch_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapResult_getTouch_1');
var _emscripten_bind_PxOverlapResult_clear_0 = Module['_emscripten_bind_PxOverlapResult_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapResult_clear_0');
var _emscripten_bind_PxOverlapResult_hasAnyHits_0 = Module['_emscripten_bind_PxOverlapResult_hasAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapResult_hasAnyHits_0');
var _emscripten_bind_PxOverlapResult_get_block_0 = Module['_emscripten_bind_PxOverlapResult_get_block_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapResult_get_block_0');
var _emscripten_bind_PxOverlapResult_set_block_1 = Module['_emscripten_bind_PxOverlapResult_set_block_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapResult_set_block_1');
var _emscripten_bind_PxOverlapResult_get_hasBlock_0 = Module['_emscripten_bind_PxOverlapResult_get_hasBlock_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapResult_get_hasBlock_0');
var _emscripten_bind_PxOverlapResult_set_hasBlock_1 = Module['_emscripten_bind_PxOverlapResult_set_hasBlock_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapResult_set_hasBlock_1');
var _emscripten_bind_PxOverlapResult___destroy___0 = Module['_emscripten_bind_PxOverlapResult___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxOverlapResult___destroy___0');
var _emscripten_bind_PxPairFlags_PxPairFlags_1 = Module['_emscripten_bind_PxPairFlags_PxPairFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPairFlags_PxPairFlags_1');
var _emscripten_bind_PxPairFlags_isSet_1 = Module['_emscripten_bind_PxPairFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPairFlags_isSet_1');
var _emscripten_bind_PxPairFlags_raise_1 = Module['_emscripten_bind_PxPairFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPairFlags_raise_1');
var _emscripten_bind_PxPairFlags_clear_1 = Module['_emscripten_bind_PxPairFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPairFlags_clear_1');
var _emscripten_bind_PxPairFlags___destroy___0 = Module['_emscripten_bind_PxPairFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPairFlags___destroy___0');
var _emscripten_bind_PxPhysics_release_0 = Module['_emscripten_bind_PxPhysics_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_release_0');
var _emscripten_bind_PxPhysics_getFoundation_0 = Module['_emscripten_bind_PxPhysics_getFoundation_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_getFoundation_0');
var _emscripten_bind_PxPhysics_createAggregate_3 = Module['_emscripten_bind_PxPhysics_createAggregate_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_createAggregate_3');
var _emscripten_bind_PxPhysics_getTolerancesScale_0 = Module['_emscripten_bind_PxPhysics_getTolerancesScale_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_getTolerancesScale_0');
var _emscripten_bind_PxPhysics_createScene_1 = Module['_emscripten_bind_PxPhysics_createScene_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_createScene_1');
var _emscripten_bind_PxPhysics_createRigidStatic_1 = Module['_emscripten_bind_PxPhysics_createRigidStatic_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_createRigidStatic_1');
var _emscripten_bind_PxPhysics_createRigidDynamic_1 = Module['_emscripten_bind_PxPhysics_createRigidDynamic_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_createRigidDynamic_1');
var _emscripten_bind_PxPhysics_createShape_2 = Module['_emscripten_bind_PxPhysics_createShape_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_createShape_2');
var _emscripten_bind_PxPhysics_createShape_3 = Module['_emscripten_bind_PxPhysics_createShape_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_createShape_3');
var _emscripten_bind_PxPhysics_createShape_4 = Module['_emscripten_bind_PxPhysics_createShape_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_createShape_4');
var _emscripten_bind_PxPhysics_createTriangleMesh_1 = Module['_emscripten_bind_PxPhysics_createTriangleMesh_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_createTriangleMesh_1');
var _emscripten_bind_PxPhysics_createConvexMesh_1 = Module['_emscripten_bind_PxPhysics_createConvexMesh_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_createConvexMesh_1');
var _emscripten_bind_PxPhysics_getNbShapes_0 = Module['_emscripten_bind_PxPhysics_getNbShapes_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_getNbShapes_0');
var _emscripten_bind_PxPhysics_createArticulationReducedCoordinate_0 = Module['_emscripten_bind_PxPhysics_createArticulationReducedCoordinate_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_createArticulationReducedCoordinate_0');
var _emscripten_bind_PxPhysics_createMaterial_3 = Module['_emscripten_bind_PxPhysics_createMaterial_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_createMaterial_3');
var _emscripten_bind_PxPhysics_getPhysicsInsertionCallback_0 = Module['_emscripten_bind_PxPhysics_getPhysicsInsertionCallback_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics_getPhysicsInsertionCallback_0');
var _emscripten_bind_PxPhysics___destroy___0 = Module['_emscripten_bind_PxPhysics___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPhysics___destroy___0');
var _emscripten_bind_PxPlane_PxPlane_0 = Module['_emscripten_bind_PxPlane_PxPlane_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_PxPlane_0');
var _emscripten_bind_PxPlane_PxPlane_2 = Module['_emscripten_bind_PxPlane_PxPlane_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_PxPlane_2');
var _emscripten_bind_PxPlane_PxPlane_3 = Module['_emscripten_bind_PxPlane_PxPlane_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_PxPlane_3');
var _emscripten_bind_PxPlane_PxPlane_4 = Module['_emscripten_bind_PxPlane_PxPlane_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_PxPlane_4');
var _emscripten_bind_PxPlane_distance_1 = Module['_emscripten_bind_PxPlane_distance_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_distance_1');
var _emscripten_bind_PxPlane_contains_1 = Module['_emscripten_bind_PxPlane_contains_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_contains_1');
var _emscripten_bind_PxPlane_project_1 = Module['_emscripten_bind_PxPlane_project_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_project_1');
var _emscripten_bind_PxPlane_pointInPlane_0 = Module['_emscripten_bind_PxPlane_pointInPlane_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_pointInPlane_0');
var _emscripten_bind_PxPlane_normalize_0 = Module['_emscripten_bind_PxPlane_normalize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_normalize_0');
var _emscripten_bind_PxPlane_transform_1 = Module['_emscripten_bind_PxPlane_transform_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_transform_1');
var _emscripten_bind_PxPlane_inverseTransform_1 = Module['_emscripten_bind_PxPlane_inverseTransform_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_inverseTransform_1');
var _emscripten_bind_PxPlane_get_n_0 = Module['_emscripten_bind_PxPlane_get_n_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_get_n_0');
var _emscripten_bind_PxPlane_set_n_1 = Module['_emscripten_bind_PxPlane_set_n_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_set_n_1');
var _emscripten_bind_PxPlane_get_d_0 = Module['_emscripten_bind_PxPlane_get_d_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_get_d_0');
var _emscripten_bind_PxPlane_set_d_1 = Module['_emscripten_bind_PxPlane_set_d_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane_set_d_1');
var _emscripten_bind_PxPlane___destroy___0 = Module['_emscripten_bind_PxPlane___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlane___destroy___0');
var _emscripten_bind_PxPlaneGeometry_PxPlaneGeometry_0 = Module['_emscripten_bind_PxPlaneGeometry_PxPlaneGeometry_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlaneGeometry_PxPlaneGeometry_0');
var _emscripten_bind_PxPlaneGeometry_getType_0 = Module['_emscripten_bind_PxPlaneGeometry_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlaneGeometry_getType_0');
var _emscripten_bind_PxPlaneGeometry___destroy___0 = Module['_emscripten_bind_PxPlaneGeometry___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPlaneGeometry___destroy___0');
var _emscripten_bind_PxPrismaticJoint_getPosition_0 = Module['_emscripten_bind_PxPrismaticJoint_getPosition_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getPosition_0');
var _emscripten_bind_PxPrismaticJoint_getVelocity_0 = Module['_emscripten_bind_PxPrismaticJoint_getVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getVelocity_0');
var _emscripten_bind_PxPrismaticJoint_setLimit_1 = Module['_emscripten_bind_PxPrismaticJoint_setLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setLimit_1');
var _emscripten_bind_PxPrismaticJoint_setPrismaticJointFlags_1 = Module['_emscripten_bind_PxPrismaticJoint_setPrismaticJointFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setPrismaticJointFlags_1');
var _emscripten_bind_PxPrismaticJoint_setPrismaticJointFlag_2 = Module['_emscripten_bind_PxPrismaticJoint_setPrismaticJointFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setPrismaticJointFlag_2');
var _emscripten_bind_PxPrismaticJoint_getPrismaticJointFlags_0 = Module['_emscripten_bind_PxPrismaticJoint_getPrismaticJointFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getPrismaticJointFlags_0');
var _emscripten_bind_PxPrismaticJoint_release_0 = Module['_emscripten_bind_PxPrismaticJoint_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_release_0');
var _emscripten_bind_PxPrismaticJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxPrismaticJoint_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getConcreteTypeName_0');
var _emscripten_bind_PxPrismaticJoint_getConcreteType_0 = Module['_emscripten_bind_PxPrismaticJoint_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getConcreteType_0');
var _emscripten_bind_PxPrismaticJoint_setBaseFlag_2 = Module['_emscripten_bind_PxPrismaticJoint_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setBaseFlag_2');
var _emscripten_bind_PxPrismaticJoint_setBaseFlags_1 = Module['_emscripten_bind_PxPrismaticJoint_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setBaseFlags_1');
var _emscripten_bind_PxPrismaticJoint_getBaseFlags_0 = Module['_emscripten_bind_PxPrismaticJoint_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getBaseFlags_0');
var _emscripten_bind_PxPrismaticJoint_isReleasable_0 = Module['_emscripten_bind_PxPrismaticJoint_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_isReleasable_0');
var _emscripten_bind_PxPrismaticJoint_setActors_2 = Module['_emscripten_bind_PxPrismaticJoint_setActors_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setActors_2');
var _emscripten_bind_PxPrismaticJoint_setLocalPose_2 = Module['_emscripten_bind_PxPrismaticJoint_setLocalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setLocalPose_2');
var _emscripten_bind_PxPrismaticJoint_getLocalPose_1 = Module['_emscripten_bind_PxPrismaticJoint_getLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getLocalPose_1');
var _emscripten_bind_PxPrismaticJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxPrismaticJoint_getRelativeTransform_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getRelativeTransform_0');
var _emscripten_bind_PxPrismaticJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxPrismaticJoint_getRelativeLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getRelativeLinearVelocity_0');
var _emscripten_bind_PxPrismaticJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxPrismaticJoint_getRelativeAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getRelativeAngularVelocity_0');
var _emscripten_bind_PxPrismaticJoint_setBreakForce_2 = Module['_emscripten_bind_PxPrismaticJoint_setBreakForce_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setBreakForce_2');
var _emscripten_bind_PxPrismaticJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxPrismaticJoint_setConstraintFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setConstraintFlags_1');
var _emscripten_bind_PxPrismaticJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxPrismaticJoint_setConstraintFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setConstraintFlag_2');
var _emscripten_bind_PxPrismaticJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxPrismaticJoint_getConstraintFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getConstraintFlags_0');
var _emscripten_bind_PxPrismaticJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxPrismaticJoint_setInvMassScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setInvMassScale0_1');
var _emscripten_bind_PxPrismaticJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxPrismaticJoint_getInvMassScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getInvMassScale0_0');
var _emscripten_bind_PxPrismaticJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxPrismaticJoint_setInvMassScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setInvMassScale1_1');
var _emscripten_bind_PxPrismaticJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxPrismaticJoint_getInvMassScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getInvMassScale1_0');
var _emscripten_bind_PxPrismaticJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxPrismaticJoint_setInvInertiaScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setInvInertiaScale0_1');
var _emscripten_bind_PxPrismaticJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxPrismaticJoint_getInvInertiaScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getInvInertiaScale0_0');
var _emscripten_bind_PxPrismaticJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxPrismaticJoint_setInvInertiaScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setInvInertiaScale1_1');
var _emscripten_bind_PxPrismaticJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxPrismaticJoint_getInvInertiaScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getInvInertiaScale1_0');
var _emscripten_bind_PxPrismaticJoint_getConstraint_0 = Module['_emscripten_bind_PxPrismaticJoint_getConstraint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getConstraint_0');
var _emscripten_bind_PxPrismaticJoint_setName_1 = Module['_emscripten_bind_PxPrismaticJoint_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_setName_1');
var _emscripten_bind_PxPrismaticJoint_getName_0 = Module['_emscripten_bind_PxPrismaticJoint_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getName_0');
var _emscripten_bind_PxPrismaticJoint_getScene_0 = Module['_emscripten_bind_PxPrismaticJoint_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_getScene_0');
var _emscripten_bind_PxPrismaticJoint_get_userData_0 = Module['_emscripten_bind_PxPrismaticJoint_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_get_userData_0');
var _emscripten_bind_PxPrismaticJoint_set_userData_1 = Module['_emscripten_bind_PxPrismaticJoint_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint_set_userData_1');
var _emscripten_bind_PxPrismaticJoint___destroy___0 = Module['_emscripten_bind_PxPrismaticJoint___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJoint___destroy___0');
var _emscripten_bind_PxPrismaticJointFlags_PxPrismaticJointFlags_1 = Module['_emscripten_bind_PxPrismaticJointFlags_PxPrismaticJointFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJointFlags_PxPrismaticJointFlags_1');
var _emscripten_bind_PxPrismaticJointFlags_isSet_1 = Module['_emscripten_bind_PxPrismaticJointFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJointFlags_isSet_1');
var _emscripten_bind_PxPrismaticJointFlags_raise_1 = Module['_emscripten_bind_PxPrismaticJointFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJointFlags_raise_1');
var _emscripten_bind_PxPrismaticJointFlags_clear_1 = Module['_emscripten_bind_PxPrismaticJointFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJointFlags_clear_1');
var _emscripten_bind_PxPrismaticJointFlags___destroy___0 = Module['_emscripten_bind_PxPrismaticJointFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPrismaticJointFlags___destroy___0');
var _emscripten_bind_PxPvd_connect_2 = Module['_emscripten_bind_PxPvd_connect_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvd_connect_2');
var _emscripten_bind_PxPvd_release_0 = Module['_emscripten_bind_PxPvd_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvd_release_0');
var _emscripten_bind_PxPvdInstrumentationFlags_PxPvdInstrumentationFlags_1 = Module['_emscripten_bind_PxPvdInstrumentationFlags_PxPvdInstrumentationFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdInstrumentationFlags_PxPvdInstrumentationFlags_1');
var _emscripten_bind_PxPvdInstrumentationFlags_isSet_1 = Module['_emscripten_bind_PxPvdInstrumentationFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdInstrumentationFlags_isSet_1');
var _emscripten_bind_PxPvdInstrumentationFlags_raise_1 = Module['_emscripten_bind_PxPvdInstrumentationFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdInstrumentationFlags_raise_1');
var _emscripten_bind_PxPvdInstrumentationFlags_clear_1 = Module['_emscripten_bind_PxPvdInstrumentationFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdInstrumentationFlags_clear_1');
var _emscripten_bind_PxPvdInstrumentationFlags___destroy___0 = Module['_emscripten_bind_PxPvdInstrumentationFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdInstrumentationFlags___destroy___0');
var _emscripten_bind_PxPvdSceneClient_setScenePvdFlag_2 = Module['_emscripten_bind_PxPvdSceneClient_setScenePvdFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdSceneClient_setScenePvdFlag_2');
var _emscripten_bind_PxPvdSceneClient_setScenePvdFlags_1 = Module['_emscripten_bind_PxPvdSceneClient_setScenePvdFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdSceneClient_setScenePvdFlags_1');
var _emscripten_bind_PxPvdSceneClient_getScenePvdFlags_0 = Module['_emscripten_bind_PxPvdSceneClient_getScenePvdFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdSceneClient_getScenePvdFlags_0');
var _emscripten_bind_PxPvdSceneClient_updateCamera_4 = Module['_emscripten_bind_PxPvdSceneClient_updateCamera_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdSceneClient_updateCamera_4');
var _emscripten_bind_PxPvdSceneFlags_PxPvdSceneFlags_1 = Module['_emscripten_bind_PxPvdSceneFlags_PxPvdSceneFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdSceneFlags_PxPvdSceneFlags_1');
var _emscripten_bind_PxPvdSceneFlags_isSet_1 = Module['_emscripten_bind_PxPvdSceneFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdSceneFlags_isSet_1');
var _emscripten_bind_PxPvdSceneFlags_raise_1 = Module['_emscripten_bind_PxPvdSceneFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdSceneFlags_raise_1');
var _emscripten_bind_PxPvdSceneFlags_clear_1 = Module['_emscripten_bind_PxPvdSceneFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdSceneFlags_clear_1');
var _emscripten_bind_PxPvdSceneFlags___destroy___0 = Module['_emscripten_bind_PxPvdSceneFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxPvdSceneFlags___destroy___0');
var _emscripten_bind_PxQuat_PxQuat_0 = Module['_emscripten_bind_PxQuat_PxQuat_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_PxQuat_0');
var _emscripten_bind_PxQuat_PxQuat_1 = Module['_emscripten_bind_PxQuat_PxQuat_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_PxQuat_1');
var _emscripten_bind_PxQuat_PxQuat_2 = Module['_emscripten_bind_PxQuat_PxQuat_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_PxQuat_2');
var _emscripten_bind_PxQuat_PxQuat_4 = Module['_emscripten_bind_PxQuat_PxQuat_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_PxQuat_4');
var _emscripten_bind_PxQuat_isIdentity_0 = Module['_emscripten_bind_PxQuat_isIdentity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_isIdentity_0');
var _emscripten_bind_PxQuat_isFinite_0 = Module['_emscripten_bind_PxQuat_isFinite_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_isFinite_0');
var _emscripten_bind_PxQuat_isUnit_0 = Module['_emscripten_bind_PxQuat_isUnit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_isUnit_0');
var _emscripten_bind_PxQuat_isSane_0 = Module['_emscripten_bind_PxQuat_isSane_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_isSane_0');
var _emscripten_bind_PxQuat_getAngle_0 = Module['_emscripten_bind_PxQuat_getAngle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_getAngle_0');
var _emscripten_bind_PxQuat_getAngle_1 = Module['_emscripten_bind_PxQuat_getAngle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_getAngle_1');
var _emscripten_bind_PxQuat_magnitudeSquared_0 = Module['_emscripten_bind_PxQuat_magnitudeSquared_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_magnitudeSquared_0');
var _emscripten_bind_PxQuat_dot_1 = Module['_emscripten_bind_PxQuat_dot_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_dot_1');
var _emscripten_bind_PxQuat_getNormalized_0 = Module['_emscripten_bind_PxQuat_getNormalized_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_getNormalized_0');
var _emscripten_bind_PxQuat_magnitude_0 = Module['_emscripten_bind_PxQuat_magnitude_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_magnitude_0');
var _emscripten_bind_PxQuat_normalize_0 = Module['_emscripten_bind_PxQuat_normalize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_normalize_0');
var _emscripten_bind_PxQuat_getConjugate_0 = Module['_emscripten_bind_PxQuat_getConjugate_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_getConjugate_0');
var _emscripten_bind_PxQuat_getImaginaryPart_0 = Module['_emscripten_bind_PxQuat_getImaginaryPart_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_getImaginaryPart_0');
var _emscripten_bind_PxQuat_getBasisVector0_0 = Module['_emscripten_bind_PxQuat_getBasisVector0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_getBasisVector0_0');
var _emscripten_bind_PxQuat_getBasisVector1_0 = Module['_emscripten_bind_PxQuat_getBasisVector1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_getBasisVector1_0');
var _emscripten_bind_PxQuat_getBasisVector2_0 = Module['_emscripten_bind_PxQuat_getBasisVector2_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_getBasisVector2_0');
var _emscripten_bind_PxQuat_rotate_1 = Module['_emscripten_bind_PxQuat_rotate_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_rotate_1');
var _emscripten_bind_PxQuat_rotateInv_1 = Module['_emscripten_bind_PxQuat_rotateInv_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_rotateInv_1');
var _emscripten_bind_PxQuat_get_x_0 = Module['_emscripten_bind_PxQuat_get_x_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_get_x_0');
var _emscripten_bind_PxQuat_set_x_1 = Module['_emscripten_bind_PxQuat_set_x_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_set_x_1');
var _emscripten_bind_PxQuat_get_y_0 = Module['_emscripten_bind_PxQuat_get_y_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_get_y_0');
var _emscripten_bind_PxQuat_set_y_1 = Module['_emscripten_bind_PxQuat_set_y_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_set_y_1');
var _emscripten_bind_PxQuat_get_z_0 = Module['_emscripten_bind_PxQuat_get_z_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_get_z_0');
var _emscripten_bind_PxQuat_set_z_1 = Module['_emscripten_bind_PxQuat_set_z_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_set_z_1');
var _emscripten_bind_PxQuat_get_w_0 = Module['_emscripten_bind_PxQuat_get_w_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_get_w_0');
var _emscripten_bind_PxQuat_set_w_1 = Module['_emscripten_bind_PxQuat_set_w_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat_set_w_1');
var _emscripten_bind_PxQuat___destroy___0 = Module['_emscripten_bind_PxQuat___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQuat___destroy___0');
var _emscripten_bind_PxQueryFilterCallbackImpl_PxQueryFilterCallbackImpl_0 = Module['_emscripten_bind_PxQueryFilterCallbackImpl_PxQueryFilterCallbackImpl_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFilterCallbackImpl_PxQueryFilterCallbackImpl_0');
var _emscripten_bind_PxQueryFilterCallbackImpl_simplePreFilter_4 = Module['_emscripten_bind_PxQueryFilterCallbackImpl_simplePreFilter_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFilterCallbackImpl_simplePreFilter_4');
var _emscripten_bind_PxQueryFilterCallbackImpl_simplePostFilter_4 = Module['_emscripten_bind_PxQueryFilterCallbackImpl_simplePostFilter_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFilterCallbackImpl_simplePostFilter_4');
var _emscripten_bind_PxQueryFilterCallbackImpl___destroy___0 = Module['_emscripten_bind_PxQueryFilterCallbackImpl___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFilterCallbackImpl___destroy___0');
var _emscripten_bind_PxQueryFilterData_PxQueryFilterData_0 = Module['_emscripten_bind_PxQueryFilterData_PxQueryFilterData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFilterData_PxQueryFilterData_0');
var _emscripten_bind_PxQueryFilterData_PxQueryFilterData_1 = Module['_emscripten_bind_PxQueryFilterData_PxQueryFilterData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFilterData_PxQueryFilterData_1');
var _emscripten_bind_PxQueryFilterData_PxQueryFilterData_2 = Module['_emscripten_bind_PxQueryFilterData_PxQueryFilterData_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFilterData_PxQueryFilterData_2');
var _emscripten_bind_PxQueryFilterData_get_data_0 = Module['_emscripten_bind_PxQueryFilterData_get_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFilterData_get_data_0');
var _emscripten_bind_PxQueryFilterData_set_data_1 = Module['_emscripten_bind_PxQueryFilterData_set_data_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFilterData_set_data_1');
var _emscripten_bind_PxQueryFilterData_get_flags_0 = Module['_emscripten_bind_PxQueryFilterData_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFilterData_get_flags_0');
var _emscripten_bind_PxQueryFilterData_set_flags_1 = Module['_emscripten_bind_PxQueryFilterData_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFilterData_set_flags_1');
var _emscripten_bind_PxQueryFilterData___destroy___0 = Module['_emscripten_bind_PxQueryFilterData___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFilterData___destroy___0');
var _emscripten_bind_PxQueryFlags_PxQueryFlags_1 = Module['_emscripten_bind_PxQueryFlags_PxQueryFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFlags_PxQueryFlags_1');
var _emscripten_bind_PxQueryFlags_isSet_1 = Module['_emscripten_bind_PxQueryFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFlags_isSet_1');
var _emscripten_bind_PxQueryFlags_raise_1 = Module['_emscripten_bind_PxQueryFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFlags_raise_1');
var _emscripten_bind_PxQueryFlags_clear_1 = Module['_emscripten_bind_PxQueryFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFlags_clear_1');
var _emscripten_bind_PxQueryFlags___destroy___0 = Module['_emscripten_bind_PxQueryFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxQueryFlags___destroy___0');
var _emscripten_bind_PxRackAndPinionJoint_setJoints_2 = Module['_emscripten_bind_PxRackAndPinionJoint_setJoints_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setJoints_2');
var _emscripten_bind_PxRackAndPinionJoint_setRatio_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setRatio_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setRatio_1');
var _emscripten_bind_PxRackAndPinionJoint_getRatio_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getRatio_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getRatio_0');
var _emscripten_bind_PxRackAndPinionJoint_setData_3 = Module['_emscripten_bind_PxRackAndPinionJoint_setData_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setData_3');
var _emscripten_bind_PxRackAndPinionJoint_release_0 = Module['_emscripten_bind_PxRackAndPinionJoint_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_release_0');
var _emscripten_bind_PxRackAndPinionJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getConcreteTypeName_0');
var _emscripten_bind_PxRackAndPinionJoint_getConcreteType_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getConcreteType_0');
var _emscripten_bind_PxRackAndPinionJoint_setBaseFlag_2 = Module['_emscripten_bind_PxRackAndPinionJoint_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setBaseFlag_2');
var _emscripten_bind_PxRackAndPinionJoint_setBaseFlags_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setBaseFlags_1');
var _emscripten_bind_PxRackAndPinionJoint_getBaseFlags_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getBaseFlags_0');
var _emscripten_bind_PxRackAndPinionJoint_isReleasable_0 = Module['_emscripten_bind_PxRackAndPinionJoint_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_isReleasable_0');
var _emscripten_bind_PxRackAndPinionJoint_setActors_2 = Module['_emscripten_bind_PxRackAndPinionJoint_setActors_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setActors_2');
var _emscripten_bind_PxRackAndPinionJoint_setLocalPose_2 = Module['_emscripten_bind_PxRackAndPinionJoint_setLocalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setLocalPose_2');
var _emscripten_bind_PxRackAndPinionJoint_getLocalPose_1 = Module['_emscripten_bind_PxRackAndPinionJoint_getLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getLocalPose_1');
var _emscripten_bind_PxRackAndPinionJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getRelativeTransform_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getRelativeTransform_0');
var _emscripten_bind_PxRackAndPinionJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getRelativeLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getRelativeLinearVelocity_0');
var _emscripten_bind_PxRackAndPinionJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getRelativeAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getRelativeAngularVelocity_0');
var _emscripten_bind_PxRackAndPinionJoint_setBreakForce_2 = Module['_emscripten_bind_PxRackAndPinionJoint_setBreakForce_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setBreakForce_2');
var _emscripten_bind_PxRackAndPinionJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setConstraintFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setConstraintFlags_1');
var _emscripten_bind_PxRackAndPinionJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxRackAndPinionJoint_setConstraintFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setConstraintFlag_2');
var _emscripten_bind_PxRackAndPinionJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getConstraintFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getConstraintFlags_0');
var _emscripten_bind_PxRackAndPinionJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setInvMassScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setInvMassScale0_1');
var _emscripten_bind_PxRackAndPinionJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getInvMassScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getInvMassScale0_0');
var _emscripten_bind_PxRackAndPinionJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setInvMassScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setInvMassScale1_1');
var _emscripten_bind_PxRackAndPinionJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getInvMassScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getInvMassScale1_0');
var _emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale0_1');
var _emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale0_0');
var _emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale1_1');
var _emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale1_0');
var _emscripten_bind_PxRackAndPinionJoint_getConstraint_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getConstraint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getConstraint_0');
var _emscripten_bind_PxRackAndPinionJoint_setName_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_setName_1');
var _emscripten_bind_PxRackAndPinionJoint_getName_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getName_0');
var _emscripten_bind_PxRackAndPinionJoint_getScene_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_getScene_0');
var _emscripten_bind_PxRackAndPinionJoint_get_userData_0 = Module['_emscripten_bind_PxRackAndPinionJoint_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_get_userData_0');
var _emscripten_bind_PxRackAndPinionJoint_set_userData_1 = Module['_emscripten_bind_PxRackAndPinionJoint_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint_set_userData_1');
var _emscripten_bind_PxRackAndPinionJoint___destroy___0 = Module['_emscripten_bind_PxRackAndPinionJoint___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRackAndPinionJoint___destroy___0');
var _emscripten_bind_PxRaycastBuffer10_PxRaycastBuffer10_0 = Module['_emscripten_bind_PxRaycastBuffer10_PxRaycastBuffer10_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastBuffer10_PxRaycastBuffer10_0');
var _emscripten_bind_PxRaycastBuffer10_getNbAnyHits_0 = Module['_emscripten_bind_PxRaycastBuffer10_getNbAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastBuffer10_getNbAnyHits_0');
var _emscripten_bind_PxRaycastBuffer10_getAnyHit_1 = Module['_emscripten_bind_PxRaycastBuffer10_getAnyHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastBuffer10_getAnyHit_1');
var _emscripten_bind_PxRaycastBuffer10_getNbTouches_0 = Module['_emscripten_bind_PxRaycastBuffer10_getNbTouches_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastBuffer10_getNbTouches_0');
var _emscripten_bind_PxRaycastBuffer10_getTouches_0 = Module['_emscripten_bind_PxRaycastBuffer10_getTouches_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastBuffer10_getTouches_0');
var _emscripten_bind_PxRaycastBuffer10_getTouch_1 = Module['_emscripten_bind_PxRaycastBuffer10_getTouch_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastBuffer10_getTouch_1');
var _emscripten_bind_PxRaycastBuffer10_getMaxNbTouches_0 = Module['_emscripten_bind_PxRaycastBuffer10_getMaxNbTouches_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastBuffer10_getMaxNbTouches_0');
var _emscripten_bind_PxRaycastBuffer10_hasAnyHits_0 = Module['_emscripten_bind_PxRaycastBuffer10_hasAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastBuffer10_hasAnyHits_0');
var _emscripten_bind_PxRaycastBuffer10_get_block_0 = Module['_emscripten_bind_PxRaycastBuffer10_get_block_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastBuffer10_get_block_0');
var _emscripten_bind_PxRaycastBuffer10_set_block_1 = Module['_emscripten_bind_PxRaycastBuffer10_set_block_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastBuffer10_set_block_1');
var _emscripten_bind_PxRaycastBuffer10_get_hasBlock_0 = Module['_emscripten_bind_PxRaycastBuffer10_get_hasBlock_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastBuffer10_get_hasBlock_0');
var _emscripten_bind_PxRaycastBuffer10_set_hasBlock_1 = Module['_emscripten_bind_PxRaycastBuffer10_set_hasBlock_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastBuffer10_set_hasBlock_1');
var _emscripten_bind_PxRaycastBuffer10___destroy___0 = Module['_emscripten_bind_PxRaycastBuffer10___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastBuffer10___destroy___0');
var _emscripten_bind_PxRaycastHit_PxRaycastHit_0 = Module['_emscripten_bind_PxRaycastHit_PxRaycastHit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_PxRaycastHit_0');
var _emscripten_bind_PxRaycastHit_hadInitialOverlap_0 = Module['_emscripten_bind_PxRaycastHit_hadInitialOverlap_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_hadInitialOverlap_0');
var _emscripten_bind_PxRaycastHit_get_actor_0 = Module['_emscripten_bind_PxRaycastHit_get_actor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_get_actor_0');
var _emscripten_bind_PxRaycastHit_set_actor_1 = Module['_emscripten_bind_PxRaycastHit_set_actor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_set_actor_1');
var _emscripten_bind_PxRaycastHit_get_shape_0 = Module['_emscripten_bind_PxRaycastHit_get_shape_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_get_shape_0');
var _emscripten_bind_PxRaycastHit_set_shape_1 = Module['_emscripten_bind_PxRaycastHit_set_shape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_set_shape_1');
var _emscripten_bind_PxRaycastHit_get_u_0 = Module['_emscripten_bind_PxRaycastHit_get_u_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_get_u_0');
var _emscripten_bind_PxRaycastHit_set_u_1 = Module['_emscripten_bind_PxRaycastHit_set_u_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_set_u_1');
var _emscripten_bind_PxRaycastHit_get_v_0 = Module['_emscripten_bind_PxRaycastHit_get_v_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_get_v_0');
var _emscripten_bind_PxRaycastHit_set_v_1 = Module['_emscripten_bind_PxRaycastHit_set_v_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_set_v_1');
var _emscripten_bind_PxRaycastHit_get_flags_0 = Module['_emscripten_bind_PxRaycastHit_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_get_flags_0');
var _emscripten_bind_PxRaycastHit_set_flags_1 = Module['_emscripten_bind_PxRaycastHit_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_set_flags_1');
var _emscripten_bind_PxRaycastHit_get_position_0 = Module['_emscripten_bind_PxRaycastHit_get_position_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_get_position_0');
var _emscripten_bind_PxRaycastHit_set_position_1 = Module['_emscripten_bind_PxRaycastHit_set_position_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_set_position_1');
var _emscripten_bind_PxRaycastHit_get_normal_0 = Module['_emscripten_bind_PxRaycastHit_get_normal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_get_normal_0');
var _emscripten_bind_PxRaycastHit_set_normal_1 = Module['_emscripten_bind_PxRaycastHit_set_normal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_set_normal_1');
var _emscripten_bind_PxRaycastHit_get_distance_0 = Module['_emscripten_bind_PxRaycastHit_get_distance_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_get_distance_0');
var _emscripten_bind_PxRaycastHit_set_distance_1 = Module['_emscripten_bind_PxRaycastHit_set_distance_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_set_distance_1');
var _emscripten_bind_PxRaycastHit_get_faceIndex_0 = Module['_emscripten_bind_PxRaycastHit_get_faceIndex_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_get_faceIndex_0');
var _emscripten_bind_PxRaycastHit_set_faceIndex_1 = Module['_emscripten_bind_PxRaycastHit_set_faceIndex_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit_set_faceIndex_1');
var _emscripten_bind_PxRaycastHit___destroy___0 = Module['_emscripten_bind_PxRaycastHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastHit___destroy___0');
var _emscripten_bind_PxRaycastResult_PxRaycastResult_0 = Module['_emscripten_bind_PxRaycastResult_PxRaycastResult_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastResult_PxRaycastResult_0');
var _emscripten_bind_PxRaycastResult_getNbAnyHits_0 = Module['_emscripten_bind_PxRaycastResult_getNbAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastResult_getNbAnyHits_0');
var _emscripten_bind_PxRaycastResult_getAnyHit_1 = Module['_emscripten_bind_PxRaycastResult_getAnyHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastResult_getAnyHit_1');
var _emscripten_bind_PxRaycastResult_getNbTouches_0 = Module['_emscripten_bind_PxRaycastResult_getNbTouches_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastResult_getNbTouches_0');
var _emscripten_bind_PxRaycastResult_getTouch_1 = Module['_emscripten_bind_PxRaycastResult_getTouch_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastResult_getTouch_1');
var _emscripten_bind_PxRaycastResult_clear_0 = Module['_emscripten_bind_PxRaycastResult_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastResult_clear_0');
var _emscripten_bind_PxRaycastResult_hasAnyHits_0 = Module['_emscripten_bind_PxRaycastResult_hasAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastResult_hasAnyHits_0');
var _emscripten_bind_PxRaycastResult_get_block_0 = Module['_emscripten_bind_PxRaycastResult_get_block_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastResult_get_block_0');
var _emscripten_bind_PxRaycastResult_set_block_1 = Module['_emscripten_bind_PxRaycastResult_set_block_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastResult_set_block_1');
var _emscripten_bind_PxRaycastResult_get_hasBlock_0 = Module['_emscripten_bind_PxRaycastResult_get_hasBlock_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastResult_get_hasBlock_0');
var _emscripten_bind_PxRaycastResult_set_hasBlock_1 = Module['_emscripten_bind_PxRaycastResult_set_hasBlock_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastResult_set_hasBlock_1');
var _emscripten_bind_PxRaycastResult___destroy___0 = Module['_emscripten_bind_PxRaycastResult___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRaycastResult___destroy___0');
var _emscripten_bind_PxRealPtr___destroy___0 = Module['_emscripten_bind_PxRealPtr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRealPtr___destroy___0');
var _emscripten_bind_PxRenderBuffer_getNbPoints_0 = Module['_emscripten_bind_PxRenderBuffer_getNbPoints_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_getNbPoints_0');
var _emscripten_bind_PxRenderBuffer_getPoints_0 = Module['_emscripten_bind_PxRenderBuffer_getPoints_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_getPoints_0');
var _emscripten_bind_PxRenderBuffer_addPoint_1 = Module['_emscripten_bind_PxRenderBuffer_addPoint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_addPoint_1');
var _emscripten_bind_PxRenderBuffer_getNbLines_0 = Module['_emscripten_bind_PxRenderBuffer_getNbLines_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_getNbLines_0');
var _emscripten_bind_PxRenderBuffer_getLines_0 = Module['_emscripten_bind_PxRenderBuffer_getLines_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_getLines_0');
var _emscripten_bind_PxRenderBuffer_addLine_1 = Module['_emscripten_bind_PxRenderBuffer_addLine_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_addLine_1');
var _emscripten_bind_PxRenderBuffer_reserveLines_1 = Module['_emscripten_bind_PxRenderBuffer_reserveLines_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_reserveLines_1');
var _emscripten_bind_PxRenderBuffer_reservePoints_1 = Module['_emscripten_bind_PxRenderBuffer_reservePoints_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_reservePoints_1');
var _emscripten_bind_PxRenderBuffer_getNbTriangles_0 = Module['_emscripten_bind_PxRenderBuffer_getNbTriangles_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_getNbTriangles_0');
var _emscripten_bind_PxRenderBuffer_getTriangles_0 = Module['_emscripten_bind_PxRenderBuffer_getTriangles_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_getTriangles_0');
var _emscripten_bind_PxRenderBuffer_addTriangle_1 = Module['_emscripten_bind_PxRenderBuffer_addTriangle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_addTriangle_1');
var _emscripten_bind_PxRenderBuffer_append_1 = Module['_emscripten_bind_PxRenderBuffer_append_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_append_1');
var _emscripten_bind_PxRenderBuffer_clear_0 = Module['_emscripten_bind_PxRenderBuffer_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_clear_0');
var _emscripten_bind_PxRenderBuffer_shift_1 = Module['_emscripten_bind_PxRenderBuffer_shift_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_shift_1');
var _emscripten_bind_PxRenderBuffer_empty_0 = Module['_emscripten_bind_PxRenderBuffer_empty_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRenderBuffer_empty_0');
var _emscripten_bind_PxRevoluteJoint_getAngle_0 = Module['_emscripten_bind_PxRevoluteJoint_getAngle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getAngle_0');
var _emscripten_bind_PxRevoluteJoint_getVelocity_0 = Module['_emscripten_bind_PxRevoluteJoint_getVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getVelocity_0');
var _emscripten_bind_PxRevoluteJoint_setLimit_1 = Module['_emscripten_bind_PxRevoluteJoint_setLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setLimit_1');
var _emscripten_bind_PxRevoluteJoint_setDriveVelocity_1 = Module['_emscripten_bind_PxRevoluteJoint_setDriveVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setDriveVelocity_1');
var _emscripten_bind_PxRevoluteJoint_setDriveVelocity_2 = Module['_emscripten_bind_PxRevoluteJoint_setDriveVelocity_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setDriveVelocity_2');
var _emscripten_bind_PxRevoluteJoint_getDriveVelocity_0 = Module['_emscripten_bind_PxRevoluteJoint_getDriveVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getDriveVelocity_0');
var _emscripten_bind_PxRevoluteJoint_setDriveForceLimit_1 = Module['_emscripten_bind_PxRevoluteJoint_setDriveForceLimit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setDriveForceLimit_1');
var _emscripten_bind_PxRevoluteJoint_getDriveForceLimit_0 = Module['_emscripten_bind_PxRevoluteJoint_getDriveForceLimit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getDriveForceLimit_0');
var _emscripten_bind_PxRevoluteJoint_setDriveGearRatio_1 = Module['_emscripten_bind_PxRevoluteJoint_setDriveGearRatio_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setDriveGearRatio_1');
var _emscripten_bind_PxRevoluteJoint_getDriveGearRatio_0 = Module['_emscripten_bind_PxRevoluteJoint_getDriveGearRatio_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getDriveGearRatio_0');
var _emscripten_bind_PxRevoluteJoint_setRevoluteJointFlags_1 = Module['_emscripten_bind_PxRevoluteJoint_setRevoluteJointFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setRevoluteJointFlags_1');
var _emscripten_bind_PxRevoluteJoint_setRevoluteJointFlag_2 = Module['_emscripten_bind_PxRevoluteJoint_setRevoluteJointFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setRevoluteJointFlag_2');
var _emscripten_bind_PxRevoluteJoint_getRevoluteJointFlags_0 = Module['_emscripten_bind_PxRevoluteJoint_getRevoluteJointFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getRevoluteJointFlags_0');
var _emscripten_bind_PxRevoluteJoint_release_0 = Module['_emscripten_bind_PxRevoluteJoint_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_release_0');
var _emscripten_bind_PxRevoluteJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxRevoluteJoint_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getConcreteTypeName_0');
var _emscripten_bind_PxRevoluteJoint_getConcreteType_0 = Module['_emscripten_bind_PxRevoluteJoint_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getConcreteType_0');
var _emscripten_bind_PxRevoluteJoint_setBaseFlag_2 = Module['_emscripten_bind_PxRevoluteJoint_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setBaseFlag_2');
var _emscripten_bind_PxRevoluteJoint_setBaseFlags_1 = Module['_emscripten_bind_PxRevoluteJoint_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setBaseFlags_1');
var _emscripten_bind_PxRevoluteJoint_getBaseFlags_0 = Module['_emscripten_bind_PxRevoluteJoint_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getBaseFlags_0');
var _emscripten_bind_PxRevoluteJoint_isReleasable_0 = Module['_emscripten_bind_PxRevoluteJoint_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_isReleasable_0');
var _emscripten_bind_PxRevoluteJoint_setActors_2 = Module['_emscripten_bind_PxRevoluteJoint_setActors_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setActors_2');
var _emscripten_bind_PxRevoluteJoint_setLocalPose_2 = Module['_emscripten_bind_PxRevoluteJoint_setLocalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setLocalPose_2');
var _emscripten_bind_PxRevoluteJoint_getLocalPose_1 = Module['_emscripten_bind_PxRevoluteJoint_getLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getLocalPose_1');
var _emscripten_bind_PxRevoluteJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxRevoluteJoint_getRelativeTransform_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getRelativeTransform_0');
var _emscripten_bind_PxRevoluteJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxRevoluteJoint_getRelativeLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getRelativeLinearVelocity_0');
var _emscripten_bind_PxRevoluteJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxRevoluteJoint_getRelativeAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getRelativeAngularVelocity_0');
var _emscripten_bind_PxRevoluteJoint_setBreakForce_2 = Module['_emscripten_bind_PxRevoluteJoint_setBreakForce_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setBreakForce_2');
var _emscripten_bind_PxRevoluteJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxRevoluteJoint_setConstraintFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setConstraintFlags_1');
var _emscripten_bind_PxRevoluteJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxRevoluteJoint_setConstraintFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setConstraintFlag_2');
var _emscripten_bind_PxRevoluteJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxRevoluteJoint_getConstraintFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getConstraintFlags_0');
var _emscripten_bind_PxRevoluteJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxRevoluteJoint_setInvMassScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setInvMassScale0_1');
var _emscripten_bind_PxRevoluteJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxRevoluteJoint_getInvMassScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getInvMassScale0_0');
var _emscripten_bind_PxRevoluteJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxRevoluteJoint_setInvMassScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setInvMassScale1_1');
var _emscripten_bind_PxRevoluteJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxRevoluteJoint_getInvMassScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getInvMassScale1_0');
var _emscripten_bind_PxRevoluteJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxRevoluteJoint_setInvInertiaScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setInvInertiaScale0_1');
var _emscripten_bind_PxRevoluteJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxRevoluteJoint_getInvInertiaScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getInvInertiaScale0_0');
var _emscripten_bind_PxRevoluteJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxRevoluteJoint_setInvInertiaScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setInvInertiaScale1_1');
var _emscripten_bind_PxRevoluteJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxRevoluteJoint_getInvInertiaScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getInvInertiaScale1_0');
var _emscripten_bind_PxRevoluteJoint_getConstraint_0 = Module['_emscripten_bind_PxRevoluteJoint_getConstraint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getConstraint_0');
var _emscripten_bind_PxRevoluteJoint_setName_1 = Module['_emscripten_bind_PxRevoluteJoint_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_setName_1');
var _emscripten_bind_PxRevoluteJoint_getName_0 = Module['_emscripten_bind_PxRevoluteJoint_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getName_0');
var _emscripten_bind_PxRevoluteJoint_getScene_0 = Module['_emscripten_bind_PxRevoluteJoint_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_getScene_0');
var _emscripten_bind_PxRevoluteJoint_get_userData_0 = Module['_emscripten_bind_PxRevoluteJoint_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_get_userData_0');
var _emscripten_bind_PxRevoluteJoint_set_userData_1 = Module['_emscripten_bind_PxRevoluteJoint_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint_set_userData_1');
var _emscripten_bind_PxRevoluteJoint___destroy___0 = Module['_emscripten_bind_PxRevoluteJoint___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJoint___destroy___0');
var _emscripten_bind_PxRevoluteJointFlags_PxRevoluteJointFlags_1 = Module['_emscripten_bind_PxRevoluteJointFlags_PxRevoluteJointFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJointFlags_PxRevoluteJointFlags_1');
var _emscripten_bind_PxRevoluteJointFlags_isSet_1 = Module['_emscripten_bind_PxRevoluteJointFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJointFlags_isSet_1');
var _emscripten_bind_PxRevoluteJointFlags_raise_1 = Module['_emscripten_bind_PxRevoluteJointFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJointFlags_raise_1');
var _emscripten_bind_PxRevoluteJointFlags_clear_1 = Module['_emscripten_bind_PxRevoluteJointFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJointFlags_clear_1');
var _emscripten_bind_PxRevoluteJointFlags___destroy___0 = Module['_emscripten_bind_PxRevoluteJointFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRevoluteJointFlags___destroy___0');
var _emscripten_bind_PxRigidActorExt_createExclusiveShape_3 = Module['_emscripten_bind_PxRigidActorExt_createExclusiveShape_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActorExt_createExclusiveShape_3');
var _emscripten_bind_PxRigidActorExt_createExclusiveShape_4 = Module['_emscripten_bind_PxRigidActorExt_createExclusiveShape_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActorExt_createExclusiveShape_4');
var _emscripten_bind_PxRigidActorExt___destroy___0 = Module['_emscripten_bind_PxRigidActorExt___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidActorExt___destroy___0');
var _emscripten_bind_PxRigidBodyExt_updateMassAndInertia_2 = Module['_emscripten_bind_PxRigidBodyExt_updateMassAndInertia_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_updateMassAndInertia_2');
var _emscripten_bind_PxRigidBodyExt_updateMassAndInertia_3 = Module['_emscripten_bind_PxRigidBodyExt_updateMassAndInertia_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_updateMassAndInertia_3');
var _emscripten_bind_PxRigidBodyExt_updateMassAndInertia_4 = Module['_emscripten_bind_PxRigidBodyExt_updateMassAndInertia_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_updateMassAndInertia_4');
var _emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_2 = Module['_emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_2');
var _emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_3 = Module['_emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_3');
var _emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_4 = Module['_emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_4');
var _emscripten_bind_PxRigidBodyExt_addForceAtPos_3 = Module['_emscripten_bind_PxRigidBodyExt_addForceAtPos_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_addForceAtPos_3');
var _emscripten_bind_PxRigidBodyExt_addForceAtPos_4 = Module['_emscripten_bind_PxRigidBodyExt_addForceAtPos_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_addForceAtPos_4');
var _emscripten_bind_PxRigidBodyExt_addForceAtPos_5 = Module['_emscripten_bind_PxRigidBodyExt_addForceAtPos_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_addForceAtPos_5');
var _emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_3 = Module['_emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_3');
var _emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_4 = Module['_emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_4');
var _emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_5 = Module['_emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_5');
var _emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_3 = Module['_emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_3');
var _emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_4 = Module['_emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_4');
var _emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_5 = Module['_emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_5');
var _emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_3 = Module['_emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_3');
var _emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_4 = Module['_emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_4');
var _emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_5 = Module['_emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_5');
var _emscripten_bind_PxRigidBodyExt_getVelocityAtPos_2 = Module['_emscripten_bind_PxRigidBodyExt_getVelocityAtPos_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_getVelocityAtPos_2');
var _emscripten_bind_PxRigidBodyExt_getLocalVelocityAtLocalPos_2 = Module['_emscripten_bind_PxRigidBodyExt_getLocalVelocityAtLocalPos_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_getLocalVelocityAtLocalPos_2');
var _emscripten_bind_PxRigidBodyExt_getVelocityAtOffset_2 = Module['_emscripten_bind_PxRigidBodyExt_getVelocityAtOffset_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_getVelocityAtOffset_2');
var _emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_5 = Module['_emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_5');
var _emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_8 = Module['_emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_8'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_8');
var _emscripten_bind_PxRigidBodyExt_computeLinearAngularImpulse_8 = Module['_emscripten_bind_PxRigidBodyExt_computeLinearAngularImpulse_8'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt_computeLinearAngularImpulse_8');
var _emscripten_bind_PxRigidBodyExt___destroy___0 = Module['_emscripten_bind_PxRigidBodyExt___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyExt___destroy___0');
var _emscripten_bind_PxRigidBodyFlags_PxRigidBodyFlags_1 = Module['_emscripten_bind_PxRigidBodyFlags_PxRigidBodyFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyFlags_PxRigidBodyFlags_1');
var _emscripten_bind_PxRigidBodyFlags_isSet_1 = Module['_emscripten_bind_PxRigidBodyFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyFlags_isSet_1');
var _emscripten_bind_PxRigidBodyFlags_raise_1 = Module['_emscripten_bind_PxRigidBodyFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyFlags_raise_1');
var _emscripten_bind_PxRigidBodyFlags_clear_1 = Module['_emscripten_bind_PxRigidBodyFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyFlags_clear_1');
var _emscripten_bind_PxRigidBodyFlags___destroy___0 = Module['_emscripten_bind_PxRigidBodyFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidBodyFlags___destroy___0');
var _emscripten_bind_PxRigidDynamic_setKinematicTarget_1 = Module['_emscripten_bind_PxRigidDynamic_setKinematicTarget_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setKinematicTarget_1');
var _emscripten_bind_PxRigidDynamic_getKinematicTarget_1 = Module['_emscripten_bind_PxRigidDynamic_getKinematicTarget_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getKinematicTarget_1');
var _emscripten_bind_PxRigidDynamic_isSleeping_0 = Module['_emscripten_bind_PxRigidDynamic_isSleeping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_isSleeping_0');
var _emscripten_bind_PxRigidDynamic_setSleepThreshold_1 = Module['_emscripten_bind_PxRigidDynamic_setSleepThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setSleepThreshold_1');
var _emscripten_bind_PxRigidDynamic_getSleepThreshold_0 = Module['_emscripten_bind_PxRigidDynamic_getSleepThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getSleepThreshold_0');
var _emscripten_bind_PxRigidDynamic_setStabilizationThreshold_1 = Module['_emscripten_bind_PxRigidDynamic_setStabilizationThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setStabilizationThreshold_1');
var _emscripten_bind_PxRigidDynamic_getStabilizationThreshold_0 = Module['_emscripten_bind_PxRigidDynamic_getStabilizationThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getStabilizationThreshold_0');
var _emscripten_bind_PxRigidDynamic_getRigidDynamicLockFlags_0 = Module['_emscripten_bind_PxRigidDynamic_getRigidDynamicLockFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getRigidDynamicLockFlags_0');
var _emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlag_2 = Module['_emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlag_2');
var _emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlags_1 = Module['_emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlags_1');
var _emscripten_bind_PxRigidDynamic_setLinearVelocity_1 = Module['_emscripten_bind_PxRigidDynamic_setLinearVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setLinearVelocity_1');
var _emscripten_bind_PxRigidDynamic_setLinearVelocity_2 = Module['_emscripten_bind_PxRigidDynamic_setLinearVelocity_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setLinearVelocity_2');
var _emscripten_bind_PxRigidDynamic_setAngularVelocity_1 = Module['_emscripten_bind_PxRigidDynamic_setAngularVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setAngularVelocity_1');
var _emscripten_bind_PxRigidDynamic_setAngularVelocity_2 = Module['_emscripten_bind_PxRigidDynamic_setAngularVelocity_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setAngularVelocity_2');
var _emscripten_bind_PxRigidDynamic_setWakeCounter_1 = Module['_emscripten_bind_PxRigidDynamic_setWakeCounter_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setWakeCounter_1');
var _emscripten_bind_PxRigidDynamic_getWakeCounter_0 = Module['_emscripten_bind_PxRigidDynamic_getWakeCounter_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getWakeCounter_0');
var _emscripten_bind_PxRigidDynamic_wakeUp_0 = Module['_emscripten_bind_PxRigidDynamic_wakeUp_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_wakeUp_0');
var _emscripten_bind_PxRigidDynamic_putToSleep_0 = Module['_emscripten_bind_PxRigidDynamic_putToSleep_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_putToSleep_0');
var _emscripten_bind_PxRigidDynamic_setSolverIterationCounts_1 = Module['_emscripten_bind_PxRigidDynamic_setSolverIterationCounts_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setSolverIterationCounts_1');
var _emscripten_bind_PxRigidDynamic_setSolverIterationCounts_2 = Module['_emscripten_bind_PxRigidDynamic_setSolverIterationCounts_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setSolverIterationCounts_2');
var _emscripten_bind_PxRigidDynamic_getContactReportThreshold_0 = Module['_emscripten_bind_PxRigidDynamic_getContactReportThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getContactReportThreshold_0');
var _emscripten_bind_PxRigidDynamic_setContactReportThreshold_1 = Module['_emscripten_bind_PxRigidDynamic_setContactReportThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setContactReportThreshold_1');
var _emscripten_bind_PxRigidDynamic_getType_0 = Module['_emscripten_bind_PxRigidDynamic_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getType_0');
var _emscripten_bind_PxRigidDynamic_getScene_0 = Module['_emscripten_bind_PxRigidDynamic_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getScene_0');
var _emscripten_bind_PxRigidDynamic_setName_1 = Module['_emscripten_bind_PxRigidDynamic_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setName_1');
var _emscripten_bind_PxRigidDynamic_getName_0 = Module['_emscripten_bind_PxRigidDynamic_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getName_0');
var _emscripten_bind_PxRigidDynamic_getWorldBounds_0 = Module['_emscripten_bind_PxRigidDynamic_getWorldBounds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getWorldBounds_0');
var _emscripten_bind_PxRigidDynamic_getWorldBounds_1 = Module['_emscripten_bind_PxRigidDynamic_getWorldBounds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getWorldBounds_1');
var _emscripten_bind_PxRigidDynamic_setActorFlag_2 = Module['_emscripten_bind_PxRigidDynamic_setActorFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setActorFlag_2');
var _emscripten_bind_PxRigidDynamic_setActorFlags_1 = Module['_emscripten_bind_PxRigidDynamic_setActorFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setActorFlags_1');
var _emscripten_bind_PxRigidDynamic_getActorFlags_0 = Module['_emscripten_bind_PxRigidDynamic_getActorFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getActorFlags_0');
var _emscripten_bind_PxRigidDynamic_setDominanceGroup_1 = Module['_emscripten_bind_PxRigidDynamic_setDominanceGroup_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setDominanceGroup_1');
var _emscripten_bind_PxRigidDynamic_getDominanceGroup_0 = Module['_emscripten_bind_PxRigidDynamic_getDominanceGroup_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getDominanceGroup_0');
var _emscripten_bind_PxRigidDynamic_setOwnerClient_1 = Module['_emscripten_bind_PxRigidDynamic_setOwnerClient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setOwnerClient_1');
var _emscripten_bind_PxRigidDynamic_getOwnerClient_0 = Module['_emscripten_bind_PxRigidDynamic_getOwnerClient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getOwnerClient_0');
var _emscripten_bind_PxRigidDynamic_release_0 = Module['_emscripten_bind_PxRigidDynamic_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_release_0');
var _emscripten_bind_PxRigidDynamic_getConcreteTypeName_0 = Module['_emscripten_bind_PxRigidDynamic_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getConcreteTypeName_0');
var _emscripten_bind_PxRigidDynamic_getConcreteType_0 = Module['_emscripten_bind_PxRigidDynamic_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getConcreteType_0');
var _emscripten_bind_PxRigidDynamic_setBaseFlag_2 = Module['_emscripten_bind_PxRigidDynamic_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setBaseFlag_2');
var _emscripten_bind_PxRigidDynamic_setBaseFlags_1 = Module['_emscripten_bind_PxRigidDynamic_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setBaseFlags_1');
var _emscripten_bind_PxRigidDynamic_getBaseFlags_0 = Module['_emscripten_bind_PxRigidDynamic_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getBaseFlags_0');
var _emscripten_bind_PxRigidDynamic_isReleasable_0 = Module['_emscripten_bind_PxRigidDynamic_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_isReleasable_0');
var _emscripten_bind_PxRigidDynamic_getGlobalPose_0 = Module['_emscripten_bind_PxRigidDynamic_getGlobalPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getGlobalPose_0');
var _emscripten_bind_PxRigidDynamic_setGlobalPose_1 = Module['_emscripten_bind_PxRigidDynamic_setGlobalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setGlobalPose_1');
var _emscripten_bind_PxRigidDynamic_setGlobalPose_2 = Module['_emscripten_bind_PxRigidDynamic_setGlobalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setGlobalPose_2');
var _emscripten_bind_PxRigidDynamic_attachShape_1 = Module['_emscripten_bind_PxRigidDynamic_attachShape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_attachShape_1');
var _emscripten_bind_PxRigidDynamic_detachShape_1 = Module['_emscripten_bind_PxRigidDynamic_detachShape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_detachShape_1');
var _emscripten_bind_PxRigidDynamic_detachShape_2 = Module['_emscripten_bind_PxRigidDynamic_detachShape_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_detachShape_2');
var _emscripten_bind_PxRigidDynamic_getNbShapes_0 = Module['_emscripten_bind_PxRigidDynamic_getNbShapes_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getNbShapes_0');
var _emscripten_bind_PxRigidDynamic_getShapes_3 = Module['_emscripten_bind_PxRigidDynamic_getShapes_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getShapes_3');
var _emscripten_bind_PxRigidDynamic_getNbConstraints_0 = Module['_emscripten_bind_PxRigidDynamic_getNbConstraints_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getNbConstraints_0');
var _emscripten_bind_PxRigidDynamic_setCMassLocalPose_1 = Module['_emscripten_bind_PxRigidDynamic_setCMassLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setCMassLocalPose_1');
var _emscripten_bind_PxRigidDynamic_getCMassLocalPose_0 = Module['_emscripten_bind_PxRigidDynamic_getCMassLocalPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getCMassLocalPose_0');
var _emscripten_bind_PxRigidDynamic_setMass_1 = Module['_emscripten_bind_PxRigidDynamic_setMass_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setMass_1');
var _emscripten_bind_PxRigidDynamic_getMass_0 = Module['_emscripten_bind_PxRigidDynamic_getMass_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getMass_0');
var _emscripten_bind_PxRigidDynamic_getInvMass_0 = Module['_emscripten_bind_PxRigidDynamic_getInvMass_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getInvMass_0');
var _emscripten_bind_PxRigidDynamic_setMassSpaceInertiaTensor_1 = Module['_emscripten_bind_PxRigidDynamic_setMassSpaceInertiaTensor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setMassSpaceInertiaTensor_1');
var _emscripten_bind_PxRigidDynamic_getMassSpaceInertiaTensor_0 = Module['_emscripten_bind_PxRigidDynamic_getMassSpaceInertiaTensor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getMassSpaceInertiaTensor_0');
var _emscripten_bind_PxRigidDynamic_getMassSpaceInvInertiaTensor_0 = Module['_emscripten_bind_PxRigidDynamic_getMassSpaceInvInertiaTensor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getMassSpaceInvInertiaTensor_0');
var _emscripten_bind_PxRigidDynamic_setLinearDamping_1 = Module['_emscripten_bind_PxRigidDynamic_setLinearDamping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setLinearDamping_1');
var _emscripten_bind_PxRigidDynamic_getLinearDamping_0 = Module['_emscripten_bind_PxRigidDynamic_getLinearDamping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getLinearDamping_0');
var _emscripten_bind_PxRigidDynamic_setAngularDamping_1 = Module['_emscripten_bind_PxRigidDynamic_setAngularDamping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setAngularDamping_1');
var _emscripten_bind_PxRigidDynamic_getAngularDamping_0 = Module['_emscripten_bind_PxRigidDynamic_getAngularDamping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getAngularDamping_0');
var _emscripten_bind_PxRigidDynamic_getLinearVelocity_0 = Module['_emscripten_bind_PxRigidDynamic_getLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getLinearVelocity_0');
var _emscripten_bind_PxRigidDynamic_getAngularVelocity_0 = Module['_emscripten_bind_PxRigidDynamic_getAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getAngularVelocity_0');
var _emscripten_bind_PxRigidDynamic_setMaxLinearVelocity_1 = Module['_emscripten_bind_PxRigidDynamic_setMaxLinearVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setMaxLinearVelocity_1');
var _emscripten_bind_PxRigidDynamic_getMaxLinearVelocity_0 = Module['_emscripten_bind_PxRigidDynamic_getMaxLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getMaxLinearVelocity_0');
var _emscripten_bind_PxRigidDynamic_setMaxAngularVelocity_1 = Module['_emscripten_bind_PxRigidDynamic_setMaxAngularVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setMaxAngularVelocity_1');
var _emscripten_bind_PxRigidDynamic_getMaxAngularVelocity_0 = Module['_emscripten_bind_PxRigidDynamic_getMaxAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getMaxAngularVelocity_0');
var _emscripten_bind_PxRigidDynamic_addForce_1 = Module['_emscripten_bind_PxRigidDynamic_addForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_addForce_1');
var _emscripten_bind_PxRigidDynamic_addForce_2 = Module['_emscripten_bind_PxRigidDynamic_addForce_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_addForce_2');
var _emscripten_bind_PxRigidDynamic_addForce_3 = Module['_emscripten_bind_PxRigidDynamic_addForce_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_addForce_3');
var _emscripten_bind_PxRigidDynamic_addTorque_1 = Module['_emscripten_bind_PxRigidDynamic_addTorque_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_addTorque_1');
var _emscripten_bind_PxRigidDynamic_addTorque_2 = Module['_emscripten_bind_PxRigidDynamic_addTorque_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_addTorque_2');
var _emscripten_bind_PxRigidDynamic_addTorque_3 = Module['_emscripten_bind_PxRigidDynamic_addTorque_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_addTorque_3');
var _emscripten_bind_PxRigidDynamic_clearForce_1 = Module['_emscripten_bind_PxRigidDynamic_clearForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_clearForce_1');
var _emscripten_bind_PxRigidDynamic_clearTorque_1 = Module['_emscripten_bind_PxRigidDynamic_clearTorque_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_clearTorque_1');
var _emscripten_bind_PxRigidDynamic_setForceAndTorque_2 = Module['_emscripten_bind_PxRigidDynamic_setForceAndTorque_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setForceAndTorque_2');
var _emscripten_bind_PxRigidDynamic_setForceAndTorque_3 = Module['_emscripten_bind_PxRigidDynamic_setForceAndTorque_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setForceAndTorque_3');
var _emscripten_bind_PxRigidDynamic_setRigidBodyFlag_2 = Module['_emscripten_bind_PxRigidDynamic_setRigidBodyFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setRigidBodyFlag_2');
var _emscripten_bind_PxRigidDynamic_setRigidBodyFlags_1 = Module['_emscripten_bind_PxRigidDynamic_setRigidBodyFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setRigidBodyFlags_1');
var _emscripten_bind_PxRigidDynamic_getRigidBodyFlags_0 = Module['_emscripten_bind_PxRigidDynamic_getRigidBodyFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getRigidBodyFlags_0');
var _emscripten_bind_PxRigidDynamic_setMinCCDAdvanceCoefficient_1 = Module['_emscripten_bind_PxRigidDynamic_setMinCCDAdvanceCoefficient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setMinCCDAdvanceCoefficient_1');
var _emscripten_bind_PxRigidDynamic_getMinCCDAdvanceCoefficient_0 = Module['_emscripten_bind_PxRigidDynamic_getMinCCDAdvanceCoefficient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getMinCCDAdvanceCoefficient_0');
var _emscripten_bind_PxRigidDynamic_setMaxDepenetrationVelocity_1 = Module['_emscripten_bind_PxRigidDynamic_setMaxDepenetrationVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setMaxDepenetrationVelocity_1');
var _emscripten_bind_PxRigidDynamic_getMaxDepenetrationVelocity_0 = Module['_emscripten_bind_PxRigidDynamic_getMaxDepenetrationVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getMaxDepenetrationVelocity_0');
var _emscripten_bind_PxRigidDynamic_setMaxContactImpulse_1 = Module['_emscripten_bind_PxRigidDynamic_setMaxContactImpulse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setMaxContactImpulse_1');
var _emscripten_bind_PxRigidDynamic_getMaxContactImpulse_0 = Module['_emscripten_bind_PxRigidDynamic_getMaxContactImpulse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getMaxContactImpulse_0');
var _emscripten_bind_PxRigidDynamic_setContactSlopCoefficient_1 = Module['_emscripten_bind_PxRigidDynamic_setContactSlopCoefficient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_setContactSlopCoefficient_1');
var _emscripten_bind_PxRigidDynamic_getContactSlopCoefficient_0 = Module['_emscripten_bind_PxRigidDynamic_getContactSlopCoefficient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_getContactSlopCoefficient_0');
var _emscripten_bind_PxRigidDynamic_get_userData_0 = Module['_emscripten_bind_PxRigidDynamic_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_get_userData_0');
var _emscripten_bind_PxRigidDynamic_set_userData_1 = Module['_emscripten_bind_PxRigidDynamic_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamic_set_userData_1');
var _emscripten_bind_PxRigidDynamicLockFlags_PxRigidDynamicLockFlags_1 = Module['_emscripten_bind_PxRigidDynamicLockFlags_PxRigidDynamicLockFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamicLockFlags_PxRigidDynamicLockFlags_1');
var _emscripten_bind_PxRigidDynamicLockFlags_isSet_1 = Module['_emscripten_bind_PxRigidDynamicLockFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamicLockFlags_isSet_1');
var _emscripten_bind_PxRigidDynamicLockFlags_raise_1 = Module['_emscripten_bind_PxRigidDynamicLockFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamicLockFlags_raise_1');
var _emscripten_bind_PxRigidDynamicLockFlags_clear_1 = Module['_emscripten_bind_PxRigidDynamicLockFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamicLockFlags_clear_1');
var _emscripten_bind_PxRigidDynamicLockFlags___destroy___0 = Module['_emscripten_bind_PxRigidDynamicLockFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidDynamicLockFlags___destroy___0');
var _emscripten_bind_PxRigidStatic_getType_0 = Module['_emscripten_bind_PxRigidStatic_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getType_0');
var _emscripten_bind_PxRigidStatic_getScene_0 = Module['_emscripten_bind_PxRigidStatic_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getScene_0');
var _emscripten_bind_PxRigidStatic_setName_1 = Module['_emscripten_bind_PxRigidStatic_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_setName_1');
var _emscripten_bind_PxRigidStatic_getName_0 = Module['_emscripten_bind_PxRigidStatic_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getName_0');
var _emscripten_bind_PxRigidStatic_getWorldBounds_0 = Module['_emscripten_bind_PxRigidStatic_getWorldBounds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getWorldBounds_0');
var _emscripten_bind_PxRigidStatic_getWorldBounds_1 = Module['_emscripten_bind_PxRigidStatic_getWorldBounds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getWorldBounds_1');
var _emscripten_bind_PxRigidStatic_setActorFlag_2 = Module['_emscripten_bind_PxRigidStatic_setActorFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_setActorFlag_2');
var _emscripten_bind_PxRigidStatic_setActorFlags_1 = Module['_emscripten_bind_PxRigidStatic_setActorFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_setActorFlags_1');
var _emscripten_bind_PxRigidStatic_getActorFlags_0 = Module['_emscripten_bind_PxRigidStatic_getActorFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getActorFlags_0');
var _emscripten_bind_PxRigidStatic_setDominanceGroup_1 = Module['_emscripten_bind_PxRigidStatic_setDominanceGroup_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_setDominanceGroup_1');
var _emscripten_bind_PxRigidStatic_getDominanceGroup_0 = Module['_emscripten_bind_PxRigidStatic_getDominanceGroup_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getDominanceGroup_0');
var _emscripten_bind_PxRigidStatic_setOwnerClient_1 = Module['_emscripten_bind_PxRigidStatic_setOwnerClient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_setOwnerClient_1');
var _emscripten_bind_PxRigidStatic_getOwnerClient_0 = Module['_emscripten_bind_PxRigidStatic_getOwnerClient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getOwnerClient_0');
var _emscripten_bind_PxRigidStatic_release_0 = Module['_emscripten_bind_PxRigidStatic_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_release_0');
var _emscripten_bind_PxRigidStatic_getConcreteTypeName_0 = Module['_emscripten_bind_PxRigidStatic_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getConcreteTypeName_0');
var _emscripten_bind_PxRigidStatic_getConcreteType_0 = Module['_emscripten_bind_PxRigidStatic_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getConcreteType_0');
var _emscripten_bind_PxRigidStatic_setBaseFlag_2 = Module['_emscripten_bind_PxRigidStatic_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_setBaseFlag_2');
var _emscripten_bind_PxRigidStatic_setBaseFlags_1 = Module['_emscripten_bind_PxRigidStatic_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_setBaseFlags_1');
var _emscripten_bind_PxRigidStatic_getBaseFlags_0 = Module['_emscripten_bind_PxRigidStatic_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getBaseFlags_0');
var _emscripten_bind_PxRigidStatic_isReleasable_0 = Module['_emscripten_bind_PxRigidStatic_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_isReleasable_0');
var _emscripten_bind_PxRigidStatic_getGlobalPose_0 = Module['_emscripten_bind_PxRigidStatic_getGlobalPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getGlobalPose_0');
var _emscripten_bind_PxRigidStatic_setGlobalPose_1 = Module['_emscripten_bind_PxRigidStatic_setGlobalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_setGlobalPose_1');
var _emscripten_bind_PxRigidStatic_setGlobalPose_2 = Module['_emscripten_bind_PxRigidStatic_setGlobalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_setGlobalPose_2');
var _emscripten_bind_PxRigidStatic_attachShape_1 = Module['_emscripten_bind_PxRigidStatic_attachShape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_attachShape_1');
var _emscripten_bind_PxRigidStatic_detachShape_1 = Module['_emscripten_bind_PxRigidStatic_detachShape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_detachShape_1');
var _emscripten_bind_PxRigidStatic_detachShape_2 = Module['_emscripten_bind_PxRigidStatic_detachShape_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_detachShape_2');
var _emscripten_bind_PxRigidStatic_getNbShapes_0 = Module['_emscripten_bind_PxRigidStatic_getNbShapes_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getNbShapes_0');
var _emscripten_bind_PxRigidStatic_getShapes_3 = Module['_emscripten_bind_PxRigidStatic_getShapes_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getShapes_3');
var _emscripten_bind_PxRigidStatic_getNbConstraints_0 = Module['_emscripten_bind_PxRigidStatic_getNbConstraints_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_getNbConstraints_0');
var _emscripten_bind_PxRigidStatic_get_userData_0 = Module['_emscripten_bind_PxRigidStatic_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_get_userData_0');
var _emscripten_bind_PxRigidStatic_set_userData_1 = Module['_emscripten_bind_PxRigidStatic_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxRigidStatic_set_userData_1');
var _emscripten_bind_PxSDFDesc_PxSDFDesc_0 = Module['_emscripten_bind_PxSDFDesc_PxSDFDesc_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_PxSDFDesc_0');
var _emscripten_bind_PxSDFDesc_isValid_0 = Module['_emscripten_bind_PxSDFDesc_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_isValid_0');
var _emscripten_bind_PxSDFDesc_get_sdf_0 = Module['_emscripten_bind_PxSDFDesc_get_sdf_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_get_sdf_0');
var _emscripten_bind_PxSDFDesc_set_sdf_1 = Module['_emscripten_bind_PxSDFDesc_set_sdf_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_set_sdf_1');
var _emscripten_bind_PxSDFDesc_get_dims_0 = Module['_emscripten_bind_PxSDFDesc_get_dims_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_get_dims_0');
var _emscripten_bind_PxSDFDesc_set_dims_1 = Module['_emscripten_bind_PxSDFDesc_set_dims_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_set_dims_1');
var _emscripten_bind_PxSDFDesc_get_meshLower_0 = Module['_emscripten_bind_PxSDFDesc_get_meshLower_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_get_meshLower_0');
var _emscripten_bind_PxSDFDesc_set_meshLower_1 = Module['_emscripten_bind_PxSDFDesc_set_meshLower_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_set_meshLower_1');
var _emscripten_bind_PxSDFDesc_get_spacing_0 = Module['_emscripten_bind_PxSDFDesc_get_spacing_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_get_spacing_0');
var _emscripten_bind_PxSDFDesc_set_spacing_1 = Module['_emscripten_bind_PxSDFDesc_set_spacing_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_set_spacing_1');
var _emscripten_bind_PxSDFDesc_get_subgridSize_0 = Module['_emscripten_bind_PxSDFDesc_get_subgridSize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_get_subgridSize_0');
var _emscripten_bind_PxSDFDesc_set_subgridSize_1 = Module['_emscripten_bind_PxSDFDesc_set_subgridSize_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_set_subgridSize_1');
var _emscripten_bind_PxSDFDesc_get_bitsPerSubgridPixel_0 = Module['_emscripten_bind_PxSDFDesc_get_bitsPerSubgridPixel_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_get_bitsPerSubgridPixel_0');
var _emscripten_bind_PxSDFDesc_set_bitsPerSubgridPixel_1 = Module['_emscripten_bind_PxSDFDesc_set_bitsPerSubgridPixel_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_set_bitsPerSubgridPixel_1');
var _emscripten_bind_PxSDFDesc_get_sdfSubgrids3DTexBlockDim_0 = Module['_emscripten_bind_PxSDFDesc_get_sdfSubgrids3DTexBlockDim_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_get_sdfSubgrids3DTexBlockDim_0');
var _emscripten_bind_PxSDFDesc_set_sdfSubgrids3DTexBlockDim_1 = Module['_emscripten_bind_PxSDFDesc_set_sdfSubgrids3DTexBlockDim_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_set_sdfSubgrids3DTexBlockDim_1');
var _emscripten_bind_PxSDFDesc_get_sdfSubgrids_0 = Module['_emscripten_bind_PxSDFDesc_get_sdfSubgrids_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_get_sdfSubgrids_0');
var _emscripten_bind_PxSDFDesc_set_sdfSubgrids_1 = Module['_emscripten_bind_PxSDFDesc_set_sdfSubgrids_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_set_sdfSubgrids_1');
var _emscripten_bind_PxSDFDesc_get_sdfStartSlots_0 = Module['_emscripten_bind_PxSDFDesc_get_sdfStartSlots_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_get_sdfStartSlots_0');
var _emscripten_bind_PxSDFDesc_set_sdfStartSlots_1 = Module['_emscripten_bind_PxSDFDesc_set_sdfStartSlots_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_set_sdfStartSlots_1');
var _emscripten_bind_PxSDFDesc_get_subgridsMinSdfValue_0 = Module['_emscripten_bind_PxSDFDesc_get_subgridsMinSdfValue_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_get_subgridsMinSdfValue_0');
var _emscripten_bind_PxSDFDesc_set_subgridsMinSdfValue_1 = Module['_emscripten_bind_PxSDFDesc_set_subgridsMinSdfValue_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_set_subgridsMinSdfValue_1');
var _emscripten_bind_PxSDFDesc_get_subgridsMaxSdfValue_0 = Module['_emscripten_bind_PxSDFDesc_get_subgridsMaxSdfValue_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_get_subgridsMaxSdfValue_0');
var _emscripten_bind_PxSDFDesc_set_subgridsMaxSdfValue_1 = Module['_emscripten_bind_PxSDFDesc_set_subgridsMaxSdfValue_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_set_subgridsMaxSdfValue_1');
var _emscripten_bind_PxSDFDesc_get_sdfBounds_0 = Module['_emscripten_bind_PxSDFDesc_get_sdfBounds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_get_sdfBounds_0');
var _emscripten_bind_PxSDFDesc_set_sdfBounds_1 = Module['_emscripten_bind_PxSDFDesc_set_sdfBounds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_set_sdfBounds_1');
var _emscripten_bind_PxSDFDesc_get_narrowBandThicknessRelativeToSdfBoundsDiagonal_0 = Module['_emscripten_bind_PxSDFDesc_get_narrowBandThicknessRelativeToSdfBoundsDiagonal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_get_narrowBandThicknessRelativeToSdfBoundsDiagonal_0');
var _emscripten_bind_PxSDFDesc_set_narrowBandThicknessRelativeToSdfBoundsDiagonal_1 = Module['_emscripten_bind_PxSDFDesc_set_narrowBandThicknessRelativeToSdfBoundsDiagonal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_set_narrowBandThicknessRelativeToSdfBoundsDiagonal_1');
var _emscripten_bind_PxSDFDesc_get_numThreadsForSdfConstruction_0 = Module['_emscripten_bind_PxSDFDesc_get_numThreadsForSdfConstruction_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_get_numThreadsForSdfConstruction_0');
var _emscripten_bind_PxSDFDesc_set_numThreadsForSdfConstruction_1 = Module['_emscripten_bind_PxSDFDesc_set_numThreadsForSdfConstruction_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc_set_numThreadsForSdfConstruction_1');
var _emscripten_bind_PxSDFDesc___destroy___0 = Module['_emscripten_bind_PxSDFDesc___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSDFDesc___destroy___0');
var _emscripten_bind_PxScene_addActor_1 = Module['_emscripten_bind_PxScene_addActor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_addActor_1');
var _emscripten_bind_PxScene_addActor_2 = Module['_emscripten_bind_PxScene_addActor_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_addActor_2');
var _emscripten_bind_PxScene_removeActor_1 = Module['_emscripten_bind_PxScene_removeActor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_removeActor_1');
var _emscripten_bind_PxScene_removeActor_2 = Module['_emscripten_bind_PxScene_removeActor_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_removeActor_2');
var _emscripten_bind_PxScene_addAggregate_1 = Module['_emscripten_bind_PxScene_addAggregate_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_addAggregate_1');
var _emscripten_bind_PxScene_removeAggregate_1 = Module['_emscripten_bind_PxScene_removeAggregate_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_removeAggregate_1');
var _emscripten_bind_PxScene_removeAggregate_2 = Module['_emscripten_bind_PxScene_removeAggregate_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_removeAggregate_2');
var _emscripten_bind_PxScene_addCollection_1 = Module['_emscripten_bind_PxScene_addCollection_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_addCollection_1');
var _emscripten_bind_PxScene_getWakeCounterResetValue_0 = Module['_emscripten_bind_PxScene_getWakeCounterResetValue_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getWakeCounterResetValue_0');
var _emscripten_bind_PxScene_shiftOrigin_1 = Module['_emscripten_bind_PxScene_shiftOrigin_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_shiftOrigin_1');
var _emscripten_bind_PxScene_addArticulation_1 = Module['_emscripten_bind_PxScene_addArticulation_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_addArticulation_1');
var _emscripten_bind_PxScene_removeArticulation_1 = Module['_emscripten_bind_PxScene_removeArticulation_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_removeArticulation_1');
var _emscripten_bind_PxScene_removeArticulation_2 = Module['_emscripten_bind_PxScene_removeArticulation_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_removeArticulation_2');
var _emscripten_bind_PxScene_getNbActors_1 = Module['_emscripten_bind_PxScene_getNbActors_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getNbActors_1');
var _emscripten_bind_PxScene_getNbArticulations_0 = Module['_emscripten_bind_PxScene_getNbArticulations_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getNbArticulations_0');
var _emscripten_bind_PxScene_getNbConstraints_0 = Module['_emscripten_bind_PxScene_getNbConstraints_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getNbConstraints_0');
var _emscripten_bind_PxScene_getNbAggregates_0 = Module['_emscripten_bind_PxScene_getNbAggregates_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getNbAggregates_0');
var _emscripten_bind_PxScene_setDominanceGroupPair_3 = Module['_emscripten_bind_PxScene_setDominanceGroupPair_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setDominanceGroupPair_3');
var _emscripten_bind_PxScene_getCpuDispatcher_0 = Module['_emscripten_bind_PxScene_getCpuDispatcher_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getCpuDispatcher_0');
var _emscripten_bind_PxScene_createClient_0 = Module['_emscripten_bind_PxScene_createClient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_createClient_0');
var _emscripten_bind_PxScene_setSimulationEventCallback_1 = Module['_emscripten_bind_PxScene_setSimulationEventCallback_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setSimulationEventCallback_1');
var _emscripten_bind_PxScene_getSimulationEventCallback_0 = Module['_emscripten_bind_PxScene_getSimulationEventCallback_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getSimulationEventCallback_0');
var _emscripten_bind_PxScene_setFilterShaderData_2 = Module['_emscripten_bind_PxScene_setFilterShaderData_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setFilterShaderData_2');
var _emscripten_bind_PxScene_getFilterShaderData_0 = Module['_emscripten_bind_PxScene_getFilterShaderData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getFilterShaderData_0');
var _emscripten_bind_PxScene_getFilterShaderDataSize_0 = Module['_emscripten_bind_PxScene_getFilterShaderDataSize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getFilterShaderDataSize_0');
var _emscripten_bind_PxScene_getFilterShader_0 = Module['_emscripten_bind_PxScene_getFilterShader_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getFilterShader_0');
var _emscripten_bind_PxScene_resetFiltering_1 = Module['_emscripten_bind_PxScene_resetFiltering_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_resetFiltering_1');
var _emscripten_bind_PxScene_getKinematicKinematicFilteringMode_0 = Module['_emscripten_bind_PxScene_getKinematicKinematicFilteringMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getKinematicKinematicFilteringMode_0');
var _emscripten_bind_PxScene_getStaticKinematicFilteringMode_0 = Module['_emscripten_bind_PxScene_getStaticKinematicFilteringMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getStaticKinematicFilteringMode_0');
var _emscripten_bind_PxScene_simulate_1 = Module['_emscripten_bind_PxScene_simulate_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_simulate_1');
var _emscripten_bind_PxScene_simulate_2 = Module['_emscripten_bind_PxScene_simulate_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_simulate_2');
var _emscripten_bind_PxScene_simulate_3 = Module['_emscripten_bind_PxScene_simulate_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_simulate_3');
var _emscripten_bind_PxScene_simulate_4 = Module['_emscripten_bind_PxScene_simulate_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_simulate_4');
var _emscripten_bind_PxScene_simulate_5 = Module['_emscripten_bind_PxScene_simulate_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_simulate_5');
var _emscripten_bind_PxScene_advance_0 = Module['_emscripten_bind_PxScene_advance_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_advance_0');
var _emscripten_bind_PxScene_advance_1 = Module['_emscripten_bind_PxScene_advance_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_advance_1');
var _emscripten_bind_PxScene_collide_1 = Module['_emscripten_bind_PxScene_collide_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_collide_1');
var _emscripten_bind_PxScene_collide_2 = Module['_emscripten_bind_PxScene_collide_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_collide_2');
var _emscripten_bind_PxScene_collide_3 = Module['_emscripten_bind_PxScene_collide_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_collide_3');
var _emscripten_bind_PxScene_collide_4 = Module['_emscripten_bind_PxScene_collide_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_collide_4');
var _emscripten_bind_PxScene_collide_5 = Module['_emscripten_bind_PxScene_collide_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_collide_5');
var _emscripten_bind_PxScene_checkResults_0 = Module['_emscripten_bind_PxScene_checkResults_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_checkResults_0');
var _emscripten_bind_PxScene_checkResults_1 = Module['_emscripten_bind_PxScene_checkResults_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_checkResults_1');
var _emscripten_bind_PxScene_fetchCollision_0 = Module['_emscripten_bind_PxScene_fetchCollision_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_fetchCollision_0');
var _emscripten_bind_PxScene_fetchCollision_1 = Module['_emscripten_bind_PxScene_fetchCollision_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_fetchCollision_1');
var _emscripten_bind_PxScene_fetchResults_0 = Module['_emscripten_bind_PxScene_fetchResults_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_fetchResults_0');
var _emscripten_bind_PxScene_fetchResults_1 = Module['_emscripten_bind_PxScene_fetchResults_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_fetchResults_1');
var _emscripten_bind_PxScene_processCallbacks_1 = Module['_emscripten_bind_PxScene_processCallbacks_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_processCallbacks_1');
var _emscripten_bind_PxScene_fetchResultsParticleSystem_0 = Module['_emscripten_bind_PxScene_fetchResultsParticleSystem_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_fetchResultsParticleSystem_0');
var _emscripten_bind_PxScene_flushSimulation_0 = Module['_emscripten_bind_PxScene_flushSimulation_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_flushSimulation_0');
var _emscripten_bind_PxScene_flushSimulation_1 = Module['_emscripten_bind_PxScene_flushSimulation_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_flushSimulation_1');
var _emscripten_bind_PxScene_setGravity_1 = Module['_emscripten_bind_PxScene_setGravity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setGravity_1');
var _emscripten_bind_PxScene_getGravity_0 = Module['_emscripten_bind_PxScene_getGravity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getGravity_0');
var _emscripten_bind_PxScene_setBounceThresholdVelocity_1 = Module['_emscripten_bind_PxScene_setBounceThresholdVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setBounceThresholdVelocity_1');
var _emscripten_bind_PxScene_getBounceThresholdVelocity_0 = Module['_emscripten_bind_PxScene_getBounceThresholdVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getBounceThresholdVelocity_0');
var _emscripten_bind_PxScene_setCCDMaxPasses_1 = Module['_emscripten_bind_PxScene_setCCDMaxPasses_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setCCDMaxPasses_1');
var _emscripten_bind_PxScene_getCCDMaxPasses_0 = Module['_emscripten_bind_PxScene_getCCDMaxPasses_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getCCDMaxPasses_0');
var _emscripten_bind_PxScene_setCCDMaxSeparation_1 = Module['_emscripten_bind_PxScene_setCCDMaxSeparation_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setCCDMaxSeparation_1');
var _emscripten_bind_PxScene_getCCDMaxSeparation_0 = Module['_emscripten_bind_PxScene_getCCDMaxSeparation_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getCCDMaxSeparation_0');
var _emscripten_bind_PxScene_setCCDThreshold_1 = Module['_emscripten_bind_PxScene_setCCDThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setCCDThreshold_1');
var _emscripten_bind_PxScene_getCCDThreshold_0 = Module['_emscripten_bind_PxScene_getCCDThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getCCDThreshold_0');
var _emscripten_bind_PxScene_setMaxBiasCoefficient_1 = Module['_emscripten_bind_PxScene_setMaxBiasCoefficient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setMaxBiasCoefficient_1');
var _emscripten_bind_PxScene_getMaxBiasCoefficient_0 = Module['_emscripten_bind_PxScene_getMaxBiasCoefficient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getMaxBiasCoefficient_0');
var _emscripten_bind_PxScene_setFrictionOffsetThreshold_1 = Module['_emscripten_bind_PxScene_setFrictionOffsetThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setFrictionOffsetThreshold_1');
var _emscripten_bind_PxScene_getFrictionOffsetThreshold_0 = Module['_emscripten_bind_PxScene_getFrictionOffsetThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getFrictionOffsetThreshold_0');
var _emscripten_bind_PxScene_setFrictionCorrelationDistance_1 = Module['_emscripten_bind_PxScene_setFrictionCorrelationDistance_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setFrictionCorrelationDistance_1');
var _emscripten_bind_PxScene_getFrictionCorrelationDistance_0 = Module['_emscripten_bind_PxScene_getFrictionCorrelationDistance_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getFrictionCorrelationDistance_0');
var _emscripten_bind_PxScene_getFrictionType_0 = Module['_emscripten_bind_PxScene_getFrictionType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getFrictionType_0');
var _emscripten_bind_PxScene_getSolverType_0 = Module['_emscripten_bind_PxScene_getSolverType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getSolverType_0');
var _emscripten_bind_PxScene_getRenderBuffer_0 = Module['_emscripten_bind_PxScene_getRenderBuffer_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getRenderBuffer_0');
var _emscripten_bind_PxScene_setVisualizationParameter_2 = Module['_emscripten_bind_PxScene_setVisualizationParameter_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setVisualizationParameter_2');
var _emscripten_bind_PxScene_getVisualizationParameter_1 = Module['_emscripten_bind_PxScene_getVisualizationParameter_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getVisualizationParameter_1');
var _emscripten_bind_PxScene_setVisualizationCullingBox_1 = Module['_emscripten_bind_PxScene_setVisualizationCullingBox_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setVisualizationCullingBox_1');
var _emscripten_bind_PxScene_getVisualizationCullingBox_0 = Module['_emscripten_bind_PxScene_getVisualizationCullingBox_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getVisualizationCullingBox_0');
var _emscripten_bind_PxScene_getSimulationStatistics_1 = Module['_emscripten_bind_PxScene_getSimulationStatistics_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getSimulationStatistics_1');
var _emscripten_bind_PxScene_getBroadPhaseType_0 = Module['_emscripten_bind_PxScene_getBroadPhaseType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getBroadPhaseType_0');
var _emscripten_bind_PxScene_getBroadPhaseCaps_1 = Module['_emscripten_bind_PxScene_getBroadPhaseCaps_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getBroadPhaseCaps_1');
var _emscripten_bind_PxScene_getNbBroadPhaseRegions_0 = Module['_emscripten_bind_PxScene_getNbBroadPhaseRegions_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getNbBroadPhaseRegions_0');
var _emscripten_bind_PxScene_getBroadPhaseRegions_2 = Module['_emscripten_bind_PxScene_getBroadPhaseRegions_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getBroadPhaseRegions_2');
var _emscripten_bind_PxScene_getBroadPhaseRegions_3 = Module['_emscripten_bind_PxScene_getBroadPhaseRegions_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getBroadPhaseRegions_3');
var _emscripten_bind_PxScene_addBroadPhaseRegion_1 = Module['_emscripten_bind_PxScene_addBroadPhaseRegion_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_addBroadPhaseRegion_1');
var _emscripten_bind_PxScene_addBroadPhaseRegion_2 = Module['_emscripten_bind_PxScene_addBroadPhaseRegion_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_addBroadPhaseRegion_2');
var _emscripten_bind_PxScene_removeBroadPhaseRegion_1 = Module['_emscripten_bind_PxScene_removeBroadPhaseRegion_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_removeBroadPhaseRegion_1');
var _emscripten_bind_PxScene_lockRead_0 = Module['_emscripten_bind_PxScene_lockRead_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_lockRead_0');
var _emscripten_bind_PxScene_lockRead_1 = Module['_emscripten_bind_PxScene_lockRead_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_lockRead_1');
var _emscripten_bind_PxScene_lockRead_2 = Module['_emscripten_bind_PxScene_lockRead_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_lockRead_2');
var _emscripten_bind_PxScene_unlockRead_0 = Module['_emscripten_bind_PxScene_unlockRead_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_unlockRead_0');
var _emscripten_bind_PxScene_lockWrite_0 = Module['_emscripten_bind_PxScene_lockWrite_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_lockWrite_0');
var _emscripten_bind_PxScene_lockWrite_1 = Module['_emscripten_bind_PxScene_lockWrite_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_lockWrite_1');
var _emscripten_bind_PxScene_lockWrite_2 = Module['_emscripten_bind_PxScene_lockWrite_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_lockWrite_2');
var _emscripten_bind_PxScene_unlockWrite_0 = Module['_emscripten_bind_PxScene_unlockWrite_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_unlockWrite_0');
var _emscripten_bind_PxScene_setNbContactDataBlocks_1 = Module['_emscripten_bind_PxScene_setNbContactDataBlocks_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setNbContactDataBlocks_1');
var _emscripten_bind_PxScene_getNbContactDataBlocksUsed_0 = Module['_emscripten_bind_PxScene_getNbContactDataBlocksUsed_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getNbContactDataBlocksUsed_0');
var _emscripten_bind_PxScene_getMaxNbContactDataBlocksUsed_0 = Module['_emscripten_bind_PxScene_getMaxNbContactDataBlocksUsed_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getMaxNbContactDataBlocksUsed_0');
var _emscripten_bind_PxScene_getContactReportStreamBufferSize_0 = Module['_emscripten_bind_PxScene_getContactReportStreamBufferSize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getContactReportStreamBufferSize_0');
var _emscripten_bind_PxScene_setSolverBatchSize_1 = Module['_emscripten_bind_PxScene_setSolverBatchSize_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setSolverBatchSize_1');
var _emscripten_bind_PxScene_getSolverBatchSize_0 = Module['_emscripten_bind_PxScene_getSolverBatchSize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getSolverBatchSize_0');
var _emscripten_bind_PxScene_setSolverArticulationBatchSize_1 = Module['_emscripten_bind_PxScene_setSolverArticulationBatchSize_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setSolverArticulationBatchSize_1');
var _emscripten_bind_PxScene_getSolverArticulationBatchSize_0 = Module['_emscripten_bind_PxScene_getSolverArticulationBatchSize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getSolverArticulationBatchSize_0');
var _emscripten_bind_PxScene_release_0 = Module['_emscripten_bind_PxScene_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_release_0');
var _emscripten_bind_PxScene_setFlag_2 = Module['_emscripten_bind_PxScene_setFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setFlag_2');
var _emscripten_bind_PxScene_getFlags_0 = Module['_emscripten_bind_PxScene_getFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getFlags_0');
var _emscripten_bind_PxScene_setLimits_1 = Module['_emscripten_bind_PxScene_setLimits_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setLimits_1');
var _emscripten_bind_PxScene_getLimits_0 = Module['_emscripten_bind_PxScene_getLimits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getLimits_0');
var _emscripten_bind_PxScene_getPhysics_0 = Module['_emscripten_bind_PxScene_getPhysics_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getPhysics_0');
var _emscripten_bind_PxScene_getTimestamp_0 = Module['_emscripten_bind_PxScene_getTimestamp_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getTimestamp_0');
var _emscripten_bind_PxScene_getScenePvdClient_0 = Module['_emscripten_bind_PxScene_getScenePvdClient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getScenePvdClient_0');
var _emscripten_bind_PxScene_setDynamicTreeRebuildRateHint_1 = Module['_emscripten_bind_PxScene_setDynamicTreeRebuildRateHint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setDynamicTreeRebuildRateHint_1');
var _emscripten_bind_PxScene_getDynamicTreeRebuildRateHint_0 = Module['_emscripten_bind_PxScene_getDynamicTreeRebuildRateHint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getDynamicTreeRebuildRateHint_0');
var _emscripten_bind_PxScene_forceRebuildDynamicTree_1 = Module['_emscripten_bind_PxScene_forceRebuildDynamicTree_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_forceRebuildDynamicTree_1');
var _emscripten_bind_PxScene_setUpdateMode_1 = Module['_emscripten_bind_PxScene_setUpdateMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setUpdateMode_1');
var _emscripten_bind_PxScene_getUpdateMode_0 = Module['_emscripten_bind_PxScene_getUpdateMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getUpdateMode_0');
var _emscripten_bind_PxScene_getStaticTimestamp_0 = Module['_emscripten_bind_PxScene_getStaticTimestamp_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getStaticTimestamp_0');
var _emscripten_bind_PxScene_flushUpdates_0 = Module['_emscripten_bind_PxScene_flushUpdates_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_flushUpdates_0');
var _emscripten_bind_PxScene_raycast_4 = Module['_emscripten_bind_PxScene_raycast_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_raycast_4');
var _emscripten_bind_PxScene_raycast_5 = Module['_emscripten_bind_PxScene_raycast_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_raycast_5');
var _emscripten_bind_PxScene_raycast_6 = Module['_emscripten_bind_PxScene_raycast_6'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_raycast_6');
var _emscripten_bind_PxScene_sweep_5 = Module['_emscripten_bind_PxScene_sweep_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_sweep_5');
var _emscripten_bind_PxScene_sweep_6 = Module['_emscripten_bind_PxScene_sweep_6'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_sweep_6');
var _emscripten_bind_PxScene_sweep_7 = Module['_emscripten_bind_PxScene_sweep_7'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_sweep_7');
var _emscripten_bind_PxScene_overlap_3 = Module['_emscripten_bind_PxScene_overlap_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_overlap_3');
var _emscripten_bind_PxScene_overlap_4 = Module['_emscripten_bind_PxScene_overlap_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_overlap_4');
var _emscripten_bind_PxScene_setSceneQueryUpdateMode_1 = Module['_emscripten_bind_PxScene_setSceneQueryUpdateMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_setSceneQueryUpdateMode_1');
var _emscripten_bind_PxScene_getSceneQueryUpdateMode_0 = Module['_emscripten_bind_PxScene_getSceneQueryUpdateMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getSceneQueryUpdateMode_0');
var _emscripten_bind_PxScene_getSceneQueryStaticTimestamp_0 = Module['_emscripten_bind_PxScene_getSceneQueryStaticTimestamp_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getSceneQueryStaticTimestamp_0');
var _emscripten_bind_PxScene_flushQueryUpdates_0 = Module['_emscripten_bind_PxScene_flushQueryUpdates_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_flushQueryUpdates_0');
var _emscripten_bind_PxScene_forceDynamicTreeRebuild_2 = Module['_emscripten_bind_PxScene_forceDynamicTreeRebuild_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_forceDynamicTreeRebuild_2');
var _emscripten_bind_PxScene_getStaticStructure_0 = Module['_emscripten_bind_PxScene_getStaticStructure_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getStaticStructure_0');
var _emscripten_bind_PxScene_getDynamicStructure_0 = Module['_emscripten_bind_PxScene_getDynamicStructure_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_getDynamicStructure_0');
var _emscripten_bind_PxScene_sceneQueriesUpdate_0 = Module['_emscripten_bind_PxScene_sceneQueriesUpdate_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_sceneQueriesUpdate_0');
var _emscripten_bind_PxScene_sceneQueriesUpdate_1 = Module['_emscripten_bind_PxScene_sceneQueriesUpdate_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_sceneQueriesUpdate_1');
var _emscripten_bind_PxScene_sceneQueriesUpdate_2 = Module['_emscripten_bind_PxScene_sceneQueriesUpdate_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_sceneQueriesUpdate_2');
var _emscripten_bind_PxScene_checkQueries_0 = Module['_emscripten_bind_PxScene_checkQueries_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_checkQueries_0');
var _emscripten_bind_PxScene_checkQueries_1 = Module['_emscripten_bind_PxScene_checkQueries_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_checkQueries_1');
var _emscripten_bind_PxScene_fetchQueries_0 = Module['_emscripten_bind_PxScene_fetchQueries_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_fetchQueries_0');
var _emscripten_bind_PxScene_fetchQueries_1 = Module['_emscripten_bind_PxScene_fetchQueries_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_fetchQueries_1');
var _emscripten_bind_PxScene_get_userData_0 = Module['_emscripten_bind_PxScene_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_get_userData_0');
var _emscripten_bind_PxScene_set_userData_1 = Module['_emscripten_bind_PxScene_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxScene_set_userData_1');
var _emscripten_bind_PxSceneDesc_PxSceneDesc_1 = Module['_emscripten_bind_PxSceneDesc_PxSceneDesc_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_PxSceneDesc_1');
var _emscripten_bind_PxSceneDesc_setToDefault_1 = Module['_emscripten_bind_PxSceneDesc_setToDefault_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_setToDefault_1');
var _emscripten_bind_PxSceneDesc_isValid_0 = Module['_emscripten_bind_PxSceneDesc_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_isValid_0');
var _emscripten_bind_PxSceneDesc_get_gravity_0 = Module['_emscripten_bind_PxSceneDesc_get_gravity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_gravity_0');
var _emscripten_bind_PxSceneDesc_set_gravity_1 = Module['_emscripten_bind_PxSceneDesc_set_gravity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_gravity_1');
var _emscripten_bind_PxSceneDesc_get_simulationEventCallback_0 = Module['_emscripten_bind_PxSceneDesc_get_simulationEventCallback_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_simulationEventCallback_0');
var _emscripten_bind_PxSceneDesc_set_simulationEventCallback_1 = Module['_emscripten_bind_PxSceneDesc_set_simulationEventCallback_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_simulationEventCallback_1');
var _emscripten_bind_PxSceneDesc_get_filterShaderData_0 = Module['_emscripten_bind_PxSceneDesc_get_filterShaderData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_filterShaderData_0');
var _emscripten_bind_PxSceneDesc_set_filterShaderData_1 = Module['_emscripten_bind_PxSceneDesc_set_filterShaderData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_filterShaderData_1');
var _emscripten_bind_PxSceneDesc_get_filterShaderDataSize_0 = Module['_emscripten_bind_PxSceneDesc_get_filterShaderDataSize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_filterShaderDataSize_0');
var _emscripten_bind_PxSceneDesc_set_filterShaderDataSize_1 = Module['_emscripten_bind_PxSceneDesc_set_filterShaderDataSize_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_filterShaderDataSize_1');
var _emscripten_bind_PxSceneDesc_get_filterShader_0 = Module['_emscripten_bind_PxSceneDesc_get_filterShader_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_filterShader_0');
var _emscripten_bind_PxSceneDesc_set_filterShader_1 = Module['_emscripten_bind_PxSceneDesc_set_filterShader_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_filterShader_1');
var _emscripten_bind_PxSceneDesc_get_kineKineFilteringMode_0 = Module['_emscripten_bind_PxSceneDesc_get_kineKineFilteringMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_kineKineFilteringMode_0');
var _emscripten_bind_PxSceneDesc_set_kineKineFilteringMode_1 = Module['_emscripten_bind_PxSceneDesc_set_kineKineFilteringMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_kineKineFilteringMode_1');
var _emscripten_bind_PxSceneDesc_get_staticKineFilteringMode_0 = Module['_emscripten_bind_PxSceneDesc_get_staticKineFilteringMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_staticKineFilteringMode_0');
var _emscripten_bind_PxSceneDesc_set_staticKineFilteringMode_1 = Module['_emscripten_bind_PxSceneDesc_set_staticKineFilteringMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_staticKineFilteringMode_1');
var _emscripten_bind_PxSceneDesc_get_broadPhaseType_0 = Module['_emscripten_bind_PxSceneDesc_get_broadPhaseType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_broadPhaseType_0');
var _emscripten_bind_PxSceneDesc_set_broadPhaseType_1 = Module['_emscripten_bind_PxSceneDesc_set_broadPhaseType_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_broadPhaseType_1');
var _emscripten_bind_PxSceneDesc_get_limits_0 = Module['_emscripten_bind_PxSceneDesc_get_limits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_limits_0');
var _emscripten_bind_PxSceneDesc_set_limits_1 = Module['_emscripten_bind_PxSceneDesc_set_limits_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_limits_1');
var _emscripten_bind_PxSceneDesc_get_frictionType_0 = Module['_emscripten_bind_PxSceneDesc_get_frictionType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_frictionType_0');
var _emscripten_bind_PxSceneDesc_set_frictionType_1 = Module['_emscripten_bind_PxSceneDesc_set_frictionType_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_frictionType_1');
var _emscripten_bind_PxSceneDesc_get_solverType_0 = Module['_emscripten_bind_PxSceneDesc_get_solverType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_solverType_0');
var _emscripten_bind_PxSceneDesc_set_solverType_1 = Module['_emscripten_bind_PxSceneDesc_set_solverType_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_solverType_1');
var _emscripten_bind_PxSceneDesc_get_bounceThresholdVelocity_0 = Module['_emscripten_bind_PxSceneDesc_get_bounceThresholdVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_bounceThresholdVelocity_0');
var _emscripten_bind_PxSceneDesc_set_bounceThresholdVelocity_1 = Module['_emscripten_bind_PxSceneDesc_set_bounceThresholdVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_bounceThresholdVelocity_1');
var _emscripten_bind_PxSceneDesc_get_frictionOffsetThreshold_0 = Module['_emscripten_bind_PxSceneDesc_get_frictionOffsetThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_frictionOffsetThreshold_0');
var _emscripten_bind_PxSceneDesc_set_frictionOffsetThreshold_1 = Module['_emscripten_bind_PxSceneDesc_set_frictionOffsetThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_frictionOffsetThreshold_1');
var _emscripten_bind_PxSceneDesc_get_frictionCorrelationDistance_0 = Module['_emscripten_bind_PxSceneDesc_get_frictionCorrelationDistance_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_frictionCorrelationDistance_0');
var _emscripten_bind_PxSceneDesc_set_frictionCorrelationDistance_1 = Module['_emscripten_bind_PxSceneDesc_set_frictionCorrelationDistance_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_frictionCorrelationDistance_1');
var _emscripten_bind_PxSceneDesc_get_flags_0 = Module['_emscripten_bind_PxSceneDesc_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_flags_0');
var _emscripten_bind_PxSceneDesc_set_flags_1 = Module['_emscripten_bind_PxSceneDesc_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_flags_1');
var _emscripten_bind_PxSceneDesc_get_cpuDispatcher_0 = Module['_emscripten_bind_PxSceneDesc_get_cpuDispatcher_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_cpuDispatcher_0');
var _emscripten_bind_PxSceneDesc_set_cpuDispatcher_1 = Module['_emscripten_bind_PxSceneDesc_set_cpuDispatcher_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_cpuDispatcher_1');
var _emscripten_bind_PxSceneDesc_get_userData_0 = Module['_emscripten_bind_PxSceneDesc_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_userData_0');
var _emscripten_bind_PxSceneDesc_set_userData_1 = Module['_emscripten_bind_PxSceneDesc_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_userData_1');
var _emscripten_bind_PxSceneDesc_get_solverBatchSize_0 = Module['_emscripten_bind_PxSceneDesc_get_solverBatchSize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_solverBatchSize_0');
var _emscripten_bind_PxSceneDesc_set_solverBatchSize_1 = Module['_emscripten_bind_PxSceneDesc_set_solverBatchSize_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_solverBatchSize_1');
var _emscripten_bind_PxSceneDesc_get_solverArticulationBatchSize_0 = Module['_emscripten_bind_PxSceneDesc_get_solverArticulationBatchSize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_solverArticulationBatchSize_0');
var _emscripten_bind_PxSceneDesc_set_solverArticulationBatchSize_1 = Module['_emscripten_bind_PxSceneDesc_set_solverArticulationBatchSize_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_solverArticulationBatchSize_1');
var _emscripten_bind_PxSceneDesc_get_nbContactDataBlocks_0 = Module['_emscripten_bind_PxSceneDesc_get_nbContactDataBlocks_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_nbContactDataBlocks_0');
var _emscripten_bind_PxSceneDesc_set_nbContactDataBlocks_1 = Module['_emscripten_bind_PxSceneDesc_set_nbContactDataBlocks_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_nbContactDataBlocks_1');
var _emscripten_bind_PxSceneDesc_get_maxNbContactDataBlocks_0 = Module['_emscripten_bind_PxSceneDesc_get_maxNbContactDataBlocks_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_maxNbContactDataBlocks_0');
var _emscripten_bind_PxSceneDesc_set_maxNbContactDataBlocks_1 = Module['_emscripten_bind_PxSceneDesc_set_maxNbContactDataBlocks_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_maxNbContactDataBlocks_1');
var _emscripten_bind_PxSceneDesc_get_maxBiasCoefficient_0 = Module['_emscripten_bind_PxSceneDesc_get_maxBiasCoefficient_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_maxBiasCoefficient_0');
var _emscripten_bind_PxSceneDesc_set_maxBiasCoefficient_1 = Module['_emscripten_bind_PxSceneDesc_set_maxBiasCoefficient_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_maxBiasCoefficient_1');
var _emscripten_bind_PxSceneDesc_get_contactReportStreamBufferSize_0 = Module['_emscripten_bind_PxSceneDesc_get_contactReportStreamBufferSize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_contactReportStreamBufferSize_0');
var _emscripten_bind_PxSceneDesc_set_contactReportStreamBufferSize_1 = Module['_emscripten_bind_PxSceneDesc_set_contactReportStreamBufferSize_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_contactReportStreamBufferSize_1');
var _emscripten_bind_PxSceneDesc_get_ccdMaxPasses_0 = Module['_emscripten_bind_PxSceneDesc_get_ccdMaxPasses_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_ccdMaxPasses_0');
var _emscripten_bind_PxSceneDesc_set_ccdMaxPasses_1 = Module['_emscripten_bind_PxSceneDesc_set_ccdMaxPasses_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_ccdMaxPasses_1');
var _emscripten_bind_PxSceneDesc_get_ccdThreshold_0 = Module['_emscripten_bind_PxSceneDesc_get_ccdThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_ccdThreshold_0');
var _emscripten_bind_PxSceneDesc_set_ccdThreshold_1 = Module['_emscripten_bind_PxSceneDesc_set_ccdThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_ccdThreshold_1');
var _emscripten_bind_PxSceneDesc_get_ccdMaxSeparation_0 = Module['_emscripten_bind_PxSceneDesc_get_ccdMaxSeparation_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_ccdMaxSeparation_0');
var _emscripten_bind_PxSceneDesc_set_ccdMaxSeparation_1 = Module['_emscripten_bind_PxSceneDesc_set_ccdMaxSeparation_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_ccdMaxSeparation_1');
var _emscripten_bind_PxSceneDesc_get_wakeCounterResetValue_0 = Module['_emscripten_bind_PxSceneDesc_get_wakeCounterResetValue_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_wakeCounterResetValue_0');
var _emscripten_bind_PxSceneDesc_set_wakeCounterResetValue_1 = Module['_emscripten_bind_PxSceneDesc_set_wakeCounterResetValue_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_wakeCounterResetValue_1');
var _emscripten_bind_PxSceneDesc_get_sanityBounds_0 = Module['_emscripten_bind_PxSceneDesc_get_sanityBounds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_sanityBounds_0');
var _emscripten_bind_PxSceneDesc_set_sanityBounds_1 = Module['_emscripten_bind_PxSceneDesc_set_sanityBounds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_sanityBounds_1');
var _emscripten_bind_PxSceneDesc_get_gpuMaxNumPartitions_0 = Module['_emscripten_bind_PxSceneDesc_get_gpuMaxNumPartitions_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_gpuMaxNumPartitions_0');
var _emscripten_bind_PxSceneDesc_set_gpuMaxNumPartitions_1 = Module['_emscripten_bind_PxSceneDesc_set_gpuMaxNumPartitions_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_gpuMaxNumPartitions_1');
var _emscripten_bind_PxSceneDesc_get_gpuMaxNumStaticPartitions_0 = Module['_emscripten_bind_PxSceneDesc_get_gpuMaxNumStaticPartitions_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_gpuMaxNumStaticPartitions_0');
var _emscripten_bind_PxSceneDesc_set_gpuMaxNumStaticPartitions_1 = Module['_emscripten_bind_PxSceneDesc_set_gpuMaxNumStaticPartitions_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_gpuMaxNumStaticPartitions_1');
var _emscripten_bind_PxSceneDesc_get_gpuComputeVersion_0 = Module['_emscripten_bind_PxSceneDesc_get_gpuComputeVersion_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_gpuComputeVersion_0');
var _emscripten_bind_PxSceneDesc_set_gpuComputeVersion_1 = Module['_emscripten_bind_PxSceneDesc_set_gpuComputeVersion_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_gpuComputeVersion_1');
var _emscripten_bind_PxSceneDesc_get_contactPairSlabSize_0 = Module['_emscripten_bind_PxSceneDesc_get_contactPairSlabSize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_contactPairSlabSize_0');
var _emscripten_bind_PxSceneDesc_set_contactPairSlabSize_1 = Module['_emscripten_bind_PxSceneDesc_set_contactPairSlabSize_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_contactPairSlabSize_1');
var _emscripten_bind_PxSceneDesc_get_staticStructure_0 = Module['_emscripten_bind_PxSceneDesc_get_staticStructure_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_staticStructure_0');
var _emscripten_bind_PxSceneDesc_set_staticStructure_1 = Module['_emscripten_bind_PxSceneDesc_set_staticStructure_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_staticStructure_1');
var _emscripten_bind_PxSceneDesc_get_dynamicStructure_0 = Module['_emscripten_bind_PxSceneDesc_get_dynamicStructure_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_dynamicStructure_0');
var _emscripten_bind_PxSceneDesc_set_dynamicStructure_1 = Module['_emscripten_bind_PxSceneDesc_set_dynamicStructure_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_dynamicStructure_1');
var _emscripten_bind_PxSceneDesc_get_dynamicTreeRebuildRateHint_0 = Module['_emscripten_bind_PxSceneDesc_get_dynamicTreeRebuildRateHint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_dynamicTreeRebuildRateHint_0');
var _emscripten_bind_PxSceneDesc_set_dynamicTreeRebuildRateHint_1 = Module['_emscripten_bind_PxSceneDesc_set_dynamicTreeRebuildRateHint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_dynamicTreeRebuildRateHint_1');
var _emscripten_bind_PxSceneDesc_get_dynamicTreeSecondaryPruner_0 = Module['_emscripten_bind_PxSceneDesc_get_dynamicTreeSecondaryPruner_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_dynamicTreeSecondaryPruner_0');
var _emscripten_bind_PxSceneDesc_set_dynamicTreeSecondaryPruner_1 = Module['_emscripten_bind_PxSceneDesc_set_dynamicTreeSecondaryPruner_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_dynamicTreeSecondaryPruner_1');
var _emscripten_bind_PxSceneDesc_get_staticBVHBuildStrategy_0 = Module['_emscripten_bind_PxSceneDesc_get_staticBVHBuildStrategy_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_staticBVHBuildStrategy_0');
var _emscripten_bind_PxSceneDesc_set_staticBVHBuildStrategy_1 = Module['_emscripten_bind_PxSceneDesc_set_staticBVHBuildStrategy_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_staticBVHBuildStrategy_1');
var _emscripten_bind_PxSceneDesc_get_dynamicBVHBuildStrategy_0 = Module['_emscripten_bind_PxSceneDesc_get_dynamicBVHBuildStrategy_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_dynamicBVHBuildStrategy_0');
var _emscripten_bind_PxSceneDesc_set_dynamicBVHBuildStrategy_1 = Module['_emscripten_bind_PxSceneDesc_set_dynamicBVHBuildStrategy_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_dynamicBVHBuildStrategy_1');
var _emscripten_bind_PxSceneDesc_get_staticNbObjectsPerNode_0 = Module['_emscripten_bind_PxSceneDesc_get_staticNbObjectsPerNode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_staticNbObjectsPerNode_0');
var _emscripten_bind_PxSceneDesc_set_staticNbObjectsPerNode_1 = Module['_emscripten_bind_PxSceneDesc_set_staticNbObjectsPerNode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_staticNbObjectsPerNode_1');
var _emscripten_bind_PxSceneDesc_get_dynamicNbObjectsPerNode_0 = Module['_emscripten_bind_PxSceneDesc_get_dynamicNbObjectsPerNode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_dynamicNbObjectsPerNode_0');
var _emscripten_bind_PxSceneDesc_set_dynamicNbObjectsPerNode_1 = Module['_emscripten_bind_PxSceneDesc_set_dynamicNbObjectsPerNode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_dynamicNbObjectsPerNode_1');
var _emscripten_bind_PxSceneDesc_get_sceneQueryUpdateMode_0 = Module['_emscripten_bind_PxSceneDesc_get_sceneQueryUpdateMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_get_sceneQueryUpdateMode_0');
var _emscripten_bind_PxSceneDesc_set_sceneQueryUpdateMode_1 = Module['_emscripten_bind_PxSceneDesc_set_sceneQueryUpdateMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc_set_sceneQueryUpdateMode_1');
var _emscripten_bind_PxSceneDesc___destroy___0 = Module['_emscripten_bind_PxSceneDesc___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneDesc___destroy___0');
var _emscripten_bind_PxSceneFlags_PxSceneFlags_1 = Module['_emscripten_bind_PxSceneFlags_PxSceneFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneFlags_PxSceneFlags_1');
var _emscripten_bind_PxSceneFlags_isSet_1 = Module['_emscripten_bind_PxSceneFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneFlags_isSet_1');
var _emscripten_bind_PxSceneFlags_raise_1 = Module['_emscripten_bind_PxSceneFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneFlags_raise_1');
var _emscripten_bind_PxSceneFlags_clear_1 = Module['_emscripten_bind_PxSceneFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneFlags_clear_1');
var _emscripten_bind_PxSceneFlags___destroy___0 = Module['_emscripten_bind_PxSceneFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneFlags___destroy___0');
var _emscripten_bind_PxSceneLimits_PxSceneLimits_0 = Module['_emscripten_bind_PxSceneLimits_PxSceneLimits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_PxSceneLimits_0');
var _emscripten_bind_PxSceneLimits_setToDefault_0 = Module['_emscripten_bind_PxSceneLimits_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_setToDefault_0');
var _emscripten_bind_PxSceneLimits_isValid_0 = Module['_emscripten_bind_PxSceneLimits_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_isValid_0');
var _emscripten_bind_PxSceneLimits_get_maxNbActors_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbActors_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_get_maxNbActors_0');
var _emscripten_bind_PxSceneLimits_set_maxNbActors_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbActors_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_set_maxNbActors_1');
var _emscripten_bind_PxSceneLimits_get_maxNbBodies_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbBodies_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_get_maxNbBodies_0');
var _emscripten_bind_PxSceneLimits_set_maxNbBodies_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbBodies_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_set_maxNbBodies_1');
var _emscripten_bind_PxSceneLimits_get_maxNbStaticShapes_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbStaticShapes_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_get_maxNbStaticShapes_0');
var _emscripten_bind_PxSceneLimits_set_maxNbStaticShapes_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbStaticShapes_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_set_maxNbStaticShapes_1');
var _emscripten_bind_PxSceneLimits_get_maxNbDynamicShapes_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbDynamicShapes_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_get_maxNbDynamicShapes_0');
var _emscripten_bind_PxSceneLimits_set_maxNbDynamicShapes_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbDynamicShapes_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_set_maxNbDynamicShapes_1');
var _emscripten_bind_PxSceneLimits_get_maxNbAggregates_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbAggregates_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_get_maxNbAggregates_0');
var _emscripten_bind_PxSceneLimits_set_maxNbAggregates_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbAggregates_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_set_maxNbAggregates_1');
var _emscripten_bind_PxSceneLimits_get_maxNbConstraints_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbConstraints_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_get_maxNbConstraints_0');
var _emscripten_bind_PxSceneLimits_set_maxNbConstraints_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbConstraints_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_set_maxNbConstraints_1');
var _emscripten_bind_PxSceneLimits_get_maxNbRegions_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbRegions_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_get_maxNbRegions_0');
var _emscripten_bind_PxSceneLimits_set_maxNbRegions_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbRegions_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_set_maxNbRegions_1');
var _emscripten_bind_PxSceneLimits_get_maxNbBroadPhaseOverlaps_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbBroadPhaseOverlaps_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_get_maxNbBroadPhaseOverlaps_0');
var _emscripten_bind_PxSceneLimits_set_maxNbBroadPhaseOverlaps_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbBroadPhaseOverlaps_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits_set_maxNbBroadPhaseOverlaps_1');
var _emscripten_bind_PxSceneLimits___destroy___0 = Module['_emscripten_bind_PxSceneLimits___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSceneLimits___destroy___0');
var _emscripten_bind_PxSerialization_isSerializable_2 = Module['_emscripten_bind_PxSerialization_isSerializable_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_isSerializable_2');
var _emscripten_bind_PxSerialization_isSerializable_3 = Module['_emscripten_bind_PxSerialization_isSerializable_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_isSerializable_3');
var _emscripten_bind_PxSerialization_complete_2 = Module['_emscripten_bind_PxSerialization_complete_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_complete_2');
var _emscripten_bind_PxSerialization_complete_3 = Module['_emscripten_bind_PxSerialization_complete_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_complete_3');
var _emscripten_bind_PxSerialization_complete_4 = Module['_emscripten_bind_PxSerialization_complete_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_complete_4');
var _emscripten_bind_PxSerialization_createSerialObjectIds_2 = Module['_emscripten_bind_PxSerialization_createSerialObjectIds_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_createSerialObjectIds_2');
var _emscripten_bind_PxSerialization_createCollectionFromXml_3 = Module['_emscripten_bind_PxSerialization_createCollectionFromXml_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_createCollectionFromXml_3');
var _emscripten_bind_PxSerialization_createCollectionFromXml_4 = Module['_emscripten_bind_PxSerialization_createCollectionFromXml_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_createCollectionFromXml_4');
var _emscripten_bind_PxSerialization_createCollectionFromBinary_2 = Module['_emscripten_bind_PxSerialization_createCollectionFromBinary_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_createCollectionFromBinary_2');
var _emscripten_bind_PxSerialization_createCollectionFromBinary_3 = Module['_emscripten_bind_PxSerialization_createCollectionFromBinary_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_createCollectionFromBinary_3');
var _emscripten_bind_PxSerialization_serializeCollectionToXml_3 = Module['_emscripten_bind_PxSerialization_serializeCollectionToXml_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_serializeCollectionToXml_3');
var _emscripten_bind_PxSerialization_serializeCollectionToXml_4 = Module['_emscripten_bind_PxSerialization_serializeCollectionToXml_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_serializeCollectionToXml_4');
var _emscripten_bind_PxSerialization_serializeCollectionToXml_5 = Module['_emscripten_bind_PxSerialization_serializeCollectionToXml_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_serializeCollectionToXml_5');
var _emscripten_bind_PxSerialization_serializeCollectionToBinary_3 = Module['_emscripten_bind_PxSerialization_serializeCollectionToBinary_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_serializeCollectionToBinary_3');
var _emscripten_bind_PxSerialization_serializeCollectionToBinary_4 = Module['_emscripten_bind_PxSerialization_serializeCollectionToBinary_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_serializeCollectionToBinary_4');
var _emscripten_bind_PxSerialization_serializeCollectionToBinary_5 = Module['_emscripten_bind_PxSerialization_serializeCollectionToBinary_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_serializeCollectionToBinary_5');
var _emscripten_bind_PxSerialization_createSerializationRegistry_1 = Module['_emscripten_bind_PxSerialization_createSerializationRegistry_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization_createSerializationRegistry_1');
var _emscripten_bind_PxSerialization___destroy___0 = Module['_emscripten_bind_PxSerialization___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerialization___destroy___0');
var _emscripten_bind_PxSerializationRegistry_release_0 = Module['_emscripten_bind_PxSerializationRegistry_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSerializationRegistry_release_0');
var _emscripten_bind_PxShape_setGeometry_1 = Module['_emscripten_bind_PxShape_setGeometry_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_setGeometry_1');
var _emscripten_bind_PxShape_getGeometry_0 = Module['_emscripten_bind_PxShape_getGeometry_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getGeometry_0');
var _emscripten_bind_PxShape_getActor_0 = Module['_emscripten_bind_PxShape_getActor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getActor_0');
var _emscripten_bind_PxShape_setMaterials_2 = Module['_emscripten_bind_PxShape_setMaterials_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_setMaterials_2');
var _emscripten_bind_PxShape_getNbMaterials_0 = Module['_emscripten_bind_PxShape_getNbMaterials_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getNbMaterials_0');
var _emscripten_bind_PxShape_getMaterials_3 = Module['_emscripten_bind_PxShape_getMaterials_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getMaterials_3');
var _emscripten_bind_PxShape_getMaterialFromInternalFaceIndex_1 = Module['_emscripten_bind_PxShape_getMaterialFromInternalFaceIndex_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getMaterialFromInternalFaceIndex_1');
var _emscripten_bind_PxShape_setContactOffset_1 = Module['_emscripten_bind_PxShape_setContactOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_setContactOffset_1');
var _emscripten_bind_PxShape_getContactOffset_0 = Module['_emscripten_bind_PxShape_getContactOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getContactOffset_0');
var _emscripten_bind_PxShape_setRestOffset_1 = Module['_emscripten_bind_PxShape_setRestOffset_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_setRestOffset_1');
var _emscripten_bind_PxShape_getRestOffset_0 = Module['_emscripten_bind_PxShape_getRestOffset_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getRestOffset_0');
var _emscripten_bind_PxShape_setTorsionalPatchRadius_1 = Module['_emscripten_bind_PxShape_setTorsionalPatchRadius_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_setTorsionalPatchRadius_1');
var _emscripten_bind_PxShape_getTorsionalPatchRadius_0 = Module['_emscripten_bind_PxShape_getTorsionalPatchRadius_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getTorsionalPatchRadius_0');
var _emscripten_bind_PxShape_setMinTorsionalPatchRadius_1 = Module['_emscripten_bind_PxShape_setMinTorsionalPatchRadius_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_setMinTorsionalPatchRadius_1');
var _emscripten_bind_PxShape_getMinTorsionalPatchRadius_0 = Module['_emscripten_bind_PxShape_getMinTorsionalPatchRadius_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getMinTorsionalPatchRadius_0');
var _emscripten_bind_PxShape_setFlag_2 = Module['_emscripten_bind_PxShape_setFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_setFlag_2');
var _emscripten_bind_PxShape_setFlags_1 = Module['_emscripten_bind_PxShape_setFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_setFlags_1');
var _emscripten_bind_PxShape_getFlags_0 = Module['_emscripten_bind_PxShape_getFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getFlags_0');
var _emscripten_bind_PxShape_isExclusive_0 = Module['_emscripten_bind_PxShape_isExclusive_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_isExclusive_0');
var _emscripten_bind_PxShape_setName_1 = Module['_emscripten_bind_PxShape_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_setName_1');
var _emscripten_bind_PxShape_getName_0 = Module['_emscripten_bind_PxShape_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getName_0');
var _emscripten_bind_PxShape_setLocalPose_1 = Module['_emscripten_bind_PxShape_setLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_setLocalPose_1');
var _emscripten_bind_PxShape_getLocalPose_0 = Module['_emscripten_bind_PxShape_getLocalPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getLocalPose_0');
var _emscripten_bind_PxShape_setSimulationFilterData_1 = Module['_emscripten_bind_PxShape_setSimulationFilterData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_setSimulationFilterData_1');
var _emscripten_bind_PxShape_getSimulationFilterData_0 = Module['_emscripten_bind_PxShape_getSimulationFilterData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getSimulationFilterData_0');
var _emscripten_bind_PxShape_setQueryFilterData_1 = Module['_emscripten_bind_PxShape_setQueryFilterData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_setQueryFilterData_1');
var _emscripten_bind_PxShape_getQueryFilterData_0 = Module['_emscripten_bind_PxShape_getQueryFilterData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getQueryFilterData_0');
var _emscripten_bind_PxShape_release_0 = Module['_emscripten_bind_PxShape_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_release_0');
var _emscripten_bind_PxShape_getConcreteTypeName_0 = Module['_emscripten_bind_PxShape_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getConcreteTypeName_0');
var _emscripten_bind_PxShape_getConcreteType_0 = Module['_emscripten_bind_PxShape_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getConcreteType_0');
var _emscripten_bind_PxShape_setBaseFlag_2 = Module['_emscripten_bind_PxShape_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_setBaseFlag_2');
var _emscripten_bind_PxShape_setBaseFlags_1 = Module['_emscripten_bind_PxShape_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_setBaseFlags_1');
var _emscripten_bind_PxShape_getBaseFlags_0 = Module['_emscripten_bind_PxShape_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getBaseFlags_0');
var _emscripten_bind_PxShape_isReleasable_0 = Module['_emscripten_bind_PxShape_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_isReleasable_0');
var _emscripten_bind_PxShape_getReferenceCount_0 = Module['_emscripten_bind_PxShape_getReferenceCount_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_getReferenceCount_0');
var _emscripten_bind_PxShape_acquireReference_0 = Module['_emscripten_bind_PxShape_acquireReference_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_acquireReference_0');
var _emscripten_bind_PxShape_get_userData_0 = Module['_emscripten_bind_PxShape_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_get_userData_0');
var _emscripten_bind_PxShape_set_userData_1 = Module['_emscripten_bind_PxShape_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShape_set_userData_1');
var _emscripten_bind_PxShapeExt_getGlobalPose_2 = Module['_emscripten_bind_PxShapeExt_getGlobalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxShapeExt_getGlobalPose_2');
var _emscripten_bind_PxShapeExt_raycast_8 = Module['_emscripten_bind_PxShapeExt_raycast_8'] = makeInvalidEarlyAccess('_emscripten_bind_PxShapeExt_raycast_8');
var _emscripten_bind_PxShapeExt_overlap_4 = Module['_emscripten_bind_PxShapeExt_overlap_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxShapeExt_overlap_4');
var _emscripten_bind_PxShapeExt_sweep_8 = Module['_emscripten_bind_PxShapeExt_sweep_8'] = makeInvalidEarlyAccess('_emscripten_bind_PxShapeExt_sweep_8');
var _emscripten_bind_PxShapeExt_getWorldBounds_2 = Module['_emscripten_bind_PxShapeExt_getWorldBounds_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxShapeExt_getWorldBounds_2');
var _emscripten_bind_PxShapeExt_getWorldBounds_3 = Module['_emscripten_bind_PxShapeExt_getWorldBounds_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxShapeExt_getWorldBounds_3');
var _emscripten_bind_PxShapeExt___destroy___0 = Module['_emscripten_bind_PxShapeExt___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShapeExt___destroy___0');
var _emscripten_bind_PxShapeFlags_PxShapeFlags_1 = Module['_emscripten_bind_PxShapeFlags_PxShapeFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShapeFlags_PxShapeFlags_1');
var _emscripten_bind_PxShapeFlags_isSet_1 = Module['_emscripten_bind_PxShapeFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShapeFlags_isSet_1');
var _emscripten_bind_PxShapeFlags_raise_1 = Module['_emscripten_bind_PxShapeFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShapeFlags_raise_1');
var _emscripten_bind_PxShapeFlags_clear_1 = Module['_emscripten_bind_PxShapeFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxShapeFlags_clear_1');
var _emscripten_bind_PxShapeFlags___destroy___0 = Module['_emscripten_bind_PxShapeFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShapeFlags___destroy___0');
var _emscripten_bind_PxShapePtr___destroy___0 = Module['_emscripten_bind_PxShapePtr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxShapePtr___destroy___0');
var _emscripten_bind_PxSimulationEventCallbackImpl_PxSimulationEventCallbackImpl_0 = Module['_emscripten_bind_PxSimulationEventCallbackImpl_PxSimulationEventCallbackImpl_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationEventCallbackImpl_PxSimulationEventCallbackImpl_0');
var _emscripten_bind_PxSimulationEventCallbackImpl_onConstraintBreak_2 = Module['_emscripten_bind_PxSimulationEventCallbackImpl_onConstraintBreak_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationEventCallbackImpl_onConstraintBreak_2');
var _emscripten_bind_PxSimulationEventCallbackImpl_onWake_2 = Module['_emscripten_bind_PxSimulationEventCallbackImpl_onWake_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationEventCallbackImpl_onWake_2');
var _emscripten_bind_PxSimulationEventCallbackImpl_onSleep_2 = Module['_emscripten_bind_PxSimulationEventCallbackImpl_onSleep_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationEventCallbackImpl_onSleep_2');
var _emscripten_bind_PxSimulationEventCallbackImpl_onContact_3 = Module['_emscripten_bind_PxSimulationEventCallbackImpl_onContact_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationEventCallbackImpl_onContact_3');
var _emscripten_bind_PxSimulationEventCallbackImpl_onTrigger_2 = Module['_emscripten_bind_PxSimulationEventCallbackImpl_onTrigger_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationEventCallbackImpl_onTrigger_2');
var _emscripten_bind_PxSimulationEventCallbackImpl___destroy___0 = Module['_emscripten_bind_PxSimulationEventCallbackImpl___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationEventCallbackImpl___destroy___0');
var _emscripten_bind_PxSimulationStatistics_get_nbActiveConstraints_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbActiveConstraints_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbActiveConstraints_0');
var _emscripten_bind_PxSimulationStatistics_set_nbActiveConstraints_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbActiveConstraints_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbActiveConstraints_1');
var _emscripten_bind_PxSimulationStatistics_get_nbActiveDynamicBodies_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbActiveDynamicBodies_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbActiveDynamicBodies_0');
var _emscripten_bind_PxSimulationStatistics_set_nbActiveDynamicBodies_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbActiveDynamicBodies_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbActiveDynamicBodies_1');
var _emscripten_bind_PxSimulationStatistics_get_nbActiveKinematicBodies_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbActiveKinematicBodies_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbActiveKinematicBodies_0');
var _emscripten_bind_PxSimulationStatistics_set_nbActiveKinematicBodies_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbActiveKinematicBodies_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbActiveKinematicBodies_1');
var _emscripten_bind_PxSimulationStatistics_get_nbStaticBodies_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbStaticBodies_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbStaticBodies_0');
var _emscripten_bind_PxSimulationStatistics_set_nbStaticBodies_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbStaticBodies_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbStaticBodies_1');
var _emscripten_bind_PxSimulationStatistics_get_nbDynamicBodies_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbDynamicBodies_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbDynamicBodies_0');
var _emscripten_bind_PxSimulationStatistics_set_nbDynamicBodies_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbDynamicBodies_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbDynamicBodies_1');
var _emscripten_bind_PxSimulationStatistics_get_nbKinematicBodies_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbKinematicBodies_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbKinematicBodies_0');
var _emscripten_bind_PxSimulationStatistics_set_nbKinematicBodies_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbKinematicBodies_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbKinematicBodies_1');
var _emscripten_bind_PxSimulationStatistics_get_nbShapes_1 = Module['_emscripten_bind_PxSimulationStatistics_get_nbShapes_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbShapes_1');
var _emscripten_bind_PxSimulationStatistics_set_nbShapes_2 = Module['_emscripten_bind_PxSimulationStatistics_set_nbShapes_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbShapes_2');
var _emscripten_bind_PxSimulationStatistics_get_nbAggregates_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbAggregates_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbAggregates_0');
var _emscripten_bind_PxSimulationStatistics_set_nbAggregates_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbAggregates_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbAggregates_1');
var _emscripten_bind_PxSimulationStatistics_get_nbArticulations_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbArticulations_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbArticulations_0');
var _emscripten_bind_PxSimulationStatistics_set_nbArticulations_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbArticulations_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbArticulations_1');
var _emscripten_bind_PxSimulationStatistics_get_nbAxisSolverConstraints_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbAxisSolverConstraints_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbAxisSolverConstraints_0');
var _emscripten_bind_PxSimulationStatistics_set_nbAxisSolverConstraints_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbAxisSolverConstraints_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbAxisSolverConstraints_1');
var _emscripten_bind_PxSimulationStatistics_get_compressedContactSize_0 = Module['_emscripten_bind_PxSimulationStatistics_get_compressedContactSize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_compressedContactSize_0');
var _emscripten_bind_PxSimulationStatistics_set_compressedContactSize_1 = Module['_emscripten_bind_PxSimulationStatistics_set_compressedContactSize_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_compressedContactSize_1');
var _emscripten_bind_PxSimulationStatistics_get_requiredContactConstraintMemory_0 = Module['_emscripten_bind_PxSimulationStatistics_get_requiredContactConstraintMemory_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_requiredContactConstraintMemory_0');
var _emscripten_bind_PxSimulationStatistics_set_requiredContactConstraintMemory_1 = Module['_emscripten_bind_PxSimulationStatistics_set_requiredContactConstraintMemory_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_requiredContactConstraintMemory_1');
var _emscripten_bind_PxSimulationStatistics_get_peakConstraintMemory_0 = Module['_emscripten_bind_PxSimulationStatistics_get_peakConstraintMemory_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_peakConstraintMemory_0');
var _emscripten_bind_PxSimulationStatistics_set_peakConstraintMemory_1 = Module['_emscripten_bind_PxSimulationStatistics_set_peakConstraintMemory_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_peakConstraintMemory_1');
var _emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsTotal_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsTotal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsTotal_0');
var _emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsTotal_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsTotal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsTotal_1');
var _emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithCacheHits_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithCacheHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithCacheHits_0');
var _emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithCacheHits_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithCacheHits_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithCacheHits_1');
var _emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithContacts_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithContacts_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithContacts_0');
var _emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithContacts_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithContacts_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithContacts_1');
var _emscripten_bind_PxSimulationStatistics_get_nbNewPairs_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbNewPairs_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbNewPairs_0');
var _emscripten_bind_PxSimulationStatistics_set_nbNewPairs_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbNewPairs_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbNewPairs_1');
var _emscripten_bind_PxSimulationStatistics_get_nbLostPairs_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbLostPairs_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbLostPairs_0');
var _emscripten_bind_PxSimulationStatistics_set_nbLostPairs_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbLostPairs_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbLostPairs_1');
var _emscripten_bind_PxSimulationStatistics_get_nbNewTouches_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbNewTouches_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbNewTouches_0');
var _emscripten_bind_PxSimulationStatistics_set_nbNewTouches_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbNewTouches_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbNewTouches_1');
var _emscripten_bind_PxSimulationStatistics_get_nbLostTouches_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbLostTouches_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbLostTouches_0');
var _emscripten_bind_PxSimulationStatistics_set_nbLostTouches_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbLostTouches_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbLostTouches_1');
var _emscripten_bind_PxSimulationStatistics_get_nbPartitions_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbPartitions_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbPartitions_0');
var _emscripten_bind_PxSimulationStatistics_set_nbPartitions_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbPartitions_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbPartitions_1');
var _emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseAdds_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseAdds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseAdds_0');
var _emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseAdds_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseAdds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseAdds_1');
var _emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseRemoves_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseRemoves_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseRemoves_0');
var _emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseRemoves_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseRemoves_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseRemoves_1');
var _emscripten_bind_PxSimulationStatistics___destroy___0 = Module['_emscripten_bind_PxSimulationStatistics___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSimulationStatistics___destroy___0');
var _emscripten_bind_PxSpatialForce_get_force_0 = Module['_emscripten_bind_PxSpatialForce_get_force_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpatialForce_get_force_0');
var _emscripten_bind_PxSpatialForce_set_force_1 = Module['_emscripten_bind_PxSpatialForce_set_force_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpatialForce_set_force_1');
var _emscripten_bind_PxSpatialForce_get_torque_0 = Module['_emscripten_bind_PxSpatialForce_get_torque_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpatialForce_get_torque_0');
var _emscripten_bind_PxSpatialForce_set_torque_1 = Module['_emscripten_bind_PxSpatialForce_set_torque_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpatialForce_set_torque_1');
var _emscripten_bind_PxSpatialForce___destroy___0 = Module['_emscripten_bind_PxSpatialForce___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpatialForce___destroy___0');
var _emscripten_bind_PxSpatialVelocity_get_linear_0 = Module['_emscripten_bind_PxSpatialVelocity_get_linear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpatialVelocity_get_linear_0');
var _emscripten_bind_PxSpatialVelocity_set_linear_1 = Module['_emscripten_bind_PxSpatialVelocity_set_linear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpatialVelocity_set_linear_1');
var _emscripten_bind_PxSpatialVelocity_get_angular_0 = Module['_emscripten_bind_PxSpatialVelocity_get_angular_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpatialVelocity_get_angular_0');
var _emscripten_bind_PxSpatialVelocity_set_angular_1 = Module['_emscripten_bind_PxSpatialVelocity_set_angular_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpatialVelocity_set_angular_1');
var _emscripten_bind_PxSpatialVelocity___destroy___0 = Module['_emscripten_bind_PxSpatialVelocity___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSpatialVelocity___destroy___0');
var _emscripten_bind_PxSphereGeometry_PxSphereGeometry_1 = Module['_emscripten_bind_PxSphereGeometry_PxSphereGeometry_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphereGeometry_PxSphereGeometry_1');
var _emscripten_bind_PxSphereGeometry_getType_0 = Module['_emscripten_bind_PxSphereGeometry_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphereGeometry_getType_0');
var _emscripten_bind_PxSphereGeometry_get_radius_0 = Module['_emscripten_bind_PxSphereGeometry_get_radius_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphereGeometry_get_radius_0');
var _emscripten_bind_PxSphereGeometry_set_radius_1 = Module['_emscripten_bind_PxSphereGeometry_set_radius_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphereGeometry_set_radius_1');
var _emscripten_bind_PxSphereGeometry___destroy___0 = Module['_emscripten_bind_PxSphereGeometry___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphereGeometry___destroy___0');
var _emscripten_bind_PxSphericalJoint_setLimitCone_1 = Module['_emscripten_bind_PxSphericalJoint_setLimitCone_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setLimitCone_1');
var _emscripten_bind_PxSphericalJoint_getSwingYAngle_0 = Module['_emscripten_bind_PxSphericalJoint_getSwingYAngle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getSwingYAngle_0');
var _emscripten_bind_PxSphericalJoint_getSwingZAngle_0 = Module['_emscripten_bind_PxSphericalJoint_getSwingZAngle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getSwingZAngle_0');
var _emscripten_bind_PxSphericalJoint_setSphericalJointFlags_1 = Module['_emscripten_bind_PxSphericalJoint_setSphericalJointFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setSphericalJointFlags_1');
var _emscripten_bind_PxSphericalJoint_setSphericalJointFlag_2 = Module['_emscripten_bind_PxSphericalJoint_setSphericalJointFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setSphericalJointFlag_2');
var _emscripten_bind_PxSphericalJoint_getSphericalJointFlags_0 = Module['_emscripten_bind_PxSphericalJoint_getSphericalJointFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getSphericalJointFlags_0');
var _emscripten_bind_PxSphericalJoint_release_0 = Module['_emscripten_bind_PxSphericalJoint_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_release_0');
var _emscripten_bind_PxSphericalJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxSphericalJoint_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getConcreteTypeName_0');
var _emscripten_bind_PxSphericalJoint_getConcreteType_0 = Module['_emscripten_bind_PxSphericalJoint_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getConcreteType_0');
var _emscripten_bind_PxSphericalJoint_setBaseFlag_2 = Module['_emscripten_bind_PxSphericalJoint_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setBaseFlag_2');
var _emscripten_bind_PxSphericalJoint_setBaseFlags_1 = Module['_emscripten_bind_PxSphericalJoint_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setBaseFlags_1');
var _emscripten_bind_PxSphericalJoint_getBaseFlags_0 = Module['_emscripten_bind_PxSphericalJoint_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getBaseFlags_0');
var _emscripten_bind_PxSphericalJoint_isReleasable_0 = Module['_emscripten_bind_PxSphericalJoint_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_isReleasable_0');
var _emscripten_bind_PxSphericalJoint_setActors_2 = Module['_emscripten_bind_PxSphericalJoint_setActors_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setActors_2');
var _emscripten_bind_PxSphericalJoint_setLocalPose_2 = Module['_emscripten_bind_PxSphericalJoint_setLocalPose_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setLocalPose_2');
var _emscripten_bind_PxSphericalJoint_getLocalPose_1 = Module['_emscripten_bind_PxSphericalJoint_getLocalPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getLocalPose_1');
var _emscripten_bind_PxSphericalJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxSphericalJoint_getRelativeTransform_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getRelativeTransform_0');
var _emscripten_bind_PxSphericalJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxSphericalJoint_getRelativeLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getRelativeLinearVelocity_0');
var _emscripten_bind_PxSphericalJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxSphericalJoint_getRelativeAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getRelativeAngularVelocity_0');
var _emscripten_bind_PxSphericalJoint_setBreakForce_2 = Module['_emscripten_bind_PxSphericalJoint_setBreakForce_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setBreakForce_2');
var _emscripten_bind_PxSphericalJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxSphericalJoint_setConstraintFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setConstraintFlags_1');
var _emscripten_bind_PxSphericalJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxSphericalJoint_setConstraintFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setConstraintFlag_2');
var _emscripten_bind_PxSphericalJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxSphericalJoint_getConstraintFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getConstraintFlags_0');
var _emscripten_bind_PxSphericalJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxSphericalJoint_setInvMassScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setInvMassScale0_1');
var _emscripten_bind_PxSphericalJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxSphericalJoint_getInvMassScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getInvMassScale0_0');
var _emscripten_bind_PxSphericalJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxSphericalJoint_setInvMassScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setInvMassScale1_1');
var _emscripten_bind_PxSphericalJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxSphericalJoint_getInvMassScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getInvMassScale1_0');
var _emscripten_bind_PxSphericalJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxSphericalJoint_setInvInertiaScale0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setInvInertiaScale0_1');
var _emscripten_bind_PxSphericalJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxSphericalJoint_getInvInertiaScale0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getInvInertiaScale0_0');
var _emscripten_bind_PxSphericalJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxSphericalJoint_setInvInertiaScale1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setInvInertiaScale1_1');
var _emscripten_bind_PxSphericalJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxSphericalJoint_getInvInertiaScale1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getInvInertiaScale1_0');
var _emscripten_bind_PxSphericalJoint_getConstraint_0 = Module['_emscripten_bind_PxSphericalJoint_getConstraint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getConstraint_0');
var _emscripten_bind_PxSphericalJoint_setName_1 = Module['_emscripten_bind_PxSphericalJoint_setName_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_setName_1');
var _emscripten_bind_PxSphericalJoint_getName_0 = Module['_emscripten_bind_PxSphericalJoint_getName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getName_0');
var _emscripten_bind_PxSphericalJoint_getScene_0 = Module['_emscripten_bind_PxSphericalJoint_getScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_getScene_0');
var _emscripten_bind_PxSphericalJoint_get_userData_0 = Module['_emscripten_bind_PxSphericalJoint_get_userData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_get_userData_0');
var _emscripten_bind_PxSphericalJoint_set_userData_1 = Module['_emscripten_bind_PxSphericalJoint_set_userData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint_set_userData_1');
var _emscripten_bind_PxSphericalJoint___destroy___0 = Module['_emscripten_bind_PxSphericalJoint___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJoint___destroy___0');
var _emscripten_bind_PxSphericalJointFlags_PxSphericalJointFlags_1 = Module['_emscripten_bind_PxSphericalJointFlags_PxSphericalJointFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJointFlags_PxSphericalJointFlags_1');
var _emscripten_bind_PxSphericalJointFlags_isSet_1 = Module['_emscripten_bind_PxSphericalJointFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJointFlags_isSet_1');
var _emscripten_bind_PxSphericalJointFlags_raise_1 = Module['_emscripten_bind_PxSphericalJointFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJointFlags_raise_1');
var _emscripten_bind_PxSphericalJointFlags_clear_1 = Module['_emscripten_bind_PxSphericalJointFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJointFlags_clear_1');
var _emscripten_bind_PxSphericalJointFlags___destroy___0 = Module['_emscripten_bind_PxSphericalJointFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSphericalJointFlags___destroy___0');
var _emscripten_bind_PxSweepBuffer10_PxSweepBuffer10_0 = Module['_emscripten_bind_PxSweepBuffer10_PxSweepBuffer10_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepBuffer10_PxSweepBuffer10_0');
var _emscripten_bind_PxSweepBuffer10_getNbAnyHits_0 = Module['_emscripten_bind_PxSweepBuffer10_getNbAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepBuffer10_getNbAnyHits_0');
var _emscripten_bind_PxSweepBuffer10_getAnyHit_1 = Module['_emscripten_bind_PxSweepBuffer10_getAnyHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepBuffer10_getAnyHit_1');
var _emscripten_bind_PxSweepBuffer10_getNbTouches_0 = Module['_emscripten_bind_PxSweepBuffer10_getNbTouches_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepBuffer10_getNbTouches_0');
var _emscripten_bind_PxSweepBuffer10_getTouches_0 = Module['_emscripten_bind_PxSweepBuffer10_getTouches_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepBuffer10_getTouches_0');
var _emscripten_bind_PxSweepBuffer10_getTouch_1 = Module['_emscripten_bind_PxSweepBuffer10_getTouch_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepBuffer10_getTouch_1');
var _emscripten_bind_PxSweepBuffer10_getMaxNbTouches_0 = Module['_emscripten_bind_PxSweepBuffer10_getMaxNbTouches_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepBuffer10_getMaxNbTouches_0');
var _emscripten_bind_PxSweepBuffer10_hasAnyHits_0 = Module['_emscripten_bind_PxSweepBuffer10_hasAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepBuffer10_hasAnyHits_0');
var _emscripten_bind_PxSweepBuffer10_get_block_0 = Module['_emscripten_bind_PxSweepBuffer10_get_block_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepBuffer10_get_block_0');
var _emscripten_bind_PxSweepBuffer10_set_block_1 = Module['_emscripten_bind_PxSweepBuffer10_set_block_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepBuffer10_set_block_1');
var _emscripten_bind_PxSweepBuffer10_get_hasBlock_0 = Module['_emscripten_bind_PxSweepBuffer10_get_hasBlock_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepBuffer10_get_hasBlock_0');
var _emscripten_bind_PxSweepBuffer10_set_hasBlock_1 = Module['_emscripten_bind_PxSweepBuffer10_set_hasBlock_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepBuffer10_set_hasBlock_1');
var _emscripten_bind_PxSweepBuffer10___destroy___0 = Module['_emscripten_bind_PxSweepBuffer10___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepBuffer10___destroy___0');
var _emscripten_bind_PxSweepHit_PxSweepHit_0 = Module['_emscripten_bind_PxSweepHit_PxSweepHit_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_PxSweepHit_0');
var _emscripten_bind_PxSweepHit_hadInitialOverlap_0 = Module['_emscripten_bind_PxSweepHit_hadInitialOverlap_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_hadInitialOverlap_0');
var _emscripten_bind_PxSweepHit_get_actor_0 = Module['_emscripten_bind_PxSweepHit_get_actor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_get_actor_0');
var _emscripten_bind_PxSweepHit_set_actor_1 = Module['_emscripten_bind_PxSweepHit_set_actor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_set_actor_1');
var _emscripten_bind_PxSweepHit_get_shape_0 = Module['_emscripten_bind_PxSweepHit_get_shape_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_get_shape_0');
var _emscripten_bind_PxSweepHit_set_shape_1 = Module['_emscripten_bind_PxSweepHit_set_shape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_set_shape_1');
var _emscripten_bind_PxSweepHit_get_flags_0 = Module['_emscripten_bind_PxSweepHit_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_get_flags_0');
var _emscripten_bind_PxSweepHit_set_flags_1 = Module['_emscripten_bind_PxSweepHit_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_set_flags_1');
var _emscripten_bind_PxSweepHit_get_position_0 = Module['_emscripten_bind_PxSweepHit_get_position_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_get_position_0');
var _emscripten_bind_PxSweepHit_set_position_1 = Module['_emscripten_bind_PxSweepHit_set_position_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_set_position_1');
var _emscripten_bind_PxSweepHit_get_normal_0 = Module['_emscripten_bind_PxSweepHit_get_normal_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_get_normal_0');
var _emscripten_bind_PxSweepHit_set_normal_1 = Module['_emscripten_bind_PxSweepHit_set_normal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_set_normal_1');
var _emscripten_bind_PxSweepHit_get_distance_0 = Module['_emscripten_bind_PxSweepHit_get_distance_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_get_distance_0');
var _emscripten_bind_PxSweepHit_set_distance_1 = Module['_emscripten_bind_PxSweepHit_set_distance_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_set_distance_1');
var _emscripten_bind_PxSweepHit_get_faceIndex_0 = Module['_emscripten_bind_PxSweepHit_get_faceIndex_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_get_faceIndex_0');
var _emscripten_bind_PxSweepHit_set_faceIndex_1 = Module['_emscripten_bind_PxSweepHit_set_faceIndex_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit_set_faceIndex_1');
var _emscripten_bind_PxSweepHit___destroy___0 = Module['_emscripten_bind_PxSweepHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepHit___destroy___0');
var _emscripten_bind_PxSweepResult_PxSweepResult_0 = Module['_emscripten_bind_PxSweepResult_PxSweepResult_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepResult_PxSweepResult_0');
var _emscripten_bind_PxSweepResult_getNbAnyHits_0 = Module['_emscripten_bind_PxSweepResult_getNbAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepResult_getNbAnyHits_0');
var _emscripten_bind_PxSweepResult_getAnyHit_1 = Module['_emscripten_bind_PxSweepResult_getAnyHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepResult_getAnyHit_1');
var _emscripten_bind_PxSweepResult_getNbTouches_0 = Module['_emscripten_bind_PxSweepResult_getNbTouches_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepResult_getNbTouches_0');
var _emscripten_bind_PxSweepResult_getTouch_1 = Module['_emscripten_bind_PxSweepResult_getTouch_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepResult_getTouch_1');
var _emscripten_bind_PxSweepResult_clear_0 = Module['_emscripten_bind_PxSweepResult_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepResult_clear_0');
var _emscripten_bind_PxSweepResult_hasAnyHits_0 = Module['_emscripten_bind_PxSweepResult_hasAnyHits_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepResult_hasAnyHits_0');
var _emscripten_bind_PxSweepResult_get_block_0 = Module['_emscripten_bind_PxSweepResult_get_block_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepResult_get_block_0');
var _emscripten_bind_PxSweepResult_set_block_1 = Module['_emscripten_bind_PxSweepResult_set_block_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepResult_set_block_1');
var _emscripten_bind_PxSweepResult_get_hasBlock_0 = Module['_emscripten_bind_PxSweepResult_get_hasBlock_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepResult_get_hasBlock_0');
var _emscripten_bind_PxSweepResult_set_hasBlock_1 = Module['_emscripten_bind_PxSweepResult_set_hasBlock_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepResult_set_hasBlock_1');
var _emscripten_bind_PxSweepResult___destroy___0 = Module['_emscripten_bind_PxSweepResult___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxSweepResult___destroy___0');
var _emscripten_bind_PxTetMaker_createConformingTetrahedronMesh_5 = Module['_emscripten_bind_PxTetMaker_createConformingTetrahedronMesh_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_createConformingTetrahedronMesh_5');
var _emscripten_bind_PxTetMaker_createVoxelTetrahedronMesh_4 = Module['_emscripten_bind_PxTetMaker_createVoxelTetrahedronMesh_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_createVoxelTetrahedronMesh_4');
var _emscripten_bind_PxTetMaker_createVoxelTetrahedronMeshFromEdgeLength_4 = Module['_emscripten_bind_PxTetMaker_createVoxelTetrahedronMeshFromEdgeLength_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_createVoxelTetrahedronMeshFromEdgeLength_4');
var _emscripten_bind_PxTetMaker_validateTriangleMesh_3 = Module['_emscripten_bind_PxTetMaker_validateTriangleMesh_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_validateTriangleMesh_3');
var _emscripten_bind_PxTetMaker_validateTetrahedronMesh_3 = Module['_emscripten_bind_PxTetMaker_validateTetrahedronMesh_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_validateTetrahedronMesh_3');
var _emscripten_bind_PxTetMaker_simplifyTriangleMesh_6 = Module['_emscripten_bind_PxTetMaker_simplifyTriangleMesh_6'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_simplifyTriangleMesh_6');
var _emscripten_bind_PxTetMaker_simplifyTriangleMesh_7 = Module['_emscripten_bind_PxTetMaker_simplifyTriangleMesh_7'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_simplifyTriangleMesh_7');
var _emscripten_bind_PxTetMaker_simplifyTriangleMesh_8 = Module['_emscripten_bind_PxTetMaker_simplifyTriangleMesh_8'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_simplifyTriangleMesh_8');
var _emscripten_bind_PxTetMaker_simplifyTriangleMesh_9 = Module['_emscripten_bind_PxTetMaker_simplifyTriangleMesh_9'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_simplifyTriangleMesh_9');
var _emscripten_bind_PxTetMaker_simplifyTriangleMesh_10 = Module['_emscripten_bind_PxTetMaker_simplifyTriangleMesh_10'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_simplifyTriangleMesh_10');
var _emscripten_bind_PxTetMaker_simplifyTriangleMesh_11 = Module['_emscripten_bind_PxTetMaker_simplifyTriangleMesh_11'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_simplifyTriangleMesh_11');
var _emscripten_bind_PxTetMaker_simplifyTriangleMesh_12 = Module['_emscripten_bind_PxTetMaker_simplifyTriangleMesh_12'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_simplifyTriangleMesh_12');
var _emscripten_bind_PxTetMaker_remeshTriangleMesh_5 = Module['_emscripten_bind_PxTetMaker_remeshTriangleMesh_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_remeshTriangleMesh_5');
var _emscripten_bind_PxTetMaker_remeshTriangleMesh_6 = Module['_emscripten_bind_PxTetMaker_remeshTriangleMesh_6'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_remeshTriangleMesh_6');
var _emscripten_bind_PxTetMaker_createTreeBasedTetrahedralMesh_6 = Module['_emscripten_bind_PxTetMaker_createTreeBasedTetrahedralMesh_6'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_createTreeBasedTetrahedralMesh_6');
var _emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_5 = Module['_emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_5');
var _emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_6 = Module['_emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_6'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_6');
var _emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_7 = Module['_emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_7'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_7');
var _emscripten_bind_PxTetMaker_detectTriangleIslands_3 = Module['_emscripten_bind_PxTetMaker_detectTriangleIslands_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_detectTriangleIslands_3');
var _emscripten_bind_PxTetMaker_findLargestIslandId_2 = Module['_emscripten_bind_PxTetMaker_findLargestIslandId_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetMaker_findLargestIslandId_2');
var _emscripten_bind_PxTetrahedronMesh_getNbVertices_0 = Module['_emscripten_bind_PxTetrahedronMesh_getNbVertices_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_getNbVertices_0');
var _emscripten_bind_PxTetrahedronMesh_getVertices_0 = Module['_emscripten_bind_PxTetrahedronMesh_getVertices_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_getVertices_0');
var _emscripten_bind_PxTetrahedronMesh_getNbTetrahedrons_0 = Module['_emscripten_bind_PxTetrahedronMesh_getNbTetrahedrons_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_getNbTetrahedrons_0');
var _emscripten_bind_PxTetrahedronMesh_getTetrahedrons_0 = Module['_emscripten_bind_PxTetrahedronMesh_getTetrahedrons_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_getTetrahedrons_0');
var _emscripten_bind_PxTetrahedronMesh_getTetrahedronMeshFlags_0 = Module['_emscripten_bind_PxTetrahedronMesh_getTetrahedronMeshFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_getTetrahedronMeshFlags_0');
var _emscripten_bind_PxTetrahedronMesh_getTetrahedraRemap_0 = Module['_emscripten_bind_PxTetrahedronMesh_getTetrahedraRemap_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_getTetrahedraRemap_0');
var _emscripten_bind_PxTetrahedronMesh_getLocalBounds_0 = Module['_emscripten_bind_PxTetrahedronMesh_getLocalBounds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_getLocalBounds_0');
var _emscripten_bind_PxTetrahedronMesh_release_0 = Module['_emscripten_bind_PxTetrahedronMesh_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_release_0');
var _emscripten_bind_PxTetrahedronMesh_getConcreteTypeName_0 = Module['_emscripten_bind_PxTetrahedronMesh_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_getConcreteTypeName_0');
var _emscripten_bind_PxTetrahedronMesh_getConcreteType_0 = Module['_emscripten_bind_PxTetrahedronMesh_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_getConcreteType_0');
var _emscripten_bind_PxTetrahedronMesh_setBaseFlag_2 = Module['_emscripten_bind_PxTetrahedronMesh_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_setBaseFlag_2');
var _emscripten_bind_PxTetrahedronMesh_setBaseFlags_1 = Module['_emscripten_bind_PxTetrahedronMesh_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_setBaseFlags_1');
var _emscripten_bind_PxTetrahedronMesh_getBaseFlags_0 = Module['_emscripten_bind_PxTetrahedronMesh_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_getBaseFlags_0');
var _emscripten_bind_PxTetrahedronMesh_isReleasable_0 = Module['_emscripten_bind_PxTetrahedronMesh_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_isReleasable_0');
var _emscripten_bind_PxTetrahedronMesh_getReferenceCount_0 = Module['_emscripten_bind_PxTetrahedronMesh_getReferenceCount_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_getReferenceCount_0');
var _emscripten_bind_PxTetrahedronMesh_acquireReference_0 = Module['_emscripten_bind_PxTetrahedronMesh_acquireReference_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMesh_acquireReference_0');
var _emscripten_bind_PxTetrahedronMeshAnalysisResults_PxTetrahedronMeshAnalysisResults_1 = Module['_emscripten_bind_PxTetrahedronMeshAnalysisResults_PxTetrahedronMeshAnalysisResults_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshAnalysisResults_PxTetrahedronMeshAnalysisResults_1');
var _emscripten_bind_PxTetrahedronMeshAnalysisResults_isSet_1 = Module['_emscripten_bind_PxTetrahedronMeshAnalysisResults_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshAnalysisResults_isSet_1');
var _emscripten_bind_PxTetrahedronMeshAnalysisResults_raise_1 = Module['_emscripten_bind_PxTetrahedronMeshAnalysisResults_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshAnalysisResults_raise_1');
var _emscripten_bind_PxTetrahedronMeshAnalysisResults_clear_1 = Module['_emscripten_bind_PxTetrahedronMeshAnalysisResults_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshAnalysisResults_clear_1');
var _emscripten_bind_PxTetrahedronMeshAnalysisResults___destroy___0 = Module['_emscripten_bind_PxTetrahedronMeshAnalysisResults___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshAnalysisResults___destroy___0');
var _emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_0 = Module['_emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_0');
var _emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_2 = Module['_emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_2');
var _emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_3 = Module['_emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_3');
var _emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_4 = Module['_emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_4');
var _emscripten_bind_PxTetrahedronMeshDesc_isValid_0 = Module['_emscripten_bind_PxTetrahedronMeshDesc_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_isValid_0');
var _emscripten_bind_PxTetrahedronMeshDesc_get_materialIndices_0 = Module['_emscripten_bind_PxTetrahedronMeshDesc_get_materialIndices_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_get_materialIndices_0');
var _emscripten_bind_PxTetrahedronMeshDesc_set_materialIndices_1 = Module['_emscripten_bind_PxTetrahedronMeshDesc_set_materialIndices_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_set_materialIndices_1');
var _emscripten_bind_PxTetrahedronMeshDesc_get_points_0 = Module['_emscripten_bind_PxTetrahedronMeshDesc_get_points_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_get_points_0');
var _emscripten_bind_PxTetrahedronMeshDesc_set_points_1 = Module['_emscripten_bind_PxTetrahedronMeshDesc_set_points_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_set_points_1');
var _emscripten_bind_PxTetrahedronMeshDesc_get_tetrahedrons_0 = Module['_emscripten_bind_PxTetrahedronMeshDesc_get_tetrahedrons_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_get_tetrahedrons_0');
var _emscripten_bind_PxTetrahedronMeshDesc_set_tetrahedrons_1 = Module['_emscripten_bind_PxTetrahedronMeshDesc_set_tetrahedrons_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_set_tetrahedrons_1');
var _emscripten_bind_PxTetrahedronMeshDesc_get_flags_0 = Module['_emscripten_bind_PxTetrahedronMeshDesc_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_get_flags_0');
var _emscripten_bind_PxTetrahedronMeshDesc_set_flags_1 = Module['_emscripten_bind_PxTetrahedronMeshDesc_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_set_flags_1');
var _emscripten_bind_PxTetrahedronMeshDesc_get_tetsPerElement_0 = Module['_emscripten_bind_PxTetrahedronMeshDesc_get_tetsPerElement_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_get_tetsPerElement_0');
var _emscripten_bind_PxTetrahedronMeshDesc_set_tetsPerElement_1 = Module['_emscripten_bind_PxTetrahedronMeshDesc_set_tetsPerElement_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc_set_tetsPerElement_1');
var _emscripten_bind_PxTetrahedronMeshDesc___destroy___0 = Module['_emscripten_bind_PxTetrahedronMeshDesc___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshDesc___destroy___0');
var _emscripten_bind_PxTetrahedronMeshExt_findTetrahedronContainingPoint_4 = Module['_emscripten_bind_PxTetrahedronMeshExt_findTetrahedronContainingPoint_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshExt_findTetrahedronContainingPoint_4');
var _emscripten_bind_PxTetrahedronMeshExt_findTetrahedronClosestToPoint_3 = Module['_emscripten_bind_PxTetrahedronMeshExt_findTetrahedronClosestToPoint_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshExt_findTetrahedronClosestToPoint_3');
var _emscripten_bind_PxTetrahedronMeshExt_createPointsToTetrahedronMap_5 = Module['_emscripten_bind_PxTetrahedronMeshExt_createPointsToTetrahedronMap_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshExt_createPointsToTetrahedronMap_5');
var _emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_2 = Module['_emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_2');
var _emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_3 = Module['_emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_3');
var _emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_4 = Module['_emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_4');
var _emscripten_bind_PxTetrahedronMeshFlags_PxTetrahedronMeshFlags_1 = Module['_emscripten_bind_PxTetrahedronMeshFlags_PxTetrahedronMeshFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshFlags_PxTetrahedronMeshFlags_1');
var _emscripten_bind_PxTetrahedronMeshFlags_isSet_1 = Module['_emscripten_bind_PxTetrahedronMeshFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshFlags_isSet_1');
var _emscripten_bind_PxTetrahedronMeshFlags_raise_1 = Module['_emscripten_bind_PxTetrahedronMeshFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshFlags_raise_1');
var _emscripten_bind_PxTetrahedronMeshFlags_clear_1 = Module['_emscripten_bind_PxTetrahedronMeshFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshFlags_clear_1');
var _emscripten_bind_PxTetrahedronMeshFlags___destroy___0 = Module['_emscripten_bind_PxTetrahedronMeshFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshFlags___destroy___0');
var _emscripten_bind_PxTetrahedronMeshGeometry_PxTetrahedronMeshGeometry_1 = Module['_emscripten_bind_PxTetrahedronMeshGeometry_PxTetrahedronMeshGeometry_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshGeometry_PxTetrahedronMeshGeometry_1');
var _emscripten_bind_PxTetrahedronMeshGeometry_isValid_0 = Module['_emscripten_bind_PxTetrahedronMeshGeometry_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshGeometry_isValid_0');
var _emscripten_bind_PxTetrahedronMeshGeometry_getType_0 = Module['_emscripten_bind_PxTetrahedronMeshGeometry_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshGeometry_getType_0');
var _emscripten_bind_PxTetrahedronMeshGeometry_get_tetrahedronMesh_0 = Module['_emscripten_bind_PxTetrahedronMeshGeometry_get_tetrahedronMesh_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshGeometry_get_tetrahedronMesh_0');
var _emscripten_bind_PxTetrahedronMeshGeometry_set_tetrahedronMesh_1 = Module['_emscripten_bind_PxTetrahedronMeshGeometry_set_tetrahedronMesh_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTetrahedronMeshGeometry_set_tetrahedronMesh_1');
var _emscripten_bind_PxTolerancesScale_PxTolerancesScale_0 = Module['_emscripten_bind_PxTolerancesScale_PxTolerancesScale_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTolerancesScale_PxTolerancesScale_0');
var _emscripten_bind_PxTolerancesScale_isValid_0 = Module['_emscripten_bind_PxTolerancesScale_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTolerancesScale_isValid_0');
var _emscripten_bind_PxTolerancesScale_get_length_0 = Module['_emscripten_bind_PxTolerancesScale_get_length_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTolerancesScale_get_length_0');
var _emscripten_bind_PxTolerancesScale_set_length_1 = Module['_emscripten_bind_PxTolerancesScale_set_length_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTolerancesScale_set_length_1');
var _emscripten_bind_PxTolerancesScale_get_speed_0 = Module['_emscripten_bind_PxTolerancesScale_get_speed_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTolerancesScale_get_speed_0');
var _emscripten_bind_PxTolerancesScale_set_speed_1 = Module['_emscripten_bind_PxTolerancesScale_set_speed_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTolerancesScale_set_speed_1');
var _emscripten_bind_PxTolerancesScale___destroy___0 = Module['_emscripten_bind_PxTolerancesScale___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTolerancesScale___destroy___0');
var _emscripten_bind_PxTopLevelFunctions_DefaultFilterShader_0 = Module['_emscripten_bind_PxTopLevelFunctions_DefaultFilterShader_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_DefaultFilterShader_0');
var _emscripten_bind_PxTopLevelFunctions_setupPassThroughFilterShader_2 = Module['_emscripten_bind_PxTopLevelFunctions_setupPassThroughFilterShader_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_setupPassThroughFilterShader_2');
var _emscripten_bind_PxTopLevelFunctions_CreateControllerManager_1 = Module['_emscripten_bind_PxTopLevelFunctions_CreateControllerManager_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreateControllerManager_1');
var _emscripten_bind_PxTopLevelFunctions_CreateControllerManager_2 = Module['_emscripten_bind_PxTopLevelFunctions_CreateControllerManager_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreateControllerManager_2');
var _emscripten_bind_PxTopLevelFunctions_CreateFoundation_3 = Module['_emscripten_bind_PxTopLevelFunctions_CreateFoundation_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreateFoundation_3');
var _emscripten_bind_PxTopLevelFunctions_CreatePhysics_3 = Module['_emscripten_bind_PxTopLevelFunctions_CreatePhysics_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreatePhysics_3');
var _emscripten_bind_PxTopLevelFunctions_CreatePhysics_4 = Module['_emscripten_bind_PxTopLevelFunctions_CreatePhysics_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreatePhysics_4');
var _emscripten_bind_PxTopLevelFunctions_CreatePhysics_5 = Module['_emscripten_bind_PxTopLevelFunctions_CreatePhysics_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreatePhysics_5');
var _emscripten_bind_PxTopLevelFunctions_DefaultCpuDispatcherCreate_1 = Module['_emscripten_bind_PxTopLevelFunctions_DefaultCpuDispatcherCreate_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_DefaultCpuDispatcherCreate_1');
var _emscripten_bind_PxTopLevelFunctions_InitExtensions_1 = Module['_emscripten_bind_PxTopLevelFunctions_InitExtensions_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_InitExtensions_1');
var _emscripten_bind_PxTopLevelFunctions_CloseExtensions_0 = Module['_emscripten_bind_PxTopLevelFunctions_CloseExtensions_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CloseExtensions_0');
var _emscripten_bind_PxTopLevelFunctions_CreatePvd_1 = Module['_emscripten_bind_PxTopLevelFunctions_CreatePvd_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreatePvd_1');
var _emscripten_bind_PxTopLevelFunctions_D6JointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_D6JointCreate_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_D6JointCreate_5');
var _emscripten_bind_PxTopLevelFunctions_DistanceJointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_DistanceJointCreate_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_DistanceJointCreate_5');
var _emscripten_bind_PxTopLevelFunctions_FixedJointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_FixedJointCreate_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_FixedJointCreate_5');
var _emscripten_bind_PxTopLevelFunctions_GearJointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_GearJointCreate_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_GearJointCreate_5');
var _emscripten_bind_PxTopLevelFunctions_PrismaticJointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_PrismaticJointCreate_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_PrismaticJointCreate_5');
var _emscripten_bind_PxTopLevelFunctions_RackAndPinionJointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_RackAndPinionJointCreate_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_RackAndPinionJointCreate_5');
var _emscripten_bind_PxTopLevelFunctions_RevoluteJointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_RevoluteJointCreate_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_RevoluteJointCreate_5');
var _emscripten_bind_PxTopLevelFunctions_SphericalJointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_SphericalJointCreate_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_SphericalJointCreate_5');
var _emscripten_bind_PxTopLevelFunctions_CreateConvexMesh_2 = Module['_emscripten_bind_PxTopLevelFunctions_CreateConvexMesh_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreateConvexMesh_2');
var _emscripten_bind_PxTopLevelFunctions_CreateTriangleMesh_2 = Module['_emscripten_bind_PxTopLevelFunctions_CreateTriangleMesh_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreateTriangleMesh_2');
var _emscripten_bind_PxTopLevelFunctions_CreateHeightField_1 = Module['_emscripten_bind_PxTopLevelFunctions_CreateHeightField_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreateHeightField_1');
var _emscripten_bind_PxTopLevelFunctions_CookTriangleMesh_3 = Module['_emscripten_bind_PxTopLevelFunctions_CookTriangleMesh_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CookTriangleMesh_3');
var _emscripten_bind_PxTopLevelFunctions_CookConvexMesh_3 = Module['_emscripten_bind_PxTopLevelFunctions_CookConvexMesh_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CookConvexMesh_3');
var _emscripten_bind_PxTopLevelFunctions_CreateDynamicFromShape_4 = Module['_emscripten_bind_PxTopLevelFunctions_CreateDynamicFromShape_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreateDynamicFromShape_4');
var _emscripten_bind_PxTopLevelFunctions_CreateDynamic_5 = Module['_emscripten_bind_PxTopLevelFunctions_CreateDynamic_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreateDynamic_5');
var _emscripten_bind_PxTopLevelFunctions_CreateDynamic_6 = Module['_emscripten_bind_PxTopLevelFunctions_CreateDynamic_6'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreateDynamic_6');
var _emscripten_bind_PxTopLevelFunctions_CreateKinematicFromShape_4 = Module['_emscripten_bind_PxTopLevelFunctions_CreateKinematicFromShape_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreateKinematicFromShape_4');
var _emscripten_bind_PxTopLevelFunctions_CreateKinematic_5 = Module['_emscripten_bind_PxTopLevelFunctions_CreateKinematic_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreateKinematic_5');
var _emscripten_bind_PxTopLevelFunctions_CreateKinematic_6 = Module['_emscripten_bind_PxTopLevelFunctions_CreateKinematic_6'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreateKinematic_6');
var _emscripten_bind_PxTopLevelFunctions_CreateStaticFromShape_3 = Module['_emscripten_bind_PxTopLevelFunctions_CreateStaticFromShape_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreateStaticFromShape_3');
var _emscripten_bind_PxTopLevelFunctions_CreateStatic_5 = Module['_emscripten_bind_PxTopLevelFunctions_CreateStatic_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreateStatic_5');
var _emscripten_bind_PxTopLevelFunctions_CreatePlane_3 = Module['_emscripten_bind_PxTopLevelFunctions_CreatePlane_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CreatePlane_3');
var _emscripten_bind_PxTopLevelFunctions_CloneShape_3 = Module['_emscripten_bind_PxTopLevelFunctions_CloneShape_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CloneShape_3');
var _emscripten_bind_PxTopLevelFunctions_CloneStatic_3 = Module['_emscripten_bind_PxTopLevelFunctions_CloneStatic_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CloneStatic_3');
var _emscripten_bind_PxTopLevelFunctions_CloneDynamic_3 = Module['_emscripten_bind_PxTopLevelFunctions_CloneDynamic_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_CloneDynamic_3');
var _emscripten_bind_PxTopLevelFunctions_ScaleRigidActor_3 = Module['_emscripten_bind_PxTopLevelFunctions_ScaleRigidActor_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_ScaleRigidActor_3');
var _emscripten_bind_PxTopLevelFunctions_IntegrateTransform_5 = Module['_emscripten_bind_PxTopLevelFunctions_IntegrateTransform_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_IntegrateTransform_5');
var _emscripten_bind_PxTopLevelFunctions_GetTriangleMeshSDFDimensions_1 = Module['_emscripten_bind_PxTopLevelFunctions_GetTriangleMeshSDFDimensions_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_GetTriangleMeshSDFDimensions_1');
var _emscripten_bind_PxTopLevelFunctions_get_PHYSICS_VERSION_0 = Module['_emscripten_bind_PxTopLevelFunctions_get_PHYSICS_VERSION_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTopLevelFunctions_get_PHYSICS_VERSION_0');
var _emscripten_bind_PxTransform_PxTransform_0 = Module['_emscripten_bind_PxTransform_PxTransform_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform_PxTransform_0');
var _emscripten_bind_PxTransform_PxTransform_1 = Module['_emscripten_bind_PxTransform_PxTransform_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform_PxTransform_1');
var _emscripten_bind_PxTransform_PxTransform_2 = Module['_emscripten_bind_PxTransform_PxTransform_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform_PxTransform_2');
var _emscripten_bind_PxTransform_getInverse_0 = Module['_emscripten_bind_PxTransform_getInverse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform_getInverse_0');
var _emscripten_bind_PxTransform_transform_1 = Module['_emscripten_bind_PxTransform_transform_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform_transform_1');
var _emscripten_bind_PxTransform_transformInv_1 = Module['_emscripten_bind_PxTransform_transformInv_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform_transformInv_1');
var _emscripten_bind_PxTransform_isValid_0 = Module['_emscripten_bind_PxTransform_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform_isValid_0');
var _emscripten_bind_PxTransform_isSane_0 = Module['_emscripten_bind_PxTransform_isSane_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform_isSane_0');
var _emscripten_bind_PxTransform_isFinite_0 = Module['_emscripten_bind_PxTransform_isFinite_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform_isFinite_0');
var _emscripten_bind_PxTransform_getNormalized_0 = Module['_emscripten_bind_PxTransform_getNormalized_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform_getNormalized_0');
var _emscripten_bind_PxTransform_get_q_0 = Module['_emscripten_bind_PxTransform_get_q_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform_get_q_0');
var _emscripten_bind_PxTransform_set_q_1 = Module['_emscripten_bind_PxTransform_set_q_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform_set_q_1');
var _emscripten_bind_PxTransform_get_p_0 = Module['_emscripten_bind_PxTransform_get_p_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform_get_p_0');
var _emscripten_bind_PxTransform_set_p_1 = Module['_emscripten_bind_PxTransform_set_p_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform_set_p_1');
var _emscripten_bind_PxTransform___destroy___0 = Module['_emscripten_bind_PxTransform___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTransform___destroy___0');
var _emscripten_bind_PxTriangle_PxTriangle_0 = Module['_emscripten_bind_PxTriangle_PxTriangle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangle_PxTriangle_0');
var _emscripten_bind_PxTriangle_PxTriangle_3 = Module['_emscripten_bind_PxTriangle_PxTriangle_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangle_PxTriangle_3');
var _emscripten_bind_PxTriangle_normal_1 = Module['_emscripten_bind_PxTriangle_normal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangle_normal_1');
var _emscripten_bind_PxTriangle_denormalizedNormal_1 = Module['_emscripten_bind_PxTriangle_denormalizedNormal_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangle_denormalizedNormal_1');
var _emscripten_bind_PxTriangle_area_0 = Module['_emscripten_bind_PxTriangle_area_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangle_area_0');
var _emscripten_bind_PxTriangle_pointFromUV_2 = Module['_emscripten_bind_PxTriangle_pointFromUV_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangle_pointFromUV_2');
var _emscripten_bind_PxTriangle___destroy___0 = Module['_emscripten_bind_PxTriangle___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangle___destroy___0');
var _emscripten_bind_PxTriangleMesh_getNbVertices_0 = Module['_emscripten_bind_PxTriangleMesh_getNbVertices_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_getNbVertices_0');
var _emscripten_bind_PxTriangleMesh_getVertices_0 = Module['_emscripten_bind_PxTriangleMesh_getVertices_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_getVertices_0');
var _emscripten_bind_PxTriangleMesh_getVerticesForModification_0 = Module['_emscripten_bind_PxTriangleMesh_getVerticesForModification_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_getVerticesForModification_0');
var _emscripten_bind_PxTriangleMesh_refitBVH_0 = Module['_emscripten_bind_PxTriangleMesh_refitBVH_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_refitBVH_0');
var _emscripten_bind_PxTriangleMesh_getNbTriangles_0 = Module['_emscripten_bind_PxTriangleMesh_getNbTriangles_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_getNbTriangles_0');
var _emscripten_bind_PxTriangleMesh_getTriangles_0 = Module['_emscripten_bind_PxTriangleMesh_getTriangles_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_getTriangles_0');
var _emscripten_bind_PxTriangleMesh_getTriangleMeshFlags_0 = Module['_emscripten_bind_PxTriangleMesh_getTriangleMeshFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_getTriangleMeshFlags_0');
var _emscripten_bind_PxTriangleMesh_getTrianglesRemap_0 = Module['_emscripten_bind_PxTriangleMesh_getTrianglesRemap_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_getTrianglesRemap_0');
var _emscripten_bind_PxTriangleMesh_getTriangleMaterialIndex_1 = Module['_emscripten_bind_PxTriangleMesh_getTriangleMaterialIndex_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_getTriangleMaterialIndex_1');
var _emscripten_bind_PxTriangleMesh_getLocalBounds_0 = Module['_emscripten_bind_PxTriangleMesh_getLocalBounds_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_getLocalBounds_0');
var _emscripten_bind_PxTriangleMesh_getSDF_0 = Module['_emscripten_bind_PxTriangleMesh_getSDF_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_getSDF_0');
var _emscripten_bind_PxTriangleMesh_setPreferSDFProjection_1 = Module['_emscripten_bind_PxTriangleMesh_setPreferSDFProjection_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_setPreferSDFProjection_1');
var _emscripten_bind_PxTriangleMesh_release_0 = Module['_emscripten_bind_PxTriangleMesh_release_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_release_0');
var _emscripten_bind_PxTriangleMesh_getConcreteTypeName_0 = Module['_emscripten_bind_PxTriangleMesh_getConcreteTypeName_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_getConcreteTypeName_0');
var _emscripten_bind_PxTriangleMesh_getConcreteType_0 = Module['_emscripten_bind_PxTriangleMesh_getConcreteType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_getConcreteType_0');
var _emscripten_bind_PxTriangleMesh_setBaseFlag_2 = Module['_emscripten_bind_PxTriangleMesh_setBaseFlag_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_setBaseFlag_2');
var _emscripten_bind_PxTriangleMesh_setBaseFlags_1 = Module['_emscripten_bind_PxTriangleMesh_setBaseFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_setBaseFlags_1');
var _emscripten_bind_PxTriangleMesh_getBaseFlags_0 = Module['_emscripten_bind_PxTriangleMesh_getBaseFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_getBaseFlags_0');
var _emscripten_bind_PxTriangleMesh_isReleasable_0 = Module['_emscripten_bind_PxTriangleMesh_isReleasable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_isReleasable_0');
var _emscripten_bind_PxTriangleMesh_getReferenceCount_0 = Module['_emscripten_bind_PxTriangleMesh_getReferenceCount_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_getReferenceCount_0');
var _emscripten_bind_PxTriangleMesh_acquireReference_0 = Module['_emscripten_bind_PxTriangleMesh_acquireReference_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMesh_acquireReference_0');
var _emscripten_bind_PxTriangleMeshAnalysisResults_PxTriangleMeshAnalysisResults_1 = Module['_emscripten_bind_PxTriangleMeshAnalysisResults_PxTriangleMeshAnalysisResults_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshAnalysisResults_PxTriangleMeshAnalysisResults_1');
var _emscripten_bind_PxTriangleMeshAnalysisResults_isSet_1 = Module['_emscripten_bind_PxTriangleMeshAnalysisResults_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshAnalysisResults_isSet_1');
var _emscripten_bind_PxTriangleMeshAnalysisResults_raise_1 = Module['_emscripten_bind_PxTriangleMeshAnalysisResults_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshAnalysisResults_raise_1');
var _emscripten_bind_PxTriangleMeshAnalysisResults_clear_1 = Module['_emscripten_bind_PxTriangleMeshAnalysisResults_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshAnalysisResults_clear_1');
var _emscripten_bind_PxTriangleMeshAnalysisResults___destroy___0 = Module['_emscripten_bind_PxTriangleMeshAnalysisResults___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshAnalysisResults___destroy___0');
var _emscripten_bind_PxTriangleMeshDesc_PxTriangleMeshDesc_0 = Module['_emscripten_bind_PxTriangleMeshDesc_PxTriangleMeshDesc_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshDesc_PxTriangleMeshDesc_0');
var _emscripten_bind_PxTriangleMeshDesc_setToDefault_0 = Module['_emscripten_bind_PxTriangleMeshDesc_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshDesc_setToDefault_0');
var _emscripten_bind_PxTriangleMeshDesc_isValid_0 = Module['_emscripten_bind_PxTriangleMeshDesc_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshDesc_isValid_0');
var _emscripten_bind_PxTriangleMeshDesc_get_materialIndices_0 = Module['_emscripten_bind_PxTriangleMeshDesc_get_materialIndices_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshDesc_get_materialIndices_0');
var _emscripten_bind_PxTriangleMeshDesc_set_materialIndices_1 = Module['_emscripten_bind_PxTriangleMeshDesc_set_materialIndices_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshDesc_set_materialIndices_1');
var _emscripten_bind_PxTriangleMeshDesc_get_sdfDesc_0 = Module['_emscripten_bind_PxTriangleMeshDesc_get_sdfDesc_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshDesc_get_sdfDesc_0');
var _emscripten_bind_PxTriangleMeshDesc_set_sdfDesc_1 = Module['_emscripten_bind_PxTriangleMeshDesc_set_sdfDesc_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshDesc_set_sdfDesc_1');
var _emscripten_bind_PxTriangleMeshDesc_get_points_0 = Module['_emscripten_bind_PxTriangleMeshDesc_get_points_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshDesc_get_points_0');
var _emscripten_bind_PxTriangleMeshDesc_set_points_1 = Module['_emscripten_bind_PxTriangleMeshDesc_set_points_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshDesc_set_points_1');
var _emscripten_bind_PxTriangleMeshDesc_get_triangles_0 = Module['_emscripten_bind_PxTriangleMeshDesc_get_triangles_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshDesc_get_triangles_0');
var _emscripten_bind_PxTriangleMeshDesc_set_triangles_1 = Module['_emscripten_bind_PxTriangleMeshDesc_set_triangles_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshDesc_set_triangles_1');
var _emscripten_bind_PxTriangleMeshDesc_get_flags_0 = Module['_emscripten_bind_PxTriangleMeshDesc_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshDesc_get_flags_0');
var _emscripten_bind_PxTriangleMeshDesc_set_flags_1 = Module['_emscripten_bind_PxTriangleMeshDesc_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshDesc_set_flags_1');
var _emscripten_bind_PxTriangleMeshDesc___destroy___0 = Module['_emscripten_bind_PxTriangleMeshDesc___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshDesc___destroy___0');
var _emscripten_bind_PxTriangleMeshFlags_PxTriangleMeshFlags_1 = Module['_emscripten_bind_PxTriangleMeshFlags_PxTriangleMeshFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshFlags_PxTriangleMeshFlags_1');
var _emscripten_bind_PxTriangleMeshFlags_isSet_1 = Module['_emscripten_bind_PxTriangleMeshFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshFlags_isSet_1');
var _emscripten_bind_PxTriangleMeshFlags_raise_1 = Module['_emscripten_bind_PxTriangleMeshFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshFlags_raise_1');
var _emscripten_bind_PxTriangleMeshFlags_clear_1 = Module['_emscripten_bind_PxTriangleMeshFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshFlags_clear_1');
var _emscripten_bind_PxTriangleMeshFlags___destroy___0 = Module['_emscripten_bind_PxTriangleMeshFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshFlags___destroy___0');
var _emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_1 = Module['_emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_1');
var _emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_2 = Module['_emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_2');
var _emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_3 = Module['_emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_3');
var _emscripten_bind_PxTriangleMeshGeometry_isValid_0 = Module['_emscripten_bind_PxTriangleMeshGeometry_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshGeometry_isValid_0');
var _emscripten_bind_PxTriangleMeshGeometry_getType_0 = Module['_emscripten_bind_PxTriangleMeshGeometry_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshGeometry_getType_0');
var _emscripten_bind_PxTriangleMeshGeometry_get_scale_0 = Module['_emscripten_bind_PxTriangleMeshGeometry_get_scale_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshGeometry_get_scale_0');
var _emscripten_bind_PxTriangleMeshGeometry_set_scale_1 = Module['_emscripten_bind_PxTriangleMeshGeometry_set_scale_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshGeometry_set_scale_1');
var _emscripten_bind_PxTriangleMeshGeometry_get_meshFlags_0 = Module['_emscripten_bind_PxTriangleMeshGeometry_get_meshFlags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshGeometry_get_meshFlags_0');
var _emscripten_bind_PxTriangleMeshGeometry_set_meshFlags_1 = Module['_emscripten_bind_PxTriangleMeshGeometry_set_meshFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshGeometry_set_meshFlags_1');
var _emscripten_bind_PxTriangleMeshGeometry_get_triangleMesh_0 = Module['_emscripten_bind_PxTriangleMeshGeometry_get_triangleMesh_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshGeometry_get_triangleMesh_0');
var _emscripten_bind_PxTriangleMeshGeometry_set_triangleMesh_1 = Module['_emscripten_bind_PxTriangleMeshGeometry_set_triangleMesh_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshGeometry_set_triangleMesh_1');
var _emscripten_bind_PxTriangleMeshGeometry___destroy___0 = Module['_emscripten_bind_PxTriangleMeshGeometry___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriangleMeshGeometry___destroy___0');
var _emscripten_bind_PxTriggerPair_get_triggerShape_0 = Module['_emscripten_bind_PxTriggerPair_get_triggerShape_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPair_get_triggerShape_0');
var _emscripten_bind_PxTriggerPair_set_triggerShape_1 = Module['_emscripten_bind_PxTriggerPair_set_triggerShape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPair_set_triggerShape_1');
var _emscripten_bind_PxTriggerPair_get_triggerActor_0 = Module['_emscripten_bind_PxTriggerPair_get_triggerActor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPair_get_triggerActor_0');
var _emscripten_bind_PxTriggerPair_set_triggerActor_1 = Module['_emscripten_bind_PxTriggerPair_set_triggerActor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPair_set_triggerActor_1');
var _emscripten_bind_PxTriggerPair_get_otherShape_0 = Module['_emscripten_bind_PxTriggerPair_get_otherShape_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPair_get_otherShape_0');
var _emscripten_bind_PxTriggerPair_set_otherShape_1 = Module['_emscripten_bind_PxTriggerPair_set_otherShape_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPair_set_otherShape_1');
var _emscripten_bind_PxTriggerPair_get_otherActor_0 = Module['_emscripten_bind_PxTriggerPair_get_otherActor_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPair_get_otherActor_0');
var _emscripten_bind_PxTriggerPair_set_otherActor_1 = Module['_emscripten_bind_PxTriggerPair_set_otherActor_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPair_set_otherActor_1');
var _emscripten_bind_PxTriggerPair_get_status_0 = Module['_emscripten_bind_PxTriggerPair_get_status_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPair_get_status_0');
var _emscripten_bind_PxTriggerPair_set_status_1 = Module['_emscripten_bind_PxTriggerPair_set_status_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPair_set_status_1');
var _emscripten_bind_PxTriggerPair_get_flags_0 = Module['_emscripten_bind_PxTriggerPair_get_flags_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPair_get_flags_0');
var _emscripten_bind_PxTriggerPair_set_flags_1 = Module['_emscripten_bind_PxTriggerPair_set_flags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPair_set_flags_1');
var _emscripten_bind_PxTriggerPair___destroy___0 = Module['_emscripten_bind_PxTriggerPair___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPair___destroy___0');
var _emscripten_bind_PxTriggerPairFlags_PxTriggerPairFlags_1 = Module['_emscripten_bind_PxTriggerPairFlags_PxTriggerPairFlags_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPairFlags_PxTriggerPairFlags_1');
var _emscripten_bind_PxTriggerPairFlags_isSet_1 = Module['_emscripten_bind_PxTriggerPairFlags_isSet_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPairFlags_isSet_1');
var _emscripten_bind_PxTriggerPairFlags_raise_1 = Module['_emscripten_bind_PxTriggerPairFlags_raise_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPairFlags_raise_1');
var _emscripten_bind_PxTriggerPairFlags_clear_1 = Module['_emscripten_bind_PxTriggerPairFlags_clear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPairFlags_clear_1');
var _emscripten_bind_PxTriggerPairFlags___destroy___0 = Module['_emscripten_bind_PxTriggerPairFlags___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTriggerPairFlags___destroy___0');
var _emscripten_bind_PxTypedBoundedData_PxU16_get_stride_0 = Module['_emscripten_bind_PxTypedBoundedData_PxU16_get_stride_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTypedBoundedData_PxU16_get_stride_0');
var _emscripten_bind_PxTypedBoundedData_PxU16_set_stride_1 = Module['_emscripten_bind_PxTypedBoundedData_PxU16_set_stride_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTypedBoundedData_PxU16_set_stride_1');
var _emscripten_bind_PxTypedBoundedData_PxU16_get_data_0 = Module['_emscripten_bind_PxTypedBoundedData_PxU16_get_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTypedBoundedData_PxU16_get_data_0');
var _emscripten_bind_PxTypedBoundedData_PxU16_set_data_1 = Module['_emscripten_bind_PxTypedBoundedData_PxU16_set_data_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTypedBoundedData_PxU16_set_data_1');
var _emscripten_bind_PxTypedBoundedData_PxU16___destroy___0 = Module['_emscripten_bind_PxTypedBoundedData_PxU16___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTypedBoundedData_PxU16___destroy___0');
var _emscripten_bind_PxTypedBoundedData_PxU16Const_get_stride_0 = Module['_emscripten_bind_PxTypedBoundedData_PxU16Const_get_stride_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTypedBoundedData_PxU16Const_get_stride_0');
var _emscripten_bind_PxTypedBoundedData_PxU16Const_set_stride_1 = Module['_emscripten_bind_PxTypedBoundedData_PxU16Const_set_stride_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTypedBoundedData_PxU16Const_set_stride_1');
var _emscripten_bind_PxTypedBoundedData_PxU16Const_get_data_0 = Module['_emscripten_bind_PxTypedBoundedData_PxU16Const_get_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTypedBoundedData_PxU16Const_get_data_0');
var _emscripten_bind_PxTypedBoundedData_PxU16Const_set_data_1 = Module['_emscripten_bind_PxTypedBoundedData_PxU16Const_set_data_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxTypedBoundedData_PxU16Const_set_data_1');
var _emscripten_bind_PxTypedBoundedData_PxU16Const___destroy___0 = Module['_emscripten_bind_PxTypedBoundedData_PxU16Const___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxTypedBoundedData_PxU16Const___destroy___0');
var _emscripten_bind_PxU16Ptr___destroy___0 = Module['_emscripten_bind_PxU16Ptr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxU16Ptr___destroy___0');
var _emscripten_bind_PxU32Ptr___destroy___0 = Module['_emscripten_bind_PxU32Ptr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxU32Ptr___destroy___0');
var _emscripten_bind_PxU8Ptr___destroy___0 = Module['_emscripten_bind_PxU8Ptr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxU8Ptr___destroy___0');
var _emscripten_bind_PxUserControllerHitReportImpl_PxUserControllerHitReportImpl_0 = Module['_emscripten_bind_PxUserControllerHitReportImpl_PxUserControllerHitReportImpl_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxUserControllerHitReportImpl_PxUserControllerHitReportImpl_0');
var _emscripten_bind_PxUserControllerHitReportImpl_onShapeHit_1 = Module['_emscripten_bind_PxUserControllerHitReportImpl_onShapeHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxUserControllerHitReportImpl_onShapeHit_1');
var _emscripten_bind_PxUserControllerHitReportImpl_onControllerHit_1 = Module['_emscripten_bind_PxUserControllerHitReportImpl_onControllerHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxUserControllerHitReportImpl_onControllerHit_1');
var _emscripten_bind_PxUserControllerHitReportImpl_onObstacleHit_1 = Module['_emscripten_bind_PxUserControllerHitReportImpl_onObstacleHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxUserControllerHitReportImpl_onObstacleHit_1');
var _emscripten_bind_PxUserControllerHitReportImpl___destroy___0 = Module['_emscripten_bind_PxUserControllerHitReportImpl___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxUserControllerHitReportImpl___destroy___0');
var _emscripten_bind_PxVec3_PxVec3_0 = Module['_emscripten_bind_PxVec3_PxVec3_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_PxVec3_0');
var _emscripten_bind_PxVec3_PxVec3_3 = Module['_emscripten_bind_PxVec3_PxVec3_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_PxVec3_3');
var _emscripten_bind_PxVec3_isZero_0 = Module['_emscripten_bind_PxVec3_isZero_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_isZero_0');
var _emscripten_bind_PxVec3_isFinite_0 = Module['_emscripten_bind_PxVec3_isFinite_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_isFinite_0');
var _emscripten_bind_PxVec3_isNormalized_0 = Module['_emscripten_bind_PxVec3_isNormalized_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_isNormalized_0');
var _emscripten_bind_PxVec3_magnitudeSquared_0 = Module['_emscripten_bind_PxVec3_magnitudeSquared_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_magnitudeSquared_0');
var _emscripten_bind_PxVec3_magnitude_0 = Module['_emscripten_bind_PxVec3_magnitude_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_magnitude_0');
var _emscripten_bind_PxVec3_dot_1 = Module['_emscripten_bind_PxVec3_dot_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_dot_1');
var _emscripten_bind_PxVec3_cross_1 = Module['_emscripten_bind_PxVec3_cross_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_cross_1');
var _emscripten_bind_PxVec3_getNormalized_0 = Module['_emscripten_bind_PxVec3_getNormalized_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_getNormalized_0');
var _emscripten_bind_PxVec3_normalize_0 = Module['_emscripten_bind_PxVec3_normalize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_normalize_0');
var _emscripten_bind_PxVec3_normalizeSafe_0 = Module['_emscripten_bind_PxVec3_normalizeSafe_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_normalizeSafe_0');
var _emscripten_bind_PxVec3_normalizeFast_0 = Module['_emscripten_bind_PxVec3_normalizeFast_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_normalizeFast_0');
var _emscripten_bind_PxVec3_multiply_1 = Module['_emscripten_bind_PxVec3_multiply_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_multiply_1');
var _emscripten_bind_PxVec3_minimum_1 = Module['_emscripten_bind_PxVec3_minimum_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_minimum_1');
var _emscripten_bind_PxVec3_minElement_0 = Module['_emscripten_bind_PxVec3_minElement_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_minElement_0');
var _emscripten_bind_PxVec3_maximum_1 = Module['_emscripten_bind_PxVec3_maximum_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_maximum_1');
var _emscripten_bind_PxVec3_maxElement_0 = Module['_emscripten_bind_PxVec3_maxElement_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_maxElement_0');
var _emscripten_bind_PxVec3_abs_0 = Module['_emscripten_bind_PxVec3_abs_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_abs_0');
var _emscripten_bind_PxVec3_get_x_0 = Module['_emscripten_bind_PxVec3_get_x_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_get_x_0');
var _emscripten_bind_PxVec3_set_x_1 = Module['_emscripten_bind_PxVec3_set_x_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_set_x_1');
var _emscripten_bind_PxVec3_get_y_0 = Module['_emscripten_bind_PxVec3_get_y_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_get_y_0');
var _emscripten_bind_PxVec3_set_y_1 = Module['_emscripten_bind_PxVec3_set_y_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_set_y_1');
var _emscripten_bind_PxVec3_get_z_0 = Module['_emscripten_bind_PxVec3_get_z_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_get_z_0');
var _emscripten_bind_PxVec3_set_z_1 = Module['_emscripten_bind_PxVec3_set_z_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3_set_z_1');
var _emscripten_bind_PxVec3___destroy___0 = Module['_emscripten_bind_PxVec3___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec3___destroy___0');
var _emscripten_bind_PxVec4_PxVec4_0 = Module['_emscripten_bind_PxVec4_PxVec4_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_PxVec4_0');
var _emscripten_bind_PxVec4_PxVec4_4 = Module['_emscripten_bind_PxVec4_PxVec4_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_PxVec4_4');
var _emscripten_bind_PxVec4_isZero_0 = Module['_emscripten_bind_PxVec4_isZero_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_isZero_0');
var _emscripten_bind_PxVec4_isFinite_0 = Module['_emscripten_bind_PxVec4_isFinite_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_isFinite_0');
var _emscripten_bind_PxVec4_isNormalized_0 = Module['_emscripten_bind_PxVec4_isNormalized_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_isNormalized_0');
var _emscripten_bind_PxVec4_magnitudeSquared_0 = Module['_emscripten_bind_PxVec4_magnitudeSquared_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_magnitudeSquared_0');
var _emscripten_bind_PxVec4_magnitude_0 = Module['_emscripten_bind_PxVec4_magnitude_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_magnitude_0');
var _emscripten_bind_PxVec4_dot_1 = Module['_emscripten_bind_PxVec4_dot_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_dot_1');
var _emscripten_bind_PxVec4_getNormalized_0 = Module['_emscripten_bind_PxVec4_getNormalized_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_getNormalized_0');
var _emscripten_bind_PxVec4_normalize_0 = Module['_emscripten_bind_PxVec4_normalize_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_normalize_0');
var _emscripten_bind_PxVec4_multiply_1 = Module['_emscripten_bind_PxVec4_multiply_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_multiply_1');
var _emscripten_bind_PxVec4_minimum_1 = Module['_emscripten_bind_PxVec4_minimum_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_minimum_1');
var _emscripten_bind_PxVec4_maximum_1 = Module['_emscripten_bind_PxVec4_maximum_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_maximum_1');
var _emscripten_bind_PxVec4_getXYZ_0 = Module['_emscripten_bind_PxVec4_getXYZ_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_getXYZ_0');
var _emscripten_bind_PxVec4_get_x_0 = Module['_emscripten_bind_PxVec4_get_x_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_get_x_0');
var _emscripten_bind_PxVec4_set_x_1 = Module['_emscripten_bind_PxVec4_set_x_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_set_x_1');
var _emscripten_bind_PxVec4_get_y_0 = Module['_emscripten_bind_PxVec4_get_y_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_get_y_0');
var _emscripten_bind_PxVec4_set_y_1 = Module['_emscripten_bind_PxVec4_set_y_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_set_y_1');
var _emscripten_bind_PxVec4_get_z_0 = Module['_emscripten_bind_PxVec4_get_z_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_get_z_0');
var _emscripten_bind_PxVec4_set_z_1 = Module['_emscripten_bind_PxVec4_set_z_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_set_z_1');
var _emscripten_bind_PxVec4_get_w_0 = Module['_emscripten_bind_PxVec4_get_w_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_get_w_0');
var _emscripten_bind_PxVec4_set_w_1 = Module['_emscripten_bind_PxVec4_set_w_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4_set_w_1');
var _emscripten_bind_PxVec4___destroy___0 = Module['_emscripten_bind_PxVec4___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVec4___destroy___0');
var _emscripten_bind_PxVehicleAckermannParams_PxVehicleAckermannParams_0 = Module['_emscripten_bind_PxVehicleAckermannParams_PxVehicleAckermannParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAckermannParams_PxVehicleAckermannParams_0');
var _emscripten_bind_PxVehicleAckermannParams_isValid_1 = Module['_emscripten_bind_PxVehicleAckermannParams_isValid_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAckermannParams_isValid_1');
var _emscripten_bind_PxVehicleAckermannParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleAckermannParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAckermannParams_transformAndScale_4');
var _emscripten_bind_PxVehicleAckermannParams_get_wheelIds_1 = Module['_emscripten_bind_PxVehicleAckermannParams_get_wheelIds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAckermannParams_get_wheelIds_1');
var _emscripten_bind_PxVehicleAckermannParams_set_wheelIds_2 = Module['_emscripten_bind_PxVehicleAckermannParams_set_wheelIds_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAckermannParams_set_wheelIds_2');
var _emscripten_bind_PxVehicleAckermannParams_get_wheelBase_0 = Module['_emscripten_bind_PxVehicleAckermannParams_get_wheelBase_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAckermannParams_get_wheelBase_0');
var _emscripten_bind_PxVehicleAckermannParams_set_wheelBase_1 = Module['_emscripten_bind_PxVehicleAckermannParams_set_wheelBase_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAckermannParams_set_wheelBase_1');
var _emscripten_bind_PxVehicleAckermannParams_get_trackWidth_0 = Module['_emscripten_bind_PxVehicleAckermannParams_get_trackWidth_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAckermannParams_get_trackWidth_0');
var _emscripten_bind_PxVehicleAckermannParams_set_trackWidth_1 = Module['_emscripten_bind_PxVehicleAckermannParams_set_trackWidth_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAckermannParams_set_trackWidth_1');
var _emscripten_bind_PxVehicleAckermannParams_get_strength_0 = Module['_emscripten_bind_PxVehicleAckermannParams_get_strength_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAckermannParams_get_strength_0');
var _emscripten_bind_PxVehicleAckermannParams_set_strength_1 = Module['_emscripten_bind_PxVehicleAckermannParams_set_strength_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAckermannParams_set_strength_1');
var _emscripten_bind_PxVehicleAckermannParams___destroy___0 = Module['_emscripten_bind_PxVehicleAckermannParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAckermannParams___destroy___0');
var _emscripten_bind_PxVehicleAntiRollForceParams_PxVehicleAntiRollForceParams_0 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_PxVehicleAntiRollForceParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollForceParams_PxVehicleAntiRollForceParams_0');
var _emscripten_bind_PxVehicleAntiRollForceParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollForceParams_transformAndScale_4');
var _emscripten_bind_PxVehicleAntiRollForceParams_isValid_1 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_isValid_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollForceParams_isValid_1');
var _emscripten_bind_PxVehicleAntiRollForceParams_get_wheel0_0 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_get_wheel0_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollForceParams_get_wheel0_0');
var _emscripten_bind_PxVehicleAntiRollForceParams_set_wheel0_1 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_set_wheel0_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollForceParams_set_wheel0_1');
var _emscripten_bind_PxVehicleAntiRollForceParams_get_wheel1_0 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_get_wheel1_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollForceParams_get_wheel1_0');
var _emscripten_bind_PxVehicleAntiRollForceParams_set_wheel1_1 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_set_wheel1_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollForceParams_set_wheel1_1');
var _emscripten_bind_PxVehicleAntiRollForceParams_get_stiffness_0 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_get_stiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollForceParams_get_stiffness_0');
var _emscripten_bind_PxVehicleAntiRollForceParams_set_stiffness_1 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_set_stiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollForceParams_set_stiffness_1');
var _emscripten_bind_PxVehicleAntiRollForceParams___destroy___0 = Module['_emscripten_bind_PxVehicleAntiRollForceParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollForceParams___destroy___0');
var _emscripten_bind_PxVehicleAntiRollTorque_PxVehicleAntiRollTorque_0 = Module['_emscripten_bind_PxVehicleAntiRollTorque_PxVehicleAntiRollTorque_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollTorque_PxVehicleAntiRollTorque_0');
var _emscripten_bind_PxVehicleAntiRollTorque_setToDefault_0 = Module['_emscripten_bind_PxVehicleAntiRollTorque_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollTorque_setToDefault_0');
var _emscripten_bind_PxVehicleAntiRollTorque_get_antiRollTorque_0 = Module['_emscripten_bind_PxVehicleAntiRollTorque_get_antiRollTorque_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollTorque_get_antiRollTorque_0');
var _emscripten_bind_PxVehicleAntiRollTorque_set_antiRollTorque_1 = Module['_emscripten_bind_PxVehicleAntiRollTorque_set_antiRollTorque_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollTorque_set_antiRollTorque_1');
var _emscripten_bind_PxVehicleAntiRollTorque___destroy___0 = Module['_emscripten_bind_PxVehicleAntiRollTorque___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAntiRollTorque___destroy___0');
var _emscripten_bind_PxVehicleAutoboxParams_PxVehicleAutoboxParams_0 = Module['_emscripten_bind_PxVehicleAutoboxParams_PxVehicleAutoboxParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxParams_PxVehicleAutoboxParams_0');
var _emscripten_bind_PxVehicleAutoboxParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleAutoboxParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxParams_transformAndScale_4');
var _emscripten_bind_PxVehicleAutoboxParams_isValid_1 = Module['_emscripten_bind_PxVehicleAutoboxParams_isValid_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxParams_isValid_1');
var _emscripten_bind_PxVehicleAutoboxParams_get_upRatios_1 = Module['_emscripten_bind_PxVehicleAutoboxParams_get_upRatios_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxParams_get_upRatios_1');
var _emscripten_bind_PxVehicleAutoboxParams_set_upRatios_2 = Module['_emscripten_bind_PxVehicleAutoboxParams_set_upRatios_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxParams_set_upRatios_2');
var _emscripten_bind_PxVehicleAutoboxParams_get_downRatios_1 = Module['_emscripten_bind_PxVehicleAutoboxParams_get_downRatios_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxParams_get_downRatios_1');
var _emscripten_bind_PxVehicleAutoboxParams_set_downRatios_2 = Module['_emscripten_bind_PxVehicleAutoboxParams_set_downRatios_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxParams_set_downRatios_2');
var _emscripten_bind_PxVehicleAutoboxParams_get_latency_0 = Module['_emscripten_bind_PxVehicleAutoboxParams_get_latency_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxParams_get_latency_0');
var _emscripten_bind_PxVehicleAutoboxParams_set_latency_1 = Module['_emscripten_bind_PxVehicleAutoboxParams_set_latency_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxParams_set_latency_1');
var _emscripten_bind_PxVehicleAutoboxParams___destroy___0 = Module['_emscripten_bind_PxVehicleAutoboxParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxParams___destroy___0');
var _emscripten_bind_PxVehicleAutoboxState_PxVehicleAutoboxState_0 = Module['_emscripten_bind_PxVehicleAutoboxState_PxVehicleAutoboxState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxState_PxVehicleAutoboxState_0');
var _emscripten_bind_PxVehicleAutoboxState_setToDefault_0 = Module['_emscripten_bind_PxVehicleAutoboxState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxState_setToDefault_0');
var _emscripten_bind_PxVehicleAutoboxState_get_timeSinceLastShift_0 = Module['_emscripten_bind_PxVehicleAutoboxState_get_timeSinceLastShift_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxState_get_timeSinceLastShift_0');
var _emscripten_bind_PxVehicleAutoboxState_set_timeSinceLastShift_1 = Module['_emscripten_bind_PxVehicleAutoboxState_set_timeSinceLastShift_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxState_set_timeSinceLastShift_1');
var _emscripten_bind_PxVehicleAutoboxState_get_activeAutoboxGearShift_0 = Module['_emscripten_bind_PxVehicleAutoboxState_get_activeAutoboxGearShift_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxState_get_activeAutoboxGearShift_0');
var _emscripten_bind_PxVehicleAutoboxState_set_activeAutoboxGearShift_1 = Module['_emscripten_bind_PxVehicleAutoboxState_set_activeAutoboxGearShift_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxState_set_activeAutoboxGearShift_1');
var _emscripten_bind_PxVehicleAutoboxState___destroy___0 = Module['_emscripten_bind_PxVehicleAutoboxState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAutoboxState___destroy___0');
var _emscripten_bind_PxVehicleAxleDescription_PxVehicleAxleDescription_0 = Module['_emscripten_bind_PxVehicleAxleDescription_PxVehicleAxleDescription_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_PxVehicleAxleDescription_0');
var _emscripten_bind_PxVehicleAxleDescription_setToDefault_0 = Module['_emscripten_bind_PxVehicleAxleDescription_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_setToDefault_0');
var _emscripten_bind_PxVehicleAxleDescription_getNbWheelsOnAxle_1 = Module['_emscripten_bind_PxVehicleAxleDescription_getNbWheelsOnAxle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_getNbWheelsOnAxle_1');
var _emscripten_bind_PxVehicleAxleDescription_getWheelOnAxle_2 = Module['_emscripten_bind_PxVehicleAxleDescription_getWheelOnAxle_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_getWheelOnAxle_2');
var _emscripten_bind_PxVehicleAxleDescription_getAxle_1 = Module['_emscripten_bind_PxVehicleAxleDescription_getAxle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_getAxle_1');
var _emscripten_bind_PxVehicleAxleDescription_isValid_0 = Module['_emscripten_bind_PxVehicleAxleDescription_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_isValid_0');
var _emscripten_bind_PxVehicleAxleDescription_get_nbAxles_0 = Module['_emscripten_bind_PxVehicleAxleDescription_get_nbAxles_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_get_nbAxles_0');
var _emscripten_bind_PxVehicleAxleDescription_set_nbAxles_1 = Module['_emscripten_bind_PxVehicleAxleDescription_set_nbAxles_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_set_nbAxles_1');
var _emscripten_bind_PxVehicleAxleDescription_get_nbWheelsPerAxle_1 = Module['_emscripten_bind_PxVehicleAxleDescription_get_nbWheelsPerAxle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_get_nbWheelsPerAxle_1');
var _emscripten_bind_PxVehicleAxleDescription_set_nbWheelsPerAxle_2 = Module['_emscripten_bind_PxVehicleAxleDescription_set_nbWheelsPerAxle_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_set_nbWheelsPerAxle_2');
var _emscripten_bind_PxVehicleAxleDescription_get_axleToWheelIds_1 = Module['_emscripten_bind_PxVehicleAxleDescription_get_axleToWheelIds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_get_axleToWheelIds_1');
var _emscripten_bind_PxVehicleAxleDescription_set_axleToWheelIds_2 = Module['_emscripten_bind_PxVehicleAxleDescription_set_axleToWheelIds_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_set_axleToWheelIds_2');
var _emscripten_bind_PxVehicleAxleDescription_get_wheelIdsInAxleOrder_1 = Module['_emscripten_bind_PxVehicleAxleDescription_get_wheelIdsInAxleOrder_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_get_wheelIdsInAxleOrder_1');
var _emscripten_bind_PxVehicleAxleDescription_set_wheelIdsInAxleOrder_2 = Module['_emscripten_bind_PxVehicleAxleDescription_set_wheelIdsInAxleOrder_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_set_wheelIdsInAxleOrder_2');
var _emscripten_bind_PxVehicleAxleDescription_get_nbWheels_0 = Module['_emscripten_bind_PxVehicleAxleDescription_get_nbWheels_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_get_nbWheels_0');
var _emscripten_bind_PxVehicleAxleDescription_set_nbWheels_1 = Module['_emscripten_bind_PxVehicleAxleDescription_set_nbWheels_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription_set_nbWheels_1');
var _emscripten_bind_PxVehicleAxleDescription___destroy___0 = Module['_emscripten_bind_PxVehicleAxleDescription___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleAxleDescription___destroy___0');
var _emscripten_bind_PxVehicleBrakeCommandResponseParams_PxVehicleBrakeCommandResponseParams_0 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_PxVehicleBrakeCommandResponseParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleBrakeCommandResponseParams_PxVehicleBrakeCommandResponseParams_0');
var _emscripten_bind_PxVehicleBrakeCommandResponseParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleBrakeCommandResponseParams_transformAndScale_4');
var _emscripten_bind_PxVehicleBrakeCommandResponseParams_isValid_1 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_isValid_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleBrakeCommandResponseParams_isValid_1');
var _emscripten_bind_PxVehicleBrakeCommandResponseParams_get_nonlinearResponse_0 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_get_nonlinearResponse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleBrakeCommandResponseParams_get_nonlinearResponse_0');
var _emscripten_bind_PxVehicleBrakeCommandResponseParams_set_nonlinearResponse_1 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_set_nonlinearResponse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleBrakeCommandResponseParams_set_nonlinearResponse_1');
var _emscripten_bind_PxVehicleBrakeCommandResponseParams_get_wheelResponseMultipliers_1 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_get_wheelResponseMultipliers_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleBrakeCommandResponseParams_get_wheelResponseMultipliers_1');
var _emscripten_bind_PxVehicleBrakeCommandResponseParams_set_wheelResponseMultipliers_2 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_set_wheelResponseMultipliers_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleBrakeCommandResponseParams_set_wheelResponseMultipliers_2');
var _emscripten_bind_PxVehicleBrakeCommandResponseParams_get_maxResponse_0 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_get_maxResponse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleBrakeCommandResponseParams_get_maxResponse_0');
var _emscripten_bind_PxVehicleBrakeCommandResponseParams_set_maxResponse_1 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_set_maxResponse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleBrakeCommandResponseParams_set_maxResponse_1');
var _emscripten_bind_PxVehicleBrakeCommandResponseParams___destroy___0 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleBrakeCommandResponseParams___destroy___0');
var _emscripten_bind_PxVehicleClutchCommandResponseParams_PxVehicleClutchCommandResponseParams_0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseParams_PxVehicleClutchCommandResponseParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchCommandResponseParams_PxVehicleClutchCommandResponseParams_0');
var _emscripten_bind_PxVehicleClutchCommandResponseParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleClutchCommandResponseParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchCommandResponseParams_transformAndScale_4');
var _emscripten_bind_PxVehicleClutchCommandResponseParams_isValid_0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchCommandResponseParams_isValid_0');
var _emscripten_bind_PxVehicleClutchCommandResponseParams_get_maxResponse_0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseParams_get_maxResponse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchCommandResponseParams_get_maxResponse_0');
var _emscripten_bind_PxVehicleClutchCommandResponseParams_set_maxResponse_1 = Module['_emscripten_bind_PxVehicleClutchCommandResponseParams_set_maxResponse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchCommandResponseParams_set_maxResponse_1');
var _emscripten_bind_PxVehicleClutchCommandResponseParams___destroy___0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchCommandResponseParams___destroy___0');
var _emscripten_bind_PxVehicleClutchCommandResponseState_PxVehicleClutchCommandResponseState_0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseState_PxVehicleClutchCommandResponseState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchCommandResponseState_PxVehicleClutchCommandResponseState_0');
var _emscripten_bind_PxVehicleClutchCommandResponseState_setToDefault_0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchCommandResponseState_setToDefault_0');
var _emscripten_bind_PxVehicleClutchCommandResponseState_get_normalisedCommandResponse_0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseState_get_normalisedCommandResponse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchCommandResponseState_get_normalisedCommandResponse_0');
var _emscripten_bind_PxVehicleClutchCommandResponseState_set_normalisedCommandResponse_1 = Module['_emscripten_bind_PxVehicleClutchCommandResponseState_set_normalisedCommandResponse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchCommandResponseState_set_normalisedCommandResponse_1');
var _emscripten_bind_PxVehicleClutchCommandResponseState_get_commandResponse_0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseState_get_commandResponse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchCommandResponseState_get_commandResponse_0');
var _emscripten_bind_PxVehicleClutchCommandResponseState_set_commandResponse_1 = Module['_emscripten_bind_PxVehicleClutchCommandResponseState_set_commandResponse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchCommandResponseState_set_commandResponse_1');
var _emscripten_bind_PxVehicleClutchCommandResponseState___destroy___0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchCommandResponseState___destroy___0');
var _emscripten_bind_PxVehicleClutchParams_PxVehicleClutchParams_0 = Module['_emscripten_bind_PxVehicleClutchParams_PxVehicleClutchParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchParams_PxVehicleClutchParams_0');
var _emscripten_bind_PxVehicleClutchParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleClutchParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchParams_transformAndScale_4');
var _emscripten_bind_PxVehicleClutchParams_isValid_0 = Module['_emscripten_bind_PxVehicleClutchParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchParams_isValid_0');
var _emscripten_bind_PxVehicleClutchParams_get_accuracyMode_0 = Module['_emscripten_bind_PxVehicleClutchParams_get_accuracyMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchParams_get_accuracyMode_0');
var _emscripten_bind_PxVehicleClutchParams_set_accuracyMode_1 = Module['_emscripten_bind_PxVehicleClutchParams_set_accuracyMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchParams_set_accuracyMode_1');
var _emscripten_bind_PxVehicleClutchParams_get_estimateIterations_0 = Module['_emscripten_bind_PxVehicleClutchParams_get_estimateIterations_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchParams_get_estimateIterations_0');
var _emscripten_bind_PxVehicleClutchParams_set_estimateIterations_1 = Module['_emscripten_bind_PxVehicleClutchParams_set_estimateIterations_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchParams_set_estimateIterations_1');
var _emscripten_bind_PxVehicleClutchParams___destroy___0 = Module['_emscripten_bind_PxVehicleClutchParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchParams___destroy___0');
var _emscripten_bind_PxVehicleClutchSlipState_PxVehicleClutchSlipState_0 = Module['_emscripten_bind_PxVehicleClutchSlipState_PxVehicleClutchSlipState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchSlipState_PxVehicleClutchSlipState_0');
var _emscripten_bind_PxVehicleClutchSlipState_setToDefault_0 = Module['_emscripten_bind_PxVehicleClutchSlipState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchSlipState_setToDefault_0');
var _emscripten_bind_PxVehicleClutchSlipState_get_clutchSlip_0 = Module['_emscripten_bind_PxVehicleClutchSlipState_get_clutchSlip_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchSlipState_get_clutchSlip_0');
var _emscripten_bind_PxVehicleClutchSlipState_set_clutchSlip_1 = Module['_emscripten_bind_PxVehicleClutchSlipState_set_clutchSlip_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchSlipState_set_clutchSlip_1');
var _emscripten_bind_PxVehicleClutchSlipState___destroy___0 = Module['_emscripten_bind_PxVehicleClutchSlipState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleClutchSlipState___destroy___0');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_PxVehicleCommandNonLinearResponseParams_0 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_PxVehicleCommandNonLinearResponseParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_PxVehicleCommandNonLinearResponseParams_0');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_clear_0 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_clear_0');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_addResponse_1 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_addResponse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_addResponse_1');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponses_1 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponses_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponses_1');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponses_2 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponses_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponses_2');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponses_0 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponses_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponses_0');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponses_1 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponses_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponses_1');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponsesPerCommandValue_1 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponsesPerCommandValue_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponsesPerCommandValue_1');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponsesPerCommandValue_2 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponsesPerCommandValue_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponsesPerCommandValue_2');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponsesPerCommandValue_1 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponsesPerCommandValue_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponsesPerCommandValue_1');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponsesPerCommandValue_2 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponsesPerCommandValue_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponsesPerCommandValue_2');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_commandValues_1 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_commandValues_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_commandValues_1');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_commandValues_2 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_commandValues_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_commandValues_2');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbCommandValues_0 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbCommandValues_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbCommandValues_0');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbCommandValues_1 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbCommandValues_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbCommandValues_1');
var _emscripten_bind_PxVehicleCommandNonLinearResponseParams___destroy___0 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandNonLinearResponseParams___destroy___0');
var _emscripten_bind_PxVehicleCommandState_PxVehicleCommandState_0 = Module['_emscripten_bind_PxVehicleCommandState_PxVehicleCommandState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandState_PxVehicleCommandState_0');
var _emscripten_bind_PxVehicleCommandState_setToDefault_0 = Module['_emscripten_bind_PxVehicleCommandState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandState_setToDefault_0');
var _emscripten_bind_PxVehicleCommandState_get_brakes_1 = Module['_emscripten_bind_PxVehicleCommandState_get_brakes_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandState_get_brakes_1');
var _emscripten_bind_PxVehicleCommandState_set_brakes_2 = Module['_emscripten_bind_PxVehicleCommandState_set_brakes_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandState_set_brakes_2');
var _emscripten_bind_PxVehicleCommandState_get_nbBrakes_0 = Module['_emscripten_bind_PxVehicleCommandState_get_nbBrakes_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandState_get_nbBrakes_0');
var _emscripten_bind_PxVehicleCommandState_set_nbBrakes_1 = Module['_emscripten_bind_PxVehicleCommandState_set_nbBrakes_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandState_set_nbBrakes_1');
var _emscripten_bind_PxVehicleCommandState_get_throttle_0 = Module['_emscripten_bind_PxVehicleCommandState_get_throttle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandState_get_throttle_0');
var _emscripten_bind_PxVehicleCommandState_set_throttle_1 = Module['_emscripten_bind_PxVehicleCommandState_set_throttle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandState_set_throttle_1');
var _emscripten_bind_PxVehicleCommandState_get_steer_0 = Module['_emscripten_bind_PxVehicleCommandState_get_steer_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandState_get_steer_0');
var _emscripten_bind_PxVehicleCommandState_set_steer_1 = Module['_emscripten_bind_PxVehicleCommandState_set_steer_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandState_set_steer_1');
var _emscripten_bind_PxVehicleCommandState___destroy___0 = Module['_emscripten_bind_PxVehicleCommandState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandState___destroy___0');
var _emscripten_bind_PxVehicleCommandValueResponseTable_PxVehicleCommandValueResponseTable_0 = Module['_emscripten_bind_PxVehicleCommandValueResponseTable_PxVehicleCommandValueResponseTable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandValueResponseTable_PxVehicleCommandValueResponseTable_0');
var _emscripten_bind_PxVehicleCommandValueResponseTable_get_commandValue_0 = Module['_emscripten_bind_PxVehicleCommandValueResponseTable_get_commandValue_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandValueResponseTable_get_commandValue_0');
var _emscripten_bind_PxVehicleCommandValueResponseTable_set_commandValue_1 = Module['_emscripten_bind_PxVehicleCommandValueResponseTable_set_commandValue_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandValueResponseTable_set_commandValue_1');
var _emscripten_bind_PxVehicleCommandValueResponseTable___destroy___0 = Module['_emscripten_bind_PxVehicleCommandValueResponseTable___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleCommandValueResponseTable___destroy___0');
var _emscripten_bind_PxVehicleComponent___destroy___0 = Module['_emscripten_bind_PxVehicleComponent___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleComponent___destroy___0');
var _emscripten_bind_PxVehicleComponentSequence_PxVehicleComponentSequence_0 = Module['_emscripten_bind_PxVehicleComponentSequence_PxVehicleComponentSequence_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleComponentSequence_PxVehicleComponentSequence_0');
var _emscripten_bind_PxVehicleComponentSequence_add_1 = Module['_emscripten_bind_PxVehicleComponentSequence_add_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleComponentSequence_add_1');
var _emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_0 = Module['_emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_0');
var _emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_1 = Module['_emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_1');
var _emscripten_bind_PxVehicleComponentSequence_endSubstepGroup_0 = Module['_emscripten_bind_PxVehicleComponentSequence_endSubstepGroup_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleComponentSequence_endSubstepGroup_0');
var _emscripten_bind_PxVehicleComponentSequence_setSubsteps_2 = Module['_emscripten_bind_PxVehicleComponentSequence_setSubsteps_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleComponentSequence_setSubsteps_2');
var _emscripten_bind_PxVehicleComponentSequence_update_2 = Module['_emscripten_bind_PxVehicleComponentSequence_update_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleComponentSequence_update_2');
var _emscripten_bind_PxVehicleComponentSequence___destroy___0 = Module['_emscripten_bind_PxVehicleComponentSequence___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleComponentSequence___destroy___0');
var _emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_0 = Module['_emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_0');
var _emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_1 = Module['_emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_1');
var _emscripten_bind_PxVehicleConstraintConnector_setConstraintState_1 = Module['_emscripten_bind_PxVehicleConstraintConnector_setConstraintState_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleConstraintConnector_setConstraintState_1');
var _emscripten_bind_PxVehicleConstraintConnector_getConstantBlock_0 = Module['_emscripten_bind_PxVehicleConstraintConnector_getConstantBlock_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleConstraintConnector_getConstantBlock_0');
var _emscripten_bind_PxVehicleConstraintConnector_prepareData_0 = Module['_emscripten_bind_PxVehicleConstraintConnector_prepareData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleConstraintConnector_prepareData_0');
var _emscripten_bind_PxVehicleConstraintConnector_updateOmniPvdProperties_0 = Module['_emscripten_bind_PxVehicleConstraintConnector_updateOmniPvdProperties_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleConstraintConnector_updateOmniPvdProperties_0');
var _emscripten_bind_PxVehicleConstraintConnector_onConstraintRelease_0 = Module['_emscripten_bind_PxVehicleConstraintConnector_onConstraintRelease_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleConstraintConnector_onConstraintRelease_0');
var _emscripten_bind_PxVehicleConstraintConnector_onComShift_1 = Module['_emscripten_bind_PxVehicleConstraintConnector_onComShift_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleConstraintConnector_onComShift_1');
var _emscripten_bind_PxVehicleConstraintConnector_onOriginShift_1 = Module['_emscripten_bind_PxVehicleConstraintConnector_onOriginShift_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleConstraintConnector_onOriginShift_1');
var _emscripten_bind_PxVehicleConstraintConnector_getSerializable_0 = Module['_emscripten_bind_PxVehicleConstraintConnector_getSerializable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleConstraintConnector_getSerializable_0');
var _emscripten_bind_PxVehicleConstraintConnector_getPrep_0 = Module['_emscripten_bind_PxVehicleConstraintConnector_getPrep_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleConstraintConnector_getPrep_0');
var _emscripten_bind_PxVehicleConstraintConnector_connectToConstraint_1 = Module['_emscripten_bind_PxVehicleConstraintConnector_connectToConstraint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleConstraintConnector_connectToConstraint_1');
var _emscripten_bind_PxVehicleConstraintConnector___destroy___0 = Module['_emscripten_bind_PxVehicleConstraintConnector___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleConstraintConnector___destroy___0');
var _emscripten_bind_PxVehicleDifferentialState_PxVehicleDifferentialState_0 = Module['_emscripten_bind_PxVehicleDifferentialState_PxVehicleDifferentialState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDifferentialState_PxVehicleDifferentialState_0');
var _emscripten_bind_PxVehicleDifferentialState_setToDefault_0 = Module['_emscripten_bind_PxVehicleDifferentialState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDifferentialState_setToDefault_0');
var _emscripten_bind_PxVehicleDifferentialState_get_connectedWheels_1 = Module['_emscripten_bind_PxVehicleDifferentialState_get_connectedWheels_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDifferentialState_get_connectedWheels_1');
var _emscripten_bind_PxVehicleDifferentialState_set_connectedWheels_2 = Module['_emscripten_bind_PxVehicleDifferentialState_set_connectedWheels_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDifferentialState_set_connectedWheels_2');
var _emscripten_bind_PxVehicleDifferentialState_get_nbConnectedWheels_0 = Module['_emscripten_bind_PxVehicleDifferentialState_get_nbConnectedWheels_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDifferentialState_get_nbConnectedWheels_0');
var _emscripten_bind_PxVehicleDifferentialState_set_nbConnectedWheels_1 = Module['_emscripten_bind_PxVehicleDifferentialState_set_nbConnectedWheels_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDifferentialState_set_nbConnectedWheels_1');
var _emscripten_bind_PxVehicleDifferentialState_get_torqueRatiosAllWheels_1 = Module['_emscripten_bind_PxVehicleDifferentialState_get_torqueRatiosAllWheels_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDifferentialState_get_torqueRatiosAllWheels_1');
var _emscripten_bind_PxVehicleDifferentialState_set_torqueRatiosAllWheels_2 = Module['_emscripten_bind_PxVehicleDifferentialState_set_torqueRatiosAllWheels_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDifferentialState_set_torqueRatiosAllWheels_2');
var _emscripten_bind_PxVehicleDifferentialState_get_aveWheelSpeedContributionAllWheels_1 = Module['_emscripten_bind_PxVehicleDifferentialState_get_aveWheelSpeedContributionAllWheels_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDifferentialState_get_aveWheelSpeedContributionAllWheels_1');
var _emscripten_bind_PxVehicleDifferentialState_set_aveWheelSpeedContributionAllWheels_2 = Module['_emscripten_bind_PxVehicleDifferentialState_set_aveWheelSpeedContributionAllWheels_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDifferentialState_set_aveWheelSpeedContributionAllWheels_2');
var _emscripten_bind_PxVehicleDifferentialState___destroy___0 = Module['_emscripten_bind_PxVehicleDifferentialState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDifferentialState___destroy___0');
var _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_PxVehicleDirectDriveThrottleCommandResponseParams_0 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_PxVehicleDirectDriveThrottleCommandResponseParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_PxVehicleDirectDriveThrottleCommandResponseParams_0');
var _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_transformAndScale_4');
var _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_isValid_1 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_isValid_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_isValid_1');
var _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_nonlinearResponse_0 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_nonlinearResponse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_nonlinearResponse_0');
var _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_nonlinearResponse_1 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_nonlinearResponse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_nonlinearResponse_1');
var _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_wheelResponseMultipliers_1 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_wheelResponseMultipliers_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_wheelResponseMultipliers_1');
var _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_wheelResponseMultipliers_2 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_wheelResponseMultipliers_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_wheelResponseMultipliers_2');
var _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_maxResponse_0 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_maxResponse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_maxResponse_0');
var _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_maxResponse_1 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_maxResponse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_maxResponse_1');
var _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams___destroy___0 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams___destroy___0');
var _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_PxVehicleDirectDriveTransmissionCommandState_0 = Module['_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_PxVehicleDirectDriveTransmissionCommandState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_PxVehicleDirectDriveTransmissionCommandState_0');
var _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_setToDefault_0 = Module['_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_setToDefault_0');
var _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_get_gear_0 = Module['_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_get_gear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_get_gear_0');
var _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_set_gear_1 = Module['_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_set_gear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_set_gear_1');
var _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState___destroy___0 = Module['_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState___destroy___0');
var _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_PxVehicleEngineDriveThrottleCommandResponseState_0 = Module['_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_PxVehicleEngineDriveThrottleCommandResponseState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_PxVehicleEngineDriveThrottleCommandResponseState_0');
var _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_setToDefault_0 = Module['_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_setToDefault_0');
var _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_get_commandResponse_0 = Module['_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_get_commandResponse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_get_commandResponse_0');
var _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_set_commandResponse_1 = Module['_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_set_commandResponse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_set_commandResponse_1');
var _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState___destroy___0 = Module['_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState___destroy___0');
var _emscripten_bind_PxVehicleEngineParams_PxVehicleEngineParams_0 = Module['_emscripten_bind_PxVehicleEngineParams_PxVehicleEngineParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_PxVehicleEngineParams_0');
var _emscripten_bind_PxVehicleEngineParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleEngineParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_transformAndScale_4');
var _emscripten_bind_PxVehicleEngineParams_isValid_0 = Module['_emscripten_bind_PxVehicleEngineParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_isValid_0');
var _emscripten_bind_PxVehicleEngineParams_get_torqueCurve_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_torqueCurve_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_get_torqueCurve_0');
var _emscripten_bind_PxVehicleEngineParams_set_torqueCurve_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_torqueCurve_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_set_torqueCurve_1');
var _emscripten_bind_PxVehicleEngineParams_get_moi_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_moi_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_get_moi_0');
var _emscripten_bind_PxVehicleEngineParams_set_moi_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_moi_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_set_moi_1');
var _emscripten_bind_PxVehicleEngineParams_get_peakTorque_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_peakTorque_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_get_peakTorque_0');
var _emscripten_bind_PxVehicleEngineParams_set_peakTorque_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_peakTorque_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_set_peakTorque_1');
var _emscripten_bind_PxVehicleEngineParams_get_idleOmega_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_idleOmega_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_get_idleOmega_0');
var _emscripten_bind_PxVehicleEngineParams_set_idleOmega_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_idleOmega_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_set_idleOmega_1');
var _emscripten_bind_PxVehicleEngineParams_get_maxOmega_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_maxOmega_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_get_maxOmega_0');
var _emscripten_bind_PxVehicleEngineParams_set_maxOmega_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_maxOmega_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_set_maxOmega_1');
var _emscripten_bind_PxVehicleEngineParams_get_dampingRateFullThrottle_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_dampingRateFullThrottle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_get_dampingRateFullThrottle_0');
var _emscripten_bind_PxVehicleEngineParams_set_dampingRateFullThrottle_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_dampingRateFullThrottle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_set_dampingRateFullThrottle_1');
var _emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchEngaged_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchEngaged_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchEngaged_0');
var _emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchEngaged_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchEngaged_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchEngaged_1');
var _emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchDisengaged_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchDisengaged_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchDisengaged_0');
var _emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchDisengaged_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchDisengaged_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchDisengaged_1');
var _emscripten_bind_PxVehicleEngineParams___destroy___0 = Module['_emscripten_bind_PxVehicleEngineParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineParams___destroy___0');
var _emscripten_bind_PxVehicleEngineState_PxVehicleEngineState_0 = Module['_emscripten_bind_PxVehicleEngineState_PxVehicleEngineState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineState_PxVehicleEngineState_0');
var _emscripten_bind_PxVehicleEngineState_setToDefault_0 = Module['_emscripten_bind_PxVehicleEngineState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineState_setToDefault_0');
var _emscripten_bind_PxVehicleEngineState_get_rotationSpeed_0 = Module['_emscripten_bind_PxVehicleEngineState_get_rotationSpeed_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineState_get_rotationSpeed_0');
var _emscripten_bind_PxVehicleEngineState_set_rotationSpeed_1 = Module['_emscripten_bind_PxVehicleEngineState_set_rotationSpeed_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineState_set_rotationSpeed_1');
var _emscripten_bind_PxVehicleEngineState___destroy___0 = Module['_emscripten_bind_PxVehicleEngineState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleEngineState___destroy___0');
var _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_PxVehicleFixedSizeLookupTableFloat_3_0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_PxVehicleFixedSizeLookupTableFloat_3_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_PxVehicleFixedSizeLookupTableFloat_3_0');
var _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_addPair_2 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_addPair_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_addPair_2');
var _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_interpolate_1 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_interpolate_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_interpolate_1');
var _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_clear_0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_clear_0');
var _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_isValid_0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_isValid_0');
var _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3___destroy___0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3___destroy___0');
var _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_PxVehicleFixedSizeLookupTableVec3_3_0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_PxVehicleFixedSizeLookupTableVec3_3_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_PxVehicleFixedSizeLookupTableVec3_3_0');
var _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_addPair_2 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_addPair_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_addPair_2');
var _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_interpolate_1 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_interpolate_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_interpolate_1');
var _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_clear_0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_clear_0');
var _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_isValid_0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_isValid_0');
var _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3___destroy___0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3___destroy___0');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_PxVehicleFourWheelDriveDifferentialParams_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_PxVehicleFourWheelDriveDifferentialParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_PxVehicleFourWheelDriveDifferentialParams_0');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_setToDefault_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_setToDefault_0');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_transformAndScale_4');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_isValid_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_isValid_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_isValid_1');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontWheelIds_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontWheelIds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontWheelIds_1');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontWheelIds_2 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontWheelIds_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontWheelIds_2');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearWheelIds_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearWheelIds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearWheelIds_1');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearWheelIds_2 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearWheelIds_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearWheelIds_2');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontBias_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontBias_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontBias_0');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontBias_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontBias_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontBias_1');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontTarget_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontTarget_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontTarget_0');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontTarget_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontTarget_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontTarget_1');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearBias_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearBias_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearBias_0');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearBias_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearBias_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearBias_1');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearTarget_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearTarget_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearTarget_0');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearTarget_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearTarget_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearTarget_1');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerBias_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerBias_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerBias_0');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerBias_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerBias_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerBias_1');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerTarget_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerTarget_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerTarget_0');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerTarget_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerTarget_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerTarget_1');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rate_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rate_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rate_0');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rate_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rate_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rate_1');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_torqueRatios_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_torqueRatios_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_torqueRatios_1');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_torqueRatios_2 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_torqueRatios_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_torqueRatios_2');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2');
var _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams___destroy___0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams___destroy___0');
var _emscripten_bind_PxVehicleFrame_PxVehicleFrame_0 = Module['_emscripten_bind_PxVehicleFrame_PxVehicleFrame_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFrame_PxVehicleFrame_0');
var _emscripten_bind_PxVehicleFrame_setToDefault_0 = Module['_emscripten_bind_PxVehicleFrame_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFrame_setToDefault_0');
var _emscripten_bind_PxVehicleFrame_getFrame_0 = Module['_emscripten_bind_PxVehicleFrame_getFrame_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFrame_getFrame_0');
var _emscripten_bind_PxVehicleFrame_isValid_0 = Module['_emscripten_bind_PxVehicleFrame_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFrame_isValid_0');
var _emscripten_bind_PxVehicleFrame_get_lngAxis_0 = Module['_emscripten_bind_PxVehicleFrame_get_lngAxis_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFrame_get_lngAxis_0');
var _emscripten_bind_PxVehicleFrame_set_lngAxis_1 = Module['_emscripten_bind_PxVehicleFrame_set_lngAxis_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFrame_set_lngAxis_1');
var _emscripten_bind_PxVehicleFrame_get_latAxis_0 = Module['_emscripten_bind_PxVehicleFrame_get_latAxis_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFrame_get_latAxis_0');
var _emscripten_bind_PxVehicleFrame_set_latAxis_1 = Module['_emscripten_bind_PxVehicleFrame_set_latAxis_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFrame_set_latAxis_1');
var _emscripten_bind_PxVehicleFrame_get_vrtAxis_0 = Module['_emscripten_bind_PxVehicleFrame_get_vrtAxis_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFrame_get_vrtAxis_0');
var _emscripten_bind_PxVehicleFrame_set_vrtAxis_1 = Module['_emscripten_bind_PxVehicleFrame_set_vrtAxis_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFrame_set_vrtAxis_1');
var _emscripten_bind_PxVehicleFrame___destroy___0 = Module['_emscripten_bind_PxVehicleFrame___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleFrame___destroy___0');
var _emscripten_bind_PxVehicleGearboxParams_PxVehicleGearboxParams_0 = Module['_emscripten_bind_PxVehicleGearboxParams_PxVehicleGearboxParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxParams_PxVehicleGearboxParams_0');
var _emscripten_bind_PxVehicleGearboxParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleGearboxParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxParams_transformAndScale_4');
var _emscripten_bind_PxVehicleGearboxParams_isValid_0 = Module['_emscripten_bind_PxVehicleGearboxParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxParams_isValid_0');
var _emscripten_bind_PxVehicleGearboxParams_get_neutralGear_0 = Module['_emscripten_bind_PxVehicleGearboxParams_get_neutralGear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxParams_get_neutralGear_0');
var _emscripten_bind_PxVehicleGearboxParams_set_neutralGear_1 = Module['_emscripten_bind_PxVehicleGearboxParams_set_neutralGear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxParams_set_neutralGear_1');
var _emscripten_bind_PxVehicleGearboxParams_get_ratios_1 = Module['_emscripten_bind_PxVehicleGearboxParams_get_ratios_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxParams_get_ratios_1');
var _emscripten_bind_PxVehicleGearboxParams_set_ratios_2 = Module['_emscripten_bind_PxVehicleGearboxParams_set_ratios_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxParams_set_ratios_2');
var _emscripten_bind_PxVehicleGearboxParams_get_finalRatio_0 = Module['_emscripten_bind_PxVehicleGearboxParams_get_finalRatio_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxParams_get_finalRatio_0');
var _emscripten_bind_PxVehicleGearboxParams_set_finalRatio_1 = Module['_emscripten_bind_PxVehicleGearboxParams_set_finalRatio_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxParams_set_finalRatio_1');
var _emscripten_bind_PxVehicleGearboxParams_get_nbRatios_0 = Module['_emscripten_bind_PxVehicleGearboxParams_get_nbRatios_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxParams_get_nbRatios_0');
var _emscripten_bind_PxVehicleGearboxParams_set_nbRatios_1 = Module['_emscripten_bind_PxVehicleGearboxParams_set_nbRatios_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxParams_set_nbRatios_1');
var _emscripten_bind_PxVehicleGearboxParams_get_switchTime_0 = Module['_emscripten_bind_PxVehicleGearboxParams_get_switchTime_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxParams_get_switchTime_0');
var _emscripten_bind_PxVehicleGearboxParams_set_switchTime_1 = Module['_emscripten_bind_PxVehicleGearboxParams_set_switchTime_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxParams_set_switchTime_1');
var _emscripten_bind_PxVehicleGearboxParams___destroy___0 = Module['_emscripten_bind_PxVehicleGearboxParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxParams___destroy___0');
var _emscripten_bind_PxVehicleGearboxState_PxVehicleGearboxState_0 = Module['_emscripten_bind_PxVehicleGearboxState_PxVehicleGearboxState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxState_PxVehicleGearboxState_0');
var _emscripten_bind_PxVehicleGearboxState_setToDefault_0 = Module['_emscripten_bind_PxVehicleGearboxState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxState_setToDefault_0');
var _emscripten_bind_PxVehicleGearboxState_get_currentGear_0 = Module['_emscripten_bind_PxVehicleGearboxState_get_currentGear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxState_get_currentGear_0');
var _emscripten_bind_PxVehicleGearboxState_set_currentGear_1 = Module['_emscripten_bind_PxVehicleGearboxState_set_currentGear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxState_set_currentGear_1');
var _emscripten_bind_PxVehicleGearboxState_get_targetGear_0 = Module['_emscripten_bind_PxVehicleGearboxState_get_targetGear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxState_get_targetGear_0');
var _emscripten_bind_PxVehicleGearboxState_set_targetGear_1 = Module['_emscripten_bind_PxVehicleGearboxState_set_targetGear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxState_set_targetGear_1');
var _emscripten_bind_PxVehicleGearboxState_get_gearSwitchTime_0 = Module['_emscripten_bind_PxVehicleGearboxState_get_gearSwitchTime_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxState_get_gearSwitchTime_0');
var _emscripten_bind_PxVehicleGearboxState_set_gearSwitchTime_1 = Module['_emscripten_bind_PxVehicleGearboxState_set_gearSwitchTime_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxState_set_gearSwitchTime_1');
var _emscripten_bind_PxVehicleGearboxState___destroy___0 = Module['_emscripten_bind_PxVehicleGearboxState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleGearboxState___destroy___0');
var _emscripten_bind_PxVehiclePhysXActor_setToDefault_0 = Module['_emscripten_bind_PxVehiclePhysXActor_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXActor_setToDefault_0');
var _emscripten_bind_PxVehiclePhysXActor_get_rigidBody_0 = Module['_emscripten_bind_PxVehiclePhysXActor_get_rigidBody_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXActor_get_rigidBody_0');
var _emscripten_bind_PxVehiclePhysXActor_set_rigidBody_1 = Module['_emscripten_bind_PxVehiclePhysXActor_set_rigidBody_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXActor_set_rigidBody_1');
var _emscripten_bind_PxVehiclePhysXActor_get_wheelShapes_1 = Module['_emscripten_bind_PxVehiclePhysXActor_get_wheelShapes_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXActor_get_wheelShapes_1');
var _emscripten_bind_PxVehiclePhysXActor_set_wheelShapes_2 = Module['_emscripten_bind_PxVehiclePhysXActor_set_wheelShapes_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXActor_set_wheelShapes_2');
var _emscripten_bind_PxVehiclePhysXActor___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXActor___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXActor___destroy___0');
var _emscripten_bind_PxVehiclePhysXConstraintState_PxVehiclePhysXConstraintState_0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_PxVehiclePhysXConstraintState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_PxVehiclePhysXConstraintState_0');
var _emscripten_bind_PxVehiclePhysXConstraintState_setToDefault_0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_setToDefault_0');
var _emscripten_bind_PxVehiclePhysXConstraintState_get_tireActiveStatus_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_tireActiveStatus_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_get_tireActiveStatus_1');
var _emscripten_bind_PxVehiclePhysXConstraintState_set_tireActiveStatus_2 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_tireActiveStatus_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_set_tireActiveStatus_2');
var _emscripten_bind_PxVehiclePhysXConstraintState_get_tireLinears_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_tireLinears_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_get_tireLinears_1');
var _emscripten_bind_PxVehiclePhysXConstraintState_set_tireLinears_2 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_tireLinears_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_set_tireLinears_2');
var _emscripten_bind_PxVehiclePhysXConstraintState_get_tireAngulars_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_tireAngulars_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_get_tireAngulars_1');
var _emscripten_bind_PxVehiclePhysXConstraintState_set_tireAngulars_2 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_tireAngulars_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_set_tireAngulars_2');
var _emscripten_bind_PxVehiclePhysXConstraintState_get_tireDamping_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_tireDamping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_get_tireDamping_1');
var _emscripten_bind_PxVehiclePhysXConstraintState_set_tireDamping_2 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_tireDamping_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_set_tireDamping_2');
var _emscripten_bind_PxVehiclePhysXConstraintState_get_suspActiveStatus_0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_suspActiveStatus_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_get_suspActiveStatus_0');
var _emscripten_bind_PxVehiclePhysXConstraintState_set_suspActiveStatus_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_suspActiveStatus_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_set_suspActiveStatus_1');
var _emscripten_bind_PxVehiclePhysXConstraintState_get_suspLinear_0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_suspLinear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_get_suspLinear_0');
var _emscripten_bind_PxVehiclePhysXConstraintState_set_suspLinear_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_suspLinear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_set_suspLinear_1');
var _emscripten_bind_PxVehiclePhysXConstraintState_get_suspAngular_0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_suspAngular_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_get_suspAngular_0');
var _emscripten_bind_PxVehiclePhysXConstraintState_set_suspAngular_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_suspAngular_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_set_suspAngular_1');
var _emscripten_bind_PxVehiclePhysXConstraintState_get_suspGeometricError_0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_suspGeometricError_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_get_suspGeometricError_0');
var _emscripten_bind_PxVehiclePhysXConstraintState_set_suspGeometricError_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_suspGeometricError_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_set_suspGeometricError_1');
var _emscripten_bind_PxVehiclePhysXConstraintState_get_restitution_0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_restitution_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_get_restitution_0');
var _emscripten_bind_PxVehiclePhysXConstraintState_set_restitution_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_restitution_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState_set_restitution_1');
var _emscripten_bind_PxVehiclePhysXConstraintState___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraintState___destroy___0');
var _emscripten_bind_PxVehiclePhysXConstraints_setToDefault_0 = Module['_emscripten_bind_PxVehiclePhysXConstraints_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraints_setToDefault_0');
var _emscripten_bind_PxVehiclePhysXConstraints_get_constraintStates_1 = Module['_emscripten_bind_PxVehiclePhysXConstraints_get_constraintStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraints_get_constraintStates_1');
var _emscripten_bind_PxVehiclePhysXConstraints_set_constraintStates_2 = Module['_emscripten_bind_PxVehiclePhysXConstraints_set_constraintStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraints_set_constraintStates_2');
var _emscripten_bind_PxVehiclePhysXConstraints_get_constraints_1 = Module['_emscripten_bind_PxVehiclePhysXConstraints_get_constraints_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraints_get_constraints_1');
var _emscripten_bind_PxVehiclePhysXConstraints_set_constraints_2 = Module['_emscripten_bind_PxVehiclePhysXConstraints_set_constraints_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraints_set_constraints_2');
var _emscripten_bind_PxVehiclePhysXConstraints_get_constraintConnectors_1 = Module['_emscripten_bind_PxVehiclePhysXConstraints_get_constraintConnectors_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraints_get_constraintConnectors_1');
var _emscripten_bind_PxVehiclePhysXConstraints_set_constraintConnectors_2 = Module['_emscripten_bind_PxVehiclePhysXConstraints_set_constraintConnectors_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraints_set_constraintConnectors_2');
var _emscripten_bind_PxVehiclePhysXConstraints___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXConstraints___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXConstraints___destroy___0');
var _emscripten_bind_PxVehiclePhysXMaterialFriction_PxVehiclePhysXMaterialFriction_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFriction_PxVehiclePhysXMaterialFriction_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFriction_PxVehiclePhysXMaterialFriction_0');
var _emscripten_bind_PxVehiclePhysXMaterialFriction_isValid_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFriction_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFriction_isValid_0');
var _emscripten_bind_PxVehiclePhysXMaterialFriction_get_material_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFriction_get_material_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFriction_get_material_0');
var _emscripten_bind_PxVehiclePhysXMaterialFriction_set_material_1 = Module['_emscripten_bind_PxVehiclePhysXMaterialFriction_set_material_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFriction_set_material_1');
var _emscripten_bind_PxVehiclePhysXMaterialFriction_get_friction_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFriction_get_friction_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFriction_get_friction_0');
var _emscripten_bind_PxVehiclePhysXMaterialFriction_set_friction_1 = Module['_emscripten_bind_PxVehiclePhysXMaterialFriction_set_friction_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFriction_set_friction_1');
var _emscripten_bind_PxVehiclePhysXMaterialFriction___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFriction___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFriction___destroy___0');
var _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_isValid_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_isValid_0');
var _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_materialFrictions_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_materialFrictions_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_materialFrictions_0');
var _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_materialFrictions_1 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_materialFrictions_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_materialFrictions_1');
var _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_nbMaterialFrictions_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_nbMaterialFrictions_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_nbMaterialFrictions_0');
var _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_nbMaterialFrictions_1 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_nbMaterialFrictions_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_nbMaterialFrictions_1');
var _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_defaultFriction_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_defaultFriction_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_defaultFriction_0');
var _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_defaultFriction_1 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_defaultFriction_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_defaultFriction_1');
var _emscripten_bind_PxVehiclePhysXMaterialFrictionParams___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXMaterialFrictionParams___destroy___0');
var _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_transformAndScale_4 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_transformAndScale_4');
var _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_isValid_0 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_isValid_0');
var _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_roadGeometryQueryType_0 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_roadGeometryQueryType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_roadGeometryQueryType_0');
var _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_roadGeometryQueryType_1 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_roadGeometryQueryType_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_roadGeometryQueryType_1');
var _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_defaultFilterData_0 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_defaultFilterData_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_defaultFilterData_0');
var _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_defaultFilterData_1 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_defaultFilterData_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_defaultFilterData_1');
var _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterDataEntries_0 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterDataEntries_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterDataEntries_0');
var _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterDataEntries_1 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterDataEntries_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterDataEntries_1');
var _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterCallback_0 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterCallback_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterCallback_0');
var _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterCallback_1 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterCallback_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterCallback_1');
var _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams___destroy___0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_PxVehiclePhysXSimulationContext_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_PxVehiclePhysXSimulationContext_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_PxVehiclePhysXSimulationContext_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_transformAndScale_4 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_transformAndScale_4');
var _emscripten_bind_PxVehiclePhysXSimulationContext_getType_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_getType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_getType_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_setToDefault_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_setToDefault_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_get_physxUnitCylinderSweepMesh_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxUnitCylinderSweepMesh_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxUnitCylinderSweepMesh_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxUnitCylinderSweepMesh_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxUnitCylinderSweepMesh_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxUnitCylinderSweepMesh_1');
var _emscripten_bind_PxVehiclePhysXSimulationContext_get_physxScene_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxScene_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxScene_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxScene_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxScene_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxScene_1');
var _emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorUpdateMode_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorUpdateMode_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorUpdateMode_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorUpdateMode_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorUpdateMode_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorUpdateMode_1');
var _emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterResetValue_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterResetValue_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterResetValue_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterResetValue_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterResetValue_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterResetValue_1');
var _emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterThreshold_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterThreshold_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterThreshold_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterThreshold_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterThreshold_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterThreshold_1');
var _emscripten_bind_PxVehiclePhysXSimulationContext_get_gravity_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_gravity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_get_gravity_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_set_gravity_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_gravity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_set_gravity_1');
var _emscripten_bind_PxVehiclePhysXSimulationContext_get_frame_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_frame_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_get_frame_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_set_frame_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_frame_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_set_frame_1');
var _emscripten_bind_PxVehiclePhysXSimulationContext_get_scale_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_scale_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_get_scale_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_set_scale_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_scale_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_set_scale_1');
var _emscripten_bind_PxVehiclePhysXSimulationContext_get_tireSlipParams_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_tireSlipParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_get_tireSlipParams_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_set_tireSlipParams_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_tireSlipParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_set_tireSlipParams_1');
var _emscripten_bind_PxVehiclePhysXSimulationContext_get_tireStickyParams_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_tireStickyParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_get_tireStickyParams_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_set_tireStickyParams_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_tireStickyParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_set_tireStickyParams_1');
var _emscripten_bind_PxVehiclePhysXSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1');
var _emscripten_bind_PxVehiclePhysXSimulationContext_get_pvdContext_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_pvdContext_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_get_pvdContext_0');
var _emscripten_bind_PxVehiclePhysXSimulationContext_set_pvdContext_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_pvdContext_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSimulationContext_set_pvdContext_1');
var _emscripten_bind_PxVehiclePhysXSteerState_setToDefault_0 = Module['_emscripten_bind_PxVehiclePhysXSteerState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSteerState_setToDefault_0');
var _emscripten_bind_PxVehiclePhysXSteerState_get_previousSteerCommand_0 = Module['_emscripten_bind_PxVehiclePhysXSteerState_get_previousSteerCommand_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSteerState_get_previousSteerCommand_0');
var _emscripten_bind_PxVehiclePhysXSteerState_set_previousSteerCommand_1 = Module['_emscripten_bind_PxVehiclePhysXSteerState_set_previousSteerCommand_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSteerState_set_previousSteerCommand_1');
var _emscripten_bind_PxVehiclePhysXSteerState___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXSteerState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSteerState___destroy___0');
var _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_transformAndScale_4 = Module['_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_transformAndScale_4');
var _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_isValid_0 = Module['_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_isValid_0');
var _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_restitution_0 = Module['_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_restitution_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_restitution_0');
var _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_restitution_1 = Module['_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_restitution_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_restitution_1');
var _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_directionForSuspensionLimitConstraint_0 = Module['_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_directionForSuspensionLimitConstraint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_directionForSuspensionLimitConstraint_0');
var _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_directionForSuspensionLimitConstraint_1 = Module['_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_directionForSuspensionLimitConstraint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_directionForSuspensionLimitConstraint_1');
var _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams___destroy___0');
var _emscripten_bind_PxVehicleRigidBodyParams_PxVehicleRigidBodyParams_0 = Module['_emscripten_bind_PxVehicleRigidBodyParams_PxVehicleRigidBodyParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyParams_PxVehicleRigidBodyParams_0');
var _emscripten_bind_PxVehicleRigidBodyParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleRigidBodyParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyParams_transformAndScale_4');
var _emscripten_bind_PxVehicleRigidBodyParams_isValid_0 = Module['_emscripten_bind_PxVehicleRigidBodyParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyParams_isValid_0');
var _emscripten_bind_PxVehicleRigidBodyParams_get_mass_0 = Module['_emscripten_bind_PxVehicleRigidBodyParams_get_mass_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyParams_get_mass_0');
var _emscripten_bind_PxVehicleRigidBodyParams_set_mass_1 = Module['_emscripten_bind_PxVehicleRigidBodyParams_set_mass_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyParams_set_mass_1');
var _emscripten_bind_PxVehicleRigidBodyParams_get_moi_0 = Module['_emscripten_bind_PxVehicleRigidBodyParams_get_moi_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyParams_get_moi_0');
var _emscripten_bind_PxVehicleRigidBodyParams_set_moi_1 = Module['_emscripten_bind_PxVehicleRigidBodyParams_set_moi_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyParams_set_moi_1');
var _emscripten_bind_PxVehicleRigidBodyParams___destroy___0 = Module['_emscripten_bind_PxVehicleRigidBodyParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyParams___destroy___0');
var _emscripten_bind_PxVehicleRigidBodyState_PxVehicleRigidBodyState_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_PxVehicleRigidBodyState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_PxVehicleRigidBodyState_0');
var _emscripten_bind_PxVehicleRigidBodyState_setToDefault_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_setToDefault_0');
var _emscripten_bind_PxVehicleRigidBodyState_getVerticalSpeed_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_getVerticalSpeed_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_getVerticalSpeed_1');
var _emscripten_bind_PxVehicleRigidBodyState_getLateralSpeed_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_getLateralSpeed_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_getLateralSpeed_1');
var _emscripten_bind_PxVehicleRigidBodyState_getLongitudinalSpeed_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_getLongitudinalSpeed_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_getLongitudinalSpeed_1');
var _emscripten_bind_PxVehicleRigidBodyState_get_pose_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_get_pose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_get_pose_0');
var _emscripten_bind_PxVehicleRigidBodyState_set_pose_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_set_pose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_set_pose_1');
var _emscripten_bind_PxVehicleRigidBodyState_get_linearVelocity_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_get_linearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_get_linearVelocity_0');
var _emscripten_bind_PxVehicleRigidBodyState_set_linearVelocity_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_set_linearVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_set_linearVelocity_1');
var _emscripten_bind_PxVehicleRigidBodyState_get_angularVelocity_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_get_angularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_get_angularVelocity_0');
var _emscripten_bind_PxVehicleRigidBodyState_set_angularVelocity_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_set_angularVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_set_angularVelocity_1');
var _emscripten_bind_PxVehicleRigidBodyState_get_previousLinearVelocity_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_get_previousLinearVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_get_previousLinearVelocity_0');
var _emscripten_bind_PxVehicleRigidBodyState_set_previousLinearVelocity_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_set_previousLinearVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_set_previousLinearVelocity_1');
var _emscripten_bind_PxVehicleRigidBodyState_get_previousAngularVelocity_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_get_previousAngularVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_get_previousAngularVelocity_0');
var _emscripten_bind_PxVehicleRigidBodyState_set_previousAngularVelocity_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_set_previousAngularVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_set_previousAngularVelocity_1');
var _emscripten_bind_PxVehicleRigidBodyState_get_externalForce_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_get_externalForce_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_get_externalForce_0');
var _emscripten_bind_PxVehicleRigidBodyState_set_externalForce_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_set_externalForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_set_externalForce_1');
var _emscripten_bind_PxVehicleRigidBodyState_get_externalTorque_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_get_externalTorque_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_get_externalTorque_0');
var _emscripten_bind_PxVehicleRigidBodyState_set_externalTorque_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_set_externalTorque_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState_set_externalTorque_1');
var _emscripten_bind_PxVehicleRigidBodyState___destroy___0 = Module['_emscripten_bind_PxVehicleRigidBodyState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRigidBodyState___destroy___0');
var _emscripten_bind_PxVehicleRoadGeometryState_PxVehicleRoadGeometryState_0 = Module['_emscripten_bind_PxVehicleRoadGeometryState_PxVehicleRoadGeometryState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRoadGeometryState_PxVehicleRoadGeometryState_0');
var _emscripten_bind_PxVehicleRoadGeometryState_setToDefault_0 = Module['_emscripten_bind_PxVehicleRoadGeometryState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRoadGeometryState_setToDefault_0');
var _emscripten_bind_PxVehicleRoadGeometryState_get_plane_0 = Module['_emscripten_bind_PxVehicleRoadGeometryState_get_plane_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRoadGeometryState_get_plane_0');
var _emscripten_bind_PxVehicleRoadGeometryState_set_plane_1 = Module['_emscripten_bind_PxVehicleRoadGeometryState_set_plane_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRoadGeometryState_set_plane_1');
var _emscripten_bind_PxVehicleRoadGeometryState_get_friction_0 = Module['_emscripten_bind_PxVehicleRoadGeometryState_get_friction_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRoadGeometryState_get_friction_0');
var _emscripten_bind_PxVehicleRoadGeometryState_set_friction_1 = Module['_emscripten_bind_PxVehicleRoadGeometryState_set_friction_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRoadGeometryState_set_friction_1');
var _emscripten_bind_PxVehicleRoadGeometryState_get_velocity_0 = Module['_emscripten_bind_PxVehicleRoadGeometryState_get_velocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRoadGeometryState_get_velocity_0');
var _emscripten_bind_PxVehicleRoadGeometryState_set_velocity_1 = Module['_emscripten_bind_PxVehicleRoadGeometryState_set_velocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRoadGeometryState_set_velocity_1');
var _emscripten_bind_PxVehicleRoadGeometryState_get_hitState_0 = Module['_emscripten_bind_PxVehicleRoadGeometryState_get_hitState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRoadGeometryState_get_hitState_0');
var _emscripten_bind_PxVehicleRoadGeometryState_set_hitState_1 = Module['_emscripten_bind_PxVehicleRoadGeometryState_set_hitState_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRoadGeometryState_set_hitState_1');
var _emscripten_bind_PxVehicleRoadGeometryState___destroy___0 = Module['_emscripten_bind_PxVehicleRoadGeometryState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleRoadGeometryState___destroy___0');
var _emscripten_bind_PxVehicleScale_PxVehicleScale_0 = Module['_emscripten_bind_PxVehicleScale_PxVehicleScale_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleScale_PxVehicleScale_0');
var _emscripten_bind_PxVehicleScale_setToDefault_0 = Module['_emscripten_bind_PxVehicleScale_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleScale_setToDefault_0');
var _emscripten_bind_PxVehicleScale_isValid_0 = Module['_emscripten_bind_PxVehicleScale_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleScale_isValid_0');
var _emscripten_bind_PxVehicleScale_get_scale_0 = Module['_emscripten_bind_PxVehicleScale_get_scale_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleScale_get_scale_0');
var _emscripten_bind_PxVehicleScale_set_scale_1 = Module['_emscripten_bind_PxVehicleScale_set_scale_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleScale_set_scale_1');
var _emscripten_bind_PxVehicleScale___destroy___0 = Module['_emscripten_bind_PxVehicleScale___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleScale___destroy___0');
var _emscripten_bind_PxVehicleSteerCommandResponseParams_PxVehicleSteerCommandResponseParams_0 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_PxVehicleSteerCommandResponseParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSteerCommandResponseParams_PxVehicleSteerCommandResponseParams_0');
var _emscripten_bind_PxVehicleSteerCommandResponseParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSteerCommandResponseParams_transformAndScale_4');
var _emscripten_bind_PxVehicleSteerCommandResponseParams_isValid_1 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_isValid_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSteerCommandResponseParams_isValid_1');
var _emscripten_bind_PxVehicleSteerCommandResponseParams_get_nonlinearResponse_0 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_get_nonlinearResponse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSteerCommandResponseParams_get_nonlinearResponse_0');
var _emscripten_bind_PxVehicleSteerCommandResponseParams_set_nonlinearResponse_1 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_set_nonlinearResponse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSteerCommandResponseParams_set_nonlinearResponse_1');
var _emscripten_bind_PxVehicleSteerCommandResponseParams_get_wheelResponseMultipliers_1 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_get_wheelResponseMultipliers_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSteerCommandResponseParams_get_wheelResponseMultipliers_1');
var _emscripten_bind_PxVehicleSteerCommandResponseParams_set_wheelResponseMultipliers_2 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_set_wheelResponseMultipliers_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSteerCommandResponseParams_set_wheelResponseMultipliers_2');
var _emscripten_bind_PxVehicleSteerCommandResponseParams_get_maxResponse_0 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_get_maxResponse_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSteerCommandResponseParams_get_maxResponse_0');
var _emscripten_bind_PxVehicleSteerCommandResponseParams_set_maxResponse_1 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_set_maxResponse_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSteerCommandResponseParams_set_maxResponse_1');
var _emscripten_bind_PxVehicleSteerCommandResponseParams___destroy___0 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSteerCommandResponseParams___destroy___0');
var _emscripten_bind_PxVehicleSuspensionComplianceParams_PxVehicleSuspensionComplianceParams_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_PxVehicleSuspensionComplianceParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceParams_PxVehicleSuspensionComplianceParams_0');
var _emscripten_bind_PxVehicleSuspensionComplianceParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceParams_transformAndScale_4');
var _emscripten_bind_PxVehicleSuspensionComplianceParams_isValid_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceParams_isValid_0');
var _emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelToeAngle_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelToeAngle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelToeAngle_0');
var _emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelToeAngle_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelToeAngle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelToeAngle_1');
var _emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelCamberAngle_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelCamberAngle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelCamberAngle_0');
var _emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelCamberAngle_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelCamberAngle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelCamberAngle_1');
var _emscripten_bind_PxVehicleSuspensionComplianceParams_get_suspForceAppPoint_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_get_suspForceAppPoint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceParams_get_suspForceAppPoint_0');
var _emscripten_bind_PxVehicleSuspensionComplianceParams_set_suspForceAppPoint_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_set_suspForceAppPoint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceParams_set_suspForceAppPoint_1');
var _emscripten_bind_PxVehicleSuspensionComplianceParams_get_tireForceAppPoint_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_get_tireForceAppPoint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceParams_get_tireForceAppPoint_0');
var _emscripten_bind_PxVehicleSuspensionComplianceParams_set_tireForceAppPoint_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_set_tireForceAppPoint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceParams_set_tireForceAppPoint_1');
var _emscripten_bind_PxVehicleSuspensionComplianceParams___destroy___0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceParams___destroy___0');
var _emscripten_bind_PxVehicleSuspensionComplianceState_PxVehicleSuspensionComplianceState_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_PxVehicleSuspensionComplianceState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceState_PxVehicleSuspensionComplianceState_0');
var _emscripten_bind_PxVehicleSuspensionComplianceState_setToDefault_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceState_setToDefault_0');
var _emscripten_bind_PxVehicleSuspensionComplianceState_get_toe_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_get_toe_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceState_get_toe_0');
var _emscripten_bind_PxVehicleSuspensionComplianceState_set_toe_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_set_toe_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceState_set_toe_1');
var _emscripten_bind_PxVehicleSuspensionComplianceState_get_camber_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_get_camber_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceState_get_camber_0');
var _emscripten_bind_PxVehicleSuspensionComplianceState_set_camber_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_set_camber_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceState_set_camber_1');
var _emscripten_bind_PxVehicleSuspensionComplianceState_get_tireForceAppPoint_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_get_tireForceAppPoint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceState_get_tireForceAppPoint_0');
var _emscripten_bind_PxVehicleSuspensionComplianceState_set_tireForceAppPoint_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_set_tireForceAppPoint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceState_set_tireForceAppPoint_1');
var _emscripten_bind_PxVehicleSuspensionComplianceState_get_suspForceAppPoint_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_get_suspForceAppPoint_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceState_get_suspForceAppPoint_0');
var _emscripten_bind_PxVehicleSuspensionComplianceState_set_suspForceAppPoint_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_set_suspForceAppPoint_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceState_set_suspForceAppPoint_1');
var _emscripten_bind_PxVehicleSuspensionComplianceState___destroy___0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionComplianceState___destroy___0');
var _emscripten_bind_PxVehicleSuspensionForce_PxVehicleSuspensionForce_0 = Module['_emscripten_bind_PxVehicleSuspensionForce_PxVehicleSuspensionForce_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForce_PxVehicleSuspensionForce_0');
var _emscripten_bind_PxVehicleSuspensionForce_setToDefault_0 = Module['_emscripten_bind_PxVehicleSuspensionForce_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForce_setToDefault_0');
var _emscripten_bind_PxVehicleSuspensionForce_get_force_0 = Module['_emscripten_bind_PxVehicleSuspensionForce_get_force_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForce_get_force_0');
var _emscripten_bind_PxVehicleSuspensionForce_set_force_1 = Module['_emscripten_bind_PxVehicleSuspensionForce_set_force_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForce_set_force_1');
var _emscripten_bind_PxVehicleSuspensionForce_get_torque_0 = Module['_emscripten_bind_PxVehicleSuspensionForce_get_torque_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForce_get_torque_0');
var _emscripten_bind_PxVehicleSuspensionForce_set_torque_1 = Module['_emscripten_bind_PxVehicleSuspensionForce_set_torque_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForce_set_torque_1');
var _emscripten_bind_PxVehicleSuspensionForce_get_normalForce_0 = Module['_emscripten_bind_PxVehicleSuspensionForce_get_normalForce_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForce_get_normalForce_0');
var _emscripten_bind_PxVehicleSuspensionForce_set_normalForce_1 = Module['_emscripten_bind_PxVehicleSuspensionForce_set_normalForce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForce_set_normalForce_1');
var _emscripten_bind_PxVehicleSuspensionForce___destroy___0 = Module['_emscripten_bind_PxVehicleSuspensionForce___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForce___destroy___0');
var _emscripten_bind_PxVehicleSuspensionForceParams_PxVehicleSuspensionForceParams_0 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_PxVehicleSuspensionForceParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForceParams_PxVehicleSuspensionForceParams_0');
var _emscripten_bind_PxVehicleSuspensionForceParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForceParams_transformAndScale_4');
var _emscripten_bind_PxVehicleSuspensionForceParams_isValid_0 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForceParams_isValid_0');
var _emscripten_bind_PxVehicleSuspensionForceParams_get_stiffness_0 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_get_stiffness_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForceParams_get_stiffness_0');
var _emscripten_bind_PxVehicleSuspensionForceParams_set_stiffness_1 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_set_stiffness_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForceParams_set_stiffness_1');
var _emscripten_bind_PxVehicleSuspensionForceParams_get_damping_0 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_get_damping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForceParams_get_damping_0');
var _emscripten_bind_PxVehicleSuspensionForceParams_set_damping_1 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_set_damping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForceParams_set_damping_1');
var _emscripten_bind_PxVehicleSuspensionForceParams_get_sprungMass_0 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_get_sprungMass_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForceParams_get_sprungMass_0');
var _emscripten_bind_PxVehicleSuspensionForceParams_set_sprungMass_1 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_set_sprungMass_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForceParams_set_sprungMass_1');
var _emscripten_bind_PxVehicleSuspensionForceParams___destroy___0 = Module['_emscripten_bind_PxVehicleSuspensionForceParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionForceParams___destroy___0');
var _emscripten_bind_PxVehicleSuspensionParams_PxVehicleSuspensionParams_0 = Module['_emscripten_bind_PxVehicleSuspensionParams_PxVehicleSuspensionParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionParams_PxVehicleSuspensionParams_0');
var _emscripten_bind_PxVehicleSuspensionParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleSuspensionParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionParams_transformAndScale_4');
var _emscripten_bind_PxVehicleSuspensionParams_isValid_0 = Module['_emscripten_bind_PxVehicleSuspensionParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionParams_isValid_0');
var _emscripten_bind_PxVehicleSuspensionParams_get_suspensionAttachment_0 = Module['_emscripten_bind_PxVehicleSuspensionParams_get_suspensionAttachment_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionParams_get_suspensionAttachment_0');
var _emscripten_bind_PxVehicleSuspensionParams_set_suspensionAttachment_1 = Module['_emscripten_bind_PxVehicleSuspensionParams_set_suspensionAttachment_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionParams_set_suspensionAttachment_1');
var _emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDir_0 = Module['_emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDir_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDir_0');
var _emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDir_1 = Module['_emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDir_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDir_1');
var _emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDist_0 = Module['_emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDist_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDist_0');
var _emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDist_1 = Module['_emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDist_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDist_1');
var _emscripten_bind_PxVehicleSuspensionParams_get_wheelAttachment_0 = Module['_emscripten_bind_PxVehicleSuspensionParams_get_wheelAttachment_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionParams_get_wheelAttachment_0');
var _emscripten_bind_PxVehicleSuspensionParams_set_wheelAttachment_1 = Module['_emscripten_bind_PxVehicleSuspensionParams_set_wheelAttachment_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionParams_set_wheelAttachment_1');
var _emscripten_bind_PxVehicleSuspensionParams___destroy___0 = Module['_emscripten_bind_PxVehicleSuspensionParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionParams___destroy___0');
var _emscripten_bind_PxVehicleSuspensionState_PxVehicleSuspensionState_0 = Module['_emscripten_bind_PxVehicleSuspensionState_PxVehicleSuspensionState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionState_PxVehicleSuspensionState_0');
var _emscripten_bind_PxVehicleSuspensionState_setToDefault_2 = Module['_emscripten_bind_PxVehicleSuspensionState_setToDefault_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionState_setToDefault_2');
var _emscripten_bind_PxVehicleSuspensionState_get_jounce_0 = Module['_emscripten_bind_PxVehicleSuspensionState_get_jounce_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionState_get_jounce_0');
var _emscripten_bind_PxVehicleSuspensionState_set_jounce_1 = Module['_emscripten_bind_PxVehicleSuspensionState_set_jounce_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionState_set_jounce_1');
var _emscripten_bind_PxVehicleSuspensionState_get_jounceSpeed_0 = Module['_emscripten_bind_PxVehicleSuspensionState_get_jounceSpeed_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionState_get_jounceSpeed_0');
var _emscripten_bind_PxVehicleSuspensionState_set_jounceSpeed_1 = Module['_emscripten_bind_PxVehicleSuspensionState_set_jounceSpeed_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionState_set_jounceSpeed_1');
var _emscripten_bind_PxVehicleSuspensionState_get_separation_0 = Module['_emscripten_bind_PxVehicleSuspensionState_get_separation_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionState_get_separation_0');
var _emscripten_bind_PxVehicleSuspensionState_set_separation_1 = Module['_emscripten_bind_PxVehicleSuspensionState_set_separation_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionState_set_separation_1');
var _emscripten_bind_PxVehicleSuspensionState___destroy___0 = Module['_emscripten_bind_PxVehicleSuspensionState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionState___destroy___0');
var _emscripten_bind_PxVehicleSuspensionStateCalculationParams_PxVehicleSuspensionStateCalculationParams_0 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams_PxVehicleSuspensionStateCalculationParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionStateCalculationParams_PxVehicleSuspensionStateCalculationParams_0');
var _emscripten_bind_PxVehicleSuspensionStateCalculationParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionStateCalculationParams_transformAndScale_4');
var _emscripten_bind_PxVehicleSuspensionStateCalculationParams_isValid_0 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionStateCalculationParams_isValid_0');
var _emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_suspensionJounceCalculationType_0 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_suspensionJounceCalculationType_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_suspensionJounceCalculationType_0');
var _emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_suspensionJounceCalculationType_1 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_suspensionJounceCalculationType_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_suspensionJounceCalculationType_1');
var _emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_limitSuspensionExpansionVelocity_0 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_limitSuspensionExpansionVelocity_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_limitSuspensionExpansionVelocity_0');
var _emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_limitSuspensionExpansionVelocity_1 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_limitSuspensionExpansionVelocity_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_limitSuspensionExpansionVelocity_1');
var _emscripten_bind_PxVehicleSuspensionStateCalculationParams___destroy___0 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleSuspensionStateCalculationParams___destroy___0');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_PxVehicleTankDriveDifferentialParams_0 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_PxVehicleTankDriveDifferentialParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_PxVehicleTankDriveDifferentialParams_0');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_setToDefault_0 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_setToDefault_0');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_getNbWheelsInTrack_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_getNbWheelsInTrack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_getNbWheelsInTrack_1');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelsInTrack_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelsInTrack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelsInTrack_1');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelInTrack_2 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelInTrack_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelInTrack_2');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_getThrustControllerIndex_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_getThrustControllerIndex_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_getThrustControllerIndex_1');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_transformAndScale_4');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_isValid_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_isValid_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_isValid_1');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbTracks_0 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbTracks_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbTracks_0');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbTracks_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbTracks_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbTracks_1');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_thrustIdPerTrack_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_thrustIdPerTrack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_thrustIdPerTrack_1');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_thrustIdPerTrack_2 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_thrustIdPerTrack_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_thrustIdPerTrack_2');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbWheelsPerTrack_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbWheelsPerTrack_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbWheelsPerTrack_1');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbWheelsPerTrack_2 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbWheelsPerTrack_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbWheelsPerTrack_2');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_trackToWheelIds_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_trackToWheelIds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_trackToWheelIds_1');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_trackToWheelIds_2 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_trackToWheelIds_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_trackToWheelIds_2');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_wheelIdsInTrackOrder_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_wheelIdsInTrackOrder_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_wheelIdsInTrackOrder_1');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_wheelIdsInTrackOrder_2 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_wheelIdsInTrackOrder_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_wheelIdsInTrackOrder_2');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_torqueRatios_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_torqueRatios_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_torqueRatios_1');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_torqueRatios_2 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_torqueRatios_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_torqueRatios_2');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_aveWheelSpeedRatios_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_aveWheelSpeedRatios_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_aveWheelSpeedRatios_1');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_aveWheelSpeedRatios_2 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_aveWheelSpeedRatios_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_aveWheelSpeedRatios_2');
var _emscripten_bind_PxVehicleTankDriveDifferentialParams___destroy___0 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveDifferentialParams___destroy___0');
var _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_PxVehicleTankDriveTransmissionCommandState_0 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_PxVehicleTankDriveTransmissionCommandState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_PxVehicleTankDriveTransmissionCommandState_0');
var _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_setToDefault_0 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_setToDefault_0');
var _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_thrusts_1 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_thrusts_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_thrusts_1');
var _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_thrusts_2 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_thrusts_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_thrusts_2');
var _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_clutch_0 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_clutch_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_clutch_0');
var _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_clutch_1 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_clutch_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_clutch_1');
var _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_targetGear_0 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_targetGear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_targetGear_0');
var _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_targetGear_1 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_targetGear_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_targetGear_1');
var _emscripten_bind_PxVehicleTankDriveTransmissionCommandState___destroy___0 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTankDriveTransmissionCommandState___destroy___0');
var _emscripten_bind_PxVehicleTireAxisStickyParams_PxVehicleTireAxisStickyParams_0 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_PxVehicleTireAxisStickyParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireAxisStickyParams_PxVehicleTireAxisStickyParams_0');
var _emscripten_bind_PxVehicleTireAxisStickyParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireAxisStickyParams_transformAndScale_4');
var _emscripten_bind_PxVehicleTireAxisStickyParams_isValid_0 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireAxisStickyParams_isValid_0');
var _emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdSpeed_0 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdSpeed_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdSpeed_0');
var _emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdSpeed_1 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdSpeed_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdSpeed_1');
var _emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdTime_0 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdTime_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdTime_0');
var _emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdTime_1 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdTime_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdTime_1');
var _emscripten_bind_PxVehicleTireAxisStickyParams_get_damping_0 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_get_damping_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireAxisStickyParams_get_damping_0');
var _emscripten_bind_PxVehicleTireAxisStickyParams_set_damping_1 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_set_damping_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireAxisStickyParams_set_damping_1');
var _emscripten_bind_PxVehicleTireAxisStickyParams___destroy___0 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireAxisStickyParams___destroy___0');
var _emscripten_bind_PxVehicleTireCamberAngleState_PxVehicleTireCamberAngleState_0 = Module['_emscripten_bind_PxVehicleTireCamberAngleState_PxVehicleTireCamberAngleState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireCamberAngleState_PxVehicleTireCamberAngleState_0');
var _emscripten_bind_PxVehicleTireCamberAngleState_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireCamberAngleState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireCamberAngleState_setToDefault_0');
var _emscripten_bind_PxVehicleTireCamberAngleState_get_camberAngle_0 = Module['_emscripten_bind_PxVehicleTireCamberAngleState_get_camberAngle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireCamberAngleState_get_camberAngle_0');
var _emscripten_bind_PxVehicleTireCamberAngleState_set_camberAngle_1 = Module['_emscripten_bind_PxVehicleTireCamberAngleState_set_camberAngle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireCamberAngleState_set_camberAngle_1');
var _emscripten_bind_PxVehicleTireCamberAngleState___destroy___0 = Module['_emscripten_bind_PxVehicleTireCamberAngleState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireCamberAngleState___destroy___0');
var _emscripten_bind_PxVehicleTireDirectionState_PxVehicleTireDirectionState_0 = Module['_emscripten_bind_PxVehicleTireDirectionState_PxVehicleTireDirectionState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireDirectionState_PxVehicleTireDirectionState_0');
var _emscripten_bind_PxVehicleTireDirectionState_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireDirectionState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireDirectionState_setToDefault_0');
var _emscripten_bind_PxVehicleTireDirectionState_get_directions_1 = Module['_emscripten_bind_PxVehicleTireDirectionState_get_directions_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireDirectionState_get_directions_1');
var _emscripten_bind_PxVehicleTireDirectionState_set_directions_2 = Module['_emscripten_bind_PxVehicleTireDirectionState_set_directions_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireDirectionState_set_directions_2');
var _emscripten_bind_PxVehicleTireDirectionState___destroy___0 = Module['_emscripten_bind_PxVehicleTireDirectionState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireDirectionState___destroy___0');
var _emscripten_bind_PxVehicleTireForce_PxVehicleTireForce_0 = Module['_emscripten_bind_PxVehicleTireForce_PxVehicleTireForce_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForce_PxVehicleTireForce_0');
var _emscripten_bind_PxVehicleTireForce_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireForce_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForce_setToDefault_0');
var _emscripten_bind_PxVehicleTireForce_get_forces_1 = Module['_emscripten_bind_PxVehicleTireForce_get_forces_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForce_get_forces_1');
var _emscripten_bind_PxVehicleTireForce_set_forces_2 = Module['_emscripten_bind_PxVehicleTireForce_set_forces_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForce_set_forces_2');
var _emscripten_bind_PxVehicleTireForce_get_torques_1 = Module['_emscripten_bind_PxVehicleTireForce_get_torques_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForce_get_torques_1');
var _emscripten_bind_PxVehicleTireForce_set_torques_2 = Module['_emscripten_bind_PxVehicleTireForce_set_torques_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForce_set_torques_2');
var _emscripten_bind_PxVehicleTireForce_get_aligningMoment_0 = Module['_emscripten_bind_PxVehicleTireForce_get_aligningMoment_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForce_get_aligningMoment_0');
var _emscripten_bind_PxVehicleTireForce_set_aligningMoment_1 = Module['_emscripten_bind_PxVehicleTireForce_set_aligningMoment_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForce_set_aligningMoment_1');
var _emscripten_bind_PxVehicleTireForce_get_wheelTorque_0 = Module['_emscripten_bind_PxVehicleTireForce_get_wheelTorque_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForce_get_wheelTorque_0');
var _emscripten_bind_PxVehicleTireForce_set_wheelTorque_1 = Module['_emscripten_bind_PxVehicleTireForce_set_wheelTorque_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForce_set_wheelTorque_1');
var _emscripten_bind_PxVehicleTireForce___destroy___0 = Module['_emscripten_bind_PxVehicleTireForce___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForce___destroy___0');
var _emscripten_bind_PxVehicleTireForceParams_PxVehicleTireForceParams_0 = Module['_emscripten_bind_PxVehicleTireForceParams_PxVehicleTireForceParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParams_PxVehicleTireForceParams_0');
var _emscripten_bind_PxVehicleTireForceParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleTireForceParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParams_transformAndScale_4');
var _emscripten_bind_PxVehicleTireForceParams_isValid_0 = Module['_emscripten_bind_PxVehicleTireForceParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParams_isValid_0');
var _emscripten_bind_PxVehicleTireForceParams_get_latStiffX_0 = Module['_emscripten_bind_PxVehicleTireForceParams_get_latStiffX_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParams_get_latStiffX_0');
var _emscripten_bind_PxVehicleTireForceParams_set_latStiffX_1 = Module['_emscripten_bind_PxVehicleTireForceParams_set_latStiffX_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParams_set_latStiffX_1');
var _emscripten_bind_PxVehicleTireForceParams_get_latStiffY_0 = Module['_emscripten_bind_PxVehicleTireForceParams_get_latStiffY_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParams_get_latStiffY_0');
var _emscripten_bind_PxVehicleTireForceParams_set_latStiffY_1 = Module['_emscripten_bind_PxVehicleTireForceParams_set_latStiffY_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParams_set_latStiffY_1');
var _emscripten_bind_PxVehicleTireForceParams_get_longStiff_0 = Module['_emscripten_bind_PxVehicleTireForceParams_get_longStiff_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParams_get_longStiff_0');
var _emscripten_bind_PxVehicleTireForceParams_set_longStiff_1 = Module['_emscripten_bind_PxVehicleTireForceParams_set_longStiff_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParams_set_longStiff_1');
var _emscripten_bind_PxVehicleTireForceParams_get_camberStiff_0 = Module['_emscripten_bind_PxVehicleTireForceParams_get_camberStiff_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParams_get_camberStiff_0');
var _emscripten_bind_PxVehicleTireForceParams_set_camberStiff_1 = Module['_emscripten_bind_PxVehicleTireForceParams_set_camberStiff_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParams_set_camberStiff_1');
var _emscripten_bind_PxVehicleTireForceParams_get_restLoad_0 = Module['_emscripten_bind_PxVehicleTireForceParams_get_restLoad_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParams_get_restLoad_0');
var _emscripten_bind_PxVehicleTireForceParams_set_restLoad_1 = Module['_emscripten_bind_PxVehicleTireForceParams_set_restLoad_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParams_set_restLoad_1');
var _emscripten_bind_PxVehicleTireForceParams___destroy___0 = Module['_emscripten_bind_PxVehicleTireForceParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParams___destroy___0');
var _emscripten_bind_PxVehicleTireForceParamsExt_setFrictionVsSlip_4 = Module['_emscripten_bind_PxVehicleTireForceParamsExt_setFrictionVsSlip_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParamsExt_setFrictionVsSlip_4');
var _emscripten_bind_PxVehicleTireForceParamsExt_setLoadFilter_4 = Module['_emscripten_bind_PxVehicleTireForceParamsExt_setLoadFilter_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireForceParamsExt_setLoadFilter_4');
var _emscripten_bind_PxVehicleTireGripState_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireGripState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireGripState_setToDefault_0');
var _emscripten_bind_PxVehicleTireGripState_get_load_0 = Module['_emscripten_bind_PxVehicleTireGripState_get_load_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireGripState_get_load_0');
var _emscripten_bind_PxVehicleTireGripState_set_load_1 = Module['_emscripten_bind_PxVehicleTireGripState_set_load_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireGripState_set_load_1');
var _emscripten_bind_PxVehicleTireGripState_get_friction_0 = Module['_emscripten_bind_PxVehicleTireGripState_get_friction_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireGripState_get_friction_0');
var _emscripten_bind_PxVehicleTireGripState_set_friction_1 = Module['_emscripten_bind_PxVehicleTireGripState_set_friction_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireGripState_set_friction_1');
var _emscripten_bind_PxVehicleTireGripState___destroy___0 = Module['_emscripten_bind_PxVehicleTireGripState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireGripState___destroy___0');
var _emscripten_bind_PxVehicleTireSlipParams_PxVehicleTireSlipParams_0 = Module['_emscripten_bind_PxVehicleTireSlipParams_PxVehicleTireSlipParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipParams_PxVehicleTireSlipParams_0');
var _emscripten_bind_PxVehicleTireSlipParams_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireSlipParams_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipParams_setToDefault_0');
var _emscripten_bind_PxVehicleTireSlipParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleTireSlipParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipParams_transformAndScale_4');
var _emscripten_bind_PxVehicleTireSlipParams_isValid_0 = Module['_emscripten_bind_PxVehicleTireSlipParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipParams_isValid_0');
var _emscripten_bind_PxVehicleTireSlipParams_get_minLatSlipDenominator_0 = Module['_emscripten_bind_PxVehicleTireSlipParams_get_minLatSlipDenominator_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipParams_get_minLatSlipDenominator_0');
var _emscripten_bind_PxVehicleTireSlipParams_set_minLatSlipDenominator_1 = Module['_emscripten_bind_PxVehicleTireSlipParams_set_minLatSlipDenominator_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipParams_set_minLatSlipDenominator_1');
var _emscripten_bind_PxVehicleTireSlipParams_get_minPassiveLongSlipDenominator_0 = Module['_emscripten_bind_PxVehicleTireSlipParams_get_minPassiveLongSlipDenominator_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipParams_get_minPassiveLongSlipDenominator_0');
var _emscripten_bind_PxVehicleTireSlipParams_set_minPassiveLongSlipDenominator_1 = Module['_emscripten_bind_PxVehicleTireSlipParams_set_minPassiveLongSlipDenominator_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipParams_set_minPassiveLongSlipDenominator_1');
var _emscripten_bind_PxVehicleTireSlipParams_get_minActiveLongSlipDenominator_0 = Module['_emscripten_bind_PxVehicleTireSlipParams_get_minActiveLongSlipDenominator_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipParams_get_minActiveLongSlipDenominator_0');
var _emscripten_bind_PxVehicleTireSlipParams_set_minActiveLongSlipDenominator_1 = Module['_emscripten_bind_PxVehicleTireSlipParams_set_minActiveLongSlipDenominator_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipParams_set_minActiveLongSlipDenominator_1');
var _emscripten_bind_PxVehicleTireSlipParams___destroy___0 = Module['_emscripten_bind_PxVehicleTireSlipParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipParams___destroy___0');
var _emscripten_bind_PxVehicleTireSlipState_PxVehicleTireSlipState_0 = Module['_emscripten_bind_PxVehicleTireSlipState_PxVehicleTireSlipState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipState_PxVehicleTireSlipState_0');
var _emscripten_bind_PxVehicleTireSlipState_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireSlipState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipState_setToDefault_0');
var _emscripten_bind_PxVehicleTireSlipState_get_slips_1 = Module['_emscripten_bind_PxVehicleTireSlipState_get_slips_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipState_get_slips_1');
var _emscripten_bind_PxVehicleTireSlipState_set_slips_2 = Module['_emscripten_bind_PxVehicleTireSlipState_set_slips_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipState_set_slips_2');
var _emscripten_bind_PxVehicleTireSlipState___destroy___0 = Module['_emscripten_bind_PxVehicleTireSlipState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSlipState___destroy___0');
var _emscripten_bind_PxVehicleTireSpeedState_PxVehicleTireSpeedState_0 = Module['_emscripten_bind_PxVehicleTireSpeedState_PxVehicleTireSpeedState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSpeedState_PxVehicleTireSpeedState_0');
var _emscripten_bind_PxVehicleTireSpeedState_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireSpeedState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSpeedState_setToDefault_0');
var _emscripten_bind_PxVehicleTireSpeedState_get_speedStates_1 = Module['_emscripten_bind_PxVehicleTireSpeedState_get_speedStates_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSpeedState_get_speedStates_1');
var _emscripten_bind_PxVehicleTireSpeedState_set_speedStates_2 = Module['_emscripten_bind_PxVehicleTireSpeedState_set_speedStates_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSpeedState_set_speedStates_2');
var _emscripten_bind_PxVehicleTireSpeedState___destroy___0 = Module['_emscripten_bind_PxVehicleTireSpeedState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireSpeedState___destroy___0');
var _emscripten_bind_PxVehicleTireStickyParams_PxVehicleTireStickyParams_0 = Module['_emscripten_bind_PxVehicleTireStickyParams_PxVehicleTireStickyParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireStickyParams_PxVehicleTireStickyParams_0');
var _emscripten_bind_PxVehicleTireStickyParams_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireStickyParams_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireStickyParams_setToDefault_0');
var _emscripten_bind_PxVehicleTireStickyParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleTireStickyParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireStickyParams_transformAndScale_4');
var _emscripten_bind_PxVehicleTireStickyParams_isValid_0 = Module['_emscripten_bind_PxVehicleTireStickyParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireStickyParams_isValid_0');
var _emscripten_bind_PxVehicleTireStickyParams_get_stickyParams_1 = Module['_emscripten_bind_PxVehicleTireStickyParams_get_stickyParams_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireStickyParams_get_stickyParams_1');
var _emscripten_bind_PxVehicleTireStickyParams_set_stickyParams_2 = Module['_emscripten_bind_PxVehicleTireStickyParams_set_stickyParams_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireStickyParams_set_stickyParams_2');
var _emscripten_bind_PxVehicleTireStickyParams___destroy___0 = Module['_emscripten_bind_PxVehicleTireStickyParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireStickyParams___destroy___0');
var _emscripten_bind_PxVehicleTireStickyState_PxVehicleTireStickyState_0 = Module['_emscripten_bind_PxVehicleTireStickyState_PxVehicleTireStickyState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireStickyState_PxVehicleTireStickyState_0');
var _emscripten_bind_PxVehicleTireStickyState_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireStickyState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireStickyState_setToDefault_0');
var _emscripten_bind_PxVehicleTireStickyState_get_lowSpeedTime_1 = Module['_emscripten_bind_PxVehicleTireStickyState_get_lowSpeedTime_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireStickyState_get_lowSpeedTime_1');
var _emscripten_bind_PxVehicleTireStickyState_set_lowSpeedTime_2 = Module['_emscripten_bind_PxVehicleTireStickyState_set_lowSpeedTime_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireStickyState_set_lowSpeedTime_2');
var _emscripten_bind_PxVehicleTireStickyState_get_activeStatus_1 = Module['_emscripten_bind_PxVehicleTireStickyState_get_activeStatus_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireStickyState_get_activeStatus_1');
var _emscripten_bind_PxVehicleTireStickyState_set_activeStatus_2 = Module['_emscripten_bind_PxVehicleTireStickyState_set_activeStatus_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireStickyState_set_activeStatus_2');
var _emscripten_bind_PxVehicleTireStickyState___destroy___0 = Module['_emscripten_bind_PxVehicleTireStickyState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTireStickyState___destroy___0');
var _emscripten_bind_PxVehicleTopLevelFunctions_InitVehicleExtension_1 = Module['_emscripten_bind_PxVehicleTopLevelFunctions_InitVehicleExtension_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTopLevelFunctions_InitVehicleExtension_1');
var _emscripten_bind_PxVehicleTopLevelFunctions_CloseVehicleExtension_0 = Module['_emscripten_bind_PxVehicleTopLevelFunctions_CloseVehicleExtension_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTopLevelFunctions_CloseVehicleExtension_0');
var _emscripten_bind_PxVehicleTopLevelFunctions_VehicleComputeSprungMasses_5 = Module['_emscripten_bind_PxVehicleTopLevelFunctions_VehicleComputeSprungMasses_5'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTopLevelFunctions_VehicleComputeSprungMasses_5');
var _emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshCreate_3 = Module['_emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshCreate_3'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshCreate_3');
var _emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshDestroy_1 = Module['_emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshDestroy_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshDestroy_1');
var _emscripten_bind_PxVehicleTopLevelFunctions_get_MAX_NB_ENGINE_TORQUE_CURVE_ENTRIES_0 = Module['_emscripten_bind_PxVehicleTopLevelFunctions_get_MAX_NB_ENGINE_TORQUE_CURVE_ENTRIES_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTopLevelFunctions_get_MAX_NB_ENGINE_TORQUE_CURVE_ENTRIES_0');
var _emscripten_bind_PxVehicleTorqueCurveLookupTable_PxVehicleTorqueCurveLookupTable_0 = Module['_emscripten_bind_PxVehicleTorqueCurveLookupTable_PxVehicleTorqueCurveLookupTable_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTorqueCurveLookupTable_PxVehicleTorqueCurveLookupTable_0');
var _emscripten_bind_PxVehicleTorqueCurveLookupTable_addPair_2 = Module['_emscripten_bind_PxVehicleTorqueCurveLookupTable_addPair_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTorqueCurveLookupTable_addPair_2');
var _emscripten_bind_PxVehicleTorqueCurveLookupTable_interpolate_1 = Module['_emscripten_bind_PxVehicleTorqueCurveLookupTable_interpolate_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTorqueCurveLookupTable_interpolate_1');
var _emscripten_bind_PxVehicleTorqueCurveLookupTable_clear_0 = Module['_emscripten_bind_PxVehicleTorqueCurveLookupTable_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTorqueCurveLookupTable_clear_0');
var _emscripten_bind_PxVehicleTorqueCurveLookupTable_isValid_0 = Module['_emscripten_bind_PxVehicleTorqueCurveLookupTable_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTorqueCurveLookupTable_isValid_0');
var _emscripten_bind_PxVehicleTorqueCurveLookupTable___destroy___0 = Module['_emscripten_bind_PxVehicleTorqueCurveLookupTable___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleTorqueCurveLookupTable___destroy___0');
var _emscripten_bind_PxVehicleWheelActuationState_PxVehicleWheelActuationState_0 = Module['_emscripten_bind_PxVehicleWheelActuationState_PxVehicleWheelActuationState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelActuationState_PxVehicleWheelActuationState_0');
var _emscripten_bind_PxVehicleWheelActuationState_setToDefault_0 = Module['_emscripten_bind_PxVehicleWheelActuationState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelActuationState_setToDefault_0');
var _emscripten_bind_PxVehicleWheelActuationState_get_isBrakeApplied_0 = Module['_emscripten_bind_PxVehicleWheelActuationState_get_isBrakeApplied_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelActuationState_get_isBrakeApplied_0');
var _emscripten_bind_PxVehicleWheelActuationState_set_isBrakeApplied_1 = Module['_emscripten_bind_PxVehicleWheelActuationState_set_isBrakeApplied_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelActuationState_set_isBrakeApplied_1');
var _emscripten_bind_PxVehicleWheelActuationState_get_isDriveApplied_0 = Module['_emscripten_bind_PxVehicleWheelActuationState_get_isDriveApplied_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelActuationState_get_isDriveApplied_0');
var _emscripten_bind_PxVehicleWheelActuationState_set_isDriveApplied_1 = Module['_emscripten_bind_PxVehicleWheelActuationState_set_isDriveApplied_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelActuationState_set_isDriveApplied_1');
var _emscripten_bind_PxVehicleWheelActuationState___destroy___0 = Module['_emscripten_bind_PxVehicleWheelActuationState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelActuationState___destroy___0');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_PxVehicleWheelConstraintGroupState_0 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_PxVehicleWheelConstraintGroupState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_PxVehicleWheelConstraintGroupState_0');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_setToDefault_0 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_setToDefault_0');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_getNbConstraintGroups_0 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_getNbConstraintGroups_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_getNbConstraintGroups_0');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_getNbWheelsInConstraintGroup_1 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_getNbWheelsInConstraintGroup_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_getNbWheelsInConstraintGroup_1');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_getWheelInConstraintGroup_2 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_getWheelInConstraintGroup_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_getWheelInConstraintGroup_2');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_getMultiplierInConstraintGroup_2 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_getMultiplierInConstraintGroup_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_getMultiplierInConstraintGroup_2');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbGroups_0 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbGroups_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbGroups_0');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbGroups_1 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbGroups_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbGroups_1');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsPerGroup_1 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsPerGroup_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsPerGroup_1');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsPerGroup_2 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsPerGroup_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsPerGroup_2');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_get_groupToWheelIds_1 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_get_groupToWheelIds_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_get_groupToWheelIds_1');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_set_groupToWheelIds_2 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_set_groupToWheelIds_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_set_groupToWheelIds_2');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelIdsInGroupOrder_1 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelIdsInGroupOrder_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelIdsInGroupOrder_1');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelIdsInGroupOrder_2 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelIdsInGroupOrder_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelIdsInGroupOrder_2');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelMultipliersInGroupOrder_1 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelMultipliersInGroupOrder_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelMultipliersInGroupOrder_1');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelMultipliersInGroupOrder_2 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelMultipliersInGroupOrder_2'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelMultipliersInGroupOrder_2');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsInGroups_0 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsInGroups_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsInGroups_0');
var _emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsInGroups_1 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsInGroups_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsInGroups_1');
var _emscripten_bind_PxVehicleWheelConstraintGroupState___destroy___0 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelConstraintGroupState___destroy___0');
var _emscripten_bind_PxVehicleWheelLocalPose_PxVehicleWheelLocalPose_0 = Module['_emscripten_bind_PxVehicleWheelLocalPose_PxVehicleWheelLocalPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelLocalPose_PxVehicleWheelLocalPose_0');
var _emscripten_bind_PxVehicleWheelLocalPose_setToDefault_0 = Module['_emscripten_bind_PxVehicleWheelLocalPose_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelLocalPose_setToDefault_0');
var _emscripten_bind_PxVehicleWheelLocalPose_get_localPose_0 = Module['_emscripten_bind_PxVehicleWheelLocalPose_get_localPose_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelLocalPose_get_localPose_0');
var _emscripten_bind_PxVehicleWheelLocalPose_set_localPose_1 = Module['_emscripten_bind_PxVehicleWheelLocalPose_set_localPose_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelLocalPose_set_localPose_1');
var _emscripten_bind_PxVehicleWheelLocalPose___destroy___0 = Module['_emscripten_bind_PxVehicleWheelLocalPose___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelLocalPose___destroy___0');
var _emscripten_bind_PxVehicleWheelParams_PxVehicleWheelParams_0 = Module['_emscripten_bind_PxVehicleWheelParams_PxVehicleWheelParams_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelParams_PxVehicleWheelParams_0');
var _emscripten_bind_PxVehicleWheelParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleWheelParams_transformAndScale_4'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelParams_transformAndScale_4');
var _emscripten_bind_PxVehicleWheelParams_isValid_0 = Module['_emscripten_bind_PxVehicleWheelParams_isValid_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelParams_isValid_0');
var _emscripten_bind_PxVehicleWheelParams_get_radius_0 = Module['_emscripten_bind_PxVehicleWheelParams_get_radius_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelParams_get_radius_0');
var _emscripten_bind_PxVehicleWheelParams_set_radius_1 = Module['_emscripten_bind_PxVehicleWheelParams_set_radius_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelParams_set_radius_1');
var _emscripten_bind_PxVehicleWheelParams_get_halfWidth_0 = Module['_emscripten_bind_PxVehicleWheelParams_get_halfWidth_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelParams_get_halfWidth_0');
var _emscripten_bind_PxVehicleWheelParams_set_halfWidth_1 = Module['_emscripten_bind_PxVehicleWheelParams_set_halfWidth_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelParams_set_halfWidth_1');
var _emscripten_bind_PxVehicleWheelParams_get_mass_0 = Module['_emscripten_bind_PxVehicleWheelParams_get_mass_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelParams_get_mass_0');
var _emscripten_bind_PxVehicleWheelParams_set_mass_1 = Module['_emscripten_bind_PxVehicleWheelParams_set_mass_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelParams_set_mass_1');
var _emscripten_bind_PxVehicleWheelParams_get_moi_0 = Module['_emscripten_bind_PxVehicleWheelParams_get_moi_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelParams_get_moi_0');
var _emscripten_bind_PxVehicleWheelParams_set_moi_1 = Module['_emscripten_bind_PxVehicleWheelParams_set_moi_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelParams_set_moi_1');
var _emscripten_bind_PxVehicleWheelParams_get_dampingRate_0 = Module['_emscripten_bind_PxVehicleWheelParams_get_dampingRate_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelParams_get_dampingRate_0');
var _emscripten_bind_PxVehicleWheelParams_set_dampingRate_1 = Module['_emscripten_bind_PxVehicleWheelParams_set_dampingRate_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelParams_set_dampingRate_1');
var _emscripten_bind_PxVehicleWheelParams___destroy___0 = Module['_emscripten_bind_PxVehicleWheelParams___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelParams___destroy___0');
var _emscripten_bind_PxVehicleWheelRigidBody1dState_PxVehicleWheelRigidBody1dState_0 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_PxVehicleWheelRigidBody1dState_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelRigidBody1dState_PxVehicleWheelRigidBody1dState_0');
var _emscripten_bind_PxVehicleWheelRigidBody1dState_setToDefault_0 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_setToDefault_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelRigidBody1dState_setToDefault_0');
var _emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationSpeed_0 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationSpeed_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationSpeed_0');
var _emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationSpeed_1 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationSpeed_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationSpeed_1');
var _emscripten_bind_PxVehicleWheelRigidBody1dState_get_correctedRotationSpeed_0 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_get_correctedRotationSpeed_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelRigidBody1dState_get_correctedRotationSpeed_0');
var _emscripten_bind_PxVehicleWheelRigidBody1dState_set_correctedRotationSpeed_1 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_set_correctedRotationSpeed_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelRigidBody1dState_set_correctedRotationSpeed_1');
var _emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationAngle_0 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationAngle_0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationAngle_0');
var _emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationAngle_1 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationAngle_1'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationAngle_1');
var _emscripten_bind_PxVehicleWheelRigidBody1dState___destroy___0 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_PxVehicleWheelRigidBody1dState___destroy___0');
var _emscripten_bind_SimplPvdTransportImpl_SimplPvdTransportImpl_0 = Module['_emscripten_bind_SimplPvdTransportImpl_SimplPvdTransportImpl_0'] = makeInvalidEarlyAccess('_emscripten_bind_SimplPvdTransportImpl_SimplPvdTransportImpl_0');
var _emscripten_bind_SimplPvdTransportImpl_connect_0 = Module['_emscripten_bind_SimplPvdTransportImpl_connect_0'] = makeInvalidEarlyAccess('_emscripten_bind_SimplPvdTransportImpl_connect_0');
var _emscripten_bind_SimplPvdTransportImpl_isConnected_0 = Module['_emscripten_bind_SimplPvdTransportImpl_isConnected_0'] = makeInvalidEarlyAccess('_emscripten_bind_SimplPvdTransportImpl_isConnected_0');
var _emscripten_bind_SimplPvdTransportImpl_disconnect_0 = Module['_emscripten_bind_SimplPvdTransportImpl_disconnect_0'] = makeInvalidEarlyAccess('_emscripten_bind_SimplPvdTransportImpl_disconnect_0');
var _emscripten_bind_SimplPvdTransportImpl_send_2 = Module['_emscripten_bind_SimplPvdTransportImpl_send_2'] = makeInvalidEarlyAccess('_emscripten_bind_SimplPvdTransportImpl_send_2');
var _emscripten_bind_SimplPvdTransportImpl_flush_0 = Module['_emscripten_bind_SimplPvdTransportImpl_flush_0'] = makeInvalidEarlyAccess('_emscripten_bind_SimplPvdTransportImpl_flush_0');
var _emscripten_bind_SimplPvdTransportImpl___destroy___0 = Module['_emscripten_bind_SimplPvdTransportImpl___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_SimplPvdTransportImpl___destroy___0');
var _emscripten_bind_SphereSupport_SphereSupport_1 = Module['_emscripten_bind_SphereSupport_SphereSupport_1'] = makeInvalidEarlyAccess('_emscripten_bind_SphereSupport_SphereSupport_1');
var _emscripten_bind_SphereSupport_getMargin_0 = Module['_emscripten_bind_SphereSupport_getMargin_0'] = makeInvalidEarlyAccess('_emscripten_bind_SphereSupport_getMargin_0');
var _emscripten_bind_SphereSupport_supportLocal_1 = Module['_emscripten_bind_SphereSupport_supportLocal_1'] = makeInvalidEarlyAccess('_emscripten_bind_SphereSupport_supportLocal_1');
var _emscripten_bind_SphereSupport_get_radius_0 = Module['_emscripten_bind_SphereSupport_get_radius_0'] = makeInvalidEarlyAccess('_emscripten_bind_SphereSupport_get_radius_0');
var _emscripten_bind_SphereSupport_set_radius_1 = Module['_emscripten_bind_SphereSupport_set_radius_1'] = makeInvalidEarlyAccess('_emscripten_bind_SphereSupport_set_radius_1');
var _emscripten_bind_SphereSupport___destroy___0 = Module['_emscripten_bind_SphereSupport___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_SphereSupport___destroy___0');
var _emscripten_bind_SupportFunctions_PxActor_getShape_2 = Module['_emscripten_bind_SupportFunctions_PxActor_getShape_2'] = makeInvalidEarlyAccess('_emscripten_bind_SupportFunctions_PxActor_getShape_2');
var _emscripten_bind_SupportFunctions_PxScene_getActiveActors_1 = Module['_emscripten_bind_SupportFunctions_PxScene_getActiveActors_1'] = makeInvalidEarlyAccess('_emscripten_bind_SupportFunctions_PxScene_getActiveActors_1');
var _emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverPositionIterations_1 = Module['_emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverPositionIterations_1'] = makeInvalidEarlyAccess('_emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverPositionIterations_1');
var _emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverVelocityIterations_1 = Module['_emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverVelocityIterations_1'] = makeInvalidEarlyAccess('_emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverVelocityIterations_1');
var _emscripten_bind_SupportFunctions___destroy___0 = Module['_emscripten_bind_SupportFunctions___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_SupportFunctions___destroy___0');
var _emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_0 = Module['_emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_0');
var _emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_1 = Module['_emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_1');
var _emscripten_bind_Vector_PxActorPtr_at_1 = Module['_emscripten_bind_Vector_PxActorPtr_at_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxActorPtr_at_1');
var _emscripten_bind_Vector_PxActorPtr_data_0 = Module['_emscripten_bind_Vector_PxActorPtr_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxActorPtr_data_0');
var _emscripten_bind_Vector_PxActorPtr_size_0 = Module['_emscripten_bind_Vector_PxActorPtr_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxActorPtr_size_0');
var _emscripten_bind_Vector_PxActorPtr_push_back_1 = Module['_emscripten_bind_Vector_PxActorPtr_push_back_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxActorPtr_push_back_1');
var _emscripten_bind_Vector_PxActorPtr_clear_0 = Module['_emscripten_bind_Vector_PxActorPtr_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxActorPtr_clear_0');
var _emscripten_bind_Vector_PxActorPtr___destroy___0 = Module['_emscripten_bind_Vector_PxActorPtr___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxActorPtr___destroy___0');
var _emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_0 = Module['_emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_0');
var _emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_1 = Module['_emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_1');
var _emscripten_bind_Vector_PxContactPairPoint_at_1 = Module['_emscripten_bind_Vector_PxContactPairPoint_at_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxContactPairPoint_at_1');
var _emscripten_bind_Vector_PxContactPairPoint_data_0 = Module['_emscripten_bind_Vector_PxContactPairPoint_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxContactPairPoint_data_0');
var _emscripten_bind_Vector_PxContactPairPoint_size_0 = Module['_emscripten_bind_Vector_PxContactPairPoint_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxContactPairPoint_size_0');
var _emscripten_bind_Vector_PxContactPairPoint_push_back_1 = Module['_emscripten_bind_Vector_PxContactPairPoint_push_back_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxContactPairPoint_push_back_1');
var _emscripten_bind_Vector_PxContactPairPoint_clear_0 = Module['_emscripten_bind_Vector_PxContactPairPoint_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxContactPairPoint_clear_0');
var _emscripten_bind_Vector_PxContactPairPoint___destroy___0 = Module['_emscripten_bind_Vector_PxContactPairPoint___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxContactPairPoint___destroy___0');
var _emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_0 = Module['_emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_0');
var _emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_1 = Module['_emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_1');
var _emscripten_bind_Vector_PxHeightFieldSample_at_1 = Module['_emscripten_bind_Vector_PxHeightFieldSample_at_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxHeightFieldSample_at_1');
var _emscripten_bind_Vector_PxHeightFieldSample_data_0 = Module['_emscripten_bind_Vector_PxHeightFieldSample_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxHeightFieldSample_data_0');
var _emscripten_bind_Vector_PxHeightFieldSample_size_0 = Module['_emscripten_bind_Vector_PxHeightFieldSample_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxHeightFieldSample_size_0');
var _emscripten_bind_Vector_PxHeightFieldSample_push_back_1 = Module['_emscripten_bind_Vector_PxHeightFieldSample_push_back_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxHeightFieldSample_push_back_1');
var _emscripten_bind_Vector_PxHeightFieldSample_clear_0 = Module['_emscripten_bind_Vector_PxHeightFieldSample_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxHeightFieldSample_clear_0');
var _emscripten_bind_Vector_PxHeightFieldSample___destroy___0 = Module['_emscripten_bind_Vector_PxHeightFieldSample___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxHeightFieldSample___destroy___0');
var _emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_0 = Module['_emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_0');
var _emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_1 = Module['_emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_1');
var _emscripten_bind_Vector_PxMaterialConst_at_1 = Module['_emscripten_bind_Vector_PxMaterialConst_at_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxMaterialConst_at_1');
var _emscripten_bind_Vector_PxMaterialConst_data_0 = Module['_emscripten_bind_Vector_PxMaterialConst_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxMaterialConst_data_0');
var _emscripten_bind_Vector_PxMaterialConst_size_0 = Module['_emscripten_bind_Vector_PxMaterialConst_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxMaterialConst_size_0');
var _emscripten_bind_Vector_PxMaterialConst_push_back_1 = Module['_emscripten_bind_Vector_PxMaterialConst_push_back_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxMaterialConst_push_back_1');
var _emscripten_bind_Vector_PxMaterialConst_clear_0 = Module['_emscripten_bind_Vector_PxMaterialConst_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxMaterialConst_clear_0');
var _emscripten_bind_Vector_PxMaterialConst___destroy___0 = Module['_emscripten_bind_Vector_PxMaterialConst___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxMaterialConst___destroy___0');
var _emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_0 = Module['_emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_0');
var _emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_1 = Module['_emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_1');
var _emscripten_bind_Vector_PxRaycastHit_at_1 = Module['_emscripten_bind_Vector_PxRaycastHit_at_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxRaycastHit_at_1');
var _emscripten_bind_Vector_PxRaycastHit_data_0 = Module['_emscripten_bind_Vector_PxRaycastHit_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxRaycastHit_data_0');
var _emscripten_bind_Vector_PxRaycastHit_size_0 = Module['_emscripten_bind_Vector_PxRaycastHit_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxRaycastHit_size_0');
var _emscripten_bind_Vector_PxRaycastHit_push_back_1 = Module['_emscripten_bind_Vector_PxRaycastHit_push_back_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxRaycastHit_push_back_1');
var _emscripten_bind_Vector_PxRaycastHit_clear_0 = Module['_emscripten_bind_Vector_PxRaycastHit_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxRaycastHit_clear_0');
var _emscripten_bind_Vector_PxRaycastHit___destroy___0 = Module['_emscripten_bind_Vector_PxRaycastHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxRaycastHit___destroy___0');
var _emscripten_bind_Vector_PxReal_Vector_PxReal_0 = Module['_emscripten_bind_Vector_PxReal_Vector_PxReal_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxReal_Vector_PxReal_0');
var _emscripten_bind_Vector_PxReal_Vector_PxReal_1 = Module['_emscripten_bind_Vector_PxReal_Vector_PxReal_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxReal_Vector_PxReal_1');
var _emscripten_bind_Vector_PxReal_at_1 = Module['_emscripten_bind_Vector_PxReal_at_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxReal_at_1');
var _emscripten_bind_Vector_PxReal_data_0 = Module['_emscripten_bind_Vector_PxReal_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxReal_data_0');
var _emscripten_bind_Vector_PxReal_size_0 = Module['_emscripten_bind_Vector_PxReal_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxReal_size_0');
var _emscripten_bind_Vector_PxReal_push_back_1 = Module['_emscripten_bind_Vector_PxReal_push_back_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxReal_push_back_1');
var _emscripten_bind_Vector_PxReal_clear_0 = Module['_emscripten_bind_Vector_PxReal_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxReal_clear_0');
var _emscripten_bind_Vector_PxReal___destroy___0 = Module['_emscripten_bind_Vector_PxReal___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxReal___destroy___0');
var _emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_0 = Module['_emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_0');
var _emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_1 = Module['_emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_1');
var _emscripten_bind_Vector_PxSweepHit_at_1 = Module['_emscripten_bind_Vector_PxSweepHit_at_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxSweepHit_at_1');
var _emscripten_bind_Vector_PxSweepHit_data_0 = Module['_emscripten_bind_Vector_PxSweepHit_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxSweepHit_data_0');
var _emscripten_bind_Vector_PxSweepHit_size_0 = Module['_emscripten_bind_Vector_PxSweepHit_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxSweepHit_size_0');
var _emscripten_bind_Vector_PxSweepHit_push_back_1 = Module['_emscripten_bind_Vector_PxSweepHit_push_back_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxSweepHit_push_back_1');
var _emscripten_bind_Vector_PxSweepHit_clear_0 = Module['_emscripten_bind_Vector_PxSweepHit_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxSweepHit_clear_0');
var _emscripten_bind_Vector_PxSweepHit___destroy___0 = Module['_emscripten_bind_Vector_PxSweepHit___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxSweepHit___destroy___0');
var _emscripten_bind_Vector_PxU16_Vector_PxU16_0 = Module['_emscripten_bind_Vector_PxU16_Vector_PxU16_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU16_Vector_PxU16_0');
var _emscripten_bind_Vector_PxU16_Vector_PxU16_1 = Module['_emscripten_bind_Vector_PxU16_Vector_PxU16_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU16_Vector_PxU16_1');
var _emscripten_bind_Vector_PxU16_at_1 = Module['_emscripten_bind_Vector_PxU16_at_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU16_at_1');
var _emscripten_bind_Vector_PxU16_data_0 = Module['_emscripten_bind_Vector_PxU16_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU16_data_0');
var _emscripten_bind_Vector_PxU16_size_0 = Module['_emscripten_bind_Vector_PxU16_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU16_size_0');
var _emscripten_bind_Vector_PxU16_push_back_1 = Module['_emscripten_bind_Vector_PxU16_push_back_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU16_push_back_1');
var _emscripten_bind_Vector_PxU16_clear_0 = Module['_emscripten_bind_Vector_PxU16_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU16_clear_0');
var _emscripten_bind_Vector_PxU16___destroy___0 = Module['_emscripten_bind_Vector_PxU16___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU16___destroy___0');
var _emscripten_bind_Vector_PxU32_Vector_PxU32_0 = Module['_emscripten_bind_Vector_PxU32_Vector_PxU32_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU32_Vector_PxU32_0');
var _emscripten_bind_Vector_PxU32_Vector_PxU32_1 = Module['_emscripten_bind_Vector_PxU32_Vector_PxU32_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU32_Vector_PxU32_1');
var _emscripten_bind_Vector_PxU32_at_1 = Module['_emscripten_bind_Vector_PxU32_at_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU32_at_1');
var _emscripten_bind_Vector_PxU32_data_0 = Module['_emscripten_bind_Vector_PxU32_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU32_data_0');
var _emscripten_bind_Vector_PxU32_size_0 = Module['_emscripten_bind_Vector_PxU32_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU32_size_0');
var _emscripten_bind_Vector_PxU32_push_back_1 = Module['_emscripten_bind_Vector_PxU32_push_back_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU32_push_back_1');
var _emscripten_bind_Vector_PxU32_clear_0 = Module['_emscripten_bind_Vector_PxU32_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU32_clear_0');
var _emscripten_bind_Vector_PxU32___destroy___0 = Module['_emscripten_bind_Vector_PxU32___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU32___destroy___0');
var _emscripten_bind_Vector_PxU8_Vector_PxU8_0 = Module['_emscripten_bind_Vector_PxU8_Vector_PxU8_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU8_Vector_PxU8_0');
var _emscripten_bind_Vector_PxU8_Vector_PxU8_1 = Module['_emscripten_bind_Vector_PxU8_Vector_PxU8_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU8_Vector_PxU8_1');
var _emscripten_bind_Vector_PxU8_at_1 = Module['_emscripten_bind_Vector_PxU8_at_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU8_at_1');
var _emscripten_bind_Vector_PxU8_data_0 = Module['_emscripten_bind_Vector_PxU8_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU8_data_0');
var _emscripten_bind_Vector_PxU8_size_0 = Module['_emscripten_bind_Vector_PxU8_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU8_size_0');
var _emscripten_bind_Vector_PxU8_push_back_1 = Module['_emscripten_bind_Vector_PxU8_push_back_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU8_push_back_1');
var _emscripten_bind_Vector_PxU8_clear_0 = Module['_emscripten_bind_Vector_PxU8_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU8_clear_0');
var _emscripten_bind_Vector_PxU8___destroy___0 = Module['_emscripten_bind_Vector_PxU8___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxU8___destroy___0');
var _emscripten_bind_Vector_PxVec3_Vector_PxVec3_0 = Module['_emscripten_bind_Vector_PxVec3_Vector_PxVec3_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec3_Vector_PxVec3_0');
var _emscripten_bind_Vector_PxVec3_Vector_PxVec3_1 = Module['_emscripten_bind_Vector_PxVec3_Vector_PxVec3_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec3_Vector_PxVec3_1');
var _emscripten_bind_Vector_PxVec3_at_1 = Module['_emscripten_bind_Vector_PxVec3_at_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec3_at_1');
var _emscripten_bind_Vector_PxVec3_data_0 = Module['_emscripten_bind_Vector_PxVec3_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec3_data_0');
var _emscripten_bind_Vector_PxVec3_size_0 = Module['_emscripten_bind_Vector_PxVec3_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec3_size_0');
var _emscripten_bind_Vector_PxVec3_push_back_1 = Module['_emscripten_bind_Vector_PxVec3_push_back_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec3_push_back_1');
var _emscripten_bind_Vector_PxVec3_clear_0 = Module['_emscripten_bind_Vector_PxVec3_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec3_clear_0');
var _emscripten_bind_Vector_PxVec3___destroy___0 = Module['_emscripten_bind_Vector_PxVec3___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec3___destroy___0');
var _emscripten_bind_Vector_PxVec4_Vector_PxVec4_0 = Module['_emscripten_bind_Vector_PxVec4_Vector_PxVec4_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec4_Vector_PxVec4_0');
var _emscripten_bind_Vector_PxVec4_Vector_PxVec4_1 = Module['_emscripten_bind_Vector_PxVec4_Vector_PxVec4_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec4_Vector_PxVec4_1');
var _emscripten_bind_Vector_PxVec4_at_1 = Module['_emscripten_bind_Vector_PxVec4_at_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec4_at_1');
var _emscripten_bind_Vector_PxVec4_data_0 = Module['_emscripten_bind_Vector_PxVec4_data_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec4_data_0');
var _emscripten_bind_Vector_PxVec4_size_0 = Module['_emscripten_bind_Vector_PxVec4_size_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec4_size_0');
var _emscripten_bind_Vector_PxVec4_push_back_1 = Module['_emscripten_bind_Vector_PxVec4_push_back_1'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec4_push_back_1');
var _emscripten_bind_Vector_PxVec4_clear_0 = Module['_emscripten_bind_Vector_PxVec4_clear_0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec4_clear_0');
var _emscripten_bind_Vector_PxVec4___destroy___0 = Module['_emscripten_bind_Vector_PxVec4___destroy___0'] = makeInvalidEarlyAccess('_emscripten_bind_Vector_PxVec4___destroy___0');
var _emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_FOURWHEELDRIVE = Module['_emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_FOURWHEELDRIVE'] = makeInvalidEarlyAccess('_emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_FOURWHEELDRIVE');
var _emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_MULTIWHEELDRIVE = Module['_emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_MULTIWHEELDRIVE'] = makeInvalidEarlyAccess('_emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_MULTIWHEELDRIVE');
var _emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_TANKDRIVE = Module['_emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_TANKDRIVE'] = makeInvalidEarlyAccess('_emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_TANKDRIVE');
var _emscripten_enum_PxActorFlagEnum_eVISUALIZATION = Module['_emscripten_enum_PxActorFlagEnum_eVISUALIZATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxActorFlagEnum_eVISUALIZATION');
var _emscripten_enum_PxActorFlagEnum_eDISABLE_GRAVITY = Module['_emscripten_enum_PxActorFlagEnum_eDISABLE_GRAVITY'] = makeInvalidEarlyAccess('_emscripten_enum_PxActorFlagEnum_eDISABLE_GRAVITY');
var _emscripten_enum_PxActorFlagEnum_eSEND_SLEEP_NOTIFIES = Module['_emscripten_enum_PxActorFlagEnum_eSEND_SLEEP_NOTIFIES'] = makeInvalidEarlyAccess('_emscripten_enum_PxActorFlagEnum_eSEND_SLEEP_NOTIFIES');
var _emscripten_enum_PxActorFlagEnum_eDISABLE_SIMULATION = Module['_emscripten_enum_PxActorFlagEnum_eDISABLE_SIMULATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxActorFlagEnum_eDISABLE_SIMULATION');
var _emscripten_enum_PxActorTypeEnum_eRIGID_STATIC = Module['_emscripten_enum_PxActorTypeEnum_eRIGID_STATIC'] = makeInvalidEarlyAccess('_emscripten_enum_PxActorTypeEnum_eRIGID_STATIC');
var _emscripten_enum_PxActorTypeEnum_eRIGID_DYNAMIC = Module['_emscripten_enum_PxActorTypeEnum_eRIGID_DYNAMIC'] = makeInvalidEarlyAccess('_emscripten_enum_PxActorTypeEnum_eRIGID_DYNAMIC');
var _emscripten_enum_PxActorTypeEnum_eARTICULATION_LINK = Module['_emscripten_enum_PxActorTypeEnum_eARTICULATION_LINK'] = makeInvalidEarlyAccess('_emscripten_enum_PxActorTypeEnum_eARTICULATION_LINK');
var _emscripten_enum_PxActorTypeEnum_eDEFORMABLE_SURFACE = Module['_emscripten_enum_PxActorTypeEnum_eDEFORMABLE_SURFACE'] = makeInvalidEarlyAccess('_emscripten_enum_PxActorTypeEnum_eDEFORMABLE_SURFACE');
var _emscripten_enum_PxActorTypeEnum_eDEFORMABLE_VOLUME = Module['_emscripten_enum_PxActorTypeEnum_eDEFORMABLE_VOLUME'] = makeInvalidEarlyAccess('_emscripten_enum_PxActorTypeEnum_eDEFORMABLE_VOLUME');
var _emscripten_enum_PxActorTypeEnum_eSOFTBODY = Module['_emscripten_enum_PxActorTypeEnum_eSOFTBODY'] = makeInvalidEarlyAccess('_emscripten_enum_PxActorTypeEnum_eSOFTBODY');
var _emscripten_enum_PxActorTypeEnum_ePBD_PARTICLESYSTEM = Module['_emscripten_enum_PxActorTypeEnum_ePBD_PARTICLESYSTEM'] = makeInvalidEarlyAccess('_emscripten_enum_PxActorTypeEnum_ePBD_PARTICLESYSTEM');
var _emscripten_enum_PxActorTypeFlagEnum_eRIGID_STATIC = Module['_emscripten_enum_PxActorTypeFlagEnum_eRIGID_STATIC'] = makeInvalidEarlyAccess('_emscripten_enum_PxActorTypeFlagEnum_eRIGID_STATIC');
var _emscripten_enum_PxActorTypeFlagEnum_eRIGID_DYNAMIC = Module['_emscripten_enum_PxActorTypeFlagEnum_eRIGID_DYNAMIC'] = makeInvalidEarlyAccess('_emscripten_enum_PxActorTypeFlagEnum_eRIGID_DYNAMIC');
var _emscripten_enum_PxArticulationAxisEnum_eTWIST = Module['_emscripten_enum_PxArticulationAxisEnum_eTWIST'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationAxisEnum_eTWIST');
var _emscripten_enum_PxArticulationAxisEnum_eSWING1 = Module['_emscripten_enum_PxArticulationAxisEnum_eSWING1'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationAxisEnum_eSWING1');
var _emscripten_enum_PxArticulationAxisEnum_eSWING2 = Module['_emscripten_enum_PxArticulationAxisEnum_eSWING2'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationAxisEnum_eSWING2');
var _emscripten_enum_PxArticulationAxisEnum_eX = Module['_emscripten_enum_PxArticulationAxisEnum_eX'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationAxisEnum_eX');
var _emscripten_enum_PxArticulationAxisEnum_eY = Module['_emscripten_enum_PxArticulationAxisEnum_eY'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationAxisEnum_eY');
var _emscripten_enum_PxArticulationAxisEnum_eZ = Module['_emscripten_enum_PxArticulationAxisEnum_eZ'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationAxisEnum_eZ');
var _emscripten_enum_PxArticulationCacheFlagEnum_eVELOCITY = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eVELOCITY'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationCacheFlagEnum_eVELOCITY');
var _emscripten_enum_PxArticulationCacheFlagEnum_eACCELERATION = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eACCELERATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationCacheFlagEnum_eACCELERATION');
var _emscripten_enum_PxArticulationCacheFlagEnum_ePOSITION = Module['_emscripten_enum_PxArticulationCacheFlagEnum_ePOSITION'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationCacheFlagEnum_ePOSITION');
var _emscripten_enum_PxArticulationCacheFlagEnum_eFORCE = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eFORCE'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationCacheFlagEnum_eFORCE');
var _emscripten_enum_PxArticulationCacheFlagEnum_eLINK_VELOCITY = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eLINK_VELOCITY'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationCacheFlagEnum_eLINK_VELOCITY');
var _emscripten_enum_PxArticulationCacheFlagEnum_eLINK_ACCELERATION = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eLINK_ACCELERATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationCacheFlagEnum_eLINK_ACCELERATION');
var _emscripten_enum_PxArticulationCacheFlagEnum_eROOT_TRANSFORM = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eROOT_TRANSFORM'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationCacheFlagEnum_eROOT_TRANSFORM');
var _emscripten_enum_PxArticulationCacheFlagEnum_eROOT_VELOCITIES = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eROOT_VELOCITIES'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationCacheFlagEnum_eROOT_VELOCITIES');
var _emscripten_enum_PxArticulationCacheFlagEnum_eLINK_INCOMING_JOINT_FORCE = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eLINK_INCOMING_JOINT_FORCE'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationCacheFlagEnum_eLINK_INCOMING_JOINT_FORCE');
var _emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_POSITIONS = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_POSITIONS'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_POSITIONS');
var _emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_VELOCITIES = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_VELOCITIES'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_VELOCITIES');
var _emscripten_enum_PxArticulationCacheFlagEnum_eALL = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eALL'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationCacheFlagEnum_eALL');
var _emscripten_enum_PxArticulationDriveTypeEnum_eFORCE = Module['_emscripten_enum_PxArticulationDriveTypeEnum_eFORCE'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationDriveTypeEnum_eFORCE');
var _emscripten_enum_PxArticulationDriveTypeEnum_eACCELERATION = Module['_emscripten_enum_PxArticulationDriveTypeEnum_eACCELERATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationDriveTypeEnum_eACCELERATION');
var _emscripten_enum_PxArticulationDriveTypeEnum_eNONE = Module['_emscripten_enum_PxArticulationDriveTypeEnum_eNONE'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationDriveTypeEnum_eNONE');
var _emscripten_enum_PxArticulationFlagEnum_eFIX_BASE = Module['_emscripten_enum_PxArticulationFlagEnum_eFIX_BASE'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationFlagEnum_eFIX_BASE');
var _emscripten_enum_PxArticulationFlagEnum_eDRIVE_LIMITS_ARE_FORCES = Module['_emscripten_enum_PxArticulationFlagEnum_eDRIVE_LIMITS_ARE_FORCES'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationFlagEnum_eDRIVE_LIMITS_ARE_FORCES');
var _emscripten_enum_PxArticulationFlagEnum_eDISABLE_SELF_COLLISION = Module['_emscripten_enum_PxArticulationFlagEnum_eDISABLE_SELF_COLLISION'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationFlagEnum_eDISABLE_SELF_COLLISION');
var _emscripten_enum_PxArticulationJointTypeEnum_eFIX = Module['_emscripten_enum_PxArticulationJointTypeEnum_eFIX'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationJointTypeEnum_eFIX');
var _emscripten_enum_PxArticulationJointTypeEnum_ePRISMATIC = Module['_emscripten_enum_PxArticulationJointTypeEnum_ePRISMATIC'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationJointTypeEnum_ePRISMATIC');
var _emscripten_enum_PxArticulationJointTypeEnum_eREVOLUTE = Module['_emscripten_enum_PxArticulationJointTypeEnum_eREVOLUTE'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationJointTypeEnum_eREVOLUTE');
var _emscripten_enum_PxArticulationJointTypeEnum_eSPHERICAL = Module['_emscripten_enum_PxArticulationJointTypeEnum_eSPHERICAL'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationJointTypeEnum_eSPHERICAL');
var _emscripten_enum_PxArticulationJointTypeEnum_eUNDEFINED = Module['_emscripten_enum_PxArticulationJointTypeEnum_eUNDEFINED'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationJointTypeEnum_eUNDEFINED');
var _emscripten_enum_PxArticulationKinematicFlagEnum_ePOSITION = Module['_emscripten_enum_PxArticulationKinematicFlagEnum_ePOSITION'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationKinematicFlagEnum_ePOSITION');
var _emscripten_enum_PxArticulationKinematicFlagEnum_eVELOCITY = Module['_emscripten_enum_PxArticulationKinematicFlagEnum_eVELOCITY'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationKinematicFlagEnum_eVELOCITY');
var _emscripten_enum_PxArticulationMotionEnum_eLOCKED = Module['_emscripten_enum_PxArticulationMotionEnum_eLOCKED'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationMotionEnum_eLOCKED');
var _emscripten_enum_PxArticulationMotionEnum_eLIMITED = Module['_emscripten_enum_PxArticulationMotionEnum_eLIMITED'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationMotionEnum_eLIMITED');
var _emscripten_enum_PxArticulationMotionEnum_eFREE = Module['_emscripten_enum_PxArticulationMotionEnum_eFREE'] = makeInvalidEarlyAccess('_emscripten_enum_PxArticulationMotionEnum_eFREE');
var _emscripten_enum_PxBVHBuildStrategyEnum_eFAST = Module['_emscripten_enum_PxBVHBuildStrategyEnum_eFAST'] = makeInvalidEarlyAccess('_emscripten_enum_PxBVHBuildStrategyEnum_eFAST');
var _emscripten_enum_PxBVHBuildStrategyEnum_eDEFAULT = Module['_emscripten_enum_PxBVHBuildStrategyEnum_eDEFAULT'] = makeInvalidEarlyAccess('_emscripten_enum_PxBVHBuildStrategyEnum_eDEFAULT');
var _emscripten_enum_PxBVHBuildStrategyEnum_eSAH = Module['_emscripten_enum_PxBVHBuildStrategyEnum_eSAH'] = makeInvalidEarlyAccess('_emscripten_enum_PxBVHBuildStrategyEnum_eSAH');
var _emscripten_enum_PxBaseFlagEnum_eOWNS_MEMORY = Module['_emscripten_enum_PxBaseFlagEnum_eOWNS_MEMORY'] = makeInvalidEarlyAccess('_emscripten_enum_PxBaseFlagEnum_eOWNS_MEMORY');
var _emscripten_enum_PxBaseFlagEnum_eIS_RELEASABLE = Module['_emscripten_enum_PxBaseFlagEnum_eIS_RELEASABLE'] = makeInvalidEarlyAccess('_emscripten_enum_PxBaseFlagEnum_eIS_RELEASABLE');
var _emscripten_enum_PxBroadPhaseTypeEnum_eSAP = Module['_emscripten_enum_PxBroadPhaseTypeEnum_eSAP'] = makeInvalidEarlyAccess('_emscripten_enum_PxBroadPhaseTypeEnum_eSAP');
var _emscripten_enum_PxBroadPhaseTypeEnum_eMBP = Module['_emscripten_enum_PxBroadPhaseTypeEnum_eMBP'] = makeInvalidEarlyAccess('_emscripten_enum_PxBroadPhaseTypeEnum_eMBP');
var _emscripten_enum_PxBroadPhaseTypeEnum_eABP = Module['_emscripten_enum_PxBroadPhaseTypeEnum_eABP'] = makeInvalidEarlyAccess('_emscripten_enum_PxBroadPhaseTypeEnum_eABP');
var _emscripten_enum_PxBroadPhaseTypeEnum_ePABP = Module['_emscripten_enum_PxBroadPhaseTypeEnum_ePABP'] = makeInvalidEarlyAccess('_emscripten_enum_PxBroadPhaseTypeEnum_ePABP');
var _emscripten_enum_PxBroadPhaseTypeEnum_eGPU = Module['_emscripten_enum_PxBroadPhaseTypeEnum_eGPU'] = makeInvalidEarlyAccess('_emscripten_enum_PxBroadPhaseTypeEnum_eGPU');
var _emscripten_enum_PxCapsuleClimbingModeEnum_eEASY = Module['_emscripten_enum_PxCapsuleClimbingModeEnum_eEASY'] = makeInvalidEarlyAccess('_emscripten_enum_PxCapsuleClimbingModeEnum_eEASY');
var _emscripten_enum_PxCapsuleClimbingModeEnum_eCONSTRAINED = Module['_emscripten_enum_PxCapsuleClimbingModeEnum_eCONSTRAINED'] = makeInvalidEarlyAccess('_emscripten_enum_PxCapsuleClimbingModeEnum_eCONSTRAINED');
var _emscripten_enum_PxCombineModeEnum_eAVERAGE = Module['_emscripten_enum_PxCombineModeEnum_eAVERAGE'] = makeInvalidEarlyAccess('_emscripten_enum_PxCombineModeEnum_eAVERAGE');
var _emscripten_enum_PxCombineModeEnum_eMIN = Module['_emscripten_enum_PxCombineModeEnum_eMIN'] = makeInvalidEarlyAccess('_emscripten_enum_PxCombineModeEnum_eMIN');
var _emscripten_enum_PxCombineModeEnum_eMULTIPLY = Module['_emscripten_enum_PxCombineModeEnum_eMULTIPLY'] = makeInvalidEarlyAccess('_emscripten_enum_PxCombineModeEnum_eMULTIPLY');
var _emscripten_enum_PxCombineModeEnum_eMAX = Module['_emscripten_enum_PxCombineModeEnum_eMAX'] = makeInvalidEarlyAccess('_emscripten_enum_PxCombineModeEnum_eMAX');
var _emscripten_enum_PxConstraintFlagEnum_eBROKEN = Module['_emscripten_enum_PxConstraintFlagEnum_eBROKEN'] = makeInvalidEarlyAccess('_emscripten_enum_PxConstraintFlagEnum_eBROKEN');
var _emscripten_enum_PxConstraintFlagEnum_eCOLLISION_ENABLED = Module['_emscripten_enum_PxConstraintFlagEnum_eCOLLISION_ENABLED'] = makeInvalidEarlyAccess('_emscripten_enum_PxConstraintFlagEnum_eCOLLISION_ENABLED');
var _emscripten_enum_PxConstraintFlagEnum_eVISUALIZATION = Module['_emscripten_enum_PxConstraintFlagEnum_eVISUALIZATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxConstraintFlagEnum_eVISUALIZATION');
var _emscripten_enum_PxConstraintFlagEnum_eDRIVE_LIMITS_ARE_FORCES = Module['_emscripten_enum_PxConstraintFlagEnum_eDRIVE_LIMITS_ARE_FORCES'] = makeInvalidEarlyAccess('_emscripten_enum_PxConstraintFlagEnum_eDRIVE_LIMITS_ARE_FORCES');
var _emscripten_enum_PxConstraintFlagEnum_eIMPROVED_SLERP = Module['_emscripten_enum_PxConstraintFlagEnum_eIMPROVED_SLERP'] = makeInvalidEarlyAccess('_emscripten_enum_PxConstraintFlagEnum_eIMPROVED_SLERP');
var _emscripten_enum_PxConstraintFlagEnum_eDISABLE_PREPROCESSING = Module['_emscripten_enum_PxConstraintFlagEnum_eDISABLE_PREPROCESSING'] = makeInvalidEarlyAccess('_emscripten_enum_PxConstraintFlagEnum_eDISABLE_PREPROCESSING');
var _emscripten_enum_PxConstraintFlagEnum_eENABLE_EXTENDED_LIMITS = Module['_emscripten_enum_PxConstraintFlagEnum_eENABLE_EXTENDED_LIMITS'] = makeInvalidEarlyAccess('_emscripten_enum_PxConstraintFlagEnum_eENABLE_EXTENDED_LIMITS');
var _emscripten_enum_PxConstraintFlagEnum_eGPU_COMPATIBLE = Module['_emscripten_enum_PxConstraintFlagEnum_eGPU_COMPATIBLE'] = makeInvalidEarlyAccess('_emscripten_enum_PxConstraintFlagEnum_eGPU_COMPATIBLE');
var _emscripten_enum_PxConstraintFlagEnum_eALWAYS_UPDATE = Module['_emscripten_enum_PxConstraintFlagEnum_eALWAYS_UPDATE'] = makeInvalidEarlyAccess('_emscripten_enum_PxConstraintFlagEnum_eALWAYS_UPDATE');
var _emscripten_enum_PxConstraintFlagEnum_eDISABLE_CONSTRAINT = Module['_emscripten_enum_PxConstraintFlagEnum_eDISABLE_CONSTRAINT'] = makeInvalidEarlyAccess('_emscripten_enum_PxConstraintFlagEnum_eDISABLE_CONSTRAINT');
var _emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_0 = Module['_emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_0'] = makeInvalidEarlyAccess('_emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_0');
var _emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_1 = Module['_emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_1'] = makeInvalidEarlyAccess('_emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_1');
var _emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_HAS_FIRST_TOUCH = Module['_emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_HAS_FIRST_TOUCH'] = makeInvalidEarlyAccess('_emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_HAS_FIRST_TOUCH');
var _emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_LOST_TOUCH = Module['_emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_LOST_TOUCH'] = makeInvalidEarlyAccess('_emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_LOST_TOUCH');
var _emscripten_enum_PxContactPairFlagEnum_eINTERNAL_HAS_IMPULSES = Module['_emscripten_enum_PxContactPairFlagEnum_eINTERNAL_HAS_IMPULSES'] = makeInvalidEarlyAccess('_emscripten_enum_PxContactPairFlagEnum_eINTERNAL_HAS_IMPULSES');
var _emscripten_enum_PxContactPairFlagEnum_eINTERNAL_CONTACTS_ARE_FLIPPED = Module['_emscripten_enum_PxContactPairFlagEnum_eINTERNAL_CONTACTS_ARE_FLIPPED'] = makeInvalidEarlyAccess('_emscripten_enum_PxContactPairFlagEnum_eINTERNAL_CONTACTS_ARE_FLIPPED');
var _emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_0 = Module['_emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_0'] = makeInvalidEarlyAccess('_emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_0');
var _emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_1 = Module['_emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_1'] = makeInvalidEarlyAccess('_emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_1');
var _emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_CAN_RIDE_ON_OBJECT = Module['_emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_CAN_RIDE_ON_OBJECT'] = makeInvalidEarlyAccess('_emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_CAN_RIDE_ON_OBJECT');
var _emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_SLIDE = Module['_emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_SLIDE'] = makeInvalidEarlyAccess('_emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_SLIDE');
var _emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_USER_DEFINED_RIDE = Module['_emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_USER_DEFINED_RIDE'] = makeInvalidEarlyAccess('_emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_USER_DEFINED_RIDE');
var _emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_SIDES = Module['_emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_SIDES'] = makeInvalidEarlyAccess('_emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_SIDES');
var _emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_UP = Module['_emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_UP'] = makeInvalidEarlyAccess('_emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_UP');
var _emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_DOWN = Module['_emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_DOWN'] = makeInvalidEarlyAccess('_emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_DOWN');
var _emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING = Module['_emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING'] = makeInvalidEarlyAccess('_emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING');
var _emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING_AND_FORCE_SLIDING = Module['_emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING_AND_FORCE_SLIDING'] = makeInvalidEarlyAccess('_emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING_AND_FORCE_SLIDING');
var _emscripten_enum_PxControllerShapeTypeEnum_eBOX = Module['_emscripten_enum_PxControllerShapeTypeEnum_eBOX'] = makeInvalidEarlyAccess('_emscripten_enum_PxControllerShapeTypeEnum_eBOX');
var _emscripten_enum_PxControllerShapeTypeEnum_eCAPSULE = Module['_emscripten_enum_PxControllerShapeTypeEnum_eCAPSULE'] = makeInvalidEarlyAccess('_emscripten_enum_PxControllerShapeTypeEnum_eCAPSULE');
var _emscripten_enum_PxConvexCoreTypeEnum_ePOINT = Module['_emscripten_enum_PxConvexCoreTypeEnum_ePOINT'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexCoreTypeEnum_ePOINT');
var _emscripten_enum_PxConvexCoreTypeEnum_eSEGMENT = Module['_emscripten_enum_PxConvexCoreTypeEnum_eSEGMENT'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexCoreTypeEnum_eSEGMENT');
var _emscripten_enum_PxConvexCoreTypeEnum_eBOX = Module['_emscripten_enum_PxConvexCoreTypeEnum_eBOX'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexCoreTypeEnum_eBOX');
var _emscripten_enum_PxConvexCoreTypeEnum_eELLIPSOID = Module['_emscripten_enum_PxConvexCoreTypeEnum_eELLIPSOID'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexCoreTypeEnum_eELLIPSOID');
var _emscripten_enum_PxConvexCoreTypeEnum_eCYLINDER = Module['_emscripten_enum_PxConvexCoreTypeEnum_eCYLINDER'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexCoreTypeEnum_eCYLINDER');
var _emscripten_enum_PxConvexCoreTypeEnum_eCONE = Module['_emscripten_enum_PxConvexCoreTypeEnum_eCONE'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexCoreTypeEnum_eCONE');
var _emscripten_enum_PxConvexFlagEnum_e16_BIT_INDICES = Module['_emscripten_enum_PxConvexFlagEnum_e16_BIT_INDICES'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexFlagEnum_e16_BIT_INDICES');
var _emscripten_enum_PxConvexFlagEnum_eCOMPUTE_CONVEX = Module['_emscripten_enum_PxConvexFlagEnum_eCOMPUTE_CONVEX'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexFlagEnum_eCOMPUTE_CONVEX');
var _emscripten_enum_PxConvexFlagEnum_eCHECK_ZERO_AREA_TRIANGLES = Module['_emscripten_enum_PxConvexFlagEnum_eCHECK_ZERO_AREA_TRIANGLES'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexFlagEnum_eCHECK_ZERO_AREA_TRIANGLES');
var _emscripten_enum_PxConvexFlagEnum_eQUANTIZE_INPUT = Module['_emscripten_enum_PxConvexFlagEnum_eQUANTIZE_INPUT'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexFlagEnum_eQUANTIZE_INPUT');
var _emscripten_enum_PxConvexFlagEnum_eDISABLE_MESH_VALIDATION = Module['_emscripten_enum_PxConvexFlagEnum_eDISABLE_MESH_VALIDATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexFlagEnum_eDISABLE_MESH_VALIDATION');
var _emscripten_enum_PxConvexFlagEnum_ePLANE_SHIFTING = Module['_emscripten_enum_PxConvexFlagEnum_ePLANE_SHIFTING'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexFlagEnum_ePLANE_SHIFTING');
var _emscripten_enum_PxConvexFlagEnum_eFAST_INERTIA_COMPUTATION = Module['_emscripten_enum_PxConvexFlagEnum_eFAST_INERTIA_COMPUTATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexFlagEnum_eFAST_INERTIA_COMPUTATION');
var _emscripten_enum_PxConvexFlagEnum_eSHIFT_VERTICES = Module['_emscripten_enum_PxConvexFlagEnum_eSHIFT_VERTICES'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexFlagEnum_eSHIFT_VERTICES');
var _emscripten_enum_PxConvexMeshCookingTypeEnum_eQUICKHULL = Module['_emscripten_enum_PxConvexMeshCookingTypeEnum_eQUICKHULL'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexMeshCookingTypeEnum_eQUICKHULL');
var _emscripten_enum_PxConvexMeshGeometryFlagEnum_eTIGHT_BOUNDS = Module['_emscripten_enum_PxConvexMeshGeometryFlagEnum_eTIGHT_BOUNDS'] = makeInvalidEarlyAccess('_emscripten_enum_PxConvexMeshGeometryFlagEnum_eTIGHT_BOUNDS');
var _emscripten_enum_PxD6AngularDriveConfigEnum_eSWING_TWIST = Module['_emscripten_enum_PxD6AngularDriveConfigEnum_eSWING_TWIST'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6AngularDriveConfigEnum_eSWING_TWIST');
var _emscripten_enum_PxD6AngularDriveConfigEnum_eSLERP = Module['_emscripten_enum_PxD6AngularDriveConfigEnum_eSLERP'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6AngularDriveConfigEnum_eSLERP');
var _emscripten_enum_PxD6AngularDriveConfigEnum_eLEGACY = Module['_emscripten_enum_PxD6AngularDriveConfigEnum_eLEGACY'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6AngularDriveConfigEnum_eLEGACY');
var _emscripten_enum_PxD6AxisEnum_eX = Module['_emscripten_enum_PxD6AxisEnum_eX'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6AxisEnum_eX');
var _emscripten_enum_PxD6AxisEnum_eY = Module['_emscripten_enum_PxD6AxisEnum_eY'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6AxisEnum_eY');
var _emscripten_enum_PxD6AxisEnum_eZ = Module['_emscripten_enum_PxD6AxisEnum_eZ'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6AxisEnum_eZ');
var _emscripten_enum_PxD6AxisEnum_eTWIST = Module['_emscripten_enum_PxD6AxisEnum_eTWIST'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6AxisEnum_eTWIST');
var _emscripten_enum_PxD6AxisEnum_eSWING1 = Module['_emscripten_enum_PxD6AxisEnum_eSWING1'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6AxisEnum_eSWING1');
var _emscripten_enum_PxD6AxisEnum_eSWING2 = Module['_emscripten_enum_PxD6AxisEnum_eSWING2'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6AxisEnum_eSWING2');
var _emscripten_enum_PxD6DriveEnum_eX = Module['_emscripten_enum_PxD6DriveEnum_eX'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6DriveEnum_eX');
var _emscripten_enum_PxD6DriveEnum_eY = Module['_emscripten_enum_PxD6DriveEnum_eY'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6DriveEnum_eY');
var _emscripten_enum_PxD6DriveEnum_eZ = Module['_emscripten_enum_PxD6DriveEnum_eZ'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6DriveEnum_eZ');
var _emscripten_enum_PxD6DriveEnum_eSWING = Module['_emscripten_enum_PxD6DriveEnum_eSWING'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6DriveEnum_eSWING');
var _emscripten_enum_PxD6DriveEnum_eTWIST = Module['_emscripten_enum_PxD6DriveEnum_eTWIST'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6DriveEnum_eTWIST');
var _emscripten_enum_PxD6DriveEnum_eSLERP = Module['_emscripten_enum_PxD6DriveEnum_eSLERP'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6DriveEnum_eSLERP');
var _emscripten_enum_PxD6DriveEnum_eSWING1 = Module['_emscripten_enum_PxD6DriveEnum_eSWING1'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6DriveEnum_eSWING1');
var _emscripten_enum_PxD6DriveEnum_eSWING2 = Module['_emscripten_enum_PxD6DriveEnum_eSWING2'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6DriveEnum_eSWING2');
var _emscripten_enum_PxD6JointDriveFlagEnum_eACCELERATION = Module['_emscripten_enum_PxD6JointDriveFlagEnum_eACCELERATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6JointDriveFlagEnum_eACCELERATION');
var _emscripten_enum_PxD6MotionEnum_eLOCKED = Module['_emscripten_enum_PxD6MotionEnum_eLOCKED'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6MotionEnum_eLOCKED');
var _emscripten_enum_PxD6MotionEnum_eLIMITED = Module['_emscripten_enum_PxD6MotionEnum_eLIMITED'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6MotionEnum_eLIMITED');
var _emscripten_enum_PxD6MotionEnum_eFREE = Module['_emscripten_enum_PxD6MotionEnum_eFREE'] = makeInvalidEarlyAccess('_emscripten_enum_PxD6MotionEnum_eFREE');
var _emscripten_enum_PxDebugColorEnum_eARGB_BLACK = Module['_emscripten_enum_PxDebugColorEnum_eARGB_BLACK'] = makeInvalidEarlyAccess('_emscripten_enum_PxDebugColorEnum_eARGB_BLACK');
var _emscripten_enum_PxDebugColorEnum_eARGB_RED = Module['_emscripten_enum_PxDebugColorEnum_eARGB_RED'] = makeInvalidEarlyAccess('_emscripten_enum_PxDebugColorEnum_eARGB_RED');
var _emscripten_enum_PxDebugColorEnum_eARGB_GREEN = Module['_emscripten_enum_PxDebugColorEnum_eARGB_GREEN'] = makeInvalidEarlyAccess('_emscripten_enum_PxDebugColorEnum_eARGB_GREEN');
var _emscripten_enum_PxDebugColorEnum_eARGB_BLUE = Module['_emscripten_enum_PxDebugColorEnum_eARGB_BLUE'] = makeInvalidEarlyAccess('_emscripten_enum_PxDebugColorEnum_eARGB_BLUE');
var _emscripten_enum_PxDebugColorEnum_eARGB_YELLOW = Module['_emscripten_enum_PxDebugColorEnum_eARGB_YELLOW'] = makeInvalidEarlyAccess('_emscripten_enum_PxDebugColorEnum_eARGB_YELLOW');
var _emscripten_enum_PxDebugColorEnum_eARGB_MAGENTA = Module['_emscripten_enum_PxDebugColorEnum_eARGB_MAGENTA'] = makeInvalidEarlyAccess('_emscripten_enum_PxDebugColorEnum_eARGB_MAGENTA');
var _emscripten_enum_PxDebugColorEnum_eARGB_CYAN = Module['_emscripten_enum_PxDebugColorEnum_eARGB_CYAN'] = makeInvalidEarlyAccess('_emscripten_enum_PxDebugColorEnum_eARGB_CYAN');
var _emscripten_enum_PxDebugColorEnum_eARGB_WHITE = Module['_emscripten_enum_PxDebugColorEnum_eARGB_WHITE'] = makeInvalidEarlyAccess('_emscripten_enum_PxDebugColorEnum_eARGB_WHITE');
var _emscripten_enum_PxDebugColorEnum_eARGB_GREY = Module['_emscripten_enum_PxDebugColorEnum_eARGB_GREY'] = makeInvalidEarlyAccess('_emscripten_enum_PxDebugColorEnum_eARGB_GREY');
var _emscripten_enum_PxDebugColorEnum_eARGB_DARKRED = Module['_emscripten_enum_PxDebugColorEnum_eARGB_DARKRED'] = makeInvalidEarlyAccess('_emscripten_enum_PxDebugColorEnum_eARGB_DARKRED');
var _emscripten_enum_PxDebugColorEnum_eARGB_DARKGREEN = Module['_emscripten_enum_PxDebugColorEnum_eARGB_DARKGREEN'] = makeInvalidEarlyAccess('_emscripten_enum_PxDebugColorEnum_eARGB_DARKGREEN');
var _emscripten_enum_PxDebugColorEnum_eARGB_DARKBLUE = Module['_emscripten_enum_PxDebugColorEnum_eARGB_DARKBLUE'] = makeInvalidEarlyAccess('_emscripten_enum_PxDebugColorEnum_eARGB_DARKBLUE');
var _emscripten_enum_PxDistanceJointFlagEnum_eMAX_DISTANCE_ENABLED = Module['_emscripten_enum_PxDistanceJointFlagEnum_eMAX_DISTANCE_ENABLED'] = makeInvalidEarlyAccess('_emscripten_enum_PxDistanceJointFlagEnum_eMAX_DISTANCE_ENABLED');
var _emscripten_enum_PxDistanceJointFlagEnum_eMIN_DISTANCE_ENABLED = Module['_emscripten_enum_PxDistanceJointFlagEnum_eMIN_DISTANCE_ENABLED'] = makeInvalidEarlyAccess('_emscripten_enum_PxDistanceJointFlagEnum_eMIN_DISTANCE_ENABLED');
var _emscripten_enum_PxDistanceJointFlagEnum_eSPRING_ENABLED = Module['_emscripten_enum_PxDistanceJointFlagEnum_eSPRING_ENABLED'] = makeInvalidEarlyAccess('_emscripten_enum_PxDistanceJointFlagEnum_eSPRING_ENABLED');
var _emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eNONE = Module['_emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eNONE'] = makeInvalidEarlyAccess('_emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eNONE');
var _emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBUCKET = Module['_emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBUCKET'] = makeInvalidEarlyAccess('_emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBUCKET');
var _emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eINCREMENTAL = Module['_emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eINCREMENTAL'] = makeInvalidEarlyAccess('_emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eINCREMENTAL');
var _emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBVH = Module['_emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBVH'] = makeInvalidEarlyAccess('_emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBVH');
var _emscripten_enum_PxErrorCodeEnum_eNO_ERROR = Module['_emscripten_enum_PxErrorCodeEnum_eNO_ERROR'] = makeInvalidEarlyAccess('_emscripten_enum_PxErrorCodeEnum_eNO_ERROR');
var _emscripten_enum_PxErrorCodeEnum_eDEBUG_INFO = Module['_emscripten_enum_PxErrorCodeEnum_eDEBUG_INFO'] = makeInvalidEarlyAccess('_emscripten_enum_PxErrorCodeEnum_eDEBUG_INFO');
var _emscripten_enum_PxErrorCodeEnum_eDEBUG_WARNING = Module['_emscripten_enum_PxErrorCodeEnum_eDEBUG_WARNING'] = makeInvalidEarlyAccess('_emscripten_enum_PxErrorCodeEnum_eDEBUG_WARNING');
var _emscripten_enum_PxErrorCodeEnum_eINVALID_PARAMETER = Module['_emscripten_enum_PxErrorCodeEnum_eINVALID_PARAMETER'] = makeInvalidEarlyAccess('_emscripten_enum_PxErrorCodeEnum_eINVALID_PARAMETER');
var _emscripten_enum_PxErrorCodeEnum_eINVALID_OPERATION = Module['_emscripten_enum_PxErrorCodeEnum_eINVALID_OPERATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxErrorCodeEnum_eINVALID_OPERATION');
var _emscripten_enum_PxErrorCodeEnum_eOUT_OF_MEMORY = Module['_emscripten_enum_PxErrorCodeEnum_eOUT_OF_MEMORY'] = makeInvalidEarlyAccess('_emscripten_enum_PxErrorCodeEnum_eOUT_OF_MEMORY');
var _emscripten_enum_PxErrorCodeEnum_eINTERNAL_ERROR = Module['_emscripten_enum_PxErrorCodeEnum_eINTERNAL_ERROR'] = makeInvalidEarlyAccess('_emscripten_enum_PxErrorCodeEnum_eINTERNAL_ERROR');
var _emscripten_enum_PxErrorCodeEnum_eABORT = Module['_emscripten_enum_PxErrorCodeEnum_eABORT'] = makeInvalidEarlyAccess('_emscripten_enum_PxErrorCodeEnum_eABORT');
var _emscripten_enum_PxErrorCodeEnum_ePERF_WARNING = Module['_emscripten_enum_PxErrorCodeEnum_ePERF_WARNING'] = makeInvalidEarlyAccess('_emscripten_enum_PxErrorCodeEnum_ePERF_WARNING');
var _emscripten_enum_PxErrorCodeEnum_eMASK_ALL = Module['_emscripten_enum_PxErrorCodeEnum_eMASK_ALL'] = makeInvalidEarlyAccess('_emscripten_enum_PxErrorCodeEnum_eMASK_ALL');
var _emscripten_enum_PxFilterFlagEnum_eKILL = Module['_emscripten_enum_PxFilterFlagEnum_eKILL'] = makeInvalidEarlyAccess('_emscripten_enum_PxFilterFlagEnum_eKILL');
var _emscripten_enum_PxFilterFlagEnum_eSUPPRESS = Module['_emscripten_enum_PxFilterFlagEnum_eSUPPRESS'] = makeInvalidEarlyAccess('_emscripten_enum_PxFilterFlagEnum_eSUPPRESS');
var _emscripten_enum_PxFilterFlagEnum_eCALLBACK = Module['_emscripten_enum_PxFilterFlagEnum_eCALLBACK'] = makeInvalidEarlyAccess('_emscripten_enum_PxFilterFlagEnum_eCALLBACK');
var _emscripten_enum_PxFilterFlagEnum_eNOTIFY = Module['_emscripten_enum_PxFilterFlagEnum_eNOTIFY'] = makeInvalidEarlyAccess('_emscripten_enum_PxFilterFlagEnum_eNOTIFY');
var _emscripten_enum_PxFilterFlagEnum_eDEFAULT = Module['_emscripten_enum_PxFilterFlagEnum_eDEFAULT'] = makeInvalidEarlyAccess('_emscripten_enum_PxFilterFlagEnum_eDEFAULT');
var _emscripten_enum_PxFilterObjectFlagEnum_eKINEMATIC = Module['_emscripten_enum_PxFilterObjectFlagEnum_eKINEMATIC'] = makeInvalidEarlyAccess('_emscripten_enum_PxFilterObjectFlagEnum_eKINEMATIC');
var _emscripten_enum_PxFilterObjectFlagEnum_eTRIGGER = Module['_emscripten_enum_PxFilterObjectFlagEnum_eTRIGGER'] = makeInvalidEarlyAccess('_emscripten_enum_PxFilterObjectFlagEnum_eTRIGGER');
var _emscripten_enum_PxForceModeEnum_eFORCE = Module['_emscripten_enum_PxForceModeEnum_eFORCE'] = makeInvalidEarlyAccess('_emscripten_enum_PxForceModeEnum_eFORCE');
var _emscripten_enum_PxForceModeEnum_eIMPULSE = Module['_emscripten_enum_PxForceModeEnum_eIMPULSE'] = makeInvalidEarlyAccess('_emscripten_enum_PxForceModeEnum_eIMPULSE');
var _emscripten_enum_PxForceModeEnum_eVELOCITY_CHANGE = Module['_emscripten_enum_PxForceModeEnum_eVELOCITY_CHANGE'] = makeInvalidEarlyAccess('_emscripten_enum_PxForceModeEnum_eVELOCITY_CHANGE');
var _emscripten_enum_PxForceModeEnum_eACCELERATION = Module['_emscripten_enum_PxForceModeEnum_eACCELERATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxForceModeEnum_eACCELERATION');
var _emscripten_enum_PxFrictionTypeEnum_ePATCH = Module['_emscripten_enum_PxFrictionTypeEnum_ePATCH'] = makeInvalidEarlyAccess('_emscripten_enum_PxFrictionTypeEnum_ePATCH');
var _emscripten_enum_PxFrictionTypeEnum_eFRICTION_COUNT = Module['_emscripten_enum_PxFrictionTypeEnum_eFRICTION_COUNT'] = makeInvalidEarlyAccess('_emscripten_enum_PxFrictionTypeEnum_eFRICTION_COUNT');
var _emscripten_enum_PxGeometryTypeEnum_eSPHERE = Module['_emscripten_enum_PxGeometryTypeEnum_eSPHERE'] = makeInvalidEarlyAccess('_emscripten_enum_PxGeometryTypeEnum_eSPHERE');
var _emscripten_enum_PxGeometryTypeEnum_ePLANE = Module['_emscripten_enum_PxGeometryTypeEnum_ePLANE'] = makeInvalidEarlyAccess('_emscripten_enum_PxGeometryTypeEnum_ePLANE');
var _emscripten_enum_PxGeometryTypeEnum_eCAPSULE = Module['_emscripten_enum_PxGeometryTypeEnum_eCAPSULE'] = makeInvalidEarlyAccess('_emscripten_enum_PxGeometryTypeEnum_eCAPSULE');
var _emscripten_enum_PxGeometryTypeEnum_eBOX = Module['_emscripten_enum_PxGeometryTypeEnum_eBOX'] = makeInvalidEarlyAccess('_emscripten_enum_PxGeometryTypeEnum_eBOX');
var _emscripten_enum_PxGeometryTypeEnum_eCONVEXCORE = Module['_emscripten_enum_PxGeometryTypeEnum_eCONVEXCORE'] = makeInvalidEarlyAccess('_emscripten_enum_PxGeometryTypeEnum_eCONVEXCORE');
var _emscripten_enum_PxGeometryTypeEnum_eCONVEXMESH = Module['_emscripten_enum_PxGeometryTypeEnum_eCONVEXMESH'] = makeInvalidEarlyAccess('_emscripten_enum_PxGeometryTypeEnum_eCONVEXMESH');
var _emscripten_enum_PxGeometryTypeEnum_ePARTICLESYSTEM = Module['_emscripten_enum_PxGeometryTypeEnum_ePARTICLESYSTEM'] = makeInvalidEarlyAccess('_emscripten_enum_PxGeometryTypeEnum_ePARTICLESYSTEM');
var _emscripten_enum_PxGeometryTypeEnum_eTETRAHEDRONMESH = Module['_emscripten_enum_PxGeometryTypeEnum_eTETRAHEDRONMESH'] = makeInvalidEarlyAccess('_emscripten_enum_PxGeometryTypeEnum_eTETRAHEDRONMESH');
var _emscripten_enum_PxGeometryTypeEnum_eTRIANGLEMESH = Module['_emscripten_enum_PxGeometryTypeEnum_eTRIANGLEMESH'] = makeInvalidEarlyAccess('_emscripten_enum_PxGeometryTypeEnum_eTRIANGLEMESH');
var _emscripten_enum_PxGeometryTypeEnum_eHEIGHTFIELD = Module['_emscripten_enum_PxGeometryTypeEnum_eHEIGHTFIELD'] = makeInvalidEarlyAccess('_emscripten_enum_PxGeometryTypeEnum_eHEIGHTFIELD');
var _emscripten_enum_PxGeometryTypeEnum_eCUSTOM = Module['_emscripten_enum_PxGeometryTypeEnum_eCUSTOM'] = makeInvalidEarlyAccess('_emscripten_enum_PxGeometryTypeEnum_eCUSTOM');
var _emscripten_enum_PxHeightFieldFlagEnum_eNO_BOUNDARY_EDGES = Module['_emscripten_enum_PxHeightFieldFlagEnum_eNO_BOUNDARY_EDGES'] = makeInvalidEarlyAccess('_emscripten_enum_PxHeightFieldFlagEnum_eNO_BOUNDARY_EDGES');
var _emscripten_enum_PxHeightFieldFormatEnum_eS16_TM = Module['_emscripten_enum_PxHeightFieldFormatEnum_eS16_TM'] = makeInvalidEarlyAccess('_emscripten_enum_PxHeightFieldFormatEnum_eS16_TM');
var _emscripten_enum_PxHitFlagEnum_ePOSITION = Module['_emscripten_enum_PxHitFlagEnum_ePOSITION'] = makeInvalidEarlyAccess('_emscripten_enum_PxHitFlagEnum_ePOSITION');
var _emscripten_enum_PxHitFlagEnum_eNORMAL = Module['_emscripten_enum_PxHitFlagEnum_eNORMAL'] = makeInvalidEarlyAccess('_emscripten_enum_PxHitFlagEnum_eNORMAL');
var _emscripten_enum_PxHitFlagEnum_eUV = Module['_emscripten_enum_PxHitFlagEnum_eUV'] = makeInvalidEarlyAccess('_emscripten_enum_PxHitFlagEnum_eUV');
var _emscripten_enum_PxHitFlagEnum_eASSUME_NO_INITIAL_OVERLAP = Module['_emscripten_enum_PxHitFlagEnum_eASSUME_NO_INITIAL_OVERLAP'] = makeInvalidEarlyAccess('_emscripten_enum_PxHitFlagEnum_eASSUME_NO_INITIAL_OVERLAP');
var _emscripten_enum_PxHitFlagEnum_eANY_HIT = Module['_emscripten_enum_PxHitFlagEnum_eANY_HIT'] = makeInvalidEarlyAccess('_emscripten_enum_PxHitFlagEnum_eANY_HIT');
var _emscripten_enum_PxHitFlagEnum_eMESH_MULTIPLE = Module['_emscripten_enum_PxHitFlagEnum_eMESH_MULTIPLE'] = makeInvalidEarlyAccess('_emscripten_enum_PxHitFlagEnum_eMESH_MULTIPLE');
var _emscripten_enum_PxHitFlagEnum_eMESH_BOTH_SIDES = Module['_emscripten_enum_PxHitFlagEnum_eMESH_BOTH_SIDES'] = makeInvalidEarlyAccess('_emscripten_enum_PxHitFlagEnum_eMESH_BOTH_SIDES');
var _emscripten_enum_PxHitFlagEnum_ePRECISE_SWEEP = Module['_emscripten_enum_PxHitFlagEnum_ePRECISE_SWEEP'] = makeInvalidEarlyAccess('_emscripten_enum_PxHitFlagEnum_ePRECISE_SWEEP');
var _emscripten_enum_PxHitFlagEnum_eMTD = Module['_emscripten_enum_PxHitFlagEnum_eMTD'] = makeInvalidEarlyAccess('_emscripten_enum_PxHitFlagEnum_eMTD');
var _emscripten_enum_PxHitFlagEnum_eFACE_INDEX = Module['_emscripten_enum_PxHitFlagEnum_eFACE_INDEX'] = makeInvalidEarlyAccess('_emscripten_enum_PxHitFlagEnum_eFACE_INDEX');
var _emscripten_enum_PxHitFlagEnum_eDEFAULT = Module['_emscripten_enum_PxHitFlagEnum_eDEFAULT'] = makeInvalidEarlyAccess('_emscripten_enum_PxHitFlagEnum_eDEFAULT');
var _emscripten_enum_PxHitFlagEnum_eMODIFIABLE_FLAGS = Module['_emscripten_enum_PxHitFlagEnum_eMODIFIABLE_FLAGS'] = makeInvalidEarlyAccess('_emscripten_enum_PxHitFlagEnum_eMODIFIABLE_FLAGS');
var _emscripten_enum_PxIDENTITYEnum_PxIdentity = Module['_emscripten_enum_PxIDENTITYEnum_PxIdentity'] = makeInvalidEarlyAccess('_emscripten_enum_PxIDENTITYEnum_PxIdentity');
var _emscripten_enum_PxJointActorIndexEnum_eACTOR0 = Module['_emscripten_enum_PxJointActorIndexEnum_eACTOR0'] = makeInvalidEarlyAccess('_emscripten_enum_PxJointActorIndexEnum_eACTOR0');
var _emscripten_enum_PxJointActorIndexEnum_eACTOR1 = Module['_emscripten_enum_PxJointActorIndexEnum_eACTOR1'] = makeInvalidEarlyAccess('_emscripten_enum_PxJointActorIndexEnum_eACTOR1');
var _emscripten_enum_PxMaterialFlagEnum_eDISABLE_FRICTION = Module['_emscripten_enum_PxMaterialFlagEnum_eDISABLE_FRICTION'] = makeInvalidEarlyAccess('_emscripten_enum_PxMaterialFlagEnum_eDISABLE_FRICTION');
var _emscripten_enum_PxMaterialFlagEnum_eDISABLE_STRONG_FRICTION = Module['_emscripten_enum_PxMaterialFlagEnum_eDISABLE_STRONG_FRICTION'] = makeInvalidEarlyAccess('_emscripten_enum_PxMaterialFlagEnum_eDISABLE_STRONG_FRICTION');
var _emscripten_enum_PxMaterialFlagEnum_eCOMPLIANT_ACCELERATION_SPRING = Module['_emscripten_enum_PxMaterialFlagEnum_eCOMPLIANT_ACCELERATION_SPRING'] = makeInvalidEarlyAccess('_emscripten_enum_PxMaterialFlagEnum_eCOMPLIANT_ACCELERATION_SPRING');
var _emscripten_enum_PxMeshCookingHintEnum_eSIM_PERFORMANCE = Module['_emscripten_enum_PxMeshCookingHintEnum_eSIM_PERFORMANCE'] = makeInvalidEarlyAccess('_emscripten_enum_PxMeshCookingHintEnum_eSIM_PERFORMANCE');
var _emscripten_enum_PxMeshCookingHintEnum_eCOOKING_PERFORMANCE = Module['_emscripten_enum_PxMeshCookingHintEnum_eCOOKING_PERFORMANCE'] = makeInvalidEarlyAccess('_emscripten_enum_PxMeshCookingHintEnum_eCOOKING_PERFORMANCE');
var _emscripten_enum_PxMeshFlagEnum_eFLIPNORMALS = Module['_emscripten_enum_PxMeshFlagEnum_eFLIPNORMALS'] = makeInvalidEarlyAccess('_emscripten_enum_PxMeshFlagEnum_eFLIPNORMALS');
var _emscripten_enum_PxMeshFlagEnum_e16_BIT_INDICES = Module['_emscripten_enum_PxMeshFlagEnum_e16_BIT_INDICES'] = makeInvalidEarlyAccess('_emscripten_enum_PxMeshFlagEnum_e16_BIT_INDICES');
var _emscripten_enum_PxMeshGeometryFlagEnum_eDOUBLE_SIDED = Module['_emscripten_enum_PxMeshGeometryFlagEnum_eDOUBLE_SIDED'] = makeInvalidEarlyAccess('_emscripten_enum_PxMeshGeometryFlagEnum_eDOUBLE_SIDED');
var _emscripten_enum_PxMeshMidPhaseEnum_eBVH33 = Module['_emscripten_enum_PxMeshMidPhaseEnum_eBVH33'] = makeInvalidEarlyAccess('_emscripten_enum_PxMeshMidPhaseEnum_eBVH33');
var _emscripten_enum_PxMeshMidPhaseEnum_eBVH34 = Module['_emscripten_enum_PxMeshMidPhaseEnum_eBVH34'] = makeInvalidEarlyAccess('_emscripten_enum_PxMeshMidPhaseEnum_eBVH34');
var _emscripten_enum_PxMeshPreprocessingFlagEnum_eWELD_VERTICES = Module['_emscripten_enum_PxMeshPreprocessingFlagEnum_eWELD_VERTICES'] = makeInvalidEarlyAccess('_emscripten_enum_PxMeshPreprocessingFlagEnum_eWELD_VERTICES');
var _emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_CLEAN_MESH = Module['_emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_CLEAN_MESH'] = makeInvalidEarlyAccess('_emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_CLEAN_MESH');
var _emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_ACTIVE_EDGES_PRECOMPUTE = Module['_emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_ACTIVE_EDGES_PRECOMPUTE'] = makeInvalidEarlyAccess('_emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_ACTIVE_EDGES_PRECOMPUTE');
var _emscripten_enum_PxMeshPreprocessingFlagEnum_eFORCE_32BIT_INDICES = Module['_emscripten_enum_PxMeshPreprocessingFlagEnum_eFORCE_32BIT_INDICES'] = makeInvalidEarlyAccess('_emscripten_enum_PxMeshPreprocessingFlagEnum_eFORCE_32BIT_INDICES');
var _emscripten_enum_PxMeshPreprocessingFlagEnum_eENABLE_INERTIA = Module['_emscripten_enum_PxMeshPreprocessingFlagEnum_eENABLE_INERTIA'] = makeInvalidEarlyAccess('_emscripten_enum_PxMeshPreprocessingFlagEnum_eENABLE_INERTIA');
var _emscripten_enum_PxPairFilteringModeEnum_eKEEP = Module['_emscripten_enum_PxPairFilteringModeEnum_eKEEP'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFilteringModeEnum_eKEEP');
var _emscripten_enum_PxPairFilteringModeEnum_eSUPPRESS = Module['_emscripten_enum_PxPairFilteringModeEnum_eSUPPRESS'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFilteringModeEnum_eSUPPRESS');
var _emscripten_enum_PxPairFilteringModeEnum_eKILL = Module['_emscripten_enum_PxPairFilteringModeEnum_eKILL'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFilteringModeEnum_eKILL');
var _emscripten_enum_PxPairFilteringModeEnum_eDEFAULT = Module['_emscripten_enum_PxPairFilteringModeEnum_eDEFAULT'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFilteringModeEnum_eDEFAULT');
var _emscripten_enum_PxPairFlagEnum_eSOLVE_CONTACT = Module['_emscripten_enum_PxPairFlagEnum_eSOLVE_CONTACT'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eSOLVE_CONTACT');
var _emscripten_enum_PxPairFlagEnum_eMODIFY_CONTACTS = Module['_emscripten_enum_PxPairFlagEnum_eMODIFY_CONTACTS'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eMODIFY_CONTACTS');
var _emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_FOUND = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_FOUND'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_FOUND');
var _emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_PERSISTS = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_PERSISTS'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_PERSISTS');
var _emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_LOST = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_LOST'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_LOST');
var _emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_CCD = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_CCD'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_CCD');
var _emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_FOUND = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_FOUND'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_FOUND');
var _emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_PERSISTS = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_PERSISTS'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_PERSISTS');
var _emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_LOST = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_LOST'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_LOST');
var _emscripten_enum_PxPairFlagEnum_eNOTIFY_CONTACT_POINTS = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_CONTACT_POINTS'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eNOTIFY_CONTACT_POINTS');
var _emscripten_enum_PxPairFlagEnum_eDETECT_DISCRETE_CONTACT = Module['_emscripten_enum_PxPairFlagEnum_eDETECT_DISCRETE_CONTACT'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eDETECT_DISCRETE_CONTACT');
var _emscripten_enum_PxPairFlagEnum_eDETECT_CCD_CONTACT = Module['_emscripten_enum_PxPairFlagEnum_eDETECT_CCD_CONTACT'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eDETECT_CCD_CONTACT');
var _emscripten_enum_PxPairFlagEnum_ePRE_SOLVER_VELOCITY = Module['_emscripten_enum_PxPairFlagEnum_ePRE_SOLVER_VELOCITY'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_ePRE_SOLVER_VELOCITY');
var _emscripten_enum_PxPairFlagEnum_ePOST_SOLVER_VELOCITY = Module['_emscripten_enum_PxPairFlagEnum_ePOST_SOLVER_VELOCITY'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_ePOST_SOLVER_VELOCITY');
var _emscripten_enum_PxPairFlagEnum_eCONTACT_EVENT_POSE = Module['_emscripten_enum_PxPairFlagEnum_eCONTACT_EVENT_POSE'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eCONTACT_EVENT_POSE');
var _emscripten_enum_PxPairFlagEnum_eNEXT_FREE = Module['_emscripten_enum_PxPairFlagEnum_eNEXT_FREE'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eNEXT_FREE');
var _emscripten_enum_PxPairFlagEnum_eCONTACT_DEFAULT = Module['_emscripten_enum_PxPairFlagEnum_eCONTACT_DEFAULT'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eCONTACT_DEFAULT');
var _emscripten_enum_PxPairFlagEnum_eTRIGGER_DEFAULT = Module['_emscripten_enum_PxPairFlagEnum_eTRIGGER_DEFAULT'] = makeInvalidEarlyAccess('_emscripten_enum_PxPairFlagEnum_eTRIGGER_DEFAULT');
var _emscripten_enum_PxPrismaticJointFlagEnum_eLIMIT_ENABLED = Module['_emscripten_enum_PxPrismaticJointFlagEnum_eLIMIT_ENABLED'] = makeInvalidEarlyAccess('_emscripten_enum_PxPrismaticJointFlagEnum_eLIMIT_ENABLED');
var _emscripten_enum_PxPruningStructureTypeEnum_eNONE = Module['_emscripten_enum_PxPruningStructureTypeEnum_eNONE'] = makeInvalidEarlyAccess('_emscripten_enum_PxPruningStructureTypeEnum_eNONE');
var _emscripten_enum_PxPruningStructureTypeEnum_eDYNAMIC_AABB_TREE = Module['_emscripten_enum_PxPruningStructureTypeEnum_eDYNAMIC_AABB_TREE'] = makeInvalidEarlyAccess('_emscripten_enum_PxPruningStructureTypeEnum_eDYNAMIC_AABB_TREE');
var _emscripten_enum_PxPruningStructureTypeEnum_eSTATIC_AABB_TREE = Module['_emscripten_enum_PxPruningStructureTypeEnum_eSTATIC_AABB_TREE'] = makeInvalidEarlyAccess('_emscripten_enum_PxPruningStructureTypeEnum_eSTATIC_AABB_TREE');
var _emscripten_enum_PxPvdInstrumentationFlagEnum_eDEBUG = Module['_emscripten_enum_PxPvdInstrumentationFlagEnum_eDEBUG'] = makeInvalidEarlyAccess('_emscripten_enum_PxPvdInstrumentationFlagEnum_eDEBUG');
var _emscripten_enum_PxPvdInstrumentationFlagEnum_ePROFILE = Module['_emscripten_enum_PxPvdInstrumentationFlagEnum_ePROFILE'] = makeInvalidEarlyAccess('_emscripten_enum_PxPvdInstrumentationFlagEnum_ePROFILE');
var _emscripten_enum_PxPvdInstrumentationFlagEnum_eMEMORY = Module['_emscripten_enum_PxPvdInstrumentationFlagEnum_eMEMORY'] = makeInvalidEarlyAccess('_emscripten_enum_PxPvdInstrumentationFlagEnum_eMEMORY');
var _emscripten_enum_PxPvdInstrumentationFlagEnum_eALL = Module['_emscripten_enum_PxPvdInstrumentationFlagEnum_eALL'] = makeInvalidEarlyAccess('_emscripten_enum_PxPvdInstrumentationFlagEnum_eALL');
var _emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONTACTS = Module['_emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONTACTS'] = makeInvalidEarlyAccess('_emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONTACTS');
var _emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_SCENEQUERIES = Module['_emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_SCENEQUERIES'] = makeInvalidEarlyAccess('_emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_SCENEQUERIES');
var _emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONSTRAINTS = Module['_emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONSTRAINTS'] = makeInvalidEarlyAccess('_emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONSTRAINTS');
var _emscripten_enum_PxQueryFlagEnum_eSTATIC = Module['_emscripten_enum_PxQueryFlagEnum_eSTATIC'] = makeInvalidEarlyAccess('_emscripten_enum_PxQueryFlagEnum_eSTATIC');
var _emscripten_enum_PxQueryFlagEnum_eDYNAMIC = Module['_emscripten_enum_PxQueryFlagEnum_eDYNAMIC'] = makeInvalidEarlyAccess('_emscripten_enum_PxQueryFlagEnum_eDYNAMIC');
var _emscripten_enum_PxQueryFlagEnum_ePREFILTER = Module['_emscripten_enum_PxQueryFlagEnum_ePREFILTER'] = makeInvalidEarlyAccess('_emscripten_enum_PxQueryFlagEnum_ePREFILTER');
var _emscripten_enum_PxQueryFlagEnum_ePOSTFILTER = Module['_emscripten_enum_PxQueryFlagEnum_ePOSTFILTER'] = makeInvalidEarlyAccess('_emscripten_enum_PxQueryFlagEnum_ePOSTFILTER');
var _emscripten_enum_PxQueryFlagEnum_eANY_HIT = Module['_emscripten_enum_PxQueryFlagEnum_eANY_HIT'] = makeInvalidEarlyAccess('_emscripten_enum_PxQueryFlagEnum_eANY_HIT');
var _emscripten_enum_PxQueryFlagEnum_eNO_BLOCK = Module['_emscripten_enum_PxQueryFlagEnum_eNO_BLOCK'] = makeInvalidEarlyAccess('_emscripten_enum_PxQueryFlagEnum_eNO_BLOCK');
var _emscripten_enum_PxQueryHitType_eNONE = Module['_emscripten_enum_PxQueryHitType_eNONE'] = makeInvalidEarlyAccess('_emscripten_enum_PxQueryHitType_eNONE');
var _emscripten_enum_PxQueryHitType_eBLOCK = Module['_emscripten_enum_PxQueryHitType_eBLOCK'] = makeInvalidEarlyAccess('_emscripten_enum_PxQueryHitType_eBLOCK');
var _emscripten_enum_PxQueryHitType_eTOUCH = Module['_emscripten_enum_PxQueryHitType_eTOUCH'] = makeInvalidEarlyAccess('_emscripten_enum_PxQueryHitType_eTOUCH');
var _emscripten_enum_PxRevoluteJointFlagEnum_eLIMIT_ENABLED = Module['_emscripten_enum_PxRevoluteJointFlagEnum_eLIMIT_ENABLED'] = makeInvalidEarlyAccess('_emscripten_enum_PxRevoluteJointFlagEnum_eLIMIT_ENABLED');
var _emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_ENABLED = Module['_emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_ENABLED'] = makeInvalidEarlyAccess('_emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_ENABLED');
var _emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_FREESPIN = Module['_emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_FREESPIN'] = makeInvalidEarlyAccess('_emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_FREESPIN');
var _emscripten_enum_PxRigidBodyFlagEnum_eKINEMATIC = Module['_emscripten_enum_PxRigidBodyFlagEnum_eKINEMATIC'] = makeInvalidEarlyAccess('_emscripten_enum_PxRigidBodyFlagEnum_eKINEMATIC');
var _emscripten_enum_PxRigidBodyFlagEnum_eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES = Module['_emscripten_enum_PxRigidBodyFlagEnum_eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES'] = makeInvalidEarlyAccess('_emscripten_enum_PxRigidBodyFlagEnum_eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES');
var _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD = Module['_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD'] = makeInvalidEarlyAccess('_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD');
var _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_FRICTION = Module['_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_FRICTION'] = makeInvalidEarlyAccess('_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_FRICTION');
var _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_POSE_INTEGRATION_PREVIEW = Module['_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_POSE_INTEGRATION_PREVIEW'] = makeInvalidEarlyAccess('_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_POSE_INTEGRATION_PREVIEW');
var _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_SPECULATIVE_CCD = Module['_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_SPECULATIVE_CCD'] = makeInvalidEarlyAccess('_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_SPECULATIVE_CCD');
var _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_MAX_CONTACT_IMPULSE = Module['_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_MAX_CONTACT_IMPULSE'] = makeInvalidEarlyAccess('_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_MAX_CONTACT_IMPULSE');
var _emscripten_enum_PxRigidBodyFlagEnum_eRETAIN_ACCELERATIONS = Module['_emscripten_enum_PxRigidBodyFlagEnum_eRETAIN_ACCELERATIONS'] = makeInvalidEarlyAccess('_emscripten_enum_PxRigidBodyFlagEnum_eRETAIN_ACCELERATIONS');
var _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_X = Module['_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_X'] = makeInvalidEarlyAccess('_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_X');
var _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Y = Module['_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Y'] = makeInvalidEarlyAccess('_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Y');
var _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Z = Module['_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Z'] = makeInvalidEarlyAccess('_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Z');
var _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_X = Module['_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_X'] = makeInvalidEarlyAccess('_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_X');
var _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Y = Module['_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Y'] = makeInvalidEarlyAccess('_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Y');
var _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Z = Module['_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Z'] = makeInvalidEarlyAccess('_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Z');
var _emscripten_enum_PxSceneFlagEnum_eENABLE_ACTIVE_ACTORS = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_ACTIVE_ACTORS'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eENABLE_ACTIVE_ACTORS');
var _emscripten_enum_PxSceneFlagEnum_eENABLE_CCD = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_CCD'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eENABLE_CCD');
var _emscripten_enum_PxSceneFlagEnum_eDISABLE_CCD_RESWEEP = Module['_emscripten_enum_PxSceneFlagEnum_eDISABLE_CCD_RESWEEP'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eDISABLE_CCD_RESWEEP');
var _emscripten_enum_PxSceneFlagEnum_eENABLE_PCM = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_PCM'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eENABLE_PCM');
var _emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_REPORT_BUFFER_RESIZE = Module['_emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_REPORT_BUFFER_RESIZE'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_REPORT_BUFFER_RESIZE');
var _emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_CACHE = Module['_emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_CACHE'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_CACHE');
var _emscripten_enum_PxSceneFlagEnum_eREQUIRE_RW_LOCK = Module['_emscripten_enum_PxSceneFlagEnum_eREQUIRE_RW_LOCK'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eREQUIRE_RW_LOCK');
var _emscripten_enum_PxSceneFlagEnum_eENABLE_STABILIZATION = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_STABILIZATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eENABLE_STABILIZATION');
var _emscripten_enum_PxSceneFlagEnum_eENABLE_AVERAGE_POINT = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_AVERAGE_POINT'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eENABLE_AVERAGE_POINT');
var _emscripten_enum_PxSceneFlagEnum_eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS = Module['_emscripten_enum_PxSceneFlagEnum_eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS');
var _emscripten_enum_PxSceneFlagEnum_eENABLE_GPU_DYNAMICS = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_GPU_DYNAMICS'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eENABLE_GPU_DYNAMICS');
var _emscripten_enum_PxSceneFlagEnum_eENABLE_ENHANCED_DETERMINISM = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_ENHANCED_DETERMINISM'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eENABLE_ENHANCED_DETERMINISM');
var _emscripten_enum_PxSceneFlagEnum_eENABLE_FRICTION_EVERY_ITERATION = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_FRICTION_EVERY_ITERATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eENABLE_FRICTION_EVERY_ITERATION');
var _emscripten_enum_PxSceneFlagEnum_eENABLE_DIRECT_GPU_API = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_DIRECT_GPU_API'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eENABLE_DIRECT_GPU_API');
var _emscripten_enum_PxSceneFlagEnum_eMUTABLE_FLAGS = Module['_emscripten_enum_PxSceneFlagEnum_eMUTABLE_FLAGS'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneFlagEnum_eMUTABLE_FLAGS');
var _emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_ENABLED = Module['_emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_ENABLED'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_ENABLED');
var _emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_DISABLED = Module['_emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_DISABLED'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_DISABLED');
var _emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_DISABLED_COMMIT_DISABLED = Module['_emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_DISABLED_COMMIT_DISABLED'] = makeInvalidEarlyAccess('_emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_DISABLED_COMMIT_DISABLED');
var _emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e8_BIT_PER_PIXEL = Module['_emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e8_BIT_PER_PIXEL'] = makeInvalidEarlyAccess('_emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e8_BIT_PER_PIXEL');
var _emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e16_BIT_PER_PIXEL = Module['_emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e16_BIT_PER_PIXEL'] = makeInvalidEarlyAccess('_emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e16_BIT_PER_PIXEL');
var _emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e32_BIT_PER_PIXEL = Module['_emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e32_BIT_PER_PIXEL'] = makeInvalidEarlyAccess('_emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e32_BIT_PER_PIXEL');
var _emscripten_enum_PxShapeFlagEnum_eSIMULATION_SHAPE = Module['_emscripten_enum_PxShapeFlagEnum_eSIMULATION_SHAPE'] = makeInvalidEarlyAccess('_emscripten_enum_PxShapeFlagEnum_eSIMULATION_SHAPE');
var _emscripten_enum_PxShapeFlagEnum_eSCENE_QUERY_SHAPE = Module['_emscripten_enum_PxShapeFlagEnum_eSCENE_QUERY_SHAPE'] = makeInvalidEarlyAccess('_emscripten_enum_PxShapeFlagEnum_eSCENE_QUERY_SHAPE');
var _emscripten_enum_PxShapeFlagEnum_eTRIGGER_SHAPE = Module['_emscripten_enum_PxShapeFlagEnum_eTRIGGER_SHAPE'] = makeInvalidEarlyAccess('_emscripten_enum_PxShapeFlagEnum_eTRIGGER_SHAPE');
var _emscripten_enum_PxShapeFlagEnum_eVISUALIZATION = Module['_emscripten_enum_PxShapeFlagEnum_eVISUALIZATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxShapeFlagEnum_eVISUALIZATION');
var _emscripten_enum_PxSolverTypeEnum_ePGS = Module['_emscripten_enum_PxSolverTypeEnum_ePGS'] = makeInvalidEarlyAccess('_emscripten_enum_PxSolverTypeEnum_ePGS');
var _emscripten_enum_PxSolverTypeEnum_eTGS = Module['_emscripten_enum_PxSolverTypeEnum_eTGS'] = makeInvalidEarlyAccess('_emscripten_enum_PxSolverTypeEnum_eTGS');
var _emscripten_enum_PxSphericalJointFlagEnum_eLIMIT_ENABLED = Module['_emscripten_enum_PxSphericalJointFlagEnum_eLIMIT_ENABLED'] = makeInvalidEarlyAccess('_emscripten_enum_PxSphericalJointFlagEnum_eLIMIT_ENABLED');
var _emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eVALID = Module['_emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eVALID'] = makeInvalidEarlyAccess('_emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eVALID');
var _emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eDEGENERATE_TETRAHEDRON = Module['_emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eDEGENERATE_TETRAHEDRON'] = makeInvalidEarlyAccess('_emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eDEGENERATE_TETRAHEDRON');
var _emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC = Module['_emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC'] = makeInvalidEarlyAccess('_emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC');
var _emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_INVALID = Module['_emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_INVALID'] = makeInvalidEarlyAccess('_emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_INVALID');
var _emscripten_enum_PxTetrahedronMeshFlagEnum_e16_BIT_INDICES = Module['_emscripten_enum_PxTetrahedronMeshFlagEnum_e16_BIT_INDICES'] = makeInvalidEarlyAccess('_emscripten_enum_PxTetrahedronMeshFlagEnum_e16_BIT_INDICES');
var _emscripten_enum_PxTetrahedronMeshFormatEnum_eTET_MESH = Module['_emscripten_enum_PxTetrahedronMeshFormatEnum_eTET_MESH'] = makeInvalidEarlyAccess('_emscripten_enum_PxTetrahedronMeshFormatEnum_eTET_MESH');
var _emscripten_enum_PxTetrahedronMeshFormatEnum_eHEX_MESH = Module['_emscripten_enum_PxTetrahedronMeshFormatEnum_eHEX_MESH'] = makeInvalidEarlyAccess('_emscripten_enum_PxTetrahedronMeshFormatEnum_eHEX_MESH');
var _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eVALID = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eVALID'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eVALID');
var _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eZERO_VOLUME = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eZERO_VOLUME'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eZERO_VOLUME');
var _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eOPEN_BOUNDARIES = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eOPEN_BOUNDARIES'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eOPEN_BOUNDARIES');
var _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eSELF_INTERSECTIONS = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eSELF_INTERSECTIONS'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eSELF_INTERSECTIONS');
var _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eINCONSISTENT_TRIANGLE_ORIENTATION = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eINCONSISTENT_TRIANGLE_ORIENTATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eINCONSISTENT_TRIANGLE_ORIENTATION');
var _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_ACUTE_ANGLED_TRIANGLES = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_ACUTE_ANGLED_TRIANGLES'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_ACUTE_ANGLED_TRIANGLES');
var _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eEDGE_SHARED_BY_MORE_THAN_TWO_TRIANGLES = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eEDGE_SHARED_BY_MORE_THAN_TWO_TRIANGLES'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eEDGE_SHARED_BY_MORE_THAN_TWO_TRIANGLES');
var _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_DUPLICATE_POINTS = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_DUPLICATE_POINTS'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_DUPLICATE_POINTS');
var _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_INVALID_POINTS = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_INVALID_POINTS'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_INVALID_POINTS');
var _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eREQUIRES_32BIT_INDEX_BUFFER = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eREQUIRES_32BIT_INDEX_BUFFER'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eREQUIRES_32BIT_INDEX_BUFFER');
var _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eTRIANGLE_INDEX_OUT_OF_RANGE = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eTRIANGLE_INDEX_OUT_OF_RANGE'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eTRIANGLE_INDEX_OUT_OF_RANGE');
var _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC');
var _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_INVALID = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_INVALID'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_INVALID');
var _emscripten_enum_PxTriangleMeshFlagEnum_e16_BIT_INDICES = Module['_emscripten_enum_PxTriangleMeshFlagEnum_e16_BIT_INDICES'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshFlagEnum_e16_BIT_INDICES');
var _emscripten_enum_PxTriangleMeshFlagEnum_eADJACENCY_INFO = Module['_emscripten_enum_PxTriangleMeshFlagEnum_eADJACENCY_INFO'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriangleMeshFlagEnum_eADJACENCY_INFO');
var _emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_TRIGGER = Module['_emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_TRIGGER'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_TRIGGER');
var _emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_OTHER = Module['_emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_OTHER'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_OTHER');
var _emscripten_enum_PxTriggerPairFlagEnum_eNEXT_FREE = Module['_emscripten_enum_PxTriggerPairFlagEnum_eNEXT_FREE'] = makeInvalidEarlyAccess('_emscripten_enum_PxTriggerPairFlagEnum_eNEXT_FREE');
var _emscripten_enum_PxVehicleAxesEnum_ePosX = Module['_emscripten_enum_PxVehicleAxesEnum_ePosX'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleAxesEnum_ePosX');
var _emscripten_enum_PxVehicleAxesEnum_eNegX = Module['_emscripten_enum_PxVehicleAxesEnum_eNegX'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleAxesEnum_eNegX');
var _emscripten_enum_PxVehicleAxesEnum_ePosY = Module['_emscripten_enum_PxVehicleAxesEnum_ePosY'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleAxesEnum_ePosY');
var _emscripten_enum_PxVehicleAxesEnum_eNegY = Module['_emscripten_enum_PxVehicleAxesEnum_eNegY'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleAxesEnum_eNegY');
var _emscripten_enum_PxVehicleAxesEnum_ePosZ = Module['_emscripten_enum_PxVehicleAxesEnum_ePosZ'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleAxesEnum_ePosZ');
var _emscripten_enum_PxVehicleAxesEnum_eNegZ = Module['_emscripten_enum_PxVehicleAxesEnum_eNegZ'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleAxesEnum_eNegZ');
var _emscripten_enum_PxVehicleClutchAccuracyModeEnum_eESTIMATE = Module['_emscripten_enum_PxVehicleClutchAccuracyModeEnum_eESTIMATE'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleClutchAccuracyModeEnum_eESTIMATE');
var _emscripten_enum_PxVehicleClutchAccuracyModeEnum_eBEST_POSSIBLE = Module['_emscripten_enum_PxVehicleClutchAccuracyModeEnum_eBEST_POSSIBLE'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleClutchAccuracyModeEnum_eBEST_POSSIBLE');
var _emscripten_enum_PxVehicleCommandNonLinearResponseParamsEnum_eMAX_NB_COMMAND_VALUES = Module['_emscripten_enum_PxVehicleCommandNonLinearResponseParamsEnum_eMAX_NB_COMMAND_VALUES'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleCommandNonLinearResponseParamsEnum_eMAX_NB_COMMAND_VALUES');
var _emscripten_enum_PxVehicleCommandValueResponseTableEnum_eMAX_NB_SPEED_RESPONSES = Module['_emscripten_enum_PxVehicleCommandValueResponseTableEnum_eMAX_NB_SPEED_RESPONSES'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleCommandValueResponseTableEnum_eMAX_NB_SPEED_RESPONSES');
var _emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eREVERSE = Module['_emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eREVERSE'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eREVERSE');
var _emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eNEUTRAL = Module['_emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eNEUTRAL'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eNEUTRAL');
var _emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eFORWARD = Module['_emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eFORWARD'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eFORWARD');
var _emscripten_enum_PxVehicleEngineDriveTransmissionCommandStateEnum_eAUTOMATIC_GEAR = Module['_emscripten_enum_PxVehicleEngineDriveTransmissionCommandStateEnum_eAUTOMATIC_GEAR'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleEngineDriveTransmissionCommandStateEnum_eAUTOMATIC_GEAR');
var _emscripten_enum_PxVehicleGearboxParamsEnum_eMAX_NB_GEARS = Module['_emscripten_enum_PxVehicleGearboxParamsEnum_eMAX_NB_GEARS'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleGearboxParamsEnum_eMAX_NB_GEARS');
var _emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_WHEELS = Module['_emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_WHEELS'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_WHEELS');
var _emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_AXLES = Module['_emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_AXLES'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_AXLES');
var _emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_VELOCITY = Module['_emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_VELOCITY'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_VELOCITY');
var _emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_ACCELERATION = Module['_emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_ACCELERATION'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_ACCELERATION');
var _emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_PXCONSTRAINT = Module['_emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_PXCONSTRAINT'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_PXCONSTRAINT');
var _emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_WHEEL = Module['_emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_WHEEL'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_WHEEL');
var _emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_WHEELS_PER_PXCONSTRAINT = Module['_emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_WHEELS_PER_PXCONSTRAINT'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_WHEELS_PER_PXCONSTRAINT');
var _emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_CONSTRAINTS_PER_VEHICLE = Module['_emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_CONSTRAINTS_PER_VEHICLE'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_CONSTRAINTS_PER_VEHICLE');
var _emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eNONE = Module['_emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eNONE'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eNONE');
var _emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eRAYCAST = Module['_emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eRAYCAST'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eRAYCAST');
var _emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eSWEEP = Module['_emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eSWEEP'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eSWEEP');
var _emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eSUSPENSION = Module['_emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eSUSPENSION'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eSUSPENSION');
var _emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eROAD_GEOMETRY_NORMAL = Module['_emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eROAD_GEOMETRY_NORMAL'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eROAD_GEOMETRY_NORMAL');
var _emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eNONE = Module['_emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eNONE'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eNONE');
var _emscripten_enum_PxVehicleSimulationContextTypeEnum_eDEFAULT = Module['_emscripten_enum_PxVehicleSimulationContextTypeEnum_eDEFAULT'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleSimulationContextTypeEnum_eDEFAULT');
var _emscripten_enum_PxVehicleSimulationContextTypeEnum_ePHYSX = Module['_emscripten_enum_PxVehicleSimulationContextTypeEnum_ePHYSX'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleSimulationContextTypeEnum_ePHYSX');
var _emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eRAYCAST = Module['_emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eRAYCAST'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eRAYCAST');
var _emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eSWEEP = Module['_emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eSWEEP'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eSWEEP');
var _emscripten_enum_PxVehicleTireDirectionModesEnum_eLONGITUDINAL = Module['_emscripten_enum_PxVehicleTireDirectionModesEnum_eLONGITUDINAL'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleTireDirectionModesEnum_eLONGITUDINAL');
var _emscripten_enum_PxVehicleTireDirectionModesEnum_eLATERAL = Module['_emscripten_enum_PxVehicleTireDirectionModesEnum_eLATERAL'] = makeInvalidEarlyAccess('_emscripten_enum_PxVehicleTireDirectionModesEnum_eLATERAL');
var _emscripten_enum_PxVisualizationParameterEnum_eSCALE = Module['_emscripten_enum_PxVisualizationParameterEnum_eSCALE'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eSCALE');
var _emscripten_enum_PxVisualizationParameterEnum_eWORLD_AXES = Module['_emscripten_enum_PxVisualizationParameterEnum_eWORLD_AXES'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eWORLD_AXES');
var _emscripten_enum_PxVisualizationParameterEnum_eBODY_AXES = Module['_emscripten_enum_PxVisualizationParameterEnum_eBODY_AXES'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eBODY_AXES');
var _emscripten_enum_PxVisualizationParameterEnum_eBODY_MASS_AXES = Module['_emscripten_enum_PxVisualizationParameterEnum_eBODY_MASS_AXES'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eBODY_MASS_AXES');
var _emscripten_enum_PxVisualizationParameterEnum_eBODY_LIN_VELOCITY = Module['_emscripten_enum_PxVisualizationParameterEnum_eBODY_LIN_VELOCITY'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eBODY_LIN_VELOCITY');
var _emscripten_enum_PxVisualizationParameterEnum_eBODY_ANG_VELOCITY = Module['_emscripten_enum_PxVisualizationParameterEnum_eBODY_ANG_VELOCITY'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eBODY_ANG_VELOCITY');
var _emscripten_enum_PxVisualizationParameterEnum_eCONTACT_POINT = Module['_emscripten_enum_PxVisualizationParameterEnum_eCONTACT_POINT'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eCONTACT_POINT');
var _emscripten_enum_PxVisualizationParameterEnum_eCONTACT_NORMAL = Module['_emscripten_enum_PxVisualizationParameterEnum_eCONTACT_NORMAL'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eCONTACT_NORMAL');
var _emscripten_enum_PxVisualizationParameterEnum_eCONTACT_ERROR = Module['_emscripten_enum_PxVisualizationParameterEnum_eCONTACT_ERROR'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eCONTACT_ERROR');
var _emscripten_enum_PxVisualizationParameterEnum_eCONTACT_FORCE = Module['_emscripten_enum_PxVisualizationParameterEnum_eCONTACT_FORCE'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eCONTACT_FORCE');
var _emscripten_enum_PxVisualizationParameterEnum_eACTOR_AXES = Module['_emscripten_enum_PxVisualizationParameterEnum_eACTOR_AXES'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eACTOR_AXES');
var _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AABBS = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AABBS'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AABBS');
var _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_SHAPES = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_SHAPES'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_SHAPES');
var _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AXES = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AXES'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AXES');
var _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_COMPOUNDS = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_COMPOUNDS'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_COMPOUNDS');
var _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_FNORMALS = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_FNORMALS'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_FNORMALS');
var _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_EDGES = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_EDGES'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_EDGES');
var _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_STATIC = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_STATIC'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_STATIC');
var _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_DYNAMIC = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_DYNAMIC'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_DYNAMIC');
var _emscripten_enum_PxVisualizationParameterEnum_eJOINT_LOCAL_FRAMES = Module['_emscripten_enum_PxVisualizationParameterEnum_eJOINT_LOCAL_FRAMES'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eJOINT_LOCAL_FRAMES');
var _emscripten_enum_PxVisualizationParameterEnum_eJOINT_LIMITS = Module['_emscripten_enum_PxVisualizationParameterEnum_eJOINT_LIMITS'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eJOINT_LIMITS');
var _emscripten_enum_PxVisualizationParameterEnum_eCULL_BOX = Module['_emscripten_enum_PxVisualizationParameterEnum_eCULL_BOX'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eCULL_BOX');
var _emscripten_enum_PxVisualizationParameterEnum_eMBP_REGIONS = Module['_emscripten_enum_PxVisualizationParameterEnum_eMBP_REGIONS'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eMBP_REGIONS');
var _emscripten_enum_PxVisualizationParameterEnum_eSIMULATION_MESH = Module['_emscripten_enum_PxVisualizationParameterEnum_eSIMULATION_MESH'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eSIMULATION_MESH');
var _emscripten_enum_PxVisualizationParameterEnum_eSDF = Module['_emscripten_enum_PxVisualizationParameterEnum_eSDF'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eSDF');
var _emscripten_enum_PxVisualizationParameterEnum_eNUM_VALUES = Module['_emscripten_enum_PxVisualizationParameterEnum_eNUM_VALUES'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eNUM_VALUES');
var _emscripten_enum_PxVisualizationParameterEnum_eFORCE_DWORD = Module['_emscripten_enum_PxVisualizationParameterEnum_eFORCE_DWORD'] = makeInvalidEarlyAccess('_emscripten_enum_PxVisualizationParameterEnum_eFORCE_DWORD');
var _fflush = makeInvalidEarlyAccess('_fflush');
var _emscripten_stack_get_end = makeInvalidEarlyAccess('_emscripten_stack_get_end');
var _emscripten_stack_get_base = makeInvalidEarlyAccess('_emscripten_stack_get_base');
var _emscripten_stack_init = makeInvalidEarlyAccess('_emscripten_stack_init');
var _emscripten_stack_get_free = makeInvalidEarlyAccess('_emscripten_stack_get_free');
var __emscripten_stack_restore = makeInvalidEarlyAccess('__emscripten_stack_restore');
var __emscripten_stack_alloc = makeInvalidEarlyAccess('__emscripten_stack_alloc');
var _emscripten_stack_get_current = makeInvalidEarlyAccess('_emscripten_stack_get_current');
var memory = makeInvalidEarlyAccess('memory');
var __indirect_function_table = makeInvalidEarlyAccess('__indirect_function_table');
var wasmMemory = makeInvalidEarlyAccess('wasmMemory');

function assignWasmExports(wasmExports) {
  assert(typeof wasmExports['webidl_free'] != 'undefined', 'missing Wasm export: webidl_free');
  _webidl_free = Module['_webidl_free'] = createExportWrapper('webidl_free', 1);
  assert(typeof wasmExports['webidl_malloc'] != 'undefined', 'missing Wasm export: webidl_malloc');
  _webidl_malloc = Module['_webidl_malloc'] = createExportWrapper('webidl_malloc', 1);
  assert(typeof wasmExports['malloc'] != 'undefined', 'missing Wasm export: malloc');
  _malloc = Module['_malloc'] = createExportWrapper('malloc', 1);
  assert(typeof wasmExports['emscripten_bind_PxBase_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBase_release_0');
  _emscripten_bind_PxBase_release_0 = Module['_emscripten_bind_PxBase_release_0'] = createExportWrapper('emscripten_bind_PxBase_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBase_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBase_getConcreteTypeName_0');
  _emscripten_bind_PxBase_getConcreteTypeName_0 = Module['_emscripten_bind_PxBase_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxBase_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBase_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBase_getConcreteType_0');
  _emscripten_bind_PxBase_getConcreteType_0 = Module['_emscripten_bind_PxBase_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxBase_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBase_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBase_setBaseFlag_2');
  _emscripten_bind_PxBase_setBaseFlag_2 = Module['_emscripten_bind_PxBase_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxBase_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxBase_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBase_setBaseFlags_1');
  _emscripten_bind_PxBase_setBaseFlags_1 = Module['_emscripten_bind_PxBase_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxBase_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBase_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBase_getBaseFlags_0');
  _emscripten_bind_PxBase_getBaseFlags_0 = Module['_emscripten_bind_PxBase_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxBase_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBase_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBase_isReleasable_0');
  _emscripten_bind_PxBase_isReleasable_0 = Module['_emscripten_bind_PxBase_isReleasable_0'] = createExportWrapper('emscripten_bind_PxBase_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActor_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_getType_0');
  _emscripten_bind_PxActor_getType_0 = Module['_emscripten_bind_PxActor_getType_0'] = createExportWrapper('emscripten_bind_PxActor_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActor_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_getScene_0');
  _emscripten_bind_PxActor_getScene_0 = Module['_emscripten_bind_PxActor_getScene_0'] = createExportWrapper('emscripten_bind_PxActor_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActor_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_setName_1');
  _emscripten_bind_PxActor_setName_1 = Module['_emscripten_bind_PxActor_setName_1'] = createExportWrapper('emscripten_bind_PxActor_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxActor_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_getName_0');
  _emscripten_bind_PxActor_getName_0 = Module['_emscripten_bind_PxActor_getName_0'] = createExportWrapper('emscripten_bind_PxActor_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActor_getWorldBounds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_getWorldBounds_0');
  _emscripten_bind_PxActor_getWorldBounds_0 = Module['_emscripten_bind_PxActor_getWorldBounds_0'] = createExportWrapper('emscripten_bind_PxActor_getWorldBounds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActor_getWorldBounds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_getWorldBounds_1');
  _emscripten_bind_PxActor_getWorldBounds_1 = Module['_emscripten_bind_PxActor_getWorldBounds_1'] = createExportWrapper('emscripten_bind_PxActor_getWorldBounds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxActor_setActorFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_setActorFlag_2');
  _emscripten_bind_PxActor_setActorFlag_2 = Module['_emscripten_bind_PxActor_setActorFlag_2'] = createExportWrapper('emscripten_bind_PxActor_setActorFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxActor_setActorFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_setActorFlags_1');
  _emscripten_bind_PxActor_setActorFlags_1 = Module['_emscripten_bind_PxActor_setActorFlags_1'] = createExportWrapper('emscripten_bind_PxActor_setActorFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxActor_getActorFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_getActorFlags_0');
  _emscripten_bind_PxActor_getActorFlags_0 = Module['_emscripten_bind_PxActor_getActorFlags_0'] = createExportWrapper('emscripten_bind_PxActor_getActorFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActor_setDominanceGroup_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_setDominanceGroup_1');
  _emscripten_bind_PxActor_setDominanceGroup_1 = Module['_emscripten_bind_PxActor_setDominanceGroup_1'] = createExportWrapper('emscripten_bind_PxActor_setDominanceGroup_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxActor_getDominanceGroup_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_getDominanceGroup_0');
  _emscripten_bind_PxActor_getDominanceGroup_0 = Module['_emscripten_bind_PxActor_getDominanceGroup_0'] = createExportWrapper('emscripten_bind_PxActor_getDominanceGroup_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActor_setOwnerClient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_setOwnerClient_1');
  _emscripten_bind_PxActor_setOwnerClient_1 = Module['_emscripten_bind_PxActor_setOwnerClient_1'] = createExportWrapper('emscripten_bind_PxActor_setOwnerClient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxActor_getOwnerClient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_getOwnerClient_0');
  _emscripten_bind_PxActor_getOwnerClient_0 = Module['_emscripten_bind_PxActor_getOwnerClient_0'] = createExportWrapper('emscripten_bind_PxActor_getOwnerClient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActor_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_release_0');
  _emscripten_bind_PxActor_release_0 = Module['_emscripten_bind_PxActor_release_0'] = createExportWrapper('emscripten_bind_PxActor_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActor_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_getConcreteTypeName_0');
  _emscripten_bind_PxActor_getConcreteTypeName_0 = Module['_emscripten_bind_PxActor_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxActor_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActor_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_getConcreteType_0');
  _emscripten_bind_PxActor_getConcreteType_0 = Module['_emscripten_bind_PxActor_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxActor_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActor_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_setBaseFlag_2');
  _emscripten_bind_PxActor_setBaseFlag_2 = Module['_emscripten_bind_PxActor_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxActor_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxActor_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_setBaseFlags_1');
  _emscripten_bind_PxActor_setBaseFlags_1 = Module['_emscripten_bind_PxActor_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxActor_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxActor_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_getBaseFlags_0');
  _emscripten_bind_PxActor_getBaseFlags_0 = Module['_emscripten_bind_PxActor_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxActor_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActor_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_isReleasable_0');
  _emscripten_bind_PxActor_isReleasable_0 = Module['_emscripten_bind_PxActor_isReleasable_0'] = createExportWrapper('emscripten_bind_PxActor_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActor_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_get_userData_0');
  _emscripten_bind_PxActor_get_userData_0 = Module['_emscripten_bind_PxActor_get_userData_0'] = createExportWrapper('emscripten_bind_PxActor_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActor_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActor_set_userData_1');
  _emscripten_bind_PxActor_set_userData_1 = Module['_emscripten_bind_PxActor_set_userData_1'] = createExportWrapper('emscripten_bind_PxActor_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQueryHit_get_faceIndex_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryHit_get_faceIndex_0');
  _emscripten_bind_PxQueryHit_get_faceIndex_0 = Module['_emscripten_bind_PxQueryHit_get_faceIndex_0'] = createExportWrapper('emscripten_bind_PxQueryHit_get_faceIndex_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQueryHit_set_faceIndex_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryHit_set_faceIndex_1');
  _emscripten_bind_PxQueryHit_set_faceIndex_1 = Module['_emscripten_bind_PxQueryHit_set_faceIndex_1'] = createExportWrapper('emscripten_bind_PxQueryHit_set_faceIndex_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQueryHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryHit___destroy___0');
  _emscripten_bind_PxQueryHit___destroy___0 = Module['_emscripten_bind_PxQueryHit___destroy___0'] = createExportWrapper('emscripten_bind_PxQueryHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicle_initialize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicle_initialize_0');
  _emscripten_bind_BaseVehicle_initialize_0 = Module['_emscripten_bind_BaseVehicle_initialize_0'] = createExportWrapper('emscripten_bind_BaseVehicle_initialize_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicle_destroyState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicle_destroyState_0');
  _emscripten_bind_BaseVehicle_destroyState_0 = Module['_emscripten_bind_BaseVehicle_destroyState_0'] = createExportWrapper('emscripten_bind_BaseVehicle_destroyState_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicle_initComponentSequence_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicle_initComponentSequence_1');
  _emscripten_bind_BaseVehicle_initComponentSequence_1 = Module['_emscripten_bind_BaseVehicle_initComponentSequence_1'] = createExportWrapper('emscripten_bind_BaseVehicle_initComponentSequence_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicle_step_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicle_step_2');
  _emscripten_bind_BaseVehicle_step_2 = Module['_emscripten_bind_BaseVehicle_step_2'] = createExportWrapper('emscripten_bind_BaseVehicle_step_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicle_get_baseParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicle_get_baseParams_0');
  _emscripten_bind_BaseVehicle_get_baseParams_0 = Module['_emscripten_bind_BaseVehicle_get_baseParams_0'] = createExportWrapper('emscripten_bind_BaseVehicle_get_baseParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicle_set_baseParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicle_set_baseParams_1');
  _emscripten_bind_BaseVehicle_set_baseParams_1 = Module['_emscripten_bind_BaseVehicle_set_baseParams_1'] = createExportWrapper('emscripten_bind_BaseVehicle_set_baseParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicle_get_baseState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicle_get_baseState_0');
  _emscripten_bind_BaseVehicle_get_baseState_0 = Module['_emscripten_bind_BaseVehicle_get_baseState_0'] = createExportWrapper('emscripten_bind_BaseVehicle_get_baseState_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicle_set_baseState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicle_set_baseState_1');
  _emscripten_bind_BaseVehicle_set_baseState_1 = Module['_emscripten_bind_BaseVehicle_set_baseState_1'] = createExportWrapper('emscripten_bind_BaseVehicle_set_baseState_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicle_get_componentSequence_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicle_get_componentSequence_0');
  _emscripten_bind_BaseVehicle_get_componentSequence_0 = Module['_emscripten_bind_BaseVehicle_get_componentSequence_0'] = createExportWrapper('emscripten_bind_BaseVehicle_get_componentSequence_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicle_set_componentSequence_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicle_set_componentSequence_1');
  _emscripten_bind_BaseVehicle_set_componentSequence_1 = Module['_emscripten_bind_BaseVehicle_set_componentSequence_1'] = createExportWrapper('emscripten_bind_BaseVehicle_set_componentSequence_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicle_get_componentSequenceSubstepGroupHandle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicle_get_componentSequenceSubstepGroupHandle_0');
  _emscripten_bind_BaseVehicle_get_componentSequenceSubstepGroupHandle_0 = Module['_emscripten_bind_BaseVehicle_get_componentSequenceSubstepGroupHandle_0'] = createExportWrapper('emscripten_bind_BaseVehicle_get_componentSequenceSubstepGroupHandle_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicle_set_componentSequenceSubstepGroupHandle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicle_set_componentSequenceSubstepGroupHandle_1');
  _emscripten_bind_BaseVehicle_set_componentSequenceSubstepGroupHandle_1 = Module['_emscripten_bind_BaseVehicle_set_componentSequenceSubstepGroupHandle_1'] = createExportWrapper('emscripten_bind_BaseVehicle_set_componentSequenceSubstepGroupHandle_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicle___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicle___destroy___0');
  _emscripten_bind_BaseVehicle___destroy___0 = Module['_emscripten_bind_BaseVehicle___destroy___0'] = createExportWrapper('emscripten_bind_BaseVehicle___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxLocationHit_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxLocationHit_get_flags_0');
  _emscripten_bind_PxLocationHit_get_flags_0 = Module['_emscripten_bind_PxLocationHit_get_flags_0'] = createExportWrapper('emscripten_bind_PxLocationHit_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxLocationHit_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxLocationHit_set_flags_1');
  _emscripten_bind_PxLocationHit_set_flags_1 = Module['_emscripten_bind_PxLocationHit_set_flags_1'] = createExportWrapper('emscripten_bind_PxLocationHit_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxLocationHit_get_position_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxLocationHit_get_position_0');
  _emscripten_bind_PxLocationHit_get_position_0 = Module['_emscripten_bind_PxLocationHit_get_position_0'] = createExportWrapper('emscripten_bind_PxLocationHit_get_position_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxLocationHit_set_position_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxLocationHit_set_position_1');
  _emscripten_bind_PxLocationHit_set_position_1 = Module['_emscripten_bind_PxLocationHit_set_position_1'] = createExportWrapper('emscripten_bind_PxLocationHit_set_position_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxLocationHit_get_normal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxLocationHit_get_normal_0');
  _emscripten_bind_PxLocationHit_get_normal_0 = Module['_emscripten_bind_PxLocationHit_get_normal_0'] = createExportWrapper('emscripten_bind_PxLocationHit_get_normal_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxLocationHit_set_normal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxLocationHit_set_normal_1');
  _emscripten_bind_PxLocationHit_set_normal_1 = Module['_emscripten_bind_PxLocationHit_set_normal_1'] = createExportWrapper('emscripten_bind_PxLocationHit_set_normal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxLocationHit_get_distance_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxLocationHit_get_distance_0');
  _emscripten_bind_PxLocationHit_get_distance_0 = Module['_emscripten_bind_PxLocationHit_get_distance_0'] = createExportWrapper('emscripten_bind_PxLocationHit_get_distance_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxLocationHit_set_distance_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxLocationHit_set_distance_1');
  _emscripten_bind_PxLocationHit_set_distance_1 = Module['_emscripten_bind_PxLocationHit_set_distance_1'] = createExportWrapper('emscripten_bind_PxLocationHit_set_distance_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxLocationHit_get_faceIndex_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxLocationHit_get_faceIndex_0');
  _emscripten_bind_PxLocationHit_get_faceIndex_0 = Module['_emscripten_bind_PxLocationHit_get_faceIndex_0'] = createExportWrapper('emscripten_bind_PxLocationHit_get_faceIndex_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxLocationHit_set_faceIndex_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxLocationHit_set_faceIndex_1');
  _emscripten_bind_PxLocationHit_set_faceIndex_1 = Module['_emscripten_bind_PxLocationHit_set_faceIndex_1'] = createExportWrapper('emscripten_bind_PxLocationHit_set_faceIndex_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxLocationHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxLocationHit___destroy___0');
  _emscripten_bind_PxLocationHit___destroy___0 = Module['_emscripten_bind_PxLocationHit___destroy___0'] = createExportWrapper('emscripten_bind_PxLocationHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPvdTransport_connect_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdTransport_connect_0');
  _emscripten_bind_PxPvdTransport_connect_0 = Module['_emscripten_bind_PxPvdTransport_connect_0'] = createExportWrapper('emscripten_bind_PxPvdTransport_connect_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPvdTransport_isConnected_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdTransport_isConnected_0');
  _emscripten_bind_PxPvdTransport_isConnected_0 = Module['_emscripten_bind_PxPvdTransport_isConnected_0'] = createExportWrapper('emscripten_bind_PxPvdTransport_isConnected_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPvdTransport_disconnect_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdTransport_disconnect_0');
  _emscripten_bind_PxPvdTransport_disconnect_0 = Module['_emscripten_bind_PxPvdTransport_disconnect_0'] = createExportWrapper('emscripten_bind_PxPvdTransport_disconnect_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPvdTransport_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdTransport_release_0');
  _emscripten_bind_PxPvdTransport_release_0 = Module['_emscripten_bind_PxPvdTransport_release_0'] = createExportWrapper('emscripten_bind_PxPvdTransport_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPvdTransport_flush_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdTransport_flush_0');
  _emscripten_bind_PxPvdTransport_flush_0 = Module['_emscripten_bind_PxPvdTransport_flush_0'] = createExportWrapper('emscripten_bind_PxPvdTransport_flush_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQueryFilterCallback___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFilterCallback___destroy___0');
  _emscripten_bind_PxQueryFilterCallback___destroy___0 = Module['_emscripten_bind_PxQueryFilterCallback___destroy___0'] = createExportWrapper('emscripten_bind_PxQueryFilterCallback___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRefCounted_getReferenceCount_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRefCounted_getReferenceCount_0');
  _emscripten_bind_PxRefCounted_getReferenceCount_0 = Module['_emscripten_bind_PxRefCounted_getReferenceCount_0'] = createExportWrapper('emscripten_bind_PxRefCounted_getReferenceCount_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRefCounted_acquireReference_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRefCounted_acquireReference_0');
  _emscripten_bind_PxRefCounted_acquireReference_0 = Module['_emscripten_bind_PxRefCounted_acquireReference_0'] = createExportWrapper('emscripten_bind_PxRefCounted_acquireReference_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRefCounted_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRefCounted_release_0');
  _emscripten_bind_PxRefCounted_release_0 = Module['_emscripten_bind_PxRefCounted_release_0'] = createExportWrapper('emscripten_bind_PxRefCounted_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRefCounted_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRefCounted_getConcreteTypeName_0');
  _emscripten_bind_PxRefCounted_getConcreteTypeName_0 = Module['_emscripten_bind_PxRefCounted_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxRefCounted_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRefCounted_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRefCounted_getConcreteType_0');
  _emscripten_bind_PxRefCounted_getConcreteType_0 = Module['_emscripten_bind_PxRefCounted_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxRefCounted_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRefCounted_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRefCounted_setBaseFlag_2');
  _emscripten_bind_PxRefCounted_setBaseFlag_2 = Module['_emscripten_bind_PxRefCounted_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxRefCounted_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRefCounted_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRefCounted_setBaseFlags_1');
  _emscripten_bind_PxRefCounted_setBaseFlags_1 = Module['_emscripten_bind_PxRefCounted_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxRefCounted_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRefCounted_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRefCounted_getBaseFlags_0');
  _emscripten_bind_PxRefCounted_getBaseFlags_0 = Module['_emscripten_bind_PxRefCounted_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxRefCounted_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRefCounted_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRefCounted_isReleasable_0');
  _emscripten_bind_PxRefCounted_isReleasable_0 = Module['_emscripten_bind_PxRefCounted_isReleasable_0'] = createExportWrapper('emscripten_bind_PxRefCounted_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getGlobalPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getGlobalPose_0');
  _emscripten_bind_PxRigidActor_getGlobalPose_0 = Module['_emscripten_bind_PxRigidActor_getGlobalPose_0'] = createExportWrapper('emscripten_bind_PxRigidActor_getGlobalPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_setGlobalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_setGlobalPose_1');
  _emscripten_bind_PxRigidActor_setGlobalPose_1 = Module['_emscripten_bind_PxRigidActor_setGlobalPose_1'] = createExportWrapper('emscripten_bind_PxRigidActor_setGlobalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_setGlobalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_setGlobalPose_2');
  _emscripten_bind_PxRigidActor_setGlobalPose_2 = Module['_emscripten_bind_PxRigidActor_setGlobalPose_2'] = createExportWrapper('emscripten_bind_PxRigidActor_setGlobalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_attachShape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_attachShape_1');
  _emscripten_bind_PxRigidActor_attachShape_1 = Module['_emscripten_bind_PxRigidActor_attachShape_1'] = createExportWrapper('emscripten_bind_PxRigidActor_attachShape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_detachShape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_detachShape_1');
  _emscripten_bind_PxRigidActor_detachShape_1 = Module['_emscripten_bind_PxRigidActor_detachShape_1'] = createExportWrapper('emscripten_bind_PxRigidActor_detachShape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_detachShape_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_detachShape_2');
  _emscripten_bind_PxRigidActor_detachShape_2 = Module['_emscripten_bind_PxRigidActor_detachShape_2'] = createExportWrapper('emscripten_bind_PxRigidActor_detachShape_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getNbShapes_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getNbShapes_0');
  _emscripten_bind_PxRigidActor_getNbShapes_0 = Module['_emscripten_bind_PxRigidActor_getNbShapes_0'] = createExportWrapper('emscripten_bind_PxRigidActor_getNbShapes_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getShapes_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getShapes_3');
  _emscripten_bind_PxRigidActor_getShapes_3 = Module['_emscripten_bind_PxRigidActor_getShapes_3'] = createExportWrapper('emscripten_bind_PxRigidActor_getShapes_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getNbConstraints_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getNbConstraints_0');
  _emscripten_bind_PxRigidActor_getNbConstraints_0 = Module['_emscripten_bind_PxRigidActor_getNbConstraints_0'] = createExportWrapper('emscripten_bind_PxRigidActor_getNbConstraints_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getType_0');
  _emscripten_bind_PxRigidActor_getType_0 = Module['_emscripten_bind_PxRigidActor_getType_0'] = createExportWrapper('emscripten_bind_PxRigidActor_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getScene_0');
  _emscripten_bind_PxRigidActor_getScene_0 = Module['_emscripten_bind_PxRigidActor_getScene_0'] = createExportWrapper('emscripten_bind_PxRigidActor_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_setName_1');
  _emscripten_bind_PxRigidActor_setName_1 = Module['_emscripten_bind_PxRigidActor_setName_1'] = createExportWrapper('emscripten_bind_PxRigidActor_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getName_0');
  _emscripten_bind_PxRigidActor_getName_0 = Module['_emscripten_bind_PxRigidActor_getName_0'] = createExportWrapper('emscripten_bind_PxRigidActor_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getWorldBounds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getWorldBounds_0');
  _emscripten_bind_PxRigidActor_getWorldBounds_0 = Module['_emscripten_bind_PxRigidActor_getWorldBounds_0'] = createExportWrapper('emscripten_bind_PxRigidActor_getWorldBounds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getWorldBounds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getWorldBounds_1');
  _emscripten_bind_PxRigidActor_getWorldBounds_1 = Module['_emscripten_bind_PxRigidActor_getWorldBounds_1'] = createExportWrapper('emscripten_bind_PxRigidActor_getWorldBounds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_setActorFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_setActorFlag_2');
  _emscripten_bind_PxRigidActor_setActorFlag_2 = Module['_emscripten_bind_PxRigidActor_setActorFlag_2'] = createExportWrapper('emscripten_bind_PxRigidActor_setActorFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_setActorFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_setActorFlags_1');
  _emscripten_bind_PxRigidActor_setActorFlags_1 = Module['_emscripten_bind_PxRigidActor_setActorFlags_1'] = createExportWrapper('emscripten_bind_PxRigidActor_setActorFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getActorFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getActorFlags_0');
  _emscripten_bind_PxRigidActor_getActorFlags_0 = Module['_emscripten_bind_PxRigidActor_getActorFlags_0'] = createExportWrapper('emscripten_bind_PxRigidActor_getActorFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_setDominanceGroup_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_setDominanceGroup_1');
  _emscripten_bind_PxRigidActor_setDominanceGroup_1 = Module['_emscripten_bind_PxRigidActor_setDominanceGroup_1'] = createExportWrapper('emscripten_bind_PxRigidActor_setDominanceGroup_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getDominanceGroup_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getDominanceGroup_0');
  _emscripten_bind_PxRigidActor_getDominanceGroup_0 = Module['_emscripten_bind_PxRigidActor_getDominanceGroup_0'] = createExportWrapper('emscripten_bind_PxRigidActor_getDominanceGroup_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_setOwnerClient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_setOwnerClient_1');
  _emscripten_bind_PxRigidActor_setOwnerClient_1 = Module['_emscripten_bind_PxRigidActor_setOwnerClient_1'] = createExportWrapper('emscripten_bind_PxRigidActor_setOwnerClient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getOwnerClient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getOwnerClient_0');
  _emscripten_bind_PxRigidActor_getOwnerClient_0 = Module['_emscripten_bind_PxRigidActor_getOwnerClient_0'] = createExportWrapper('emscripten_bind_PxRigidActor_getOwnerClient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_release_0');
  _emscripten_bind_PxRigidActor_release_0 = Module['_emscripten_bind_PxRigidActor_release_0'] = createExportWrapper('emscripten_bind_PxRigidActor_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getConcreteTypeName_0');
  _emscripten_bind_PxRigidActor_getConcreteTypeName_0 = Module['_emscripten_bind_PxRigidActor_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxRigidActor_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getConcreteType_0');
  _emscripten_bind_PxRigidActor_getConcreteType_0 = Module['_emscripten_bind_PxRigidActor_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxRigidActor_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_setBaseFlag_2');
  _emscripten_bind_PxRigidActor_setBaseFlag_2 = Module['_emscripten_bind_PxRigidActor_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxRigidActor_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_setBaseFlags_1');
  _emscripten_bind_PxRigidActor_setBaseFlags_1 = Module['_emscripten_bind_PxRigidActor_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxRigidActor_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_getBaseFlags_0');
  _emscripten_bind_PxRigidActor_getBaseFlags_0 = Module['_emscripten_bind_PxRigidActor_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxRigidActor_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_isReleasable_0');
  _emscripten_bind_PxRigidActor_isReleasable_0 = Module['_emscripten_bind_PxRigidActor_isReleasable_0'] = createExportWrapper('emscripten_bind_PxRigidActor_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_get_userData_0');
  _emscripten_bind_PxRigidActor_get_userData_0 = Module['_emscripten_bind_PxRigidActor_get_userData_0'] = createExportWrapper('emscripten_bind_PxRigidActor_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActor_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActor_set_userData_1');
  _emscripten_bind_PxRigidActor_set_userData_1 = Module['_emscripten_bind_PxRigidActor_set_userData_1'] = createExportWrapper('emscripten_bind_PxRigidActor_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_setDynamicTreeRebuildRateHint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_setDynamicTreeRebuildRateHint_1');
  _emscripten_bind_PxSceneQuerySystemBase_setDynamicTreeRebuildRateHint_1 = Module['_emscripten_bind_PxSceneQuerySystemBase_setDynamicTreeRebuildRateHint_1'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_setDynamicTreeRebuildRateHint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_getDynamicTreeRebuildRateHint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_getDynamicTreeRebuildRateHint_0');
  _emscripten_bind_PxSceneQuerySystemBase_getDynamicTreeRebuildRateHint_0 = Module['_emscripten_bind_PxSceneQuerySystemBase_getDynamicTreeRebuildRateHint_0'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_getDynamicTreeRebuildRateHint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_forceRebuildDynamicTree_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_forceRebuildDynamicTree_1');
  _emscripten_bind_PxSceneQuerySystemBase_forceRebuildDynamicTree_1 = Module['_emscripten_bind_PxSceneQuerySystemBase_forceRebuildDynamicTree_1'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_forceRebuildDynamicTree_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_setUpdateMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_setUpdateMode_1');
  _emscripten_bind_PxSceneQuerySystemBase_setUpdateMode_1 = Module['_emscripten_bind_PxSceneQuerySystemBase_setUpdateMode_1'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_setUpdateMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_getUpdateMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_getUpdateMode_0');
  _emscripten_bind_PxSceneQuerySystemBase_getUpdateMode_0 = Module['_emscripten_bind_PxSceneQuerySystemBase_getUpdateMode_0'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_getUpdateMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_getStaticTimestamp_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_getStaticTimestamp_0');
  _emscripten_bind_PxSceneQuerySystemBase_getStaticTimestamp_0 = Module['_emscripten_bind_PxSceneQuerySystemBase_getStaticTimestamp_0'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_getStaticTimestamp_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_flushUpdates_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_flushUpdates_0');
  _emscripten_bind_PxSceneQuerySystemBase_flushUpdates_0 = Module['_emscripten_bind_PxSceneQuerySystemBase_flushUpdates_0'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_flushUpdates_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_raycast_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_raycast_4');
  _emscripten_bind_PxSceneQuerySystemBase_raycast_4 = Module['_emscripten_bind_PxSceneQuerySystemBase_raycast_4'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_raycast_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_raycast_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_raycast_5');
  _emscripten_bind_PxSceneQuerySystemBase_raycast_5 = Module['_emscripten_bind_PxSceneQuerySystemBase_raycast_5'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_raycast_5', 6);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_raycast_6'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_raycast_6');
  _emscripten_bind_PxSceneQuerySystemBase_raycast_6 = Module['_emscripten_bind_PxSceneQuerySystemBase_raycast_6'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_raycast_6', 7);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_sweep_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_sweep_5');
  _emscripten_bind_PxSceneQuerySystemBase_sweep_5 = Module['_emscripten_bind_PxSceneQuerySystemBase_sweep_5'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_sweep_5', 6);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_sweep_6'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_sweep_6');
  _emscripten_bind_PxSceneQuerySystemBase_sweep_6 = Module['_emscripten_bind_PxSceneQuerySystemBase_sweep_6'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_sweep_6', 7);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_sweep_7'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_sweep_7');
  _emscripten_bind_PxSceneQuerySystemBase_sweep_7 = Module['_emscripten_bind_PxSceneQuerySystemBase_sweep_7'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_sweep_7', 8);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_overlap_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_overlap_3');
  _emscripten_bind_PxSceneQuerySystemBase_overlap_3 = Module['_emscripten_bind_PxSceneQuerySystemBase_overlap_3'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_overlap_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxSceneQuerySystemBase_overlap_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneQuerySystemBase_overlap_4');
  _emscripten_bind_PxSceneQuerySystemBase_overlap_4 = Module['_emscripten_bind_PxSceneQuerySystemBase_overlap_4'] = createExportWrapper('emscripten_bind_PxSceneQuerySystemBase_overlap_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxSimulationEventCallback___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationEventCallback___destroy___0');
  _emscripten_bind_PxSimulationEventCallback___destroy___0 = Module['_emscripten_bind_PxSimulationEventCallback___destroy___0'] = createExportWrapper('emscripten_bind_PxSimulationEventCallback___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationFilterShader___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationFilterShader___destroy___0');
  _emscripten_bind_PxSimulationFilterShader___destroy___0 = Module['_emscripten_bind_PxSimulationFilterShader___destroy___0'] = createExportWrapper('emscripten_bind_PxSimulationFilterShader___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_Support_getMargin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Support_getMargin_0');
  _emscripten_bind_Support_getMargin_0 = Module['_emscripten_bind_Support_getMargin_0'] = createExportWrapper('emscripten_bind_Support_getMargin_0', 1);
  assert(typeof wasmExports['emscripten_bind_Support_supportLocal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Support_supportLocal_1');
  _emscripten_bind_Support_supportLocal_1 = Module['_emscripten_bind_Support_supportLocal_1'] = createExportWrapper('emscripten_bind_Support_supportLocal_1', 2);
  assert(typeof wasmExports['emscripten_bind_Support___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_Support___destroy___0');
  _emscripten_bind_Support___destroy___0 = Module['_emscripten_bind_Support___destroy___0'] = createExportWrapper('emscripten_bind_Support___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_CustomSupport_getCustomMargin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_CustomSupport_getCustomMargin_0');
  _emscripten_bind_CustomSupport_getCustomMargin_0 = Module['_emscripten_bind_CustomSupport_getCustomMargin_0'] = createExportWrapper('emscripten_bind_CustomSupport_getCustomMargin_0', 1);
  assert(typeof wasmExports['emscripten_bind_CustomSupport_getCustomSupportLocal_2'] != 'undefined', 'missing Wasm export: emscripten_bind_CustomSupport_getCustomSupportLocal_2');
  _emscripten_bind_CustomSupport_getCustomSupportLocal_2 = Module['_emscripten_bind_CustomSupport_getCustomSupportLocal_2'] = createExportWrapper('emscripten_bind_CustomSupport_getCustomSupportLocal_2', 3);
  assert(typeof wasmExports['emscripten_bind_CustomSupport_getMargin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_CustomSupport_getMargin_0');
  _emscripten_bind_CustomSupport_getMargin_0 = Module['_emscripten_bind_CustomSupport_getMargin_0'] = createExportWrapper('emscripten_bind_CustomSupport_getMargin_0', 1);
  assert(typeof wasmExports['emscripten_bind_CustomSupport_supportLocal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_CustomSupport_supportLocal_1');
  _emscripten_bind_CustomSupport_supportLocal_1 = Module['_emscripten_bind_CustomSupport_supportLocal_1'] = createExportWrapper('emscripten_bind_CustomSupport_supportLocal_1', 2);
  assert(typeof wasmExports['emscripten_bind_CustomSupport___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_CustomSupport___destroy___0');
  _emscripten_bind_CustomSupport___destroy___0 = Module['_emscripten_bind_CustomSupport___destroy___0'] = createExportWrapper('emscripten_bind_CustomSupport___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PassThroughFilterShader_filterShader_10'] != 'undefined', 'missing Wasm export: emscripten_bind_PassThroughFilterShader_filterShader_10');
  _emscripten_bind_PassThroughFilterShader_filterShader_10 = Module['_emscripten_bind_PassThroughFilterShader_filterShader_10'] = createExportWrapper('emscripten_bind_PassThroughFilterShader_filterShader_10', 11);
  assert(typeof wasmExports['emscripten_bind_PassThroughFilterShader_get_outputPairFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PassThroughFilterShader_get_outputPairFlags_0');
  _emscripten_bind_PassThroughFilterShader_get_outputPairFlags_0 = Module['_emscripten_bind_PassThroughFilterShader_get_outputPairFlags_0'] = createExportWrapper('emscripten_bind_PassThroughFilterShader_get_outputPairFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PassThroughFilterShader_set_outputPairFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PassThroughFilterShader_set_outputPairFlags_1');
  _emscripten_bind_PassThroughFilterShader_set_outputPairFlags_1 = Module['_emscripten_bind_PassThroughFilterShader_set_outputPairFlags_1'] = createExportWrapper('emscripten_bind_PassThroughFilterShader_set_outputPairFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PassThroughFilterShader___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PassThroughFilterShader___destroy___0');
  _emscripten_bind_PassThroughFilterShader___destroy___0 = Module['_emscripten_bind_PassThroughFilterShader___destroy___0'] = createExportWrapper('emscripten_bind_PassThroughFilterShader___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_initialize_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_initialize_3');
  _emscripten_bind_PhysXActorVehicle_initialize_3 = Module['_emscripten_bind_PhysXActorVehicle_initialize_3'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_initialize_3', 4);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_destroyState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_destroyState_0');
  _emscripten_bind_PhysXActorVehicle_destroyState_0 = Module['_emscripten_bind_PhysXActorVehicle_destroyState_0'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_destroyState_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_initComponentSequence_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_initComponentSequence_1');
  _emscripten_bind_PhysXActorVehicle_initComponentSequence_1 = Module['_emscripten_bind_PhysXActorVehicle_initComponentSequence_1'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_initComponentSequence_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_step_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_step_2');
  _emscripten_bind_PhysXActorVehicle_step_2 = Module['_emscripten_bind_PhysXActorVehicle_step_2'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_step_2', 3);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_get_physXParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_get_physXParams_0');
  _emscripten_bind_PhysXActorVehicle_get_physXParams_0 = Module['_emscripten_bind_PhysXActorVehicle_get_physXParams_0'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_get_physXParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_set_physXParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_set_physXParams_1');
  _emscripten_bind_PhysXActorVehicle_set_physXParams_1 = Module['_emscripten_bind_PhysXActorVehicle_set_physXParams_1'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_set_physXParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_get_physXState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_get_physXState_0');
  _emscripten_bind_PhysXActorVehicle_get_physXState_0 = Module['_emscripten_bind_PhysXActorVehicle_get_physXState_0'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_get_physXState_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_set_physXState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_set_physXState_1');
  _emscripten_bind_PhysXActorVehicle_set_physXState_1 = Module['_emscripten_bind_PhysXActorVehicle_set_physXState_1'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_set_physXState_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_get_commandState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_get_commandState_0');
  _emscripten_bind_PhysXActorVehicle_get_commandState_0 = Module['_emscripten_bind_PhysXActorVehicle_get_commandState_0'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_get_commandState_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_set_commandState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_set_commandState_1');
  _emscripten_bind_PhysXActorVehicle_set_commandState_1 = Module['_emscripten_bind_PhysXActorVehicle_set_commandState_1'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_set_commandState_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_get_baseParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_get_baseParams_0');
  _emscripten_bind_PhysXActorVehicle_get_baseParams_0 = Module['_emscripten_bind_PhysXActorVehicle_get_baseParams_0'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_get_baseParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_set_baseParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_set_baseParams_1');
  _emscripten_bind_PhysXActorVehicle_set_baseParams_1 = Module['_emscripten_bind_PhysXActorVehicle_set_baseParams_1'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_set_baseParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_get_baseState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_get_baseState_0');
  _emscripten_bind_PhysXActorVehicle_get_baseState_0 = Module['_emscripten_bind_PhysXActorVehicle_get_baseState_0'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_get_baseState_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_set_baseState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_set_baseState_1');
  _emscripten_bind_PhysXActorVehicle_set_baseState_1 = Module['_emscripten_bind_PhysXActorVehicle_set_baseState_1'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_set_baseState_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_get_componentSequence_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_get_componentSequence_0');
  _emscripten_bind_PhysXActorVehicle_get_componentSequence_0 = Module['_emscripten_bind_PhysXActorVehicle_get_componentSequence_0'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_get_componentSequence_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_set_componentSequence_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_set_componentSequence_1');
  _emscripten_bind_PhysXActorVehicle_set_componentSequence_1 = Module['_emscripten_bind_PhysXActorVehicle_set_componentSequence_1'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_set_componentSequence_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_get_componentSequenceSubstepGroupHandle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_get_componentSequenceSubstepGroupHandle_0');
  _emscripten_bind_PhysXActorVehicle_get_componentSequenceSubstepGroupHandle_0 = Module['_emscripten_bind_PhysXActorVehicle_get_componentSequenceSubstepGroupHandle_0'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_get_componentSequenceSubstepGroupHandle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle_set_componentSequenceSubstepGroupHandle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle_set_componentSequenceSubstepGroupHandle_1');
  _emscripten_bind_PhysXActorVehicle_set_componentSequenceSubstepGroupHandle_1 = Module['_emscripten_bind_PhysXActorVehicle_set_componentSequenceSubstepGroupHandle_1'] = createExportWrapper('emscripten_bind_PhysXActorVehicle_set_componentSequenceSubstepGroupHandle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXActorVehicle___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXActorVehicle___destroy___0');
  _emscripten_bind_PhysXActorVehicle___destroy___0 = Module['_emscripten_bind_PhysXActorVehicle___destroy___0'] = createExportWrapper('emscripten_bind_PhysXActorVehicle___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_setStiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_setStiffness_1');
  _emscripten_bind_PxArticulationTendon_setStiffness_1 = Module['_emscripten_bind_PxArticulationTendon_setStiffness_1'] = createExportWrapper('emscripten_bind_PxArticulationTendon_setStiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_getStiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_getStiffness_0');
  _emscripten_bind_PxArticulationTendon_getStiffness_0 = Module['_emscripten_bind_PxArticulationTendon_getStiffness_0'] = createExportWrapper('emscripten_bind_PxArticulationTendon_getStiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_setDamping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_setDamping_1');
  _emscripten_bind_PxArticulationTendon_setDamping_1 = Module['_emscripten_bind_PxArticulationTendon_setDamping_1'] = createExportWrapper('emscripten_bind_PxArticulationTendon_setDamping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_getDamping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_getDamping_0');
  _emscripten_bind_PxArticulationTendon_getDamping_0 = Module['_emscripten_bind_PxArticulationTendon_getDamping_0'] = createExportWrapper('emscripten_bind_PxArticulationTendon_getDamping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_setLimitStiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_setLimitStiffness_1');
  _emscripten_bind_PxArticulationTendon_setLimitStiffness_1 = Module['_emscripten_bind_PxArticulationTendon_setLimitStiffness_1'] = createExportWrapper('emscripten_bind_PxArticulationTendon_setLimitStiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_getLimitStiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_getLimitStiffness_0');
  _emscripten_bind_PxArticulationTendon_getLimitStiffness_0 = Module['_emscripten_bind_PxArticulationTendon_getLimitStiffness_0'] = createExportWrapper('emscripten_bind_PxArticulationTendon_getLimitStiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_setOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_setOffset_1');
  _emscripten_bind_PxArticulationTendon_setOffset_1 = Module['_emscripten_bind_PxArticulationTendon_setOffset_1'] = createExportWrapper('emscripten_bind_PxArticulationTendon_setOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_setOffset_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_setOffset_2');
  _emscripten_bind_PxArticulationTendon_setOffset_2 = Module['_emscripten_bind_PxArticulationTendon_setOffset_2'] = createExportWrapper('emscripten_bind_PxArticulationTendon_setOffset_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_getOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_getOffset_0');
  _emscripten_bind_PxArticulationTendon_getOffset_0 = Module['_emscripten_bind_PxArticulationTendon_getOffset_0'] = createExportWrapper('emscripten_bind_PxArticulationTendon_getOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_getArticulation_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_getArticulation_0');
  _emscripten_bind_PxArticulationTendon_getArticulation_0 = Module['_emscripten_bind_PxArticulationTendon_getArticulation_0'] = createExportWrapper('emscripten_bind_PxArticulationTendon_getArticulation_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_release_0');
  _emscripten_bind_PxArticulationTendon_release_0 = Module['_emscripten_bind_PxArticulationTendon_release_0'] = createExportWrapper('emscripten_bind_PxArticulationTendon_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_getConcreteTypeName_0');
  _emscripten_bind_PxArticulationTendon_getConcreteTypeName_0 = Module['_emscripten_bind_PxArticulationTendon_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxArticulationTendon_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_getConcreteType_0');
  _emscripten_bind_PxArticulationTendon_getConcreteType_0 = Module['_emscripten_bind_PxArticulationTendon_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxArticulationTendon_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_setBaseFlag_2');
  _emscripten_bind_PxArticulationTendon_setBaseFlag_2 = Module['_emscripten_bind_PxArticulationTendon_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxArticulationTendon_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_setBaseFlags_1');
  _emscripten_bind_PxArticulationTendon_setBaseFlags_1 = Module['_emscripten_bind_PxArticulationTendon_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxArticulationTendon_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_getBaseFlags_0');
  _emscripten_bind_PxArticulationTendon_getBaseFlags_0 = Module['_emscripten_bind_PxArticulationTendon_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxArticulationTendon_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon_isReleasable_0');
  _emscripten_bind_PxArticulationTendon_isReleasable_0 = Module['_emscripten_bind_PxArticulationTendon_isReleasable_0'] = createExportWrapper('emscripten_bind_PxArticulationTendon_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendon___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendon___destroy___0');
  _emscripten_bind_PxArticulationTendon___destroy___0 = Module['_emscripten_bind_PxArticulationTendon___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationTendon___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBaseMaterial_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseMaterial_release_0');
  _emscripten_bind_PxBaseMaterial_release_0 = Module['_emscripten_bind_PxBaseMaterial_release_0'] = createExportWrapper('emscripten_bind_PxBaseMaterial_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBaseMaterial_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseMaterial_getConcreteTypeName_0');
  _emscripten_bind_PxBaseMaterial_getConcreteTypeName_0 = Module['_emscripten_bind_PxBaseMaterial_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxBaseMaterial_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBaseMaterial_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseMaterial_getConcreteType_0');
  _emscripten_bind_PxBaseMaterial_getConcreteType_0 = Module['_emscripten_bind_PxBaseMaterial_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxBaseMaterial_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBaseMaterial_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseMaterial_setBaseFlag_2');
  _emscripten_bind_PxBaseMaterial_setBaseFlag_2 = Module['_emscripten_bind_PxBaseMaterial_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxBaseMaterial_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxBaseMaterial_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseMaterial_setBaseFlags_1');
  _emscripten_bind_PxBaseMaterial_setBaseFlags_1 = Module['_emscripten_bind_PxBaseMaterial_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxBaseMaterial_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBaseMaterial_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseMaterial_getBaseFlags_0');
  _emscripten_bind_PxBaseMaterial_getBaseFlags_0 = Module['_emscripten_bind_PxBaseMaterial_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxBaseMaterial_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBaseMaterial_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseMaterial_isReleasable_0');
  _emscripten_bind_PxBaseMaterial_isReleasable_0 = Module['_emscripten_bind_PxBaseMaterial_isReleasable_0'] = createExportWrapper('emscripten_bind_PxBaseMaterial_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBaseMaterial_getReferenceCount_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseMaterial_getReferenceCount_0');
  _emscripten_bind_PxBaseMaterial_getReferenceCount_0 = Module['_emscripten_bind_PxBaseMaterial_getReferenceCount_0'] = createExportWrapper('emscripten_bind_PxBaseMaterial_getReferenceCount_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBaseMaterial_acquireReference_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseMaterial_acquireReference_0');
  _emscripten_bind_PxBaseMaterial_acquireReference_0 = Module['_emscripten_bind_PxBaseMaterial_acquireReference_0'] = createExportWrapper('emscripten_bind_PxBaseMaterial_acquireReference_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBaseMaterial___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseMaterial___destroy___0');
  _emscripten_bind_PxBaseMaterial___destroy___0 = Module['_emscripten_bind_PxBaseMaterial___destroy___0'] = createExportWrapper('emscripten_bind_PxBaseMaterial___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraintConnector_prepareData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintConnector_prepareData_0');
  _emscripten_bind_PxConstraintConnector_prepareData_0 = Module['_emscripten_bind_PxConstraintConnector_prepareData_0'] = createExportWrapper('emscripten_bind_PxConstraintConnector_prepareData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraintConnector_updateOmniPvdProperties_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintConnector_updateOmniPvdProperties_0');
  _emscripten_bind_PxConstraintConnector_updateOmniPvdProperties_0 = Module['_emscripten_bind_PxConstraintConnector_updateOmniPvdProperties_0'] = createExportWrapper('emscripten_bind_PxConstraintConnector_updateOmniPvdProperties_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraintConnector_onConstraintRelease_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintConnector_onConstraintRelease_0');
  _emscripten_bind_PxConstraintConnector_onConstraintRelease_0 = Module['_emscripten_bind_PxConstraintConnector_onConstraintRelease_0'] = createExportWrapper('emscripten_bind_PxConstraintConnector_onConstraintRelease_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraintConnector_onComShift_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintConnector_onComShift_1');
  _emscripten_bind_PxConstraintConnector_onComShift_1 = Module['_emscripten_bind_PxConstraintConnector_onComShift_1'] = createExportWrapper('emscripten_bind_PxConstraintConnector_onComShift_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConstraintConnector_onOriginShift_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintConnector_onOriginShift_1');
  _emscripten_bind_PxConstraintConnector_onOriginShift_1 = Module['_emscripten_bind_PxConstraintConnector_onOriginShift_1'] = createExportWrapper('emscripten_bind_PxConstraintConnector_onOriginShift_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConstraintConnector_getSerializable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintConnector_getSerializable_0');
  _emscripten_bind_PxConstraintConnector_getSerializable_0 = Module['_emscripten_bind_PxConstraintConnector_getSerializable_0'] = createExportWrapper('emscripten_bind_PxConstraintConnector_getSerializable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraintConnector_getPrep_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintConnector_getPrep_0');
  _emscripten_bind_PxConstraintConnector_getPrep_0 = Module['_emscripten_bind_PxConstraintConnector_getPrep_0'] = createExportWrapper('emscripten_bind_PxConstraintConnector_getPrep_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraintConnector_getConstantBlock_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintConnector_getConstantBlock_0');
  _emscripten_bind_PxConstraintConnector_getConstantBlock_0 = Module['_emscripten_bind_PxConstraintConnector_getConstantBlock_0'] = createExportWrapper('emscripten_bind_PxConstraintConnector_getConstantBlock_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraintConnector_connectToConstraint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintConnector_connectToConstraint_1');
  _emscripten_bind_PxConstraintConnector_connectToConstraint_1 = Module['_emscripten_bind_PxConstraintConnector_connectToConstraint_1'] = createExportWrapper('emscripten_bind_PxConstraintConnector_connectToConstraint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConstraintConnector___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintConnector___destroy___0');
  _emscripten_bind_PxConstraintConnector___destroy___0 = Module['_emscripten_bind_PxConstraintConnector___destroy___0'] = createExportWrapper('emscripten_bind_PxConstraintConnector___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxController_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_getType_0');
  _emscripten_bind_PxController_getType_0 = Module['_emscripten_bind_PxController_getType_0'] = createExportWrapper('emscripten_bind_PxController_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxController_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_release_0');
  _emscripten_bind_PxController_release_0 = Module['_emscripten_bind_PxController_release_0'] = createExportWrapper('emscripten_bind_PxController_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxController_move_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_move_4');
  _emscripten_bind_PxController_move_4 = Module['_emscripten_bind_PxController_move_4'] = createExportWrapper('emscripten_bind_PxController_move_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxController_move_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_move_5');
  _emscripten_bind_PxController_move_5 = Module['_emscripten_bind_PxController_move_5'] = createExportWrapper('emscripten_bind_PxController_move_5', 6);
  assert(typeof wasmExports['emscripten_bind_PxController_setPosition_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_setPosition_1');
  _emscripten_bind_PxController_setPosition_1 = Module['_emscripten_bind_PxController_setPosition_1'] = createExportWrapper('emscripten_bind_PxController_setPosition_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxController_getPosition_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_getPosition_0');
  _emscripten_bind_PxController_getPosition_0 = Module['_emscripten_bind_PxController_getPosition_0'] = createExportWrapper('emscripten_bind_PxController_getPosition_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxController_setFootPosition_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_setFootPosition_1');
  _emscripten_bind_PxController_setFootPosition_1 = Module['_emscripten_bind_PxController_setFootPosition_1'] = createExportWrapper('emscripten_bind_PxController_setFootPosition_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxController_getFootPosition_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_getFootPosition_0');
  _emscripten_bind_PxController_getFootPosition_0 = Module['_emscripten_bind_PxController_getFootPosition_0'] = createExportWrapper('emscripten_bind_PxController_getFootPosition_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxController_getActor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_getActor_0');
  _emscripten_bind_PxController_getActor_0 = Module['_emscripten_bind_PxController_getActor_0'] = createExportWrapper('emscripten_bind_PxController_getActor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxController_setStepOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_setStepOffset_1');
  _emscripten_bind_PxController_setStepOffset_1 = Module['_emscripten_bind_PxController_setStepOffset_1'] = createExportWrapper('emscripten_bind_PxController_setStepOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxController_getStepOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_getStepOffset_0');
  _emscripten_bind_PxController_getStepOffset_0 = Module['_emscripten_bind_PxController_getStepOffset_0'] = createExportWrapper('emscripten_bind_PxController_getStepOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxController_setNonWalkableMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_setNonWalkableMode_1');
  _emscripten_bind_PxController_setNonWalkableMode_1 = Module['_emscripten_bind_PxController_setNonWalkableMode_1'] = createExportWrapper('emscripten_bind_PxController_setNonWalkableMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxController_getNonWalkableMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_getNonWalkableMode_0');
  _emscripten_bind_PxController_getNonWalkableMode_0 = Module['_emscripten_bind_PxController_getNonWalkableMode_0'] = createExportWrapper('emscripten_bind_PxController_getNonWalkableMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxController_getContactOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_getContactOffset_0');
  _emscripten_bind_PxController_getContactOffset_0 = Module['_emscripten_bind_PxController_getContactOffset_0'] = createExportWrapper('emscripten_bind_PxController_getContactOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxController_setContactOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_setContactOffset_1');
  _emscripten_bind_PxController_setContactOffset_1 = Module['_emscripten_bind_PxController_setContactOffset_1'] = createExportWrapper('emscripten_bind_PxController_setContactOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxController_getUpDirection_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_getUpDirection_0');
  _emscripten_bind_PxController_getUpDirection_0 = Module['_emscripten_bind_PxController_getUpDirection_0'] = createExportWrapper('emscripten_bind_PxController_getUpDirection_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxController_setUpDirection_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_setUpDirection_1');
  _emscripten_bind_PxController_setUpDirection_1 = Module['_emscripten_bind_PxController_setUpDirection_1'] = createExportWrapper('emscripten_bind_PxController_setUpDirection_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxController_getSlopeLimit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_getSlopeLimit_0');
  _emscripten_bind_PxController_getSlopeLimit_0 = Module['_emscripten_bind_PxController_getSlopeLimit_0'] = createExportWrapper('emscripten_bind_PxController_getSlopeLimit_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxController_setSlopeLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_setSlopeLimit_1');
  _emscripten_bind_PxController_setSlopeLimit_1 = Module['_emscripten_bind_PxController_setSlopeLimit_1'] = createExportWrapper('emscripten_bind_PxController_setSlopeLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxController_invalidateCache_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_invalidateCache_0');
  _emscripten_bind_PxController_invalidateCache_0 = Module['_emscripten_bind_PxController_invalidateCache_0'] = createExportWrapper('emscripten_bind_PxController_invalidateCache_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxController_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_getScene_0');
  _emscripten_bind_PxController_getScene_0 = Module['_emscripten_bind_PxController_getScene_0'] = createExportWrapper('emscripten_bind_PxController_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxController_getUserData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_getUserData_0');
  _emscripten_bind_PxController_getUserData_0 = Module['_emscripten_bind_PxController_getUserData_0'] = createExportWrapper('emscripten_bind_PxController_getUserData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxController_setUserData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_setUserData_1');
  _emscripten_bind_PxController_setUserData_1 = Module['_emscripten_bind_PxController_setUserData_1'] = createExportWrapper('emscripten_bind_PxController_setUserData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxController_getState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_getState_1');
  _emscripten_bind_PxController_getState_1 = Module['_emscripten_bind_PxController_getState_1'] = createExportWrapper('emscripten_bind_PxController_getState_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxController_getStats_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_getStats_1');
  _emscripten_bind_PxController_getStats_1 = Module['_emscripten_bind_PxController_getStats_1'] = createExportWrapper('emscripten_bind_PxController_getStats_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxController_resize_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxController_resize_1');
  _emscripten_bind_PxController_resize_1 = Module['_emscripten_bind_PxController_resize_1'] = createExportWrapper('emscripten_bind_PxController_resize_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_isValid_0');
  _emscripten_bind_PxControllerDesc_isValid_0 = Module['_emscripten_bind_PxControllerDesc_isValid_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_getType_0');
  _emscripten_bind_PxControllerDesc_getType_0 = Module['_emscripten_bind_PxControllerDesc_getType_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_position_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_position_0');
  _emscripten_bind_PxControllerDesc_get_position_0 = Module['_emscripten_bind_PxControllerDesc_get_position_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_position_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_position_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_position_1');
  _emscripten_bind_PxControllerDesc_set_position_1 = Module['_emscripten_bind_PxControllerDesc_set_position_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_position_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_upDirection_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_upDirection_0');
  _emscripten_bind_PxControllerDesc_get_upDirection_0 = Module['_emscripten_bind_PxControllerDesc_get_upDirection_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_upDirection_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_upDirection_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_upDirection_1');
  _emscripten_bind_PxControllerDesc_set_upDirection_1 = Module['_emscripten_bind_PxControllerDesc_set_upDirection_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_upDirection_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_slopeLimit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_slopeLimit_0');
  _emscripten_bind_PxControllerDesc_get_slopeLimit_0 = Module['_emscripten_bind_PxControllerDesc_get_slopeLimit_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_slopeLimit_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_slopeLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_slopeLimit_1');
  _emscripten_bind_PxControllerDesc_set_slopeLimit_1 = Module['_emscripten_bind_PxControllerDesc_set_slopeLimit_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_slopeLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_invisibleWallHeight_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_invisibleWallHeight_0');
  _emscripten_bind_PxControllerDesc_get_invisibleWallHeight_0 = Module['_emscripten_bind_PxControllerDesc_get_invisibleWallHeight_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_invisibleWallHeight_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_invisibleWallHeight_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_invisibleWallHeight_1');
  _emscripten_bind_PxControllerDesc_set_invisibleWallHeight_1 = Module['_emscripten_bind_PxControllerDesc_set_invisibleWallHeight_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_invisibleWallHeight_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_maxJumpHeight_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_maxJumpHeight_0');
  _emscripten_bind_PxControllerDesc_get_maxJumpHeight_0 = Module['_emscripten_bind_PxControllerDesc_get_maxJumpHeight_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_maxJumpHeight_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_maxJumpHeight_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_maxJumpHeight_1');
  _emscripten_bind_PxControllerDesc_set_maxJumpHeight_1 = Module['_emscripten_bind_PxControllerDesc_set_maxJumpHeight_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_maxJumpHeight_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_contactOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_contactOffset_0');
  _emscripten_bind_PxControllerDesc_get_contactOffset_0 = Module['_emscripten_bind_PxControllerDesc_get_contactOffset_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_contactOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_contactOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_contactOffset_1');
  _emscripten_bind_PxControllerDesc_set_contactOffset_1 = Module['_emscripten_bind_PxControllerDesc_set_contactOffset_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_contactOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_stepOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_stepOffset_0');
  _emscripten_bind_PxControllerDesc_get_stepOffset_0 = Module['_emscripten_bind_PxControllerDesc_get_stepOffset_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_stepOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_stepOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_stepOffset_1');
  _emscripten_bind_PxControllerDesc_set_stepOffset_1 = Module['_emscripten_bind_PxControllerDesc_set_stepOffset_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_stepOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_density_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_density_0');
  _emscripten_bind_PxControllerDesc_get_density_0 = Module['_emscripten_bind_PxControllerDesc_get_density_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_density_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_density_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_density_1');
  _emscripten_bind_PxControllerDesc_set_density_1 = Module['_emscripten_bind_PxControllerDesc_set_density_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_density_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_scaleCoeff_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_scaleCoeff_0');
  _emscripten_bind_PxControllerDesc_get_scaleCoeff_0 = Module['_emscripten_bind_PxControllerDesc_get_scaleCoeff_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_scaleCoeff_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_scaleCoeff_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_scaleCoeff_1');
  _emscripten_bind_PxControllerDesc_set_scaleCoeff_1 = Module['_emscripten_bind_PxControllerDesc_set_scaleCoeff_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_scaleCoeff_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_volumeGrowth_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_volumeGrowth_0');
  _emscripten_bind_PxControllerDesc_get_volumeGrowth_0 = Module['_emscripten_bind_PxControllerDesc_get_volumeGrowth_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_volumeGrowth_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_volumeGrowth_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_volumeGrowth_1');
  _emscripten_bind_PxControllerDesc_set_volumeGrowth_1 = Module['_emscripten_bind_PxControllerDesc_set_volumeGrowth_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_volumeGrowth_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_reportCallback_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_reportCallback_0');
  _emscripten_bind_PxControllerDesc_get_reportCallback_0 = Module['_emscripten_bind_PxControllerDesc_get_reportCallback_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_reportCallback_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_reportCallback_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_reportCallback_1');
  _emscripten_bind_PxControllerDesc_set_reportCallback_1 = Module['_emscripten_bind_PxControllerDesc_set_reportCallback_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_reportCallback_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_behaviorCallback_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_behaviorCallback_0');
  _emscripten_bind_PxControllerDesc_get_behaviorCallback_0 = Module['_emscripten_bind_PxControllerDesc_get_behaviorCallback_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_behaviorCallback_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_behaviorCallback_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_behaviorCallback_1');
  _emscripten_bind_PxControllerDesc_set_behaviorCallback_1 = Module['_emscripten_bind_PxControllerDesc_set_behaviorCallback_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_behaviorCallback_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_nonWalkableMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_nonWalkableMode_0');
  _emscripten_bind_PxControllerDesc_get_nonWalkableMode_0 = Module['_emscripten_bind_PxControllerDesc_get_nonWalkableMode_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_nonWalkableMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_nonWalkableMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_nonWalkableMode_1');
  _emscripten_bind_PxControllerDesc_set_nonWalkableMode_1 = Module['_emscripten_bind_PxControllerDesc_set_nonWalkableMode_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_nonWalkableMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_material_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_material_0');
  _emscripten_bind_PxControllerDesc_get_material_0 = Module['_emscripten_bind_PxControllerDesc_get_material_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_material_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_material_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_material_1');
  _emscripten_bind_PxControllerDesc_set_material_1 = Module['_emscripten_bind_PxControllerDesc_set_material_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_material_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_registerDeletionListener_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_registerDeletionListener_0');
  _emscripten_bind_PxControllerDesc_get_registerDeletionListener_0 = Module['_emscripten_bind_PxControllerDesc_get_registerDeletionListener_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_registerDeletionListener_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_registerDeletionListener_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_registerDeletionListener_1');
  _emscripten_bind_PxControllerDesc_set_registerDeletionListener_1 = Module['_emscripten_bind_PxControllerDesc_set_registerDeletionListener_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_registerDeletionListener_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_get_userData_0');
  _emscripten_bind_PxControllerDesc_get_userData_0 = Module['_emscripten_bind_PxControllerDesc_get_userData_0'] = createExportWrapper('emscripten_bind_PxControllerDesc_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerDesc_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerDesc_set_userData_1');
  _emscripten_bind_PxControllerDesc_set_userData_1 = Module['_emscripten_bind_PxControllerDesc_set_userData_1'] = createExportWrapper('emscripten_bind_PxControllerDesc_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilterCallback_filter_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilterCallback_filter_2');
  _emscripten_bind_PxControllerFilterCallback_filter_2 = Module['_emscripten_bind_PxControllerFilterCallback_filter_2'] = createExportWrapper('emscripten_bind_PxControllerFilterCallback_filter_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilterCallback___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilterCallback___destroy___0');
  _emscripten_bind_PxControllerFilterCallback___destroy___0 = Module['_emscripten_bind_PxControllerFilterCallback___destroy___0'] = createExportWrapper('emscripten_bind_PxControllerFilterCallback___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerHit_get_controller_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerHit_get_controller_0');
  _emscripten_bind_PxControllerHit_get_controller_0 = Module['_emscripten_bind_PxControllerHit_get_controller_0'] = createExportWrapper('emscripten_bind_PxControllerHit_get_controller_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerHit_set_controller_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerHit_set_controller_1');
  _emscripten_bind_PxControllerHit_set_controller_1 = Module['_emscripten_bind_PxControllerHit_set_controller_1'] = createExportWrapper('emscripten_bind_PxControllerHit_set_controller_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerHit_get_worldPos_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerHit_get_worldPos_0');
  _emscripten_bind_PxControllerHit_get_worldPos_0 = Module['_emscripten_bind_PxControllerHit_get_worldPos_0'] = createExportWrapper('emscripten_bind_PxControllerHit_get_worldPos_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerHit_set_worldPos_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerHit_set_worldPos_1');
  _emscripten_bind_PxControllerHit_set_worldPos_1 = Module['_emscripten_bind_PxControllerHit_set_worldPos_1'] = createExportWrapper('emscripten_bind_PxControllerHit_set_worldPos_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerHit_get_worldNormal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerHit_get_worldNormal_0');
  _emscripten_bind_PxControllerHit_get_worldNormal_0 = Module['_emscripten_bind_PxControllerHit_get_worldNormal_0'] = createExportWrapper('emscripten_bind_PxControllerHit_get_worldNormal_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerHit_set_worldNormal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerHit_set_worldNormal_1');
  _emscripten_bind_PxControllerHit_set_worldNormal_1 = Module['_emscripten_bind_PxControllerHit_set_worldNormal_1'] = createExportWrapper('emscripten_bind_PxControllerHit_set_worldNormal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerHit_get_dir_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerHit_get_dir_0');
  _emscripten_bind_PxControllerHit_get_dir_0 = Module['_emscripten_bind_PxControllerHit_get_dir_0'] = createExportWrapper('emscripten_bind_PxControllerHit_get_dir_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerHit_set_dir_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerHit_set_dir_1');
  _emscripten_bind_PxControllerHit_set_dir_1 = Module['_emscripten_bind_PxControllerHit_set_dir_1'] = createExportWrapper('emscripten_bind_PxControllerHit_set_dir_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerHit_get_length_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerHit_get_length_0');
  _emscripten_bind_PxControllerHit_get_length_0 = Module['_emscripten_bind_PxControllerHit_get_length_0'] = createExportWrapper('emscripten_bind_PxControllerHit_get_length_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerHit_set_length_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerHit_set_length_1');
  _emscripten_bind_PxControllerHit_set_length_1 = Module['_emscripten_bind_PxControllerHit_set_length_1'] = createExportWrapper('emscripten_bind_PxControllerHit_set_length_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerHit___destroy___0');
  _emscripten_bind_PxControllerHit___destroy___0 = Module['_emscripten_bind_PxControllerHit___destroy___0'] = createExportWrapper('emscripten_bind_PxControllerHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCpuDispatcher___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCpuDispatcher___destroy___0');
  _emscripten_bind_PxCpuDispatcher___destroy___0 = Module['_emscripten_bind_PxCpuDispatcher___destroy___0'] = createExportWrapper('emscripten_bind_PxCpuDispatcher___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxErrorCallback_reportError_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxErrorCallback_reportError_4');
  _emscripten_bind_PxErrorCallback_reportError_4 = Module['_emscripten_bind_PxErrorCallback_reportError_4'] = createExportWrapper('emscripten_bind_PxErrorCallback_reportError_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxErrorCallback___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxErrorCallback___destroy___0');
  _emscripten_bind_PxErrorCallback___destroy___0 = Module['_emscripten_bind_PxErrorCallback___destroy___0'] = createExportWrapper('emscripten_bind_PxErrorCallback___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_hadInitialOverlap_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_hadInitialOverlap_0');
  _emscripten_bind_PxGeomRaycastHit_hadInitialOverlap_0 = Module['_emscripten_bind_PxGeomRaycastHit_hadInitialOverlap_0'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_hadInitialOverlap_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_get_u_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_get_u_0');
  _emscripten_bind_PxGeomRaycastHit_get_u_0 = Module['_emscripten_bind_PxGeomRaycastHit_get_u_0'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_get_u_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_set_u_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_set_u_1');
  _emscripten_bind_PxGeomRaycastHit_set_u_1 = Module['_emscripten_bind_PxGeomRaycastHit_set_u_1'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_set_u_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_get_v_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_get_v_0');
  _emscripten_bind_PxGeomRaycastHit_get_v_0 = Module['_emscripten_bind_PxGeomRaycastHit_get_v_0'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_get_v_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_set_v_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_set_v_1');
  _emscripten_bind_PxGeomRaycastHit_set_v_1 = Module['_emscripten_bind_PxGeomRaycastHit_set_v_1'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_set_v_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_get_flags_0');
  _emscripten_bind_PxGeomRaycastHit_get_flags_0 = Module['_emscripten_bind_PxGeomRaycastHit_get_flags_0'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_set_flags_1');
  _emscripten_bind_PxGeomRaycastHit_set_flags_1 = Module['_emscripten_bind_PxGeomRaycastHit_set_flags_1'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_get_position_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_get_position_0');
  _emscripten_bind_PxGeomRaycastHit_get_position_0 = Module['_emscripten_bind_PxGeomRaycastHit_get_position_0'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_get_position_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_set_position_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_set_position_1');
  _emscripten_bind_PxGeomRaycastHit_set_position_1 = Module['_emscripten_bind_PxGeomRaycastHit_set_position_1'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_set_position_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_get_normal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_get_normal_0');
  _emscripten_bind_PxGeomRaycastHit_get_normal_0 = Module['_emscripten_bind_PxGeomRaycastHit_get_normal_0'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_get_normal_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_set_normal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_set_normal_1');
  _emscripten_bind_PxGeomRaycastHit_set_normal_1 = Module['_emscripten_bind_PxGeomRaycastHit_set_normal_1'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_set_normal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_get_distance_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_get_distance_0');
  _emscripten_bind_PxGeomRaycastHit_get_distance_0 = Module['_emscripten_bind_PxGeomRaycastHit_get_distance_0'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_get_distance_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_set_distance_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_set_distance_1');
  _emscripten_bind_PxGeomRaycastHit_set_distance_1 = Module['_emscripten_bind_PxGeomRaycastHit_set_distance_1'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_set_distance_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_get_faceIndex_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_get_faceIndex_0');
  _emscripten_bind_PxGeomRaycastHit_get_faceIndex_0 = Module['_emscripten_bind_PxGeomRaycastHit_get_faceIndex_0'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_get_faceIndex_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit_set_faceIndex_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit_set_faceIndex_1');
  _emscripten_bind_PxGeomRaycastHit_set_faceIndex_1 = Module['_emscripten_bind_PxGeomRaycastHit_set_faceIndex_1'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit_set_faceIndex_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGeomRaycastHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomRaycastHit___destroy___0');
  _emscripten_bind_PxGeomRaycastHit___destroy___0 = Module['_emscripten_bind_PxGeomRaycastHit___destroy___0'] = createExportWrapper('emscripten_bind_PxGeomRaycastHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomSweepHit_hadInitialOverlap_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomSweepHit_hadInitialOverlap_0');
  _emscripten_bind_PxGeomSweepHit_hadInitialOverlap_0 = Module['_emscripten_bind_PxGeomSweepHit_hadInitialOverlap_0'] = createExportWrapper('emscripten_bind_PxGeomSweepHit_hadInitialOverlap_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomSweepHit_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomSweepHit_get_flags_0');
  _emscripten_bind_PxGeomSweepHit_get_flags_0 = Module['_emscripten_bind_PxGeomSweepHit_get_flags_0'] = createExportWrapper('emscripten_bind_PxGeomSweepHit_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomSweepHit_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomSweepHit_set_flags_1');
  _emscripten_bind_PxGeomSweepHit_set_flags_1 = Module['_emscripten_bind_PxGeomSweepHit_set_flags_1'] = createExportWrapper('emscripten_bind_PxGeomSweepHit_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGeomSweepHit_get_position_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomSweepHit_get_position_0');
  _emscripten_bind_PxGeomSweepHit_get_position_0 = Module['_emscripten_bind_PxGeomSweepHit_get_position_0'] = createExportWrapper('emscripten_bind_PxGeomSweepHit_get_position_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomSweepHit_set_position_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomSweepHit_set_position_1');
  _emscripten_bind_PxGeomSweepHit_set_position_1 = Module['_emscripten_bind_PxGeomSweepHit_set_position_1'] = createExportWrapper('emscripten_bind_PxGeomSweepHit_set_position_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGeomSweepHit_get_normal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomSweepHit_get_normal_0');
  _emscripten_bind_PxGeomSweepHit_get_normal_0 = Module['_emscripten_bind_PxGeomSweepHit_get_normal_0'] = createExportWrapper('emscripten_bind_PxGeomSweepHit_get_normal_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomSweepHit_set_normal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomSweepHit_set_normal_1');
  _emscripten_bind_PxGeomSweepHit_set_normal_1 = Module['_emscripten_bind_PxGeomSweepHit_set_normal_1'] = createExportWrapper('emscripten_bind_PxGeomSweepHit_set_normal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGeomSweepHit_get_distance_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomSweepHit_get_distance_0');
  _emscripten_bind_PxGeomSweepHit_get_distance_0 = Module['_emscripten_bind_PxGeomSweepHit_get_distance_0'] = createExportWrapper('emscripten_bind_PxGeomSweepHit_get_distance_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomSweepHit_set_distance_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomSweepHit_set_distance_1');
  _emscripten_bind_PxGeomSweepHit_set_distance_1 = Module['_emscripten_bind_PxGeomSweepHit_set_distance_1'] = createExportWrapper('emscripten_bind_PxGeomSweepHit_set_distance_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGeomSweepHit_get_faceIndex_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomSweepHit_get_faceIndex_0');
  _emscripten_bind_PxGeomSweepHit_get_faceIndex_0 = Module['_emscripten_bind_PxGeomSweepHit_get_faceIndex_0'] = createExportWrapper('emscripten_bind_PxGeomSweepHit_get_faceIndex_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeomSweepHit_set_faceIndex_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomSweepHit_set_faceIndex_1');
  _emscripten_bind_PxGeomSweepHit_set_faceIndex_1 = Module['_emscripten_bind_PxGeomSweepHit_set_faceIndex_1'] = createExportWrapper('emscripten_bind_PxGeomSweepHit_set_faceIndex_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGeomSweepHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeomSweepHit___destroy___0');
  _emscripten_bind_PxGeomSweepHit___destroy___0 = Module['_emscripten_bind_PxGeomSweepHit___destroy___0'] = createExportWrapper('emscripten_bind_PxGeomSweepHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeometry_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometry_getType_0');
  _emscripten_bind_PxGeometry_getType_0 = Module['_emscripten_bind_PxGeometry_getType_0'] = createExportWrapper('emscripten_bind_PxGeometry_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeometry___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometry___destroy___0');
  _emscripten_bind_PxGeometry___destroy___0 = Module['_emscripten_bind_PxGeometry___destroy___0'] = createExportWrapper('emscripten_bind_PxGeometry___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxI32ConstPtr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxI32ConstPtr___destroy___0');
  _emscripten_bind_PxI32ConstPtr___destroy___0 = Module['_emscripten_bind_PxI32ConstPtr___destroy___0'] = createExportWrapper('emscripten_bind_PxI32ConstPtr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxInputData___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxInputData___destroy___0');
  _emscripten_bind_PxInputData___destroy___0 = Module['_emscripten_bind_PxInputData___destroy___0'] = createExportWrapper('emscripten_bind_PxInputData___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_setActors_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_setActors_2');
  _emscripten_bind_PxJoint_setActors_2 = Module['_emscripten_bind_PxJoint_setActors_2'] = createExportWrapper('emscripten_bind_PxJoint_setActors_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxJoint_setLocalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_setLocalPose_2');
  _emscripten_bind_PxJoint_setLocalPose_2 = Module['_emscripten_bind_PxJoint_setLocalPose_2'] = createExportWrapper('emscripten_bind_PxJoint_setLocalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getLocalPose_1');
  _emscripten_bind_PxJoint_getLocalPose_1 = Module['_emscripten_bind_PxJoint_getLocalPose_1'] = createExportWrapper('emscripten_bind_PxJoint_getLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getRelativeTransform_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getRelativeTransform_0');
  _emscripten_bind_PxJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxJoint_getRelativeTransform_0'] = createExportWrapper('emscripten_bind_PxJoint_getRelativeTransform_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getRelativeLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getRelativeLinearVelocity_0');
  _emscripten_bind_PxJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxJoint_getRelativeLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxJoint_getRelativeLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getRelativeAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getRelativeAngularVelocity_0');
  _emscripten_bind_PxJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxJoint_getRelativeAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxJoint_getRelativeAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_setBreakForce_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_setBreakForce_2');
  _emscripten_bind_PxJoint_setBreakForce_2 = Module['_emscripten_bind_PxJoint_setBreakForce_2'] = createExportWrapper('emscripten_bind_PxJoint_setBreakForce_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxJoint_setConstraintFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_setConstraintFlags_1');
  _emscripten_bind_PxJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxJoint_setConstraintFlags_1'] = createExportWrapper('emscripten_bind_PxJoint_setConstraintFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJoint_setConstraintFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_setConstraintFlag_2');
  _emscripten_bind_PxJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxJoint_setConstraintFlag_2'] = createExportWrapper('emscripten_bind_PxJoint_setConstraintFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getConstraintFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getConstraintFlags_0');
  _emscripten_bind_PxJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxJoint_getConstraintFlags_0'] = createExportWrapper('emscripten_bind_PxJoint_getConstraintFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_setInvMassScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_setInvMassScale0_1');
  _emscripten_bind_PxJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxJoint_setInvMassScale0_1'] = createExportWrapper('emscripten_bind_PxJoint_setInvMassScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getInvMassScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getInvMassScale0_0');
  _emscripten_bind_PxJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxJoint_getInvMassScale0_0'] = createExportWrapper('emscripten_bind_PxJoint_getInvMassScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_setInvMassScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_setInvMassScale1_1');
  _emscripten_bind_PxJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxJoint_setInvMassScale1_1'] = createExportWrapper('emscripten_bind_PxJoint_setInvMassScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getInvMassScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getInvMassScale1_0');
  _emscripten_bind_PxJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxJoint_getInvMassScale1_0'] = createExportWrapper('emscripten_bind_PxJoint_getInvMassScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_setInvInertiaScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_setInvInertiaScale0_1');
  _emscripten_bind_PxJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxJoint_setInvInertiaScale0_1'] = createExportWrapper('emscripten_bind_PxJoint_setInvInertiaScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getInvInertiaScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getInvInertiaScale0_0');
  _emscripten_bind_PxJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxJoint_getInvInertiaScale0_0'] = createExportWrapper('emscripten_bind_PxJoint_getInvInertiaScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_setInvInertiaScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_setInvInertiaScale1_1');
  _emscripten_bind_PxJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxJoint_setInvInertiaScale1_1'] = createExportWrapper('emscripten_bind_PxJoint_setInvInertiaScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getInvInertiaScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getInvInertiaScale1_0');
  _emscripten_bind_PxJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxJoint_getInvInertiaScale1_0'] = createExportWrapper('emscripten_bind_PxJoint_getInvInertiaScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getConstraint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getConstraint_0');
  _emscripten_bind_PxJoint_getConstraint_0 = Module['_emscripten_bind_PxJoint_getConstraint_0'] = createExportWrapper('emscripten_bind_PxJoint_getConstraint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_setName_1');
  _emscripten_bind_PxJoint_setName_1 = Module['_emscripten_bind_PxJoint_setName_1'] = createExportWrapper('emscripten_bind_PxJoint_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getName_0');
  _emscripten_bind_PxJoint_getName_0 = Module['_emscripten_bind_PxJoint_getName_0'] = createExportWrapper('emscripten_bind_PxJoint_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getScene_0');
  _emscripten_bind_PxJoint_getScene_0 = Module['_emscripten_bind_PxJoint_getScene_0'] = createExportWrapper('emscripten_bind_PxJoint_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_release_0');
  _emscripten_bind_PxJoint_release_0 = Module['_emscripten_bind_PxJoint_release_0'] = createExportWrapper('emscripten_bind_PxJoint_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getConcreteTypeName_0');
  _emscripten_bind_PxJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxJoint_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxJoint_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getConcreteType_0');
  _emscripten_bind_PxJoint_getConcreteType_0 = Module['_emscripten_bind_PxJoint_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxJoint_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_setBaseFlag_2');
  _emscripten_bind_PxJoint_setBaseFlag_2 = Module['_emscripten_bind_PxJoint_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxJoint_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxJoint_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_setBaseFlags_1');
  _emscripten_bind_PxJoint_setBaseFlags_1 = Module['_emscripten_bind_PxJoint_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxJoint_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJoint_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_getBaseFlags_0');
  _emscripten_bind_PxJoint_getBaseFlags_0 = Module['_emscripten_bind_PxJoint_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxJoint_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_isReleasable_0');
  _emscripten_bind_PxJoint_isReleasable_0 = Module['_emscripten_bind_PxJoint_isReleasable_0'] = createExportWrapper('emscripten_bind_PxJoint_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_get_userData_0');
  _emscripten_bind_PxJoint_get_userData_0 = Module['_emscripten_bind_PxJoint_get_userData_0'] = createExportWrapper('emscripten_bind_PxJoint_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJoint_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJoint_set_userData_1');
  _emscripten_bind_PxJoint_set_userData_1 = Module['_emscripten_bind_PxJoint_set_userData_1'] = createExportWrapper('emscripten_bind_PxJoint_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitParameters_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitParameters_isValid_0');
  _emscripten_bind_PxJointLimitParameters_isValid_0 = Module['_emscripten_bind_PxJointLimitParameters_isValid_0'] = createExportWrapper('emscripten_bind_PxJointLimitParameters_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitParameters_isSoft_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitParameters_isSoft_0');
  _emscripten_bind_PxJointLimitParameters_isSoft_0 = Module['_emscripten_bind_PxJointLimitParameters_isSoft_0'] = createExportWrapper('emscripten_bind_PxJointLimitParameters_isSoft_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitParameters_get_restitution_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitParameters_get_restitution_0');
  _emscripten_bind_PxJointLimitParameters_get_restitution_0 = Module['_emscripten_bind_PxJointLimitParameters_get_restitution_0'] = createExportWrapper('emscripten_bind_PxJointLimitParameters_get_restitution_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitParameters_set_restitution_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitParameters_set_restitution_1');
  _emscripten_bind_PxJointLimitParameters_set_restitution_1 = Module['_emscripten_bind_PxJointLimitParameters_set_restitution_1'] = createExportWrapper('emscripten_bind_PxJointLimitParameters_set_restitution_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitParameters_get_bounceThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitParameters_get_bounceThreshold_0');
  _emscripten_bind_PxJointLimitParameters_get_bounceThreshold_0 = Module['_emscripten_bind_PxJointLimitParameters_get_bounceThreshold_0'] = createExportWrapper('emscripten_bind_PxJointLimitParameters_get_bounceThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitParameters_set_bounceThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitParameters_set_bounceThreshold_1');
  _emscripten_bind_PxJointLimitParameters_set_bounceThreshold_1 = Module['_emscripten_bind_PxJointLimitParameters_set_bounceThreshold_1'] = createExportWrapper('emscripten_bind_PxJointLimitParameters_set_bounceThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitParameters_get_stiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitParameters_get_stiffness_0');
  _emscripten_bind_PxJointLimitParameters_get_stiffness_0 = Module['_emscripten_bind_PxJointLimitParameters_get_stiffness_0'] = createExportWrapper('emscripten_bind_PxJointLimitParameters_get_stiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitParameters_set_stiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitParameters_set_stiffness_1');
  _emscripten_bind_PxJointLimitParameters_set_stiffness_1 = Module['_emscripten_bind_PxJointLimitParameters_set_stiffness_1'] = createExportWrapper('emscripten_bind_PxJointLimitParameters_set_stiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitParameters_get_damping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitParameters_get_damping_0');
  _emscripten_bind_PxJointLimitParameters_get_damping_0 = Module['_emscripten_bind_PxJointLimitParameters_get_damping_0'] = createExportWrapper('emscripten_bind_PxJointLimitParameters_get_damping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitParameters_set_damping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitParameters_set_damping_1');
  _emscripten_bind_PxJointLimitParameters_set_damping_1 = Module['_emscripten_bind_PxJointLimitParameters_set_damping_1'] = createExportWrapper('emscripten_bind_PxJointLimitParameters_set_damping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxObstacle_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacle_getType_0');
  _emscripten_bind_PxObstacle_getType_0 = Module['_emscripten_bind_PxObstacle_getType_0'] = createExportWrapper('emscripten_bind_PxObstacle_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxObstacle_get_mUserData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacle_get_mUserData_0');
  _emscripten_bind_PxObstacle_get_mUserData_0 = Module['_emscripten_bind_PxObstacle_get_mUserData_0'] = createExportWrapper('emscripten_bind_PxObstacle_get_mUserData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxObstacle_set_mUserData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacle_set_mUserData_1');
  _emscripten_bind_PxObstacle_set_mUserData_1 = Module['_emscripten_bind_PxObstacle_set_mUserData_1'] = createExportWrapper('emscripten_bind_PxObstacle_set_mUserData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxObstacle_get_mPos_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacle_get_mPos_0');
  _emscripten_bind_PxObstacle_get_mPos_0 = Module['_emscripten_bind_PxObstacle_get_mPos_0'] = createExportWrapper('emscripten_bind_PxObstacle_get_mPos_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxObstacle_set_mPos_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacle_set_mPos_1');
  _emscripten_bind_PxObstacle_set_mPos_1 = Module['_emscripten_bind_PxObstacle_set_mPos_1'] = createExportWrapper('emscripten_bind_PxObstacle_set_mPos_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxObstacle_get_mRot_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacle_get_mRot_0');
  _emscripten_bind_PxObstacle_get_mRot_0 = Module['_emscripten_bind_PxObstacle_get_mRot_0'] = createExportWrapper('emscripten_bind_PxObstacle_get_mRot_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxObstacle_set_mRot_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacle_set_mRot_1');
  _emscripten_bind_PxObstacle_set_mRot_1 = Module['_emscripten_bind_PxObstacle_set_mRot_1'] = createExportWrapper('emscripten_bind_PxObstacle_set_mRot_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxObstacle___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacle___destroy___0');
  _emscripten_bind_PxObstacle___destroy___0 = Module['_emscripten_bind_PxObstacle___destroy___0'] = createExportWrapper('emscripten_bind_PxObstacle___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOutputStream___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOutputStream___destroy___0');
  _emscripten_bind_PxOutputStream___destroy___0 = Module['_emscripten_bind_PxOutputStream___destroy___0'] = createExportWrapper('emscripten_bind_PxOutputStream___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapCallback_hasAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapCallback_hasAnyHits_0');
  _emscripten_bind_PxOverlapCallback_hasAnyHits_0 = Module['_emscripten_bind_PxOverlapCallback_hasAnyHits_0'] = createExportWrapper('emscripten_bind_PxOverlapCallback_hasAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapCallback___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapCallback___destroy___0');
  _emscripten_bind_PxOverlapCallback___destroy___0 = Module['_emscripten_bind_PxOverlapCallback___destroy___0'] = createExportWrapper('emscripten_bind_PxOverlapCallback___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastCallback_hasAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastCallback_hasAnyHits_0');
  _emscripten_bind_PxRaycastCallback_hasAnyHits_0 = Module['_emscripten_bind_PxRaycastCallback_hasAnyHits_0'] = createExportWrapper('emscripten_bind_PxRaycastCallback_hasAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastCallback___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastCallback___destroy___0');
  _emscripten_bind_PxRaycastCallback___destroy___0 = Module['_emscripten_bind_PxRaycastCallback___destroy___0'] = createExportWrapper('emscripten_bind_PxRaycastCallback___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRealConstPtr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRealConstPtr___destroy___0');
  _emscripten_bind_PxRealConstPtr___destroy___0 = Module['_emscripten_bind_PxRealConstPtr___destroy___0'] = createExportWrapper('emscripten_bind_PxRealConstPtr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setCMassLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setCMassLocalPose_1');
  _emscripten_bind_PxRigidBody_setCMassLocalPose_1 = Module['_emscripten_bind_PxRigidBody_setCMassLocalPose_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setCMassLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getCMassLocalPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getCMassLocalPose_0');
  _emscripten_bind_PxRigidBody_getCMassLocalPose_0 = Module['_emscripten_bind_PxRigidBody_getCMassLocalPose_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getCMassLocalPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setMass_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setMass_1');
  _emscripten_bind_PxRigidBody_setMass_1 = Module['_emscripten_bind_PxRigidBody_setMass_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setMass_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getMass_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getMass_0');
  _emscripten_bind_PxRigidBody_getMass_0 = Module['_emscripten_bind_PxRigidBody_getMass_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getMass_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getInvMass_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getInvMass_0');
  _emscripten_bind_PxRigidBody_getInvMass_0 = Module['_emscripten_bind_PxRigidBody_getInvMass_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getInvMass_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setMassSpaceInertiaTensor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setMassSpaceInertiaTensor_1');
  _emscripten_bind_PxRigidBody_setMassSpaceInertiaTensor_1 = Module['_emscripten_bind_PxRigidBody_setMassSpaceInertiaTensor_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setMassSpaceInertiaTensor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getMassSpaceInertiaTensor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getMassSpaceInertiaTensor_0');
  _emscripten_bind_PxRigidBody_getMassSpaceInertiaTensor_0 = Module['_emscripten_bind_PxRigidBody_getMassSpaceInertiaTensor_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getMassSpaceInertiaTensor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getMassSpaceInvInertiaTensor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getMassSpaceInvInertiaTensor_0');
  _emscripten_bind_PxRigidBody_getMassSpaceInvInertiaTensor_0 = Module['_emscripten_bind_PxRigidBody_getMassSpaceInvInertiaTensor_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getMassSpaceInvInertiaTensor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setLinearDamping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setLinearDamping_1');
  _emscripten_bind_PxRigidBody_setLinearDamping_1 = Module['_emscripten_bind_PxRigidBody_setLinearDamping_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setLinearDamping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getLinearDamping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getLinearDamping_0');
  _emscripten_bind_PxRigidBody_getLinearDamping_0 = Module['_emscripten_bind_PxRigidBody_getLinearDamping_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getLinearDamping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setAngularDamping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setAngularDamping_1');
  _emscripten_bind_PxRigidBody_setAngularDamping_1 = Module['_emscripten_bind_PxRigidBody_setAngularDamping_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setAngularDamping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getAngularDamping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getAngularDamping_0');
  _emscripten_bind_PxRigidBody_getAngularDamping_0 = Module['_emscripten_bind_PxRigidBody_getAngularDamping_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getAngularDamping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getLinearVelocity_0');
  _emscripten_bind_PxRigidBody_getLinearVelocity_0 = Module['_emscripten_bind_PxRigidBody_getLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getAngularVelocity_0');
  _emscripten_bind_PxRigidBody_getAngularVelocity_0 = Module['_emscripten_bind_PxRigidBody_getAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setMaxLinearVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setMaxLinearVelocity_1');
  _emscripten_bind_PxRigidBody_setMaxLinearVelocity_1 = Module['_emscripten_bind_PxRigidBody_setMaxLinearVelocity_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setMaxLinearVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getMaxLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getMaxLinearVelocity_0');
  _emscripten_bind_PxRigidBody_getMaxLinearVelocity_0 = Module['_emscripten_bind_PxRigidBody_getMaxLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getMaxLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setMaxAngularVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setMaxAngularVelocity_1');
  _emscripten_bind_PxRigidBody_setMaxAngularVelocity_1 = Module['_emscripten_bind_PxRigidBody_setMaxAngularVelocity_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setMaxAngularVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getMaxAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getMaxAngularVelocity_0');
  _emscripten_bind_PxRigidBody_getMaxAngularVelocity_0 = Module['_emscripten_bind_PxRigidBody_getMaxAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getMaxAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_addForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_addForce_1');
  _emscripten_bind_PxRigidBody_addForce_1 = Module['_emscripten_bind_PxRigidBody_addForce_1'] = createExportWrapper('emscripten_bind_PxRigidBody_addForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_addForce_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_addForce_2');
  _emscripten_bind_PxRigidBody_addForce_2 = Module['_emscripten_bind_PxRigidBody_addForce_2'] = createExportWrapper('emscripten_bind_PxRigidBody_addForce_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_addForce_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_addForce_3');
  _emscripten_bind_PxRigidBody_addForce_3 = Module['_emscripten_bind_PxRigidBody_addForce_3'] = createExportWrapper('emscripten_bind_PxRigidBody_addForce_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_addTorque_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_addTorque_1');
  _emscripten_bind_PxRigidBody_addTorque_1 = Module['_emscripten_bind_PxRigidBody_addTorque_1'] = createExportWrapper('emscripten_bind_PxRigidBody_addTorque_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_addTorque_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_addTorque_2');
  _emscripten_bind_PxRigidBody_addTorque_2 = Module['_emscripten_bind_PxRigidBody_addTorque_2'] = createExportWrapper('emscripten_bind_PxRigidBody_addTorque_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_addTorque_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_addTorque_3');
  _emscripten_bind_PxRigidBody_addTorque_3 = Module['_emscripten_bind_PxRigidBody_addTorque_3'] = createExportWrapper('emscripten_bind_PxRigidBody_addTorque_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_clearForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_clearForce_1');
  _emscripten_bind_PxRigidBody_clearForce_1 = Module['_emscripten_bind_PxRigidBody_clearForce_1'] = createExportWrapper('emscripten_bind_PxRigidBody_clearForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_clearTorque_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_clearTorque_1');
  _emscripten_bind_PxRigidBody_clearTorque_1 = Module['_emscripten_bind_PxRigidBody_clearTorque_1'] = createExportWrapper('emscripten_bind_PxRigidBody_clearTorque_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setForceAndTorque_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setForceAndTorque_2');
  _emscripten_bind_PxRigidBody_setForceAndTorque_2 = Module['_emscripten_bind_PxRigidBody_setForceAndTorque_2'] = createExportWrapper('emscripten_bind_PxRigidBody_setForceAndTorque_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setForceAndTorque_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setForceAndTorque_3');
  _emscripten_bind_PxRigidBody_setForceAndTorque_3 = Module['_emscripten_bind_PxRigidBody_setForceAndTorque_3'] = createExportWrapper('emscripten_bind_PxRigidBody_setForceAndTorque_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setRigidBodyFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setRigidBodyFlag_2');
  _emscripten_bind_PxRigidBody_setRigidBodyFlag_2 = Module['_emscripten_bind_PxRigidBody_setRigidBodyFlag_2'] = createExportWrapper('emscripten_bind_PxRigidBody_setRigidBodyFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setRigidBodyFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setRigidBodyFlags_1');
  _emscripten_bind_PxRigidBody_setRigidBodyFlags_1 = Module['_emscripten_bind_PxRigidBody_setRigidBodyFlags_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setRigidBodyFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getRigidBodyFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getRigidBodyFlags_0');
  _emscripten_bind_PxRigidBody_getRigidBodyFlags_0 = Module['_emscripten_bind_PxRigidBody_getRigidBodyFlags_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getRigidBodyFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setMinCCDAdvanceCoefficient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setMinCCDAdvanceCoefficient_1');
  _emscripten_bind_PxRigidBody_setMinCCDAdvanceCoefficient_1 = Module['_emscripten_bind_PxRigidBody_setMinCCDAdvanceCoefficient_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setMinCCDAdvanceCoefficient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getMinCCDAdvanceCoefficient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getMinCCDAdvanceCoefficient_0');
  _emscripten_bind_PxRigidBody_getMinCCDAdvanceCoefficient_0 = Module['_emscripten_bind_PxRigidBody_getMinCCDAdvanceCoefficient_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getMinCCDAdvanceCoefficient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setMaxDepenetrationVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setMaxDepenetrationVelocity_1');
  _emscripten_bind_PxRigidBody_setMaxDepenetrationVelocity_1 = Module['_emscripten_bind_PxRigidBody_setMaxDepenetrationVelocity_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setMaxDepenetrationVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getMaxDepenetrationVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getMaxDepenetrationVelocity_0');
  _emscripten_bind_PxRigidBody_getMaxDepenetrationVelocity_0 = Module['_emscripten_bind_PxRigidBody_getMaxDepenetrationVelocity_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getMaxDepenetrationVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setMaxContactImpulse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setMaxContactImpulse_1');
  _emscripten_bind_PxRigidBody_setMaxContactImpulse_1 = Module['_emscripten_bind_PxRigidBody_setMaxContactImpulse_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setMaxContactImpulse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getMaxContactImpulse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getMaxContactImpulse_0');
  _emscripten_bind_PxRigidBody_getMaxContactImpulse_0 = Module['_emscripten_bind_PxRigidBody_getMaxContactImpulse_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getMaxContactImpulse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setContactSlopCoefficient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setContactSlopCoefficient_1');
  _emscripten_bind_PxRigidBody_setContactSlopCoefficient_1 = Module['_emscripten_bind_PxRigidBody_setContactSlopCoefficient_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setContactSlopCoefficient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getContactSlopCoefficient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getContactSlopCoefficient_0');
  _emscripten_bind_PxRigidBody_getContactSlopCoefficient_0 = Module['_emscripten_bind_PxRigidBody_getContactSlopCoefficient_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getContactSlopCoefficient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getType_0');
  _emscripten_bind_PxRigidBody_getType_0 = Module['_emscripten_bind_PxRigidBody_getType_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getScene_0');
  _emscripten_bind_PxRigidBody_getScene_0 = Module['_emscripten_bind_PxRigidBody_getScene_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setName_1');
  _emscripten_bind_PxRigidBody_setName_1 = Module['_emscripten_bind_PxRigidBody_setName_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getName_0');
  _emscripten_bind_PxRigidBody_getName_0 = Module['_emscripten_bind_PxRigidBody_getName_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getWorldBounds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getWorldBounds_0');
  _emscripten_bind_PxRigidBody_getWorldBounds_0 = Module['_emscripten_bind_PxRigidBody_getWorldBounds_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getWorldBounds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getWorldBounds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getWorldBounds_1');
  _emscripten_bind_PxRigidBody_getWorldBounds_1 = Module['_emscripten_bind_PxRigidBody_getWorldBounds_1'] = createExportWrapper('emscripten_bind_PxRigidBody_getWorldBounds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setActorFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setActorFlag_2');
  _emscripten_bind_PxRigidBody_setActorFlag_2 = Module['_emscripten_bind_PxRigidBody_setActorFlag_2'] = createExportWrapper('emscripten_bind_PxRigidBody_setActorFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setActorFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setActorFlags_1');
  _emscripten_bind_PxRigidBody_setActorFlags_1 = Module['_emscripten_bind_PxRigidBody_setActorFlags_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setActorFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getActorFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getActorFlags_0');
  _emscripten_bind_PxRigidBody_getActorFlags_0 = Module['_emscripten_bind_PxRigidBody_getActorFlags_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getActorFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setDominanceGroup_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setDominanceGroup_1');
  _emscripten_bind_PxRigidBody_setDominanceGroup_1 = Module['_emscripten_bind_PxRigidBody_setDominanceGroup_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setDominanceGroup_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getDominanceGroup_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getDominanceGroup_0');
  _emscripten_bind_PxRigidBody_getDominanceGroup_0 = Module['_emscripten_bind_PxRigidBody_getDominanceGroup_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getDominanceGroup_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setOwnerClient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setOwnerClient_1');
  _emscripten_bind_PxRigidBody_setOwnerClient_1 = Module['_emscripten_bind_PxRigidBody_setOwnerClient_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setOwnerClient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getOwnerClient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getOwnerClient_0');
  _emscripten_bind_PxRigidBody_getOwnerClient_0 = Module['_emscripten_bind_PxRigidBody_getOwnerClient_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getOwnerClient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_release_0');
  _emscripten_bind_PxRigidBody_release_0 = Module['_emscripten_bind_PxRigidBody_release_0'] = createExportWrapper('emscripten_bind_PxRigidBody_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getConcreteTypeName_0');
  _emscripten_bind_PxRigidBody_getConcreteTypeName_0 = Module['_emscripten_bind_PxRigidBody_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getConcreteType_0');
  _emscripten_bind_PxRigidBody_getConcreteType_0 = Module['_emscripten_bind_PxRigidBody_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setBaseFlag_2');
  _emscripten_bind_PxRigidBody_setBaseFlag_2 = Module['_emscripten_bind_PxRigidBody_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxRigidBody_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setBaseFlags_1');
  _emscripten_bind_PxRigidBody_setBaseFlags_1 = Module['_emscripten_bind_PxRigidBody_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getBaseFlags_0');
  _emscripten_bind_PxRigidBody_getBaseFlags_0 = Module['_emscripten_bind_PxRigidBody_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_isReleasable_0');
  _emscripten_bind_PxRigidBody_isReleasable_0 = Module['_emscripten_bind_PxRigidBody_isReleasable_0'] = createExportWrapper('emscripten_bind_PxRigidBody_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getGlobalPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getGlobalPose_0');
  _emscripten_bind_PxRigidBody_getGlobalPose_0 = Module['_emscripten_bind_PxRigidBody_getGlobalPose_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getGlobalPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setGlobalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setGlobalPose_1');
  _emscripten_bind_PxRigidBody_setGlobalPose_1 = Module['_emscripten_bind_PxRigidBody_setGlobalPose_1'] = createExportWrapper('emscripten_bind_PxRigidBody_setGlobalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_setGlobalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_setGlobalPose_2');
  _emscripten_bind_PxRigidBody_setGlobalPose_2 = Module['_emscripten_bind_PxRigidBody_setGlobalPose_2'] = createExportWrapper('emscripten_bind_PxRigidBody_setGlobalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_attachShape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_attachShape_1');
  _emscripten_bind_PxRigidBody_attachShape_1 = Module['_emscripten_bind_PxRigidBody_attachShape_1'] = createExportWrapper('emscripten_bind_PxRigidBody_attachShape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_detachShape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_detachShape_1');
  _emscripten_bind_PxRigidBody_detachShape_1 = Module['_emscripten_bind_PxRigidBody_detachShape_1'] = createExportWrapper('emscripten_bind_PxRigidBody_detachShape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_detachShape_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_detachShape_2');
  _emscripten_bind_PxRigidBody_detachShape_2 = Module['_emscripten_bind_PxRigidBody_detachShape_2'] = createExportWrapper('emscripten_bind_PxRigidBody_detachShape_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getNbShapes_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getNbShapes_0');
  _emscripten_bind_PxRigidBody_getNbShapes_0 = Module['_emscripten_bind_PxRigidBody_getNbShapes_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getNbShapes_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getShapes_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getShapes_3');
  _emscripten_bind_PxRigidBody_getShapes_3 = Module['_emscripten_bind_PxRigidBody_getShapes_3'] = createExportWrapper('emscripten_bind_PxRigidBody_getShapes_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_getNbConstraints_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_getNbConstraints_0');
  _emscripten_bind_PxRigidBody_getNbConstraints_0 = Module['_emscripten_bind_PxRigidBody_getNbConstraints_0'] = createExportWrapper('emscripten_bind_PxRigidBody_getNbConstraints_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_get_userData_0');
  _emscripten_bind_PxRigidBody_get_userData_0 = Module['_emscripten_bind_PxRigidBody_get_userData_0'] = createExportWrapper('emscripten_bind_PxRigidBody_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBody_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBody_set_userData_1');
  _emscripten_bind_PxRigidBody_set_userData_1 = Module['_emscripten_bind_PxRigidBody_set_userData_1'] = createExportWrapper('emscripten_bind_PxRigidBody_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_setSceneQueryUpdateMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_setSceneQueryUpdateMode_1');
  _emscripten_bind_PxSceneSQSystem_setSceneQueryUpdateMode_1 = Module['_emscripten_bind_PxSceneSQSystem_setSceneQueryUpdateMode_1'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_setSceneQueryUpdateMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_getSceneQueryUpdateMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_getSceneQueryUpdateMode_0');
  _emscripten_bind_PxSceneSQSystem_getSceneQueryUpdateMode_0 = Module['_emscripten_bind_PxSceneSQSystem_getSceneQueryUpdateMode_0'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_getSceneQueryUpdateMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_getSceneQueryStaticTimestamp_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_getSceneQueryStaticTimestamp_0');
  _emscripten_bind_PxSceneSQSystem_getSceneQueryStaticTimestamp_0 = Module['_emscripten_bind_PxSceneSQSystem_getSceneQueryStaticTimestamp_0'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_getSceneQueryStaticTimestamp_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_flushQueryUpdates_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_flushQueryUpdates_0');
  _emscripten_bind_PxSceneSQSystem_flushQueryUpdates_0 = Module['_emscripten_bind_PxSceneSQSystem_flushQueryUpdates_0'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_flushQueryUpdates_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_forceDynamicTreeRebuild_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_forceDynamicTreeRebuild_2');
  _emscripten_bind_PxSceneSQSystem_forceDynamicTreeRebuild_2 = Module['_emscripten_bind_PxSceneSQSystem_forceDynamicTreeRebuild_2'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_forceDynamicTreeRebuild_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_getStaticStructure_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_getStaticStructure_0');
  _emscripten_bind_PxSceneSQSystem_getStaticStructure_0 = Module['_emscripten_bind_PxSceneSQSystem_getStaticStructure_0'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_getStaticStructure_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_getDynamicStructure_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_getDynamicStructure_0');
  _emscripten_bind_PxSceneSQSystem_getDynamicStructure_0 = Module['_emscripten_bind_PxSceneSQSystem_getDynamicStructure_0'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_getDynamicStructure_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_0');
  _emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_0 = Module['_emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_0'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_1');
  _emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_1 = Module['_emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_1'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_2');
  _emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_2 = Module['_emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_2'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_checkQueries_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_checkQueries_0');
  _emscripten_bind_PxSceneSQSystem_checkQueries_0 = Module['_emscripten_bind_PxSceneSQSystem_checkQueries_0'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_checkQueries_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_checkQueries_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_checkQueries_1');
  _emscripten_bind_PxSceneSQSystem_checkQueries_1 = Module['_emscripten_bind_PxSceneSQSystem_checkQueries_1'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_checkQueries_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_fetchQueries_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_fetchQueries_0');
  _emscripten_bind_PxSceneSQSystem_fetchQueries_0 = Module['_emscripten_bind_PxSceneSQSystem_fetchQueries_0'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_fetchQueries_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_fetchQueries_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_fetchQueries_1');
  _emscripten_bind_PxSceneSQSystem_fetchQueries_1 = Module['_emscripten_bind_PxSceneSQSystem_fetchQueries_1'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_fetchQueries_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_setDynamicTreeRebuildRateHint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_setDynamicTreeRebuildRateHint_1');
  _emscripten_bind_PxSceneSQSystem_setDynamicTreeRebuildRateHint_1 = Module['_emscripten_bind_PxSceneSQSystem_setDynamicTreeRebuildRateHint_1'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_setDynamicTreeRebuildRateHint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_getDynamicTreeRebuildRateHint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_getDynamicTreeRebuildRateHint_0');
  _emscripten_bind_PxSceneSQSystem_getDynamicTreeRebuildRateHint_0 = Module['_emscripten_bind_PxSceneSQSystem_getDynamicTreeRebuildRateHint_0'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_getDynamicTreeRebuildRateHint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_forceRebuildDynamicTree_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_forceRebuildDynamicTree_1');
  _emscripten_bind_PxSceneSQSystem_forceRebuildDynamicTree_1 = Module['_emscripten_bind_PxSceneSQSystem_forceRebuildDynamicTree_1'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_forceRebuildDynamicTree_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_setUpdateMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_setUpdateMode_1');
  _emscripten_bind_PxSceneSQSystem_setUpdateMode_1 = Module['_emscripten_bind_PxSceneSQSystem_setUpdateMode_1'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_setUpdateMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_getUpdateMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_getUpdateMode_0');
  _emscripten_bind_PxSceneSQSystem_getUpdateMode_0 = Module['_emscripten_bind_PxSceneSQSystem_getUpdateMode_0'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_getUpdateMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_getStaticTimestamp_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_getStaticTimestamp_0');
  _emscripten_bind_PxSceneSQSystem_getStaticTimestamp_0 = Module['_emscripten_bind_PxSceneSQSystem_getStaticTimestamp_0'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_getStaticTimestamp_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_flushUpdates_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_flushUpdates_0');
  _emscripten_bind_PxSceneSQSystem_flushUpdates_0 = Module['_emscripten_bind_PxSceneSQSystem_flushUpdates_0'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_flushUpdates_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_raycast_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_raycast_4');
  _emscripten_bind_PxSceneSQSystem_raycast_4 = Module['_emscripten_bind_PxSceneSQSystem_raycast_4'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_raycast_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_raycast_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_raycast_5');
  _emscripten_bind_PxSceneSQSystem_raycast_5 = Module['_emscripten_bind_PxSceneSQSystem_raycast_5'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_raycast_5', 6);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_raycast_6'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_raycast_6');
  _emscripten_bind_PxSceneSQSystem_raycast_6 = Module['_emscripten_bind_PxSceneSQSystem_raycast_6'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_raycast_6', 7);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_sweep_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_sweep_5');
  _emscripten_bind_PxSceneSQSystem_sweep_5 = Module['_emscripten_bind_PxSceneSQSystem_sweep_5'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_sweep_5', 6);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_sweep_6'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_sweep_6');
  _emscripten_bind_PxSceneSQSystem_sweep_6 = Module['_emscripten_bind_PxSceneSQSystem_sweep_6'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_sweep_6', 7);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_sweep_7'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_sweep_7');
  _emscripten_bind_PxSceneSQSystem_sweep_7 = Module['_emscripten_bind_PxSceneSQSystem_sweep_7'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_sweep_7', 8);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_overlap_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_overlap_3');
  _emscripten_bind_PxSceneSQSystem_overlap_3 = Module['_emscripten_bind_PxSceneSQSystem_overlap_3'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_overlap_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxSceneSQSystem_overlap_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneSQSystem_overlap_4');
  _emscripten_bind_PxSceneSQSystem_overlap_4 = Module['_emscripten_bind_PxSceneSQSystem_overlap_4'] = createExportWrapper('emscripten_bind_PxSceneSQSystem_overlap_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxSimpleTriangleMesh_PxSimpleTriangleMesh_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimpleTriangleMesh_PxSimpleTriangleMesh_0');
  _emscripten_bind_PxSimpleTriangleMesh_PxSimpleTriangleMesh_0 = Module['_emscripten_bind_PxSimpleTriangleMesh_PxSimpleTriangleMesh_0'] = createExportWrapper('emscripten_bind_PxSimpleTriangleMesh_PxSimpleTriangleMesh_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxSimpleTriangleMesh_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimpleTriangleMesh_setToDefault_0');
  _emscripten_bind_PxSimpleTriangleMesh_setToDefault_0 = Module['_emscripten_bind_PxSimpleTriangleMesh_setToDefault_0'] = createExportWrapper('emscripten_bind_PxSimpleTriangleMesh_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimpleTriangleMesh_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimpleTriangleMesh_isValid_0');
  _emscripten_bind_PxSimpleTriangleMesh_isValid_0 = Module['_emscripten_bind_PxSimpleTriangleMesh_isValid_0'] = createExportWrapper('emscripten_bind_PxSimpleTriangleMesh_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimpleTriangleMesh_get_points_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimpleTriangleMesh_get_points_0');
  _emscripten_bind_PxSimpleTriangleMesh_get_points_0 = Module['_emscripten_bind_PxSimpleTriangleMesh_get_points_0'] = createExportWrapper('emscripten_bind_PxSimpleTriangleMesh_get_points_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimpleTriangleMesh_set_points_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimpleTriangleMesh_set_points_1');
  _emscripten_bind_PxSimpleTriangleMesh_set_points_1 = Module['_emscripten_bind_PxSimpleTriangleMesh_set_points_1'] = createExportWrapper('emscripten_bind_PxSimpleTriangleMesh_set_points_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimpleTriangleMesh_get_triangles_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimpleTriangleMesh_get_triangles_0');
  _emscripten_bind_PxSimpleTriangleMesh_get_triangles_0 = Module['_emscripten_bind_PxSimpleTriangleMesh_get_triangles_0'] = createExportWrapper('emscripten_bind_PxSimpleTriangleMesh_get_triangles_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimpleTriangleMesh_set_triangles_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimpleTriangleMesh_set_triangles_1');
  _emscripten_bind_PxSimpleTriangleMesh_set_triangles_1 = Module['_emscripten_bind_PxSimpleTriangleMesh_set_triangles_1'] = createExportWrapper('emscripten_bind_PxSimpleTriangleMesh_set_triangles_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimpleTriangleMesh_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimpleTriangleMesh_get_flags_0');
  _emscripten_bind_PxSimpleTriangleMesh_get_flags_0 = Module['_emscripten_bind_PxSimpleTriangleMesh_get_flags_0'] = createExportWrapper('emscripten_bind_PxSimpleTriangleMesh_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimpleTriangleMesh_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimpleTriangleMesh_set_flags_1');
  _emscripten_bind_PxSimpleTriangleMesh_set_flags_1 = Module['_emscripten_bind_PxSimpleTriangleMesh_set_flags_1'] = createExportWrapper('emscripten_bind_PxSimpleTriangleMesh_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimpleTriangleMesh___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimpleTriangleMesh___destroy___0');
  _emscripten_bind_PxSimpleTriangleMesh___destroy___0 = Module['_emscripten_bind_PxSimpleTriangleMesh___destroy___0'] = createExportWrapper('emscripten_bind_PxSimpleTriangleMesh___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSpring_PxSpring_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpring_PxSpring_2');
  _emscripten_bind_PxSpring_PxSpring_2 = Module['_emscripten_bind_PxSpring_PxSpring_2'] = createExportWrapper('emscripten_bind_PxSpring_PxSpring_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxSpring_get_stiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpring_get_stiffness_0');
  _emscripten_bind_PxSpring_get_stiffness_0 = Module['_emscripten_bind_PxSpring_get_stiffness_0'] = createExportWrapper('emscripten_bind_PxSpring_get_stiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSpring_set_stiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpring_set_stiffness_1');
  _emscripten_bind_PxSpring_set_stiffness_1 = Module['_emscripten_bind_PxSpring_set_stiffness_1'] = createExportWrapper('emscripten_bind_PxSpring_set_stiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSpring_get_damping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpring_get_damping_0');
  _emscripten_bind_PxSpring_get_damping_0 = Module['_emscripten_bind_PxSpring_get_damping_0'] = createExportWrapper('emscripten_bind_PxSpring_get_damping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSpring_set_damping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpring_set_damping_1');
  _emscripten_bind_PxSpring_set_damping_1 = Module['_emscripten_bind_PxSpring_set_damping_1'] = createExportWrapper('emscripten_bind_PxSpring_set_damping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSpring___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpring___destroy___0');
  _emscripten_bind_PxSpring___destroy___0 = Module['_emscripten_bind_PxSpring___destroy___0'] = createExportWrapper('emscripten_bind_PxSpring___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxStridedData_get_stride_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxStridedData_get_stride_0');
  _emscripten_bind_PxStridedData_get_stride_0 = Module['_emscripten_bind_PxStridedData_get_stride_0'] = createExportWrapper('emscripten_bind_PxStridedData_get_stride_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxStridedData_set_stride_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxStridedData_set_stride_1');
  _emscripten_bind_PxStridedData_set_stride_1 = Module['_emscripten_bind_PxStridedData_set_stride_1'] = createExportWrapper('emscripten_bind_PxStridedData_set_stride_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxStridedData_get_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxStridedData_get_data_0');
  _emscripten_bind_PxStridedData_get_data_0 = Module['_emscripten_bind_PxStridedData_get_data_0'] = createExportWrapper('emscripten_bind_PxStridedData_get_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxStridedData_set_data_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxStridedData_set_data_1');
  _emscripten_bind_PxStridedData_set_data_1 = Module['_emscripten_bind_PxStridedData_set_data_1'] = createExportWrapper('emscripten_bind_PxStridedData_set_data_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxStridedData___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxStridedData___destroy___0');
  _emscripten_bind_PxStridedData___destroy___0 = Module['_emscripten_bind_PxStridedData___destroy___0'] = createExportWrapper('emscripten_bind_PxStridedData___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepCallback_hasAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepCallback_hasAnyHits_0');
  _emscripten_bind_PxSweepCallback_hasAnyHits_0 = Module['_emscripten_bind_PxSweepCallback_hasAnyHits_0'] = createExportWrapper('emscripten_bind_PxSweepCallback_hasAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepCallback___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepCallback___destroy___0');
  _emscripten_bind_PxSweepCallback___destroy___0 = Module['_emscripten_bind_PxSweepCallback___destroy___0'] = createExportWrapper('emscripten_bind_PxSweepCallback___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxU16ConstPtr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxU16ConstPtr___destroy___0');
  _emscripten_bind_PxU16ConstPtr___destroy___0 = Module['_emscripten_bind_PxU16ConstPtr___destroy___0'] = createExportWrapper('emscripten_bind_PxU16ConstPtr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxU32ConstPtr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxU32ConstPtr___destroy___0');
  _emscripten_bind_PxU32ConstPtr___destroy___0 = Module['_emscripten_bind_PxU32ConstPtr___destroy___0'] = createExportWrapper('emscripten_bind_PxU32ConstPtr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxU8ConstPtr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxU8ConstPtr___destroy___0');
  _emscripten_bind_PxU8ConstPtr___destroy___0 = Module['_emscripten_bind_PxU8ConstPtr___destroy___0'] = createExportWrapper('emscripten_bind_PxU8ConstPtr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxUserControllerHitReport_onShapeHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxUserControllerHitReport_onShapeHit_1');
  _emscripten_bind_PxUserControllerHitReport_onShapeHit_1 = Module['_emscripten_bind_PxUserControllerHitReport_onShapeHit_1'] = createExportWrapper('emscripten_bind_PxUserControllerHitReport_onShapeHit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxUserControllerHitReport_onControllerHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxUserControllerHitReport_onControllerHit_1');
  _emscripten_bind_PxUserControllerHitReport_onControllerHit_1 = Module['_emscripten_bind_PxUserControllerHitReport_onControllerHit_1'] = createExportWrapper('emscripten_bind_PxUserControllerHitReport_onControllerHit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxUserControllerHitReport_onObstacleHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxUserControllerHitReport_onObstacleHit_1');
  _emscripten_bind_PxUserControllerHitReport_onObstacleHit_1 = Module['_emscripten_bind_PxUserControllerHitReport_onObstacleHit_1'] = createExportWrapper('emscripten_bind_PxUserControllerHitReport_onObstacleHit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandResponseParams_PxVehicleCommandResponseParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandResponseParams_PxVehicleCommandResponseParams_0');
  _emscripten_bind_PxVehicleCommandResponseParams_PxVehicleCommandResponseParams_0 = Module['_emscripten_bind_PxVehicleCommandResponseParams_PxVehicleCommandResponseParams_0'] = createExportWrapper('emscripten_bind_PxVehicleCommandResponseParams_PxVehicleCommandResponseParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandResponseParams_get_nonlinearResponse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandResponseParams_get_nonlinearResponse_0');
  _emscripten_bind_PxVehicleCommandResponseParams_get_nonlinearResponse_0 = Module['_emscripten_bind_PxVehicleCommandResponseParams_get_nonlinearResponse_0'] = createExportWrapper('emscripten_bind_PxVehicleCommandResponseParams_get_nonlinearResponse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandResponseParams_set_nonlinearResponse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandResponseParams_set_nonlinearResponse_1');
  _emscripten_bind_PxVehicleCommandResponseParams_set_nonlinearResponse_1 = Module['_emscripten_bind_PxVehicleCommandResponseParams_set_nonlinearResponse_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandResponseParams_set_nonlinearResponse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandResponseParams_get_wheelResponseMultipliers_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandResponseParams_get_wheelResponseMultipliers_1');
  _emscripten_bind_PxVehicleCommandResponseParams_get_wheelResponseMultipliers_1 = Module['_emscripten_bind_PxVehicleCommandResponseParams_get_wheelResponseMultipliers_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandResponseParams_get_wheelResponseMultipliers_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandResponseParams_set_wheelResponseMultipliers_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandResponseParams_set_wheelResponseMultipliers_2');
  _emscripten_bind_PxVehicleCommandResponseParams_set_wheelResponseMultipliers_2 = Module['_emscripten_bind_PxVehicleCommandResponseParams_set_wheelResponseMultipliers_2'] = createExportWrapper('emscripten_bind_PxVehicleCommandResponseParams_set_wheelResponseMultipliers_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandResponseParams_get_maxResponse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandResponseParams_get_maxResponse_0');
  _emscripten_bind_PxVehicleCommandResponseParams_get_maxResponse_0 = Module['_emscripten_bind_PxVehicleCommandResponseParams_get_maxResponse_0'] = createExportWrapper('emscripten_bind_PxVehicleCommandResponseParams_get_maxResponse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandResponseParams_set_maxResponse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandResponseParams_set_maxResponse_1');
  _emscripten_bind_PxVehicleCommandResponseParams_set_maxResponse_1 = Module['_emscripten_bind_PxVehicleCommandResponseParams_set_maxResponse_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandResponseParams_set_maxResponse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandResponseParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandResponseParams___destroy___0');
  _emscripten_bind_PxVehicleCommandResponseParams___destroy___0 = Module['_emscripten_bind_PxVehicleCommandResponseParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleCommandResponseParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_PxVehicleEngineDriveTransmissionCommandState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_PxVehicleEngineDriveTransmissionCommandState_0');
  _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_PxVehicleEngineDriveTransmissionCommandState_0 = Module['_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_PxVehicleEngineDriveTransmissionCommandState_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_PxVehicleEngineDriveTransmissionCommandState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_setToDefault_0');
  _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_setToDefault_0 = Module['_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_clutch_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_clutch_0');
  _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_clutch_0 = Module['_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_clutch_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_clutch_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_clutch_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_clutch_1');
  _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_clutch_1 = Module['_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_clutch_1'] = createExportWrapper('emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_clutch_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_targetGear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_targetGear_0');
  _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_targetGear_0 = Module['_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_targetGear_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_targetGear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_targetGear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_targetGear_1');
  _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_targetGear_1 = Module['_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_targetGear_1'] = createExportWrapper('emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_targetGear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineDriveTransmissionCommandState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineDriveTransmissionCommandState___destroy___0');
  _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState___destroy___0 = Module['_emscripten_bind_PxVehicleEngineDriveTransmissionCommandState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleEngineDriveTransmissionCommandState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_PxVehicleMultiWheelDriveDifferentialParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_PxVehicleMultiWheelDriveDifferentialParams_0');
  _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_PxVehicleMultiWheelDriveDifferentialParams_0 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_PxVehicleMultiWheelDriveDifferentialParams_0'] = createExportWrapper('emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_PxVehicleMultiWheelDriveDifferentialParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_setToDefault_0');
  _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_setToDefault_0 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_transformAndScale_4');
  _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_isValid_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_isValid_1');
  _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_isValid_1 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_isValid_1'] = createExportWrapper('emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_isValid_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_torqueRatios_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_torqueRatios_1');
  _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_torqueRatios_1 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_torqueRatios_1'] = createExportWrapper('emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_torqueRatios_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_torqueRatios_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_torqueRatios_2');
  _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_torqueRatios_2 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_torqueRatios_2'] = createExportWrapper('emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_torqueRatios_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1');
  _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1'] = createExportWrapper('emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2');
  _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2'] = createExportWrapper('emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams___destroy___0');
  _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams___destroy___0 = Module['_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_PxVehicleSimulationContext_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_PxVehicleSimulationContext_0');
  _emscripten_bind_PxVehicleSimulationContext_PxVehicleSimulationContext_0 = Module['_emscripten_bind_PxVehicleSimulationContext_PxVehicleSimulationContext_0'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_PxVehicleSimulationContext_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_getType_0');
  _emscripten_bind_PxVehicleSimulationContext_getType_0 = Module['_emscripten_bind_PxVehicleSimulationContext_getType_0'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_setToDefault_0');
  _emscripten_bind_PxVehicleSimulationContext_setToDefault_0 = Module['_emscripten_bind_PxVehicleSimulationContext_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_transformAndScale_4');
  _emscripten_bind_PxVehicleSimulationContext_transformAndScale_4 = Module['_emscripten_bind_PxVehicleSimulationContext_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_get_gravity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_get_gravity_0');
  _emscripten_bind_PxVehicleSimulationContext_get_gravity_0 = Module['_emscripten_bind_PxVehicleSimulationContext_get_gravity_0'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_get_gravity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_set_gravity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_set_gravity_1');
  _emscripten_bind_PxVehicleSimulationContext_set_gravity_1 = Module['_emscripten_bind_PxVehicleSimulationContext_set_gravity_1'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_set_gravity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_get_frame_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_get_frame_0');
  _emscripten_bind_PxVehicleSimulationContext_get_frame_0 = Module['_emscripten_bind_PxVehicleSimulationContext_get_frame_0'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_get_frame_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_set_frame_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_set_frame_1');
  _emscripten_bind_PxVehicleSimulationContext_set_frame_1 = Module['_emscripten_bind_PxVehicleSimulationContext_set_frame_1'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_set_frame_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_get_scale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_get_scale_0');
  _emscripten_bind_PxVehicleSimulationContext_get_scale_0 = Module['_emscripten_bind_PxVehicleSimulationContext_get_scale_0'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_get_scale_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_set_scale_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_set_scale_1');
  _emscripten_bind_PxVehicleSimulationContext_set_scale_1 = Module['_emscripten_bind_PxVehicleSimulationContext_set_scale_1'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_set_scale_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_get_tireSlipParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_get_tireSlipParams_0');
  _emscripten_bind_PxVehicleSimulationContext_get_tireSlipParams_0 = Module['_emscripten_bind_PxVehicleSimulationContext_get_tireSlipParams_0'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_get_tireSlipParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_set_tireSlipParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_set_tireSlipParams_1');
  _emscripten_bind_PxVehicleSimulationContext_set_tireSlipParams_1 = Module['_emscripten_bind_PxVehicleSimulationContext_set_tireSlipParams_1'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_set_tireSlipParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_get_tireStickyParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_get_tireStickyParams_0');
  _emscripten_bind_PxVehicleSimulationContext_get_tireStickyParams_0 = Module['_emscripten_bind_PxVehicleSimulationContext_get_tireStickyParams_0'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_get_tireStickyParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_set_tireStickyParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_set_tireStickyParams_1');
  _emscripten_bind_PxVehicleSimulationContext_set_tireStickyParams_1 = Module['_emscripten_bind_PxVehicleSimulationContext_set_tireStickyParams_1'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_set_tireStickyParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0');
  _emscripten_bind_PxVehicleSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0 = Module['_emscripten_bind_PxVehicleSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1');
  _emscripten_bind_PxVehicleSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1 = Module['_emscripten_bind_PxVehicleSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_get_pvdContext_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_get_pvdContext_0');
  _emscripten_bind_PxVehicleSimulationContext_get_pvdContext_0 = Module['_emscripten_bind_PxVehicleSimulationContext_get_pvdContext_0'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_get_pvdContext_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext_set_pvdContext_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext_set_pvdContext_1');
  _emscripten_bind_PxVehicleSimulationContext_set_pvdContext_1 = Module['_emscripten_bind_PxVehicleSimulationContext_set_pvdContext_1'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext_set_pvdContext_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSimulationContext___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSimulationContext___destroy___0');
  _emscripten_bind_PxVehicleSimulationContext___destroy___0 = Module['_emscripten_bind_PxVehicleSimulationContext___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleSimulationContext___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_SimpleControllerBehaviorCallback_getShapeBehaviorFlags_2'] != 'undefined', 'missing Wasm export: emscripten_bind_SimpleControllerBehaviorCallback_getShapeBehaviorFlags_2');
  _emscripten_bind_SimpleControllerBehaviorCallback_getShapeBehaviorFlags_2 = Module['_emscripten_bind_SimpleControllerBehaviorCallback_getShapeBehaviorFlags_2'] = createExportWrapper('emscripten_bind_SimpleControllerBehaviorCallback_getShapeBehaviorFlags_2', 3);
  assert(typeof wasmExports['emscripten_bind_SimpleControllerBehaviorCallback_getControllerBehaviorFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_SimpleControllerBehaviorCallback_getControllerBehaviorFlags_1');
  _emscripten_bind_SimpleControllerBehaviorCallback_getControllerBehaviorFlags_1 = Module['_emscripten_bind_SimpleControllerBehaviorCallback_getControllerBehaviorFlags_1'] = createExportWrapper('emscripten_bind_SimpleControllerBehaviorCallback_getControllerBehaviorFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_SimpleControllerBehaviorCallback_getObstacleBehaviorFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_SimpleControllerBehaviorCallback_getObstacleBehaviorFlags_1');
  _emscripten_bind_SimpleControllerBehaviorCallback_getObstacleBehaviorFlags_1 = Module['_emscripten_bind_SimpleControllerBehaviorCallback_getObstacleBehaviorFlags_1'] = createExportWrapper('emscripten_bind_SimpleControllerBehaviorCallback_getObstacleBehaviorFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_SimpleControllerBehaviorCallback___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimpleControllerBehaviorCallback___destroy___0');
  _emscripten_bind_SimpleControllerBehaviorCallback___destroy___0 = Module['_emscripten_bind_SimpleControllerBehaviorCallback___destroy___0'] = createExportWrapper('emscripten_bind_SimpleControllerBehaviorCallback___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_SimplePvdTransport_send_2'] != 'undefined', 'missing Wasm export: emscripten_bind_SimplePvdTransport_send_2');
  _emscripten_bind_SimplePvdTransport_send_2 = Module['_emscripten_bind_SimplePvdTransport_send_2'] = createExportWrapper('emscripten_bind_SimplePvdTransport_send_2', 3);
  assert(typeof wasmExports['emscripten_bind_SimplePvdTransport_connect_0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimplePvdTransport_connect_0');
  _emscripten_bind_SimplePvdTransport_connect_0 = Module['_emscripten_bind_SimplePvdTransport_connect_0'] = createExportWrapper('emscripten_bind_SimplePvdTransport_connect_0', 1);
  assert(typeof wasmExports['emscripten_bind_SimplePvdTransport_isConnected_0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimplePvdTransport_isConnected_0');
  _emscripten_bind_SimplePvdTransport_isConnected_0 = Module['_emscripten_bind_SimplePvdTransport_isConnected_0'] = createExportWrapper('emscripten_bind_SimplePvdTransport_isConnected_0', 1);
  assert(typeof wasmExports['emscripten_bind_SimplePvdTransport_disconnect_0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimplePvdTransport_disconnect_0');
  _emscripten_bind_SimplePvdTransport_disconnect_0 = Module['_emscripten_bind_SimplePvdTransport_disconnect_0'] = createExportWrapper('emscripten_bind_SimplePvdTransport_disconnect_0', 1);
  assert(typeof wasmExports['emscripten_bind_SimplePvdTransport_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimplePvdTransport_release_0');
  _emscripten_bind_SimplePvdTransport_release_0 = Module['_emscripten_bind_SimplePvdTransport_release_0'] = createExportWrapper('emscripten_bind_SimplePvdTransport_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_SimplePvdTransport_flush_0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimplePvdTransport_flush_0');
  _emscripten_bind_SimplePvdTransport_flush_0 = Module['_emscripten_bind_SimplePvdTransport_flush_0'] = createExportWrapper('emscripten_bind_SimplePvdTransport_flush_0', 1);
  assert(typeof wasmExports['emscripten_bind_SimplePvdTransport___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimplePvdTransport___destroy___0');
  _emscripten_bind_SimplePvdTransport___destroy___0 = Module['_emscripten_bind_SimplePvdTransport___destroy___0'] = createExportWrapper('emscripten_bind_SimplePvdTransport___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_SimpleQueryFilterCallback_simplePreFilter_4'] != 'undefined', 'missing Wasm export: emscripten_bind_SimpleQueryFilterCallback_simplePreFilter_4');
  _emscripten_bind_SimpleQueryFilterCallback_simplePreFilter_4 = Module['_emscripten_bind_SimpleQueryFilterCallback_simplePreFilter_4'] = createExportWrapper('emscripten_bind_SimpleQueryFilterCallback_simplePreFilter_4', 5);
  assert(typeof wasmExports['emscripten_bind_SimpleQueryFilterCallback_simplePostFilter_4'] != 'undefined', 'missing Wasm export: emscripten_bind_SimpleQueryFilterCallback_simplePostFilter_4');
  _emscripten_bind_SimpleQueryFilterCallback_simplePostFilter_4 = Module['_emscripten_bind_SimpleQueryFilterCallback_simplePostFilter_4'] = createExportWrapper('emscripten_bind_SimpleQueryFilterCallback_simplePostFilter_4', 5);
  assert(typeof wasmExports['emscripten_bind_SimpleQueryFilterCallback___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimpleQueryFilterCallback___destroy___0');
  _emscripten_bind_SimpleQueryFilterCallback___destroy___0 = Module['_emscripten_bind_SimpleQueryFilterCallback___destroy___0'] = createExportWrapper('emscripten_bind_SimpleQueryFilterCallback___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_SimpleSimulationEventCallback_onConstraintBreak_2'] != 'undefined', 'missing Wasm export: emscripten_bind_SimpleSimulationEventCallback_onConstraintBreak_2');
  _emscripten_bind_SimpleSimulationEventCallback_onConstraintBreak_2 = Module['_emscripten_bind_SimpleSimulationEventCallback_onConstraintBreak_2'] = createExportWrapper('emscripten_bind_SimpleSimulationEventCallback_onConstraintBreak_2', 3);
  assert(typeof wasmExports['emscripten_bind_SimpleSimulationEventCallback_onWake_2'] != 'undefined', 'missing Wasm export: emscripten_bind_SimpleSimulationEventCallback_onWake_2');
  _emscripten_bind_SimpleSimulationEventCallback_onWake_2 = Module['_emscripten_bind_SimpleSimulationEventCallback_onWake_2'] = createExportWrapper('emscripten_bind_SimpleSimulationEventCallback_onWake_2', 3);
  assert(typeof wasmExports['emscripten_bind_SimpleSimulationEventCallback_onSleep_2'] != 'undefined', 'missing Wasm export: emscripten_bind_SimpleSimulationEventCallback_onSleep_2');
  _emscripten_bind_SimpleSimulationEventCallback_onSleep_2 = Module['_emscripten_bind_SimpleSimulationEventCallback_onSleep_2'] = createExportWrapper('emscripten_bind_SimpleSimulationEventCallback_onSleep_2', 3);
  assert(typeof wasmExports['emscripten_bind_SimpleSimulationEventCallback_onContact_3'] != 'undefined', 'missing Wasm export: emscripten_bind_SimpleSimulationEventCallback_onContact_3');
  _emscripten_bind_SimpleSimulationEventCallback_onContact_3 = Module['_emscripten_bind_SimpleSimulationEventCallback_onContact_3'] = createExportWrapper('emscripten_bind_SimpleSimulationEventCallback_onContact_3', 4);
  assert(typeof wasmExports['emscripten_bind_SimpleSimulationEventCallback_onTrigger_2'] != 'undefined', 'missing Wasm export: emscripten_bind_SimpleSimulationEventCallback_onTrigger_2');
  _emscripten_bind_SimpleSimulationEventCallback_onTrigger_2 = Module['_emscripten_bind_SimpleSimulationEventCallback_onTrigger_2'] = createExportWrapper('emscripten_bind_SimpleSimulationEventCallback_onTrigger_2', 3);
  assert(typeof wasmExports['emscripten_bind_SimpleSimulationEventCallback___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimpleSimulationEventCallback___destroy___0');
  _emscripten_bind_SimpleSimulationEventCallback___destroy___0 = Module['_emscripten_bind_SimpleSimulationEventCallback___destroy___0'] = createExportWrapper('emscripten_bind_SimpleSimulationEventCallback___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_VoidPtr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_VoidPtr___destroy___0');
  _emscripten_bind_VoidPtr___destroy___0 = Module['_emscripten_bind_VoidPtr___destroy___0'] = createExportWrapper('emscripten_bind_VoidPtr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_BaseVehicleParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_BaseVehicleParams_0');
  _emscripten_bind_BaseVehicleParams_BaseVehicleParams_0 = Module['_emscripten_bind_BaseVehicleParams_BaseVehicleParams_0'] = createExportWrapper('emscripten_bind_BaseVehicleParams_BaseVehicleParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_transformAndScale_4');
  _emscripten_bind_BaseVehicleParams_transformAndScale_4 = Module['_emscripten_bind_BaseVehicleParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_BaseVehicleParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_isValid_0');
  _emscripten_bind_BaseVehicleParams_isValid_0 = Module['_emscripten_bind_BaseVehicleParams_isValid_0'] = createExportWrapper('emscripten_bind_BaseVehicleParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_axleDescription_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_axleDescription_0');
  _emscripten_bind_BaseVehicleParams_get_axleDescription_0 = Module['_emscripten_bind_BaseVehicleParams_get_axleDescription_0'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_axleDescription_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_axleDescription_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_axleDescription_1');
  _emscripten_bind_BaseVehicleParams_set_axleDescription_1 = Module['_emscripten_bind_BaseVehicleParams_set_axleDescription_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_axleDescription_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_frame_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_frame_0');
  _emscripten_bind_BaseVehicleParams_get_frame_0 = Module['_emscripten_bind_BaseVehicleParams_get_frame_0'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_frame_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_frame_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_frame_1');
  _emscripten_bind_BaseVehicleParams_set_frame_1 = Module['_emscripten_bind_BaseVehicleParams_set_frame_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_frame_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_scale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_scale_0');
  _emscripten_bind_BaseVehicleParams_get_scale_0 = Module['_emscripten_bind_BaseVehicleParams_get_scale_0'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_scale_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_scale_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_scale_1');
  _emscripten_bind_BaseVehicleParams_set_scale_1 = Module['_emscripten_bind_BaseVehicleParams_set_scale_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_scale_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_suspensionStateCalculationParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_suspensionStateCalculationParams_0');
  _emscripten_bind_BaseVehicleParams_get_suspensionStateCalculationParams_0 = Module['_emscripten_bind_BaseVehicleParams_get_suspensionStateCalculationParams_0'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_suspensionStateCalculationParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_suspensionStateCalculationParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_suspensionStateCalculationParams_1');
  _emscripten_bind_BaseVehicleParams_set_suspensionStateCalculationParams_1 = Module['_emscripten_bind_BaseVehicleParams_set_suspensionStateCalculationParams_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_suspensionStateCalculationParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_brakeResponseParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_brakeResponseParams_1');
  _emscripten_bind_BaseVehicleParams_get_brakeResponseParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_brakeResponseParams_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_brakeResponseParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_brakeResponseParams_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_brakeResponseParams_2');
  _emscripten_bind_BaseVehicleParams_set_brakeResponseParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_brakeResponseParams_2'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_brakeResponseParams_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_steerResponseParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_steerResponseParams_0');
  _emscripten_bind_BaseVehicleParams_get_steerResponseParams_0 = Module['_emscripten_bind_BaseVehicleParams_get_steerResponseParams_0'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_steerResponseParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_steerResponseParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_steerResponseParams_1');
  _emscripten_bind_BaseVehicleParams_set_steerResponseParams_1 = Module['_emscripten_bind_BaseVehicleParams_set_steerResponseParams_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_steerResponseParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_ackermannParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_ackermannParams_1');
  _emscripten_bind_BaseVehicleParams_get_ackermannParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_ackermannParams_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_ackermannParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_ackermannParams_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_ackermannParams_2');
  _emscripten_bind_BaseVehicleParams_set_ackermannParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_ackermannParams_2'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_ackermannParams_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_suspensionParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_suspensionParams_1');
  _emscripten_bind_BaseVehicleParams_get_suspensionParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_suspensionParams_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_suspensionParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_suspensionParams_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_suspensionParams_2');
  _emscripten_bind_BaseVehicleParams_set_suspensionParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_suspensionParams_2'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_suspensionParams_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_suspensionComplianceParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_suspensionComplianceParams_1');
  _emscripten_bind_BaseVehicleParams_get_suspensionComplianceParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_suspensionComplianceParams_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_suspensionComplianceParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_suspensionComplianceParams_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_suspensionComplianceParams_2');
  _emscripten_bind_BaseVehicleParams_set_suspensionComplianceParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_suspensionComplianceParams_2'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_suspensionComplianceParams_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_suspensionForceParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_suspensionForceParams_1');
  _emscripten_bind_BaseVehicleParams_get_suspensionForceParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_suspensionForceParams_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_suspensionForceParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_suspensionForceParams_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_suspensionForceParams_2');
  _emscripten_bind_BaseVehicleParams_set_suspensionForceParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_suspensionForceParams_2'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_suspensionForceParams_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_antiRollForceParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_antiRollForceParams_1');
  _emscripten_bind_BaseVehicleParams_get_antiRollForceParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_antiRollForceParams_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_antiRollForceParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_antiRollForceParams_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_antiRollForceParams_2');
  _emscripten_bind_BaseVehicleParams_set_antiRollForceParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_antiRollForceParams_2'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_antiRollForceParams_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_nbAntiRollForceParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_nbAntiRollForceParams_0');
  _emscripten_bind_BaseVehicleParams_get_nbAntiRollForceParams_0 = Module['_emscripten_bind_BaseVehicleParams_get_nbAntiRollForceParams_0'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_nbAntiRollForceParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_nbAntiRollForceParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_nbAntiRollForceParams_1');
  _emscripten_bind_BaseVehicleParams_set_nbAntiRollForceParams_1 = Module['_emscripten_bind_BaseVehicleParams_set_nbAntiRollForceParams_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_nbAntiRollForceParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_tireForceParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_tireForceParams_1');
  _emscripten_bind_BaseVehicleParams_get_tireForceParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_tireForceParams_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_tireForceParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_tireForceParams_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_tireForceParams_2');
  _emscripten_bind_BaseVehicleParams_set_tireForceParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_tireForceParams_2'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_tireForceParams_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_wheelParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_wheelParams_1');
  _emscripten_bind_BaseVehicleParams_get_wheelParams_1 = Module['_emscripten_bind_BaseVehicleParams_get_wheelParams_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_wheelParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_wheelParams_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_wheelParams_2');
  _emscripten_bind_BaseVehicleParams_set_wheelParams_2 = Module['_emscripten_bind_BaseVehicleParams_set_wheelParams_2'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_wheelParams_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_get_rigidBodyParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_get_rigidBodyParams_0');
  _emscripten_bind_BaseVehicleParams_get_rigidBodyParams_0 = Module['_emscripten_bind_BaseVehicleParams_get_rigidBodyParams_0'] = createExportWrapper('emscripten_bind_BaseVehicleParams_get_rigidBodyParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams_set_rigidBodyParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams_set_rigidBodyParams_1');
  _emscripten_bind_BaseVehicleParams_set_rigidBodyParams_1 = Module['_emscripten_bind_BaseVehicleParams_set_rigidBodyParams_1'] = createExportWrapper('emscripten_bind_BaseVehicleParams_set_rigidBodyParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleParams___destroy___0');
  _emscripten_bind_BaseVehicleParams___destroy___0 = Module['_emscripten_bind_BaseVehicleParams___destroy___0'] = createExportWrapper('emscripten_bind_BaseVehicleParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_BaseVehicleState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_BaseVehicleState_0');
  _emscripten_bind_BaseVehicleState_BaseVehicleState_0 = Module['_emscripten_bind_BaseVehicleState_BaseVehicleState_0'] = createExportWrapper('emscripten_bind_BaseVehicleState_BaseVehicleState_0', 0);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_setToDefault_0');
  _emscripten_bind_BaseVehicleState_setToDefault_0 = Module['_emscripten_bind_BaseVehicleState_setToDefault_0'] = createExportWrapper('emscripten_bind_BaseVehicleState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_brakeCommandResponseStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_brakeCommandResponseStates_1');
  _emscripten_bind_BaseVehicleState_get_brakeCommandResponseStates_1 = Module['_emscripten_bind_BaseVehicleState_get_brakeCommandResponseStates_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_brakeCommandResponseStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_brakeCommandResponseStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_brakeCommandResponseStates_2');
  _emscripten_bind_BaseVehicleState_set_brakeCommandResponseStates_2 = Module['_emscripten_bind_BaseVehicleState_set_brakeCommandResponseStates_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_brakeCommandResponseStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_steerCommandResponseStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_steerCommandResponseStates_1');
  _emscripten_bind_BaseVehicleState_get_steerCommandResponseStates_1 = Module['_emscripten_bind_BaseVehicleState_get_steerCommandResponseStates_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_steerCommandResponseStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_steerCommandResponseStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_steerCommandResponseStates_2');
  _emscripten_bind_BaseVehicleState_set_steerCommandResponseStates_2 = Module['_emscripten_bind_BaseVehicleState_set_steerCommandResponseStates_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_steerCommandResponseStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_actuationStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_actuationStates_1');
  _emscripten_bind_BaseVehicleState_get_actuationStates_1 = Module['_emscripten_bind_BaseVehicleState_get_actuationStates_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_actuationStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_actuationStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_actuationStates_2');
  _emscripten_bind_BaseVehicleState_set_actuationStates_2 = Module['_emscripten_bind_BaseVehicleState_set_actuationStates_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_actuationStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_roadGeomStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_roadGeomStates_1');
  _emscripten_bind_BaseVehicleState_get_roadGeomStates_1 = Module['_emscripten_bind_BaseVehicleState_get_roadGeomStates_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_roadGeomStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_roadGeomStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_roadGeomStates_2');
  _emscripten_bind_BaseVehicleState_set_roadGeomStates_2 = Module['_emscripten_bind_BaseVehicleState_set_roadGeomStates_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_roadGeomStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_suspensionStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_suspensionStates_1');
  _emscripten_bind_BaseVehicleState_get_suspensionStates_1 = Module['_emscripten_bind_BaseVehicleState_get_suspensionStates_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_suspensionStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_suspensionStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_suspensionStates_2');
  _emscripten_bind_BaseVehicleState_set_suspensionStates_2 = Module['_emscripten_bind_BaseVehicleState_set_suspensionStates_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_suspensionStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_suspensionComplianceStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_suspensionComplianceStates_1');
  _emscripten_bind_BaseVehicleState_get_suspensionComplianceStates_1 = Module['_emscripten_bind_BaseVehicleState_get_suspensionComplianceStates_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_suspensionComplianceStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_suspensionComplianceStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_suspensionComplianceStates_2');
  _emscripten_bind_BaseVehicleState_set_suspensionComplianceStates_2 = Module['_emscripten_bind_BaseVehicleState_set_suspensionComplianceStates_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_suspensionComplianceStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_suspensionForces_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_suspensionForces_1');
  _emscripten_bind_BaseVehicleState_get_suspensionForces_1 = Module['_emscripten_bind_BaseVehicleState_get_suspensionForces_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_suspensionForces_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_suspensionForces_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_suspensionForces_2');
  _emscripten_bind_BaseVehicleState_set_suspensionForces_2 = Module['_emscripten_bind_BaseVehicleState_set_suspensionForces_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_suspensionForces_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_antiRollTorque_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_antiRollTorque_0');
  _emscripten_bind_BaseVehicleState_get_antiRollTorque_0 = Module['_emscripten_bind_BaseVehicleState_get_antiRollTorque_0'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_antiRollTorque_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_antiRollTorque_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_antiRollTorque_1');
  _emscripten_bind_BaseVehicleState_set_antiRollTorque_1 = Module['_emscripten_bind_BaseVehicleState_set_antiRollTorque_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_antiRollTorque_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_tireGripStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_tireGripStates_1');
  _emscripten_bind_BaseVehicleState_get_tireGripStates_1 = Module['_emscripten_bind_BaseVehicleState_get_tireGripStates_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_tireGripStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_tireGripStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_tireGripStates_2');
  _emscripten_bind_BaseVehicleState_set_tireGripStates_2 = Module['_emscripten_bind_BaseVehicleState_set_tireGripStates_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_tireGripStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_tireDirectionStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_tireDirectionStates_1');
  _emscripten_bind_BaseVehicleState_get_tireDirectionStates_1 = Module['_emscripten_bind_BaseVehicleState_get_tireDirectionStates_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_tireDirectionStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_tireDirectionStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_tireDirectionStates_2');
  _emscripten_bind_BaseVehicleState_set_tireDirectionStates_2 = Module['_emscripten_bind_BaseVehicleState_set_tireDirectionStates_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_tireDirectionStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_tireSpeedStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_tireSpeedStates_1');
  _emscripten_bind_BaseVehicleState_get_tireSpeedStates_1 = Module['_emscripten_bind_BaseVehicleState_get_tireSpeedStates_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_tireSpeedStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_tireSpeedStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_tireSpeedStates_2');
  _emscripten_bind_BaseVehicleState_set_tireSpeedStates_2 = Module['_emscripten_bind_BaseVehicleState_set_tireSpeedStates_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_tireSpeedStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_tireSlipStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_tireSlipStates_1');
  _emscripten_bind_BaseVehicleState_get_tireSlipStates_1 = Module['_emscripten_bind_BaseVehicleState_get_tireSlipStates_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_tireSlipStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_tireSlipStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_tireSlipStates_2');
  _emscripten_bind_BaseVehicleState_set_tireSlipStates_2 = Module['_emscripten_bind_BaseVehicleState_set_tireSlipStates_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_tireSlipStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_tireCamberAngleStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_tireCamberAngleStates_1');
  _emscripten_bind_BaseVehicleState_get_tireCamberAngleStates_1 = Module['_emscripten_bind_BaseVehicleState_get_tireCamberAngleStates_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_tireCamberAngleStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_tireCamberAngleStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_tireCamberAngleStates_2');
  _emscripten_bind_BaseVehicleState_set_tireCamberAngleStates_2 = Module['_emscripten_bind_BaseVehicleState_set_tireCamberAngleStates_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_tireCamberAngleStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_tireStickyStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_tireStickyStates_1');
  _emscripten_bind_BaseVehicleState_get_tireStickyStates_1 = Module['_emscripten_bind_BaseVehicleState_get_tireStickyStates_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_tireStickyStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_tireStickyStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_tireStickyStates_2');
  _emscripten_bind_BaseVehicleState_set_tireStickyStates_2 = Module['_emscripten_bind_BaseVehicleState_set_tireStickyStates_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_tireStickyStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_tireForces_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_tireForces_1');
  _emscripten_bind_BaseVehicleState_get_tireForces_1 = Module['_emscripten_bind_BaseVehicleState_get_tireForces_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_tireForces_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_tireForces_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_tireForces_2');
  _emscripten_bind_BaseVehicleState_set_tireForces_2 = Module['_emscripten_bind_BaseVehicleState_set_tireForces_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_tireForces_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_wheelRigidBody1dStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_wheelRigidBody1dStates_1');
  _emscripten_bind_BaseVehicleState_get_wheelRigidBody1dStates_1 = Module['_emscripten_bind_BaseVehicleState_get_wheelRigidBody1dStates_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_wheelRigidBody1dStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_wheelRigidBody1dStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_wheelRigidBody1dStates_2');
  _emscripten_bind_BaseVehicleState_set_wheelRigidBody1dStates_2 = Module['_emscripten_bind_BaseVehicleState_set_wheelRigidBody1dStates_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_wheelRigidBody1dStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_wheelLocalPoses_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_wheelLocalPoses_1');
  _emscripten_bind_BaseVehicleState_get_wheelLocalPoses_1 = Module['_emscripten_bind_BaseVehicleState_get_wheelLocalPoses_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_wheelLocalPoses_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_wheelLocalPoses_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_wheelLocalPoses_2');
  _emscripten_bind_BaseVehicleState_set_wheelLocalPoses_2 = Module['_emscripten_bind_BaseVehicleState_set_wheelLocalPoses_2'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_wheelLocalPoses_2', 3);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_get_rigidBodyState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_get_rigidBodyState_0');
  _emscripten_bind_BaseVehicleState_get_rigidBodyState_0 = Module['_emscripten_bind_BaseVehicleState_get_rigidBodyState_0'] = createExportWrapper('emscripten_bind_BaseVehicleState_get_rigidBodyState_0', 1);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState_set_rigidBodyState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState_set_rigidBodyState_1');
  _emscripten_bind_BaseVehicleState_set_rigidBodyState_1 = Module['_emscripten_bind_BaseVehicleState_set_rigidBodyState_1'] = createExportWrapper('emscripten_bind_BaseVehicleState_set_rigidBodyState_1', 2);
  assert(typeof wasmExports['emscripten_bind_BaseVehicleState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_BaseVehicleState___destroy___0');
  _emscripten_bind_BaseVehicleState___destroy___0 = Module['_emscripten_bind_BaseVehicleState___destroy___0'] = createExportWrapper('emscripten_bind_BaseVehicleState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_BoxSupport_BoxSupport_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BoxSupport_BoxSupport_1');
  _emscripten_bind_BoxSupport_BoxSupport_1 = Module['_emscripten_bind_BoxSupport_BoxSupport_1'] = createExportWrapper('emscripten_bind_BoxSupport_BoxSupport_1', 1);
  assert(typeof wasmExports['emscripten_bind_BoxSupport_BoxSupport_2'] != 'undefined', 'missing Wasm export: emscripten_bind_BoxSupport_BoxSupport_2');
  _emscripten_bind_BoxSupport_BoxSupport_2 = Module['_emscripten_bind_BoxSupport_BoxSupport_2'] = createExportWrapper('emscripten_bind_BoxSupport_BoxSupport_2', 2);
  assert(typeof wasmExports['emscripten_bind_BoxSupport_getMargin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BoxSupport_getMargin_0');
  _emscripten_bind_BoxSupport_getMargin_0 = Module['_emscripten_bind_BoxSupport_getMargin_0'] = createExportWrapper('emscripten_bind_BoxSupport_getMargin_0', 1);
  assert(typeof wasmExports['emscripten_bind_BoxSupport_supportLocal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BoxSupport_supportLocal_1');
  _emscripten_bind_BoxSupport_supportLocal_1 = Module['_emscripten_bind_BoxSupport_supportLocal_1'] = createExportWrapper('emscripten_bind_BoxSupport_supportLocal_1', 2);
  assert(typeof wasmExports['emscripten_bind_BoxSupport_get_halfExtents_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BoxSupport_get_halfExtents_0');
  _emscripten_bind_BoxSupport_get_halfExtents_0 = Module['_emscripten_bind_BoxSupport_get_halfExtents_0'] = createExportWrapper('emscripten_bind_BoxSupport_get_halfExtents_0', 1);
  assert(typeof wasmExports['emscripten_bind_BoxSupport_set_halfExtents_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BoxSupport_set_halfExtents_1');
  _emscripten_bind_BoxSupport_set_halfExtents_1 = Module['_emscripten_bind_BoxSupport_set_halfExtents_1'] = createExportWrapper('emscripten_bind_BoxSupport_set_halfExtents_1', 2);
  assert(typeof wasmExports['emscripten_bind_BoxSupport_get_margin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_BoxSupport_get_margin_0');
  _emscripten_bind_BoxSupport_get_margin_0 = Module['_emscripten_bind_BoxSupport_get_margin_0'] = createExportWrapper('emscripten_bind_BoxSupport_get_margin_0', 1);
  assert(typeof wasmExports['emscripten_bind_BoxSupport_set_margin_1'] != 'undefined', 'missing Wasm export: emscripten_bind_BoxSupport_set_margin_1');
  _emscripten_bind_BoxSupport_set_margin_1 = Module['_emscripten_bind_BoxSupport_set_margin_1'] = createExportWrapper('emscripten_bind_BoxSupport_set_margin_1', 2);
  assert(typeof wasmExports['emscripten_bind_BoxSupport___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_BoxSupport___destroy___0');
  _emscripten_bind_BoxSupport___destroy___0 = Module['_emscripten_bind_BoxSupport___destroy___0'] = createExportWrapper('emscripten_bind_BoxSupport___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_CapsuleSupport_CapsuleSupport_2'] != 'undefined', 'missing Wasm export: emscripten_bind_CapsuleSupport_CapsuleSupport_2');
  _emscripten_bind_CapsuleSupport_CapsuleSupport_2 = Module['_emscripten_bind_CapsuleSupport_CapsuleSupport_2'] = createExportWrapper('emscripten_bind_CapsuleSupport_CapsuleSupport_2', 2);
  assert(typeof wasmExports['emscripten_bind_CapsuleSupport_getMargin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_CapsuleSupport_getMargin_0');
  _emscripten_bind_CapsuleSupport_getMargin_0 = Module['_emscripten_bind_CapsuleSupport_getMargin_0'] = createExportWrapper('emscripten_bind_CapsuleSupport_getMargin_0', 1);
  assert(typeof wasmExports['emscripten_bind_CapsuleSupport_supportLocal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_CapsuleSupport_supportLocal_1');
  _emscripten_bind_CapsuleSupport_supportLocal_1 = Module['_emscripten_bind_CapsuleSupport_supportLocal_1'] = createExportWrapper('emscripten_bind_CapsuleSupport_supportLocal_1', 2);
  assert(typeof wasmExports['emscripten_bind_CapsuleSupport_get_radius_0'] != 'undefined', 'missing Wasm export: emscripten_bind_CapsuleSupport_get_radius_0');
  _emscripten_bind_CapsuleSupport_get_radius_0 = Module['_emscripten_bind_CapsuleSupport_get_radius_0'] = createExportWrapper('emscripten_bind_CapsuleSupport_get_radius_0', 1);
  assert(typeof wasmExports['emscripten_bind_CapsuleSupport_set_radius_1'] != 'undefined', 'missing Wasm export: emscripten_bind_CapsuleSupport_set_radius_1');
  _emscripten_bind_CapsuleSupport_set_radius_1 = Module['_emscripten_bind_CapsuleSupport_set_radius_1'] = createExportWrapper('emscripten_bind_CapsuleSupport_set_radius_1', 2);
  assert(typeof wasmExports['emscripten_bind_CapsuleSupport_get_halfHeight_0'] != 'undefined', 'missing Wasm export: emscripten_bind_CapsuleSupport_get_halfHeight_0');
  _emscripten_bind_CapsuleSupport_get_halfHeight_0 = Module['_emscripten_bind_CapsuleSupport_get_halfHeight_0'] = createExportWrapper('emscripten_bind_CapsuleSupport_get_halfHeight_0', 1);
  assert(typeof wasmExports['emscripten_bind_CapsuleSupport_set_halfHeight_1'] != 'undefined', 'missing Wasm export: emscripten_bind_CapsuleSupport_set_halfHeight_1');
  _emscripten_bind_CapsuleSupport_set_halfHeight_1 = Module['_emscripten_bind_CapsuleSupport_set_halfHeight_1'] = createExportWrapper('emscripten_bind_CapsuleSupport_set_halfHeight_1', 2);
  assert(typeof wasmExports['emscripten_bind_CapsuleSupport___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_CapsuleSupport___destroy___0');
  _emscripten_bind_CapsuleSupport___destroy___0 = Module['_emscripten_bind_CapsuleSupport___destroy___0'] = createExportWrapper('emscripten_bind_CapsuleSupport___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_0'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_0');
  _emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_0 = Module['_emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_0'] = createExportWrapper('emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_0', 0);
  assert(typeof wasmExports['emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_1'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_1');
  _emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_1 = Module['_emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_1'] = createExportWrapper('emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_1', 1);
  assert(typeof wasmExports['emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_2'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_2');
  _emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_2 = Module['_emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_2'] = createExportWrapper('emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_2', 2);
  assert(typeof wasmExports['emscripten_bind_ConvexGeomSupport_getMargin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexGeomSupport_getMargin_0');
  _emscripten_bind_ConvexGeomSupport_getMargin_0 = Module['_emscripten_bind_ConvexGeomSupport_getMargin_0'] = createExportWrapper('emscripten_bind_ConvexGeomSupport_getMargin_0', 1);
  assert(typeof wasmExports['emscripten_bind_ConvexGeomSupport_supportLocal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexGeomSupport_supportLocal_1');
  _emscripten_bind_ConvexGeomSupport_supportLocal_1 = Module['_emscripten_bind_ConvexGeomSupport_supportLocal_1'] = createExportWrapper('emscripten_bind_ConvexGeomSupport_supportLocal_1', 2);
  assert(typeof wasmExports['emscripten_bind_ConvexGeomSupport___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexGeomSupport___destroy___0');
  _emscripten_bind_ConvexGeomSupport___destroy___0 = Module['_emscripten_bind_ConvexGeomSupport___destroy___0'] = createExportWrapper('emscripten_bind_ConvexGeomSupport___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_1'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_1');
  _emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_1 = Module['_emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_1'] = createExportWrapper('emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_1', 1);
  assert(typeof wasmExports['emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_2'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_2');
  _emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_2 = Module['_emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_2'] = createExportWrapper('emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_2', 2);
  assert(typeof wasmExports['emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_3'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_3');
  _emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_3 = Module['_emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_3'] = createExportWrapper('emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_3', 3);
  assert(typeof wasmExports['emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_4'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_4');
  _emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_4 = Module['_emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_4'] = createExportWrapper('emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_4', 4);
  assert(typeof wasmExports['emscripten_bind_ConvexMeshSupport_getMargin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexMeshSupport_getMargin_0');
  _emscripten_bind_ConvexMeshSupport_getMargin_0 = Module['_emscripten_bind_ConvexMeshSupport_getMargin_0'] = createExportWrapper('emscripten_bind_ConvexMeshSupport_getMargin_0', 1);
  assert(typeof wasmExports['emscripten_bind_ConvexMeshSupport_supportLocal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexMeshSupport_supportLocal_1');
  _emscripten_bind_ConvexMeshSupport_supportLocal_1 = Module['_emscripten_bind_ConvexMeshSupport_supportLocal_1'] = createExportWrapper('emscripten_bind_ConvexMeshSupport_supportLocal_1', 2);
  assert(typeof wasmExports['emscripten_bind_ConvexMeshSupport_get_scale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexMeshSupport_get_scale_0');
  _emscripten_bind_ConvexMeshSupport_get_scale_0 = Module['_emscripten_bind_ConvexMeshSupport_get_scale_0'] = createExportWrapper('emscripten_bind_ConvexMeshSupport_get_scale_0', 1);
  assert(typeof wasmExports['emscripten_bind_ConvexMeshSupport_set_scale_1'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexMeshSupport_set_scale_1');
  _emscripten_bind_ConvexMeshSupport_set_scale_1 = Module['_emscripten_bind_ConvexMeshSupport_set_scale_1'] = createExportWrapper('emscripten_bind_ConvexMeshSupport_set_scale_1', 2);
  assert(typeof wasmExports['emscripten_bind_ConvexMeshSupport_get_scaleRotation_0'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexMeshSupport_get_scaleRotation_0');
  _emscripten_bind_ConvexMeshSupport_get_scaleRotation_0 = Module['_emscripten_bind_ConvexMeshSupport_get_scaleRotation_0'] = createExportWrapper('emscripten_bind_ConvexMeshSupport_get_scaleRotation_0', 1);
  assert(typeof wasmExports['emscripten_bind_ConvexMeshSupport_set_scaleRotation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexMeshSupport_set_scaleRotation_1');
  _emscripten_bind_ConvexMeshSupport_set_scaleRotation_1 = Module['_emscripten_bind_ConvexMeshSupport_set_scaleRotation_1'] = createExportWrapper('emscripten_bind_ConvexMeshSupport_set_scaleRotation_1', 2);
  assert(typeof wasmExports['emscripten_bind_ConvexMeshSupport_get_margin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexMeshSupport_get_margin_0');
  _emscripten_bind_ConvexMeshSupport_get_margin_0 = Module['_emscripten_bind_ConvexMeshSupport_get_margin_0'] = createExportWrapper('emscripten_bind_ConvexMeshSupport_get_margin_0', 1);
  assert(typeof wasmExports['emscripten_bind_ConvexMeshSupport_set_margin_1'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexMeshSupport_set_margin_1');
  _emscripten_bind_ConvexMeshSupport_set_margin_1 = Module['_emscripten_bind_ConvexMeshSupport_set_margin_1'] = createExportWrapper('emscripten_bind_ConvexMeshSupport_set_margin_1', 2);
  assert(typeof wasmExports['emscripten_bind_ConvexMeshSupport___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_ConvexMeshSupport___destroy___0');
  _emscripten_bind_ConvexMeshSupport___destroy___0 = Module['_emscripten_bind_ConvexMeshSupport___destroy___0'] = createExportWrapper('emscripten_bind_ConvexMeshSupport___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_CustomSupportImpl_CustomSupportImpl_0'] != 'undefined', 'missing Wasm export: emscripten_bind_CustomSupportImpl_CustomSupportImpl_0');
  _emscripten_bind_CustomSupportImpl_CustomSupportImpl_0 = Module['_emscripten_bind_CustomSupportImpl_CustomSupportImpl_0'] = createExportWrapper('emscripten_bind_CustomSupportImpl_CustomSupportImpl_0', 0);
  assert(typeof wasmExports['emscripten_bind_CustomSupportImpl_getCustomMargin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_CustomSupportImpl_getCustomMargin_0');
  _emscripten_bind_CustomSupportImpl_getCustomMargin_0 = Module['_emscripten_bind_CustomSupportImpl_getCustomMargin_0'] = createExportWrapper('emscripten_bind_CustomSupportImpl_getCustomMargin_0', 1);
  assert(typeof wasmExports['emscripten_bind_CustomSupportImpl_getCustomSupportLocal_2'] != 'undefined', 'missing Wasm export: emscripten_bind_CustomSupportImpl_getCustomSupportLocal_2');
  _emscripten_bind_CustomSupportImpl_getCustomSupportLocal_2 = Module['_emscripten_bind_CustomSupportImpl_getCustomSupportLocal_2'] = createExportWrapper('emscripten_bind_CustomSupportImpl_getCustomSupportLocal_2', 3);
  assert(typeof wasmExports['emscripten_bind_CustomSupportImpl___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_CustomSupportImpl___destroy___0');
  _emscripten_bind_CustomSupportImpl___destroy___0 = Module['_emscripten_bind_CustomSupportImpl___destroy___0'] = createExportWrapper('emscripten_bind_CustomSupportImpl___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_DirectDriveVehicle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_DirectDriveVehicle_0');
  _emscripten_bind_DirectDriveVehicle_DirectDriveVehicle_0 = Module['_emscripten_bind_DirectDriveVehicle_DirectDriveVehicle_0'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_DirectDriveVehicle_0', 0);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_initialize_3'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_initialize_3');
  _emscripten_bind_DirectDriveVehicle_initialize_3 = Module['_emscripten_bind_DirectDriveVehicle_initialize_3'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_initialize_3', 4);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_initialize_4'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_initialize_4');
  _emscripten_bind_DirectDriveVehicle_initialize_4 = Module['_emscripten_bind_DirectDriveVehicle_initialize_4'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_initialize_4', 5);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_initComponentSequence_1'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_initComponentSequence_1');
  _emscripten_bind_DirectDriveVehicle_initComponentSequence_1 = Module['_emscripten_bind_DirectDriveVehicle_initComponentSequence_1'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_initComponentSequence_1', 2);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_destroyState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_destroyState_0');
  _emscripten_bind_DirectDriveVehicle_destroyState_0 = Module['_emscripten_bind_DirectDriveVehicle_destroyState_0'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_destroyState_0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_step_2'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_step_2');
  _emscripten_bind_DirectDriveVehicle_step_2 = Module['_emscripten_bind_DirectDriveVehicle_step_2'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_step_2', 3);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_get_directDriveParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_get_directDriveParams_0');
  _emscripten_bind_DirectDriveVehicle_get_directDriveParams_0 = Module['_emscripten_bind_DirectDriveVehicle_get_directDriveParams_0'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_get_directDriveParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_set_directDriveParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_set_directDriveParams_1');
  _emscripten_bind_DirectDriveVehicle_set_directDriveParams_1 = Module['_emscripten_bind_DirectDriveVehicle_set_directDriveParams_1'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_set_directDriveParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_get_directDriveState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_get_directDriveState_0');
  _emscripten_bind_DirectDriveVehicle_get_directDriveState_0 = Module['_emscripten_bind_DirectDriveVehicle_get_directDriveState_0'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_get_directDriveState_0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_set_directDriveState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_set_directDriveState_1');
  _emscripten_bind_DirectDriveVehicle_set_directDriveState_1 = Module['_emscripten_bind_DirectDriveVehicle_set_directDriveState_1'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_set_directDriveState_1', 2);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_get_transmissionCommandState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_get_transmissionCommandState_0');
  _emscripten_bind_DirectDriveVehicle_get_transmissionCommandState_0 = Module['_emscripten_bind_DirectDriveVehicle_get_transmissionCommandState_0'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_get_transmissionCommandState_0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_set_transmissionCommandState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_set_transmissionCommandState_1');
  _emscripten_bind_DirectDriveVehicle_set_transmissionCommandState_1 = Module['_emscripten_bind_DirectDriveVehicle_set_transmissionCommandState_1'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_set_transmissionCommandState_1', 2);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_get_baseParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_get_baseParams_0');
  _emscripten_bind_DirectDriveVehicle_get_baseParams_0 = Module['_emscripten_bind_DirectDriveVehicle_get_baseParams_0'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_get_baseParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_set_baseParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_set_baseParams_1');
  _emscripten_bind_DirectDriveVehicle_set_baseParams_1 = Module['_emscripten_bind_DirectDriveVehicle_set_baseParams_1'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_set_baseParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_get_baseState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_get_baseState_0');
  _emscripten_bind_DirectDriveVehicle_get_baseState_0 = Module['_emscripten_bind_DirectDriveVehicle_get_baseState_0'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_get_baseState_0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_set_baseState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_set_baseState_1');
  _emscripten_bind_DirectDriveVehicle_set_baseState_1 = Module['_emscripten_bind_DirectDriveVehicle_set_baseState_1'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_set_baseState_1', 2);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_get_componentSequence_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_get_componentSequence_0');
  _emscripten_bind_DirectDriveVehicle_get_componentSequence_0 = Module['_emscripten_bind_DirectDriveVehicle_get_componentSequence_0'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_get_componentSequence_0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_set_componentSequence_1'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_set_componentSequence_1');
  _emscripten_bind_DirectDriveVehicle_set_componentSequence_1 = Module['_emscripten_bind_DirectDriveVehicle_set_componentSequence_1'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_set_componentSequence_1', 2);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_get_componentSequenceSubstepGroupHandle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_get_componentSequenceSubstepGroupHandle_0');
  _emscripten_bind_DirectDriveVehicle_get_componentSequenceSubstepGroupHandle_0 = Module['_emscripten_bind_DirectDriveVehicle_get_componentSequenceSubstepGroupHandle_0'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_get_componentSequenceSubstepGroupHandle_0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_set_componentSequenceSubstepGroupHandle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_set_componentSequenceSubstepGroupHandle_1');
  _emscripten_bind_DirectDriveVehicle_set_componentSequenceSubstepGroupHandle_1 = Module['_emscripten_bind_DirectDriveVehicle_set_componentSequenceSubstepGroupHandle_1'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_set_componentSequenceSubstepGroupHandle_1', 2);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_get_physXParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_get_physXParams_0');
  _emscripten_bind_DirectDriveVehicle_get_physXParams_0 = Module['_emscripten_bind_DirectDriveVehicle_get_physXParams_0'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_get_physXParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_set_physXParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_set_physXParams_1');
  _emscripten_bind_DirectDriveVehicle_set_physXParams_1 = Module['_emscripten_bind_DirectDriveVehicle_set_physXParams_1'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_set_physXParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_get_physXState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_get_physXState_0');
  _emscripten_bind_DirectDriveVehicle_get_physXState_0 = Module['_emscripten_bind_DirectDriveVehicle_get_physXState_0'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_get_physXState_0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_set_physXState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_set_physXState_1');
  _emscripten_bind_DirectDriveVehicle_set_physXState_1 = Module['_emscripten_bind_DirectDriveVehicle_set_physXState_1'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_set_physXState_1', 2);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_get_commandState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_get_commandState_0');
  _emscripten_bind_DirectDriveVehicle_get_commandState_0 = Module['_emscripten_bind_DirectDriveVehicle_get_commandState_0'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_get_commandState_0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle_set_commandState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle_set_commandState_1');
  _emscripten_bind_DirectDriveVehicle_set_commandState_1 = Module['_emscripten_bind_DirectDriveVehicle_set_commandState_1'] = createExportWrapper('emscripten_bind_DirectDriveVehicle_set_commandState_1', 2);
  assert(typeof wasmExports['emscripten_bind_DirectDriveVehicle___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDriveVehicle___destroy___0');
  _emscripten_bind_DirectDriveVehicle___destroy___0 = Module['_emscripten_bind_DirectDriveVehicle___destroy___0'] = createExportWrapper('emscripten_bind_DirectDriveVehicle___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDrivetrainParams_DirectDrivetrainParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDrivetrainParams_DirectDrivetrainParams_0');
  _emscripten_bind_DirectDrivetrainParams_DirectDrivetrainParams_0 = Module['_emscripten_bind_DirectDrivetrainParams_DirectDrivetrainParams_0'] = createExportWrapper('emscripten_bind_DirectDrivetrainParams_DirectDrivetrainParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_DirectDrivetrainParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDrivetrainParams_transformAndScale_4');
  _emscripten_bind_DirectDrivetrainParams_transformAndScale_4 = Module['_emscripten_bind_DirectDrivetrainParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_DirectDrivetrainParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_DirectDrivetrainParams_isValid_1'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDrivetrainParams_isValid_1');
  _emscripten_bind_DirectDrivetrainParams_isValid_1 = Module['_emscripten_bind_DirectDrivetrainParams_isValid_1'] = createExportWrapper('emscripten_bind_DirectDrivetrainParams_isValid_1', 2);
  assert(typeof wasmExports['emscripten_bind_DirectDrivetrainParams_get_directDriveThrottleResponseParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDrivetrainParams_get_directDriveThrottleResponseParams_0');
  _emscripten_bind_DirectDrivetrainParams_get_directDriveThrottleResponseParams_0 = Module['_emscripten_bind_DirectDrivetrainParams_get_directDriveThrottleResponseParams_0'] = createExportWrapper('emscripten_bind_DirectDrivetrainParams_get_directDriveThrottleResponseParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDrivetrainParams_set_directDriveThrottleResponseParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDrivetrainParams_set_directDriveThrottleResponseParams_1');
  _emscripten_bind_DirectDrivetrainParams_set_directDriveThrottleResponseParams_1 = Module['_emscripten_bind_DirectDrivetrainParams_set_directDriveThrottleResponseParams_1'] = createExportWrapper('emscripten_bind_DirectDrivetrainParams_set_directDriveThrottleResponseParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_DirectDrivetrainParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDrivetrainParams___destroy___0');
  _emscripten_bind_DirectDrivetrainParams___destroy___0 = Module['_emscripten_bind_DirectDrivetrainParams___destroy___0'] = createExportWrapper('emscripten_bind_DirectDrivetrainParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDrivetrainState_DirectDrivetrainState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDrivetrainState_DirectDrivetrainState_0');
  _emscripten_bind_DirectDrivetrainState_DirectDrivetrainState_0 = Module['_emscripten_bind_DirectDrivetrainState_DirectDrivetrainState_0'] = createExportWrapper('emscripten_bind_DirectDrivetrainState_DirectDrivetrainState_0', 0);
  assert(typeof wasmExports['emscripten_bind_DirectDrivetrainState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDrivetrainState_setToDefault_0');
  _emscripten_bind_DirectDrivetrainState_setToDefault_0 = Module['_emscripten_bind_DirectDrivetrainState_setToDefault_0'] = createExportWrapper('emscripten_bind_DirectDrivetrainState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_DirectDrivetrainState_get_directDriveThrottleResponseStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDrivetrainState_get_directDriveThrottleResponseStates_1');
  _emscripten_bind_DirectDrivetrainState_get_directDriveThrottleResponseStates_1 = Module['_emscripten_bind_DirectDrivetrainState_get_directDriveThrottleResponseStates_1'] = createExportWrapper('emscripten_bind_DirectDrivetrainState_get_directDriveThrottleResponseStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_DirectDrivetrainState_set_directDriveThrottleResponseStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDrivetrainState_set_directDriveThrottleResponseStates_2');
  _emscripten_bind_DirectDrivetrainState_set_directDriveThrottleResponseStates_2 = Module['_emscripten_bind_DirectDrivetrainState_set_directDriveThrottleResponseStates_2'] = createExportWrapper('emscripten_bind_DirectDrivetrainState_set_directDriveThrottleResponseStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_DirectDrivetrainState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_DirectDrivetrainState___destroy___0');
  _emscripten_bind_DirectDrivetrainState___destroy___0 = Module['_emscripten_bind_DirectDrivetrainState___destroy___0'] = createExportWrapper('emscripten_bind_DirectDrivetrainState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_EngineDriveVehicle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_EngineDriveVehicle_0');
  _emscripten_bind_EngineDriveVehicle_EngineDriveVehicle_0 = Module['_emscripten_bind_EngineDriveVehicle_EngineDriveVehicle_0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_EngineDriveVehicle_0', 0);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_initialize_4'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_initialize_4');
  _emscripten_bind_EngineDriveVehicle_initialize_4 = Module['_emscripten_bind_EngineDriveVehicle_initialize_4'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_initialize_4', 5);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_initialize_5'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_initialize_5');
  _emscripten_bind_EngineDriveVehicle_initialize_5 = Module['_emscripten_bind_EngineDriveVehicle_initialize_5'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_initialize_5', 6);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_initComponentSequence_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_initComponentSequence_1');
  _emscripten_bind_EngineDriveVehicle_initComponentSequence_1 = Module['_emscripten_bind_EngineDriveVehicle_initComponentSequence_1'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_initComponentSequence_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_destroyState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_destroyState_0');
  _emscripten_bind_EngineDriveVehicle_destroyState_0 = Module['_emscripten_bind_EngineDriveVehicle_destroyState_0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_destroyState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_step_2'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_step_2');
  _emscripten_bind_EngineDriveVehicle_step_2 = Module['_emscripten_bind_EngineDriveVehicle_step_2'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_step_2', 3);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_get_engineDriveParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_get_engineDriveParams_0');
  _emscripten_bind_EngineDriveVehicle_get_engineDriveParams_0 = Module['_emscripten_bind_EngineDriveVehicle_get_engineDriveParams_0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_get_engineDriveParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_set_engineDriveParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_set_engineDriveParams_1');
  _emscripten_bind_EngineDriveVehicle_set_engineDriveParams_1 = Module['_emscripten_bind_EngineDriveVehicle_set_engineDriveParams_1'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_set_engineDriveParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_get_engineDriveState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_get_engineDriveState_0');
  _emscripten_bind_EngineDriveVehicle_get_engineDriveState_0 = Module['_emscripten_bind_EngineDriveVehicle_get_engineDriveState_0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_get_engineDriveState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_set_engineDriveState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_set_engineDriveState_1');
  _emscripten_bind_EngineDriveVehicle_set_engineDriveState_1 = Module['_emscripten_bind_EngineDriveVehicle_set_engineDriveState_1'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_set_engineDriveState_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_get_transmissionCommandState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_get_transmissionCommandState_0');
  _emscripten_bind_EngineDriveVehicle_get_transmissionCommandState_0 = Module['_emscripten_bind_EngineDriveVehicle_get_transmissionCommandState_0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_get_transmissionCommandState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_set_transmissionCommandState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_set_transmissionCommandState_1');
  _emscripten_bind_EngineDriveVehicle_set_transmissionCommandState_1 = Module['_emscripten_bind_EngineDriveVehicle_set_transmissionCommandState_1'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_set_transmissionCommandState_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_get_tankDriveTransmissionCommandState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_get_tankDriveTransmissionCommandState_0');
  _emscripten_bind_EngineDriveVehicle_get_tankDriveTransmissionCommandState_0 = Module['_emscripten_bind_EngineDriveVehicle_get_tankDriveTransmissionCommandState_0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_get_tankDriveTransmissionCommandState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_set_tankDriveTransmissionCommandState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_set_tankDriveTransmissionCommandState_1');
  _emscripten_bind_EngineDriveVehicle_set_tankDriveTransmissionCommandState_1 = Module['_emscripten_bind_EngineDriveVehicle_set_tankDriveTransmissionCommandState_1'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_set_tankDriveTransmissionCommandState_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_get_differentialType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_get_differentialType_0');
  _emscripten_bind_EngineDriveVehicle_get_differentialType_0 = Module['_emscripten_bind_EngineDriveVehicle_get_differentialType_0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_get_differentialType_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_set_differentialType_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_set_differentialType_1');
  _emscripten_bind_EngineDriveVehicle_set_differentialType_1 = Module['_emscripten_bind_EngineDriveVehicle_set_differentialType_1'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_set_differentialType_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_get_baseParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_get_baseParams_0');
  _emscripten_bind_EngineDriveVehicle_get_baseParams_0 = Module['_emscripten_bind_EngineDriveVehicle_get_baseParams_0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_get_baseParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_set_baseParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_set_baseParams_1');
  _emscripten_bind_EngineDriveVehicle_set_baseParams_1 = Module['_emscripten_bind_EngineDriveVehicle_set_baseParams_1'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_set_baseParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_get_baseState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_get_baseState_0');
  _emscripten_bind_EngineDriveVehicle_get_baseState_0 = Module['_emscripten_bind_EngineDriveVehicle_get_baseState_0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_get_baseState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_set_baseState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_set_baseState_1');
  _emscripten_bind_EngineDriveVehicle_set_baseState_1 = Module['_emscripten_bind_EngineDriveVehicle_set_baseState_1'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_set_baseState_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_get_componentSequence_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_get_componentSequence_0');
  _emscripten_bind_EngineDriveVehicle_get_componentSequence_0 = Module['_emscripten_bind_EngineDriveVehicle_get_componentSequence_0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_get_componentSequence_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_set_componentSequence_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_set_componentSequence_1');
  _emscripten_bind_EngineDriveVehicle_set_componentSequence_1 = Module['_emscripten_bind_EngineDriveVehicle_set_componentSequence_1'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_set_componentSequence_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_get_componentSequenceSubstepGroupHandle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_get_componentSequenceSubstepGroupHandle_0');
  _emscripten_bind_EngineDriveVehicle_get_componentSequenceSubstepGroupHandle_0 = Module['_emscripten_bind_EngineDriveVehicle_get_componentSequenceSubstepGroupHandle_0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_get_componentSequenceSubstepGroupHandle_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_set_componentSequenceSubstepGroupHandle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_set_componentSequenceSubstepGroupHandle_1');
  _emscripten_bind_EngineDriveVehicle_set_componentSequenceSubstepGroupHandle_1 = Module['_emscripten_bind_EngineDriveVehicle_set_componentSequenceSubstepGroupHandle_1'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_set_componentSequenceSubstepGroupHandle_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_get_physXParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_get_physXParams_0');
  _emscripten_bind_EngineDriveVehicle_get_physXParams_0 = Module['_emscripten_bind_EngineDriveVehicle_get_physXParams_0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_get_physXParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_set_physXParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_set_physXParams_1');
  _emscripten_bind_EngineDriveVehicle_set_physXParams_1 = Module['_emscripten_bind_EngineDriveVehicle_set_physXParams_1'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_set_physXParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_get_physXState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_get_physXState_0');
  _emscripten_bind_EngineDriveVehicle_get_physXState_0 = Module['_emscripten_bind_EngineDriveVehicle_get_physXState_0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_get_physXState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_set_physXState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_set_physXState_1');
  _emscripten_bind_EngineDriveVehicle_set_physXState_1 = Module['_emscripten_bind_EngineDriveVehicle_set_physXState_1'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_set_physXState_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_get_commandState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_get_commandState_0');
  _emscripten_bind_EngineDriveVehicle_get_commandState_0 = Module['_emscripten_bind_EngineDriveVehicle_get_commandState_0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_get_commandState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle_set_commandState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle_set_commandState_1');
  _emscripten_bind_EngineDriveVehicle_set_commandState_1 = Module['_emscripten_bind_EngineDriveVehicle_set_commandState_1'] = createExportWrapper('emscripten_bind_EngineDriveVehicle_set_commandState_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDriveVehicle___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDriveVehicle___destroy___0');
  _emscripten_bind_EngineDriveVehicle___destroy___0 = Module['_emscripten_bind_EngineDriveVehicle___destroy___0'] = createExportWrapper('emscripten_bind_EngineDriveVehicle___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_EngineDrivetrainParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_EngineDrivetrainParams_0');
  _emscripten_bind_EngineDrivetrainParams_EngineDrivetrainParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_EngineDrivetrainParams_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_EngineDrivetrainParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_transformAndScale_4');
  _emscripten_bind_EngineDrivetrainParams_transformAndScale_4 = Module['_emscripten_bind_EngineDrivetrainParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_isValid_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_isValid_1');
  _emscripten_bind_EngineDrivetrainParams_isValid_1 = Module['_emscripten_bind_EngineDrivetrainParams_isValid_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_isValid_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_get_autoboxParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_get_autoboxParams_0');
  _emscripten_bind_EngineDrivetrainParams_get_autoboxParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_autoboxParams_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_get_autoboxParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_set_autoboxParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_set_autoboxParams_1');
  _emscripten_bind_EngineDrivetrainParams_set_autoboxParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_autoboxParams_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_set_autoboxParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_get_clutchCommandResponseParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_get_clutchCommandResponseParams_0');
  _emscripten_bind_EngineDrivetrainParams_get_clutchCommandResponseParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_clutchCommandResponseParams_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_get_clutchCommandResponseParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_set_clutchCommandResponseParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_set_clutchCommandResponseParams_1');
  _emscripten_bind_EngineDrivetrainParams_set_clutchCommandResponseParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_clutchCommandResponseParams_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_set_clutchCommandResponseParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_get_engineParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_get_engineParams_0');
  _emscripten_bind_EngineDrivetrainParams_get_engineParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_engineParams_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_get_engineParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_set_engineParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_set_engineParams_1');
  _emscripten_bind_EngineDrivetrainParams_set_engineParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_engineParams_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_set_engineParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_get_gearBoxParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_get_gearBoxParams_0');
  _emscripten_bind_EngineDrivetrainParams_get_gearBoxParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_gearBoxParams_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_get_gearBoxParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_set_gearBoxParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_set_gearBoxParams_1');
  _emscripten_bind_EngineDrivetrainParams_set_gearBoxParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_gearBoxParams_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_set_gearBoxParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_get_multiWheelDifferentialParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_get_multiWheelDifferentialParams_0');
  _emscripten_bind_EngineDrivetrainParams_get_multiWheelDifferentialParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_multiWheelDifferentialParams_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_get_multiWheelDifferentialParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_set_multiWheelDifferentialParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_set_multiWheelDifferentialParams_1');
  _emscripten_bind_EngineDrivetrainParams_set_multiWheelDifferentialParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_multiWheelDifferentialParams_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_set_multiWheelDifferentialParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_get_fourWheelDifferentialParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_get_fourWheelDifferentialParams_0');
  _emscripten_bind_EngineDrivetrainParams_get_fourWheelDifferentialParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_fourWheelDifferentialParams_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_get_fourWheelDifferentialParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_set_fourWheelDifferentialParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_set_fourWheelDifferentialParams_1');
  _emscripten_bind_EngineDrivetrainParams_set_fourWheelDifferentialParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_fourWheelDifferentialParams_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_set_fourWheelDifferentialParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_get_tankDifferentialParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_get_tankDifferentialParams_0');
  _emscripten_bind_EngineDrivetrainParams_get_tankDifferentialParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_tankDifferentialParams_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_get_tankDifferentialParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_set_tankDifferentialParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_set_tankDifferentialParams_1');
  _emscripten_bind_EngineDrivetrainParams_set_tankDifferentialParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_tankDifferentialParams_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_set_tankDifferentialParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_get_clutchParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_get_clutchParams_0');
  _emscripten_bind_EngineDrivetrainParams_get_clutchParams_0 = Module['_emscripten_bind_EngineDrivetrainParams_get_clutchParams_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_get_clutchParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams_set_clutchParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams_set_clutchParams_1');
  _emscripten_bind_EngineDrivetrainParams_set_clutchParams_1 = Module['_emscripten_bind_EngineDrivetrainParams_set_clutchParams_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams_set_clutchParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainParams___destroy___0');
  _emscripten_bind_EngineDrivetrainParams___destroy___0 = Module['_emscripten_bind_EngineDrivetrainParams___destroy___0'] = createExportWrapper('emscripten_bind_EngineDrivetrainParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_EngineDrivetrainState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_EngineDrivetrainState_0');
  _emscripten_bind_EngineDrivetrainState_EngineDrivetrainState_0 = Module['_emscripten_bind_EngineDrivetrainState_EngineDrivetrainState_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_EngineDrivetrainState_0', 0);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_setToDefault_0');
  _emscripten_bind_EngineDrivetrainState_setToDefault_0 = Module['_emscripten_bind_EngineDrivetrainState_setToDefault_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_get_throttleCommandResponseState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_get_throttleCommandResponseState_0');
  _emscripten_bind_EngineDrivetrainState_get_throttleCommandResponseState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_throttleCommandResponseState_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_get_throttleCommandResponseState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_set_throttleCommandResponseState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_set_throttleCommandResponseState_1');
  _emscripten_bind_EngineDrivetrainState_set_throttleCommandResponseState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_throttleCommandResponseState_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_set_throttleCommandResponseState_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_get_autoboxState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_get_autoboxState_0');
  _emscripten_bind_EngineDrivetrainState_get_autoboxState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_autoboxState_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_get_autoboxState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_set_autoboxState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_set_autoboxState_1');
  _emscripten_bind_EngineDrivetrainState_set_autoboxState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_autoboxState_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_set_autoboxState_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_get_clutchCommandResponseState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_get_clutchCommandResponseState_0');
  _emscripten_bind_EngineDrivetrainState_get_clutchCommandResponseState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_clutchCommandResponseState_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_get_clutchCommandResponseState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_set_clutchCommandResponseState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_set_clutchCommandResponseState_1');
  _emscripten_bind_EngineDrivetrainState_set_clutchCommandResponseState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_clutchCommandResponseState_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_set_clutchCommandResponseState_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_get_differentialState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_get_differentialState_0');
  _emscripten_bind_EngineDrivetrainState_get_differentialState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_differentialState_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_get_differentialState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_set_differentialState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_set_differentialState_1');
  _emscripten_bind_EngineDrivetrainState_set_differentialState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_differentialState_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_set_differentialState_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_get_wheelConstraintGroupState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_get_wheelConstraintGroupState_0');
  _emscripten_bind_EngineDrivetrainState_get_wheelConstraintGroupState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_wheelConstraintGroupState_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_get_wheelConstraintGroupState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_set_wheelConstraintGroupState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_set_wheelConstraintGroupState_1');
  _emscripten_bind_EngineDrivetrainState_set_wheelConstraintGroupState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_wheelConstraintGroupState_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_set_wheelConstraintGroupState_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_get_engineState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_get_engineState_0');
  _emscripten_bind_EngineDrivetrainState_get_engineState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_engineState_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_get_engineState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_set_engineState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_set_engineState_1');
  _emscripten_bind_EngineDrivetrainState_set_engineState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_engineState_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_set_engineState_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_get_gearboxState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_get_gearboxState_0');
  _emscripten_bind_EngineDrivetrainState_get_gearboxState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_gearboxState_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_get_gearboxState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_set_gearboxState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_set_gearboxState_1');
  _emscripten_bind_EngineDrivetrainState_set_gearboxState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_gearboxState_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_set_gearboxState_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_get_clutchState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_get_clutchState_0');
  _emscripten_bind_EngineDrivetrainState_get_clutchState_0 = Module['_emscripten_bind_EngineDrivetrainState_get_clutchState_0'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_get_clutchState_0', 1);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState_set_clutchState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState_set_clutchState_1');
  _emscripten_bind_EngineDrivetrainState_set_clutchState_1 = Module['_emscripten_bind_EngineDrivetrainState_set_clutchState_1'] = createExportWrapper('emscripten_bind_EngineDrivetrainState_set_clutchState_1', 2);
  assert(typeof wasmExports['emscripten_bind_EngineDrivetrainState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_EngineDrivetrainState___destroy___0');
  _emscripten_bind_EngineDrivetrainState___destroy___0 = Module['_emscripten_bind_EngineDrivetrainState___destroy___0'] = createExportWrapper('emscripten_bind_EngineDrivetrainState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getU8At_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getU8At_2');
  _emscripten_bind_NativeArrayHelpers_getU8At_2 = Module['_emscripten_bind_NativeArrayHelpers_getU8At_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getU8At_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getU16At_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getU16At_2');
  _emscripten_bind_NativeArrayHelpers_getU16At_2 = Module['_emscripten_bind_NativeArrayHelpers_getU16At_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getU16At_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getU32At_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getU32At_2');
  _emscripten_bind_NativeArrayHelpers_getU32At_2 = Module['_emscripten_bind_NativeArrayHelpers_getU32At_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getU32At_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getRealAt_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getRealAt_2');
  _emscripten_bind_NativeArrayHelpers_getRealAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getRealAt_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getRealAt_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_setU8At_3'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_setU8At_3');
  _emscripten_bind_NativeArrayHelpers_setU8At_3 = Module['_emscripten_bind_NativeArrayHelpers_setU8At_3'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_setU8At_3', 3);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_setU16At_3'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_setU16At_3');
  _emscripten_bind_NativeArrayHelpers_setU16At_3 = Module['_emscripten_bind_NativeArrayHelpers_setU16At_3'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_setU16At_3', 3);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_setU32At_3'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_setU32At_3');
  _emscripten_bind_NativeArrayHelpers_setU32At_3 = Module['_emscripten_bind_NativeArrayHelpers_setU32At_3'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_setU32At_3', 3);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_setRealAt_3'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_setRealAt_3');
  _emscripten_bind_NativeArrayHelpers_setRealAt_3 = Module['_emscripten_bind_NativeArrayHelpers_setRealAt_3'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_setRealAt_3', 3);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_voidToU8Ptr_1'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_voidToU8Ptr_1');
  _emscripten_bind_NativeArrayHelpers_voidToU8Ptr_1 = Module['_emscripten_bind_NativeArrayHelpers_voidToU8Ptr_1'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_voidToU8Ptr_1', 1);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_voidToU16Ptr_1'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_voidToU16Ptr_1');
  _emscripten_bind_NativeArrayHelpers_voidToU16Ptr_1 = Module['_emscripten_bind_NativeArrayHelpers_voidToU16Ptr_1'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_voidToU16Ptr_1', 1);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_voidToU32Ptr_1'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_voidToU32Ptr_1');
  _emscripten_bind_NativeArrayHelpers_voidToU32Ptr_1 = Module['_emscripten_bind_NativeArrayHelpers_voidToU32Ptr_1'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_voidToU32Ptr_1', 1);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_voidToI32Ptr_1'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_voidToI32Ptr_1');
  _emscripten_bind_NativeArrayHelpers_voidToI32Ptr_1 = Module['_emscripten_bind_NativeArrayHelpers_voidToI32Ptr_1'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_voidToI32Ptr_1', 1);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_voidToRealPtr_1'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_voidToRealPtr_1');
  _emscripten_bind_NativeArrayHelpers_voidToRealPtr_1 = Module['_emscripten_bind_NativeArrayHelpers_voidToRealPtr_1'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_voidToRealPtr_1', 1);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getActorAt_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getActorAt_2');
  _emscripten_bind_NativeArrayHelpers_getActorAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getActorAt_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getActorAt_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getBounds3At_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getBounds3At_2');
  _emscripten_bind_NativeArrayHelpers_getBounds3At_2 = Module['_emscripten_bind_NativeArrayHelpers_getBounds3At_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getBounds3At_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getContactPairAt_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getContactPairAt_2');
  _emscripten_bind_NativeArrayHelpers_getContactPairAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getContactPairAt_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getContactPairAt_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getContactPairHeaderAt_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getContactPairHeaderAt_2');
  _emscripten_bind_NativeArrayHelpers_getContactPairHeaderAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getContactPairHeaderAt_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getContactPairHeaderAt_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getControllerAt_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getControllerAt_2');
  _emscripten_bind_NativeArrayHelpers_getControllerAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getControllerAt_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getControllerAt_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getControllerShapeHitAt_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getControllerShapeHitAt_2');
  _emscripten_bind_NativeArrayHelpers_getControllerShapeHitAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getControllerShapeHitAt_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getControllerShapeHitAt_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getControllersHitAt_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getControllersHitAt_2');
  _emscripten_bind_NativeArrayHelpers_getControllersHitAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getControllersHitAt_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getControllersHitAt_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getControllerObstacleHitAt_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getControllerObstacleHitAt_2');
  _emscripten_bind_NativeArrayHelpers_getControllerObstacleHitAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getControllerObstacleHitAt_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getControllerObstacleHitAt_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getDebugPointAt_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getDebugPointAt_2');
  _emscripten_bind_NativeArrayHelpers_getDebugPointAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getDebugPointAt_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getDebugPointAt_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getDebugLineAt_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getDebugLineAt_2');
  _emscripten_bind_NativeArrayHelpers_getDebugLineAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getDebugLineAt_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getDebugLineAt_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getDebugTriangleAt_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getDebugTriangleAt_2');
  _emscripten_bind_NativeArrayHelpers_getDebugTriangleAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getDebugTriangleAt_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getDebugTriangleAt_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getObstacleAt_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getObstacleAt_2');
  _emscripten_bind_NativeArrayHelpers_getObstacleAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getObstacleAt_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getObstacleAt_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getShapeAt_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getShapeAt_2');
  _emscripten_bind_NativeArrayHelpers_getShapeAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getShapeAt_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getShapeAt_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getTriggerPairAt_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getTriggerPairAt_2');
  _emscripten_bind_NativeArrayHelpers_getTriggerPairAt_2 = Module['_emscripten_bind_NativeArrayHelpers_getTriggerPairAt_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getTriggerPairAt_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers_getVec3At_2'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers_getVec3At_2');
  _emscripten_bind_NativeArrayHelpers_getVec3At_2 = Module['_emscripten_bind_NativeArrayHelpers_getVec3At_2'] = createExportWrapper('emscripten_bind_NativeArrayHelpers_getVec3At_2', 2);
  assert(typeof wasmExports['emscripten_bind_NativeArrayHelpers___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_NativeArrayHelpers___destroy___0');
  _emscripten_bind_NativeArrayHelpers___destroy___0 = Module['_emscripten_bind_NativeArrayHelpers___destroy___0'] = createExportWrapper('emscripten_bind_NativeArrayHelpers___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PassThroughFilterShaderImpl_PassThroughFilterShaderImpl_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PassThroughFilterShaderImpl_PassThroughFilterShaderImpl_0');
  _emscripten_bind_PassThroughFilterShaderImpl_PassThroughFilterShaderImpl_0 = Module['_emscripten_bind_PassThroughFilterShaderImpl_PassThroughFilterShaderImpl_0'] = createExportWrapper('emscripten_bind_PassThroughFilterShaderImpl_PassThroughFilterShaderImpl_0', 0);
  assert(typeof wasmExports['emscripten_bind_PassThroughFilterShaderImpl_filterShader_10'] != 'undefined', 'missing Wasm export: emscripten_bind_PassThroughFilterShaderImpl_filterShader_10');
  _emscripten_bind_PassThroughFilterShaderImpl_filterShader_10 = Module['_emscripten_bind_PassThroughFilterShaderImpl_filterShader_10'] = createExportWrapper('emscripten_bind_PassThroughFilterShaderImpl_filterShader_10', 11);
  assert(typeof wasmExports['emscripten_bind_PassThroughFilterShaderImpl___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PassThroughFilterShaderImpl___destroy___0');
  _emscripten_bind_PassThroughFilterShaderImpl___destroy___0 = Module['_emscripten_bind_PassThroughFilterShaderImpl___destroy___0'] = createExportWrapper('emscripten_bind_PassThroughFilterShaderImpl___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_PhysXIntegrationParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_PhysXIntegrationParams_0');
  _emscripten_bind_PhysXIntegrationParams_PhysXIntegrationParams_0 = Module['_emscripten_bind_PhysXIntegrationParams_PhysXIntegrationParams_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_PhysXIntegrationParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_transformAndScale_4');
  _emscripten_bind_PhysXIntegrationParams_transformAndScale_4 = Module['_emscripten_bind_PhysXIntegrationParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_isValid_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_isValid_1');
  _emscripten_bind_PhysXIntegrationParams_isValid_1 = Module['_emscripten_bind_PhysXIntegrationParams_isValid_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_isValid_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_create_10'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_create_10');
  _emscripten_bind_PhysXIntegrationParams_create_10 = Module['_emscripten_bind_PhysXIntegrationParams_create_10'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_create_10', 11);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_get_physxRoadGeometryQueryParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_get_physxRoadGeometryQueryParams_0');
  _emscripten_bind_PhysXIntegrationParams_get_physxRoadGeometryQueryParams_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxRoadGeometryQueryParams_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_get_physxRoadGeometryQueryParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_set_physxRoadGeometryQueryParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_set_physxRoadGeometryQueryParams_1');
  _emscripten_bind_PhysXIntegrationParams_set_physxRoadGeometryQueryParams_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxRoadGeometryQueryParams_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_set_physxRoadGeometryQueryParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_get_physxMaterialFrictionParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_get_physxMaterialFrictionParams_1');
  _emscripten_bind_PhysXIntegrationParams_get_physxMaterialFrictionParams_1 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxMaterialFrictionParams_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_get_physxMaterialFrictionParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_set_physxMaterialFrictionParams_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_set_physxMaterialFrictionParams_2');
  _emscripten_bind_PhysXIntegrationParams_set_physxMaterialFrictionParams_2 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxMaterialFrictionParams_2'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_set_physxMaterialFrictionParams_2', 3);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_get_physxSuspensionLimitConstraintParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_get_physxSuspensionLimitConstraintParams_1');
  _emscripten_bind_PhysXIntegrationParams_get_physxSuspensionLimitConstraintParams_1 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxSuspensionLimitConstraintParams_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_get_physxSuspensionLimitConstraintParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_set_physxSuspensionLimitConstraintParams_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_set_physxSuspensionLimitConstraintParams_2');
  _emscripten_bind_PhysXIntegrationParams_set_physxSuspensionLimitConstraintParams_2 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxSuspensionLimitConstraintParams_2'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_set_physxSuspensionLimitConstraintParams_2', 3);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_get_physxActorCMassLocalPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_get_physxActorCMassLocalPose_0');
  _emscripten_bind_PhysXIntegrationParams_get_physxActorCMassLocalPose_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorCMassLocalPose_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_get_physxActorCMassLocalPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_set_physxActorCMassLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_set_physxActorCMassLocalPose_1');
  _emscripten_bind_PhysXIntegrationParams_set_physxActorCMassLocalPose_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorCMassLocalPose_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_set_physxActorCMassLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_get_physxActorGeometry_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_get_physxActorGeometry_0');
  _emscripten_bind_PhysXIntegrationParams_get_physxActorGeometry_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorGeometry_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_get_physxActorGeometry_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_set_physxActorGeometry_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_set_physxActorGeometry_1');
  _emscripten_bind_PhysXIntegrationParams_set_physxActorGeometry_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorGeometry_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_set_physxActorGeometry_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_get_physxActorBoxShapeLocalPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_get_physxActorBoxShapeLocalPose_0');
  _emscripten_bind_PhysXIntegrationParams_get_physxActorBoxShapeLocalPose_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorBoxShapeLocalPose_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_get_physxActorBoxShapeLocalPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_set_physxActorBoxShapeLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_set_physxActorBoxShapeLocalPose_1');
  _emscripten_bind_PhysXIntegrationParams_set_physxActorBoxShapeLocalPose_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorBoxShapeLocalPose_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_set_physxActorBoxShapeLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_get_physxWheelShapeLocalPoses_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_get_physxWheelShapeLocalPoses_1');
  _emscripten_bind_PhysXIntegrationParams_get_physxWheelShapeLocalPoses_1 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxWheelShapeLocalPoses_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_get_physxWheelShapeLocalPoses_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_set_physxWheelShapeLocalPoses_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_set_physxWheelShapeLocalPoses_2');
  _emscripten_bind_PhysXIntegrationParams_set_physxWheelShapeLocalPoses_2 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxWheelShapeLocalPoses_2'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_set_physxWheelShapeLocalPoses_2', 3);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_get_physxActorShapeFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_get_physxActorShapeFlags_0');
  _emscripten_bind_PhysXIntegrationParams_get_physxActorShapeFlags_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorShapeFlags_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_get_physxActorShapeFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_set_physxActorShapeFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_set_physxActorShapeFlags_1');
  _emscripten_bind_PhysXIntegrationParams_set_physxActorShapeFlags_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorShapeFlags_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_set_physxActorShapeFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_get_physxActorSimulationFilterData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_get_physxActorSimulationFilterData_0');
  _emscripten_bind_PhysXIntegrationParams_get_physxActorSimulationFilterData_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorSimulationFilterData_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_get_physxActorSimulationFilterData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_set_physxActorSimulationFilterData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_set_physxActorSimulationFilterData_1');
  _emscripten_bind_PhysXIntegrationParams_set_physxActorSimulationFilterData_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorSimulationFilterData_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_set_physxActorSimulationFilterData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_get_physxActorQueryFilterData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_get_physxActorQueryFilterData_0');
  _emscripten_bind_PhysXIntegrationParams_get_physxActorQueryFilterData_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorQueryFilterData_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_get_physxActorQueryFilterData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_set_physxActorQueryFilterData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_set_physxActorQueryFilterData_1');
  _emscripten_bind_PhysXIntegrationParams_set_physxActorQueryFilterData_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorQueryFilterData_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_set_physxActorQueryFilterData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_get_physxActorWheelShapeFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_get_physxActorWheelShapeFlags_0');
  _emscripten_bind_PhysXIntegrationParams_get_physxActorWheelShapeFlags_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorWheelShapeFlags_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_get_physxActorWheelShapeFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_set_physxActorWheelShapeFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_set_physxActorWheelShapeFlags_1');
  _emscripten_bind_PhysXIntegrationParams_set_physxActorWheelShapeFlags_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorWheelShapeFlags_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_set_physxActorWheelShapeFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_get_physxActorWheelSimulationFilterData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_get_physxActorWheelSimulationFilterData_0');
  _emscripten_bind_PhysXIntegrationParams_get_physxActorWheelSimulationFilterData_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorWheelSimulationFilterData_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_get_physxActorWheelSimulationFilterData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_set_physxActorWheelSimulationFilterData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_set_physxActorWheelSimulationFilterData_1');
  _emscripten_bind_PhysXIntegrationParams_set_physxActorWheelSimulationFilterData_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorWheelSimulationFilterData_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_set_physxActorWheelSimulationFilterData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_get_physxActorWheelQueryFilterData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_get_physxActorWheelQueryFilterData_0');
  _emscripten_bind_PhysXIntegrationParams_get_physxActorWheelQueryFilterData_0 = Module['_emscripten_bind_PhysXIntegrationParams_get_physxActorWheelQueryFilterData_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_get_physxActorWheelQueryFilterData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams_set_physxActorWheelQueryFilterData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams_set_physxActorWheelQueryFilterData_1');
  _emscripten_bind_PhysXIntegrationParams_set_physxActorWheelQueryFilterData_1 = Module['_emscripten_bind_PhysXIntegrationParams_set_physxActorWheelQueryFilterData_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams_set_physxActorWheelQueryFilterData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationParams___destroy___0');
  _emscripten_bind_PhysXIntegrationParams___destroy___0 = Module['_emscripten_bind_PhysXIntegrationParams___destroy___0'] = createExportWrapper('emscripten_bind_PhysXIntegrationParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationState_PhysXIntegrationState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationState_PhysXIntegrationState_0');
  _emscripten_bind_PhysXIntegrationState_PhysXIntegrationState_0 = Module['_emscripten_bind_PhysXIntegrationState_PhysXIntegrationState_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationState_PhysXIntegrationState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationState_destroyState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationState_destroyState_0');
  _emscripten_bind_PhysXIntegrationState_destroyState_0 = Module['_emscripten_bind_PhysXIntegrationState_destroyState_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationState_destroyState_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationState_setToDefault_0');
  _emscripten_bind_PhysXIntegrationState_setToDefault_0 = Module['_emscripten_bind_PhysXIntegrationState_setToDefault_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationState_create_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationState_create_5');
  _emscripten_bind_PhysXIntegrationState_create_5 = Module['_emscripten_bind_PhysXIntegrationState_create_5'] = createExportWrapper('emscripten_bind_PhysXIntegrationState_create_5', 6);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationState_get_physxActor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationState_get_physxActor_0');
  _emscripten_bind_PhysXIntegrationState_get_physxActor_0 = Module['_emscripten_bind_PhysXIntegrationState_get_physxActor_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationState_get_physxActor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationState_set_physxActor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationState_set_physxActor_1');
  _emscripten_bind_PhysXIntegrationState_set_physxActor_1 = Module['_emscripten_bind_PhysXIntegrationState_set_physxActor_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationState_set_physxActor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationState_get_physxSteerState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationState_get_physxSteerState_0');
  _emscripten_bind_PhysXIntegrationState_get_physxSteerState_0 = Module['_emscripten_bind_PhysXIntegrationState_get_physxSteerState_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationState_get_physxSteerState_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationState_set_physxSteerState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationState_set_physxSteerState_1');
  _emscripten_bind_PhysXIntegrationState_set_physxSteerState_1 = Module['_emscripten_bind_PhysXIntegrationState_set_physxSteerState_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationState_set_physxSteerState_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationState_get_physxConstraints_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationState_get_physxConstraints_0');
  _emscripten_bind_PhysXIntegrationState_get_physxConstraints_0 = Module['_emscripten_bind_PhysXIntegrationState_get_physxConstraints_0'] = createExportWrapper('emscripten_bind_PhysXIntegrationState_get_physxConstraints_0', 1);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationState_set_physxConstraints_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationState_set_physxConstraints_1');
  _emscripten_bind_PhysXIntegrationState_set_physxConstraints_1 = Module['_emscripten_bind_PhysXIntegrationState_set_physxConstraints_1'] = createExportWrapper('emscripten_bind_PhysXIntegrationState_set_physxConstraints_1', 2);
  assert(typeof wasmExports['emscripten_bind_PhysXIntegrationState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PhysXIntegrationState___destroy___0');
  _emscripten_bind_PhysXIntegrationState___destroy___0 = Module['_emscripten_bind_PhysXIntegrationState___destroy___0'] = createExportWrapper('emscripten_bind_PhysXIntegrationState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActorFlags_PxActorFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActorFlags_PxActorFlags_1');
  _emscripten_bind_PxActorFlags_PxActorFlags_1 = Module['_emscripten_bind_PxActorFlags_PxActorFlags_1'] = createExportWrapper('emscripten_bind_PxActorFlags_PxActorFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxActorFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActorFlags_isSet_1');
  _emscripten_bind_PxActorFlags_isSet_1 = Module['_emscripten_bind_PxActorFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxActorFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxActorFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActorFlags_raise_1');
  _emscripten_bind_PxActorFlags_raise_1 = Module['_emscripten_bind_PxActorFlags_raise_1'] = createExportWrapper('emscripten_bind_PxActorFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxActorFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActorFlags_clear_1');
  _emscripten_bind_PxActorFlags_clear_1 = Module['_emscripten_bind_PxActorFlags_clear_1'] = createExportWrapper('emscripten_bind_PxActorFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxActorFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActorFlags___destroy___0');
  _emscripten_bind_PxActorFlags___destroy___0 = Module['_emscripten_bind_PxActorFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxActorFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActorPtr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActorPtr___destroy___0');
  _emscripten_bind_PxActorPtr___destroy___0 = Module['_emscripten_bind_PxActorPtr___destroy___0'] = createExportWrapper('emscripten_bind_PxActorPtr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxActorTypeFlags_PxActorTypeFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActorTypeFlags_PxActorTypeFlags_1');
  _emscripten_bind_PxActorTypeFlags_PxActorTypeFlags_1 = Module['_emscripten_bind_PxActorTypeFlags_PxActorTypeFlags_1'] = createExportWrapper('emscripten_bind_PxActorTypeFlags_PxActorTypeFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxActorTypeFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActorTypeFlags_isSet_1');
  _emscripten_bind_PxActorTypeFlags_isSet_1 = Module['_emscripten_bind_PxActorTypeFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxActorTypeFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxActorTypeFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActorTypeFlags_raise_1');
  _emscripten_bind_PxActorTypeFlags_raise_1 = Module['_emscripten_bind_PxActorTypeFlags_raise_1'] = createExportWrapper('emscripten_bind_PxActorTypeFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxActorTypeFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActorTypeFlags_clear_1');
  _emscripten_bind_PxActorTypeFlags_clear_1 = Module['_emscripten_bind_PxActorTypeFlags_clear_1'] = createExportWrapper('emscripten_bind_PxActorTypeFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxActorTypeFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxActorTypeFlags___destroy___0');
  _emscripten_bind_PxActorTypeFlags___destroy___0 = Module['_emscripten_bind_PxActorTypeFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxActorTypeFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_addActor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_addActor_1');
  _emscripten_bind_PxAggregate_addActor_1 = Module['_emscripten_bind_PxAggregate_addActor_1'] = createExportWrapper('emscripten_bind_PxAggregate_addActor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_addActor_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_addActor_2');
  _emscripten_bind_PxAggregate_addActor_2 = Module['_emscripten_bind_PxAggregate_addActor_2'] = createExportWrapper('emscripten_bind_PxAggregate_addActor_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_removeActor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_removeActor_1');
  _emscripten_bind_PxAggregate_removeActor_1 = Module['_emscripten_bind_PxAggregate_removeActor_1'] = createExportWrapper('emscripten_bind_PxAggregate_removeActor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_addArticulation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_addArticulation_1');
  _emscripten_bind_PxAggregate_addArticulation_1 = Module['_emscripten_bind_PxAggregate_addArticulation_1'] = createExportWrapper('emscripten_bind_PxAggregate_addArticulation_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_removeArticulation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_removeArticulation_1');
  _emscripten_bind_PxAggregate_removeArticulation_1 = Module['_emscripten_bind_PxAggregate_removeArticulation_1'] = createExportWrapper('emscripten_bind_PxAggregate_removeArticulation_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_getNbActors_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_getNbActors_0');
  _emscripten_bind_PxAggregate_getNbActors_0 = Module['_emscripten_bind_PxAggregate_getNbActors_0'] = createExportWrapper('emscripten_bind_PxAggregate_getNbActors_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_getMaxNbActors_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_getMaxNbActors_0');
  _emscripten_bind_PxAggregate_getMaxNbActors_0 = Module['_emscripten_bind_PxAggregate_getMaxNbActors_0'] = createExportWrapper('emscripten_bind_PxAggregate_getMaxNbActors_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_getMaxNbShapes_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_getMaxNbShapes_0');
  _emscripten_bind_PxAggregate_getMaxNbShapes_0 = Module['_emscripten_bind_PxAggregate_getMaxNbShapes_0'] = createExportWrapper('emscripten_bind_PxAggregate_getMaxNbShapes_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_getScene_0');
  _emscripten_bind_PxAggregate_getScene_0 = Module['_emscripten_bind_PxAggregate_getScene_0'] = createExportWrapper('emscripten_bind_PxAggregate_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_getSelfCollision_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_getSelfCollision_0');
  _emscripten_bind_PxAggregate_getSelfCollision_0 = Module['_emscripten_bind_PxAggregate_getSelfCollision_0'] = createExportWrapper('emscripten_bind_PxAggregate_getSelfCollision_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_release_0');
  _emscripten_bind_PxAggregate_release_0 = Module['_emscripten_bind_PxAggregate_release_0'] = createExportWrapper('emscripten_bind_PxAggregate_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_getConcreteTypeName_0');
  _emscripten_bind_PxAggregate_getConcreteTypeName_0 = Module['_emscripten_bind_PxAggregate_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxAggregate_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_getConcreteType_0');
  _emscripten_bind_PxAggregate_getConcreteType_0 = Module['_emscripten_bind_PxAggregate_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxAggregate_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_setBaseFlag_2');
  _emscripten_bind_PxAggregate_setBaseFlag_2 = Module['_emscripten_bind_PxAggregate_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxAggregate_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_setBaseFlags_1');
  _emscripten_bind_PxAggregate_setBaseFlags_1 = Module['_emscripten_bind_PxAggregate_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxAggregate_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_getBaseFlags_0');
  _emscripten_bind_PxAggregate_getBaseFlags_0 = Module['_emscripten_bind_PxAggregate_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxAggregate_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxAggregate_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxAggregate_isReleasable_0');
  _emscripten_bind_PxAggregate_isReleasable_0 = Module['_emscripten_bind_PxAggregate_isReleasable_0'] = createExportWrapper('emscripten_bind_PxAggregate_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_0');
  _emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_0 = Module['_emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_0'] = createExportWrapper('emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_1');
  _emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_1 = Module['_emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_1'] = createExportWrapper('emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxActorPtr_get_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxActorPtr_get_1');
  _emscripten_bind_PxArray_PxActorPtr_get_1 = Module['_emscripten_bind_PxArray_PxActorPtr_get_1'] = createExportWrapper('emscripten_bind_PxArray_PxActorPtr_get_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxActorPtr_set_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxActorPtr_set_2');
  _emscripten_bind_PxArray_PxActorPtr_set_2 = Module['_emscripten_bind_PxArray_PxActorPtr_set_2'] = createExportWrapper('emscripten_bind_PxArray_PxActorPtr_set_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxActorPtr_begin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxActorPtr_begin_0');
  _emscripten_bind_PxArray_PxActorPtr_begin_0 = Module['_emscripten_bind_PxArray_PxActorPtr_begin_0'] = createExportWrapper('emscripten_bind_PxArray_PxActorPtr_begin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxActorPtr_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxActorPtr_size_0');
  _emscripten_bind_PxArray_PxActorPtr_size_0 = Module['_emscripten_bind_PxArray_PxActorPtr_size_0'] = createExportWrapper('emscripten_bind_PxArray_PxActorPtr_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxActorPtr_pushBack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxActorPtr_pushBack_1');
  _emscripten_bind_PxArray_PxActorPtr_pushBack_1 = Module['_emscripten_bind_PxArray_PxActorPtr_pushBack_1'] = createExportWrapper('emscripten_bind_PxArray_PxActorPtr_pushBack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxActorPtr_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxActorPtr_clear_0');
  _emscripten_bind_PxArray_PxActorPtr_clear_0 = Module['_emscripten_bind_PxArray_PxActorPtr_clear_0'] = createExportWrapper('emscripten_bind_PxArray_PxActorPtr_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxActorPtr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxActorPtr___destroy___0');
  _emscripten_bind_PxArray_PxActorPtr___destroy___0 = Module['_emscripten_bind_PxArray_PxActorPtr___destroy___0'] = createExportWrapper('emscripten_bind_PxArray_PxActorPtr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_0');
  _emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_0 = Module['_emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_0'] = createExportWrapper('emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_1');
  _emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_1 = Module['_emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_1'] = createExportWrapper('emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxContactPairPoint_get_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxContactPairPoint_get_1');
  _emscripten_bind_PxArray_PxContactPairPoint_get_1 = Module['_emscripten_bind_PxArray_PxContactPairPoint_get_1'] = createExportWrapper('emscripten_bind_PxArray_PxContactPairPoint_get_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxContactPairPoint_set_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxContactPairPoint_set_2');
  _emscripten_bind_PxArray_PxContactPairPoint_set_2 = Module['_emscripten_bind_PxArray_PxContactPairPoint_set_2'] = createExportWrapper('emscripten_bind_PxArray_PxContactPairPoint_set_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxContactPairPoint_begin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxContactPairPoint_begin_0');
  _emscripten_bind_PxArray_PxContactPairPoint_begin_0 = Module['_emscripten_bind_PxArray_PxContactPairPoint_begin_0'] = createExportWrapper('emscripten_bind_PxArray_PxContactPairPoint_begin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxContactPairPoint_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxContactPairPoint_size_0');
  _emscripten_bind_PxArray_PxContactPairPoint_size_0 = Module['_emscripten_bind_PxArray_PxContactPairPoint_size_0'] = createExportWrapper('emscripten_bind_PxArray_PxContactPairPoint_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxContactPairPoint_pushBack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxContactPairPoint_pushBack_1');
  _emscripten_bind_PxArray_PxContactPairPoint_pushBack_1 = Module['_emscripten_bind_PxArray_PxContactPairPoint_pushBack_1'] = createExportWrapper('emscripten_bind_PxArray_PxContactPairPoint_pushBack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxContactPairPoint_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxContactPairPoint_clear_0');
  _emscripten_bind_PxArray_PxContactPairPoint_clear_0 = Module['_emscripten_bind_PxArray_PxContactPairPoint_clear_0'] = createExportWrapper('emscripten_bind_PxArray_PxContactPairPoint_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxContactPairPoint___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxContactPairPoint___destroy___0');
  _emscripten_bind_PxArray_PxContactPairPoint___destroy___0 = Module['_emscripten_bind_PxArray_PxContactPairPoint___destroy___0'] = createExportWrapper('emscripten_bind_PxArray_PxContactPairPoint___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_0');
  _emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_0 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_0'] = createExportWrapper('emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_1');
  _emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_1 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_1'] = createExportWrapper('emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxHeightFieldSample_get_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxHeightFieldSample_get_1');
  _emscripten_bind_PxArray_PxHeightFieldSample_get_1 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_get_1'] = createExportWrapper('emscripten_bind_PxArray_PxHeightFieldSample_get_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxHeightFieldSample_set_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxHeightFieldSample_set_2');
  _emscripten_bind_PxArray_PxHeightFieldSample_set_2 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_set_2'] = createExportWrapper('emscripten_bind_PxArray_PxHeightFieldSample_set_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxHeightFieldSample_begin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxHeightFieldSample_begin_0');
  _emscripten_bind_PxArray_PxHeightFieldSample_begin_0 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_begin_0'] = createExportWrapper('emscripten_bind_PxArray_PxHeightFieldSample_begin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxHeightFieldSample_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxHeightFieldSample_size_0');
  _emscripten_bind_PxArray_PxHeightFieldSample_size_0 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_size_0'] = createExportWrapper('emscripten_bind_PxArray_PxHeightFieldSample_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxHeightFieldSample_pushBack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxHeightFieldSample_pushBack_1');
  _emscripten_bind_PxArray_PxHeightFieldSample_pushBack_1 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_pushBack_1'] = createExportWrapper('emscripten_bind_PxArray_PxHeightFieldSample_pushBack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxHeightFieldSample_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxHeightFieldSample_clear_0');
  _emscripten_bind_PxArray_PxHeightFieldSample_clear_0 = Module['_emscripten_bind_PxArray_PxHeightFieldSample_clear_0'] = createExportWrapper('emscripten_bind_PxArray_PxHeightFieldSample_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxHeightFieldSample___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxHeightFieldSample___destroy___0');
  _emscripten_bind_PxArray_PxHeightFieldSample___destroy___0 = Module['_emscripten_bind_PxArray_PxHeightFieldSample___destroy___0'] = createExportWrapper('emscripten_bind_PxArray_PxHeightFieldSample___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_0');
  _emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_0 = Module['_emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_0'] = createExportWrapper('emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_1');
  _emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_1 = Module['_emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_1'] = createExportWrapper('emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxMaterialConst_get_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxMaterialConst_get_1');
  _emscripten_bind_PxArray_PxMaterialConst_get_1 = Module['_emscripten_bind_PxArray_PxMaterialConst_get_1'] = createExportWrapper('emscripten_bind_PxArray_PxMaterialConst_get_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxMaterialConst_set_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxMaterialConst_set_2');
  _emscripten_bind_PxArray_PxMaterialConst_set_2 = Module['_emscripten_bind_PxArray_PxMaterialConst_set_2'] = createExportWrapper('emscripten_bind_PxArray_PxMaterialConst_set_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxMaterialConst_begin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxMaterialConst_begin_0');
  _emscripten_bind_PxArray_PxMaterialConst_begin_0 = Module['_emscripten_bind_PxArray_PxMaterialConst_begin_0'] = createExportWrapper('emscripten_bind_PxArray_PxMaterialConst_begin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxMaterialConst_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxMaterialConst_size_0');
  _emscripten_bind_PxArray_PxMaterialConst_size_0 = Module['_emscripten_bind_PxArray_PxMaterialConst_size_0'] = createExportWrapper('emscripten_bind_PxArray_PxMaterialConst_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxMaterialConst_pushBack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxMaterialConst_pushBack_1');
  _emscripten_bind_PxArray_PxMaterialConst_pushBack_1 = Module['_emscripten_bind_PxArray_PxMaterialConst_pushBack_1'] = createExportWrapper('emscripten_bind_PxArray_PxMaterialConst_pushBack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxMaterialConst_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxMaterialConst_clear_0');
  _emscripten_bind_PxArray_PxMaterialConst_clear_0 = Module['_emscripten_bind_PxArray_PxMaterialConst_clear_0'] = createExportWrapper('emscripten_bind_PxArray_PxMaterialConst_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxMaterialConst___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxMaterialConst___destroy___0');
  _emscripten_bind_PxArray_PxMaterialConst___destroy___0 = Module['_emscripten_bind_PxArray_PxMaterialConst___destroy___0'] = createExportWrapper('emscripten_bind_PxArray_PxMaterialConst___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_0');
  _emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_0 = Module['_emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_0'] = createExportWrapper('emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_1');
  _emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_1 = Module['_emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_1'] = createExportWrapper('emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxRaycastHit_get_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxRaycastHit_get_1');
  _emscripten_bind_PxArray_PxRaycastHit_get_1 = Module['_emscripten_bind_PxArray_PxRaycastHit_get_1'] = createExportWrapper('emscripten_bind_PxArray_PxRaycastHit_get_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxRaycastHit_set_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxRaycastHit_set_2');
  _emscripten_bind_PxArray_PxRaycastHit_set_2 = Module['_emscripten_bind_PxArray_PxRaycastHit_set_2'] = createExportWrapper('emscripten_bind_PxArray_PxRaycastHit_set_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxRaycastHit_begin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxRaycastHit_begin_0');
  _emscripten_bind_PxArray_PxRaycastHit_begin_0 = Module['_emscripten_bind_PxArray_PxRaycastHit_begin_0'] = createExportWrapper('emscripten_bind_PxArray_PxRaycastHit_begin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxRaycastHit_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxRaycastHit_size_0');
  _emscripten_bind_PxArray_PxRaycastHit_size_0 = Module['_emscripten_bind_PxArray_PxRaycastHit_size_0'] = createExportWrapper('emscripten_bind_PxArray_PxRaycastHit_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxRaycastHit_pushBack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxRaycastHit_pushBack_1');
  _emscripten_bind_PxArray_PxRaycastHit_pushBack_1 = Module['_emscripten_bind_PxArray_PxRaycastHit_pushBack_1'] = createExportWrapper('emscripten_bind_PxArray_PxRaycastHit_pushBack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxRaycastHit_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxRaycastHit_clear_0');
  _emscripten_bind_PxArray_PxRaycastHit_clear_0 = Module['_emscripten_bind_PxArray_PxRaycastHit_clear_0'] = createExportWrapper('emscripten_bind_PxArray_PxRaycastHit_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxRaycastHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxRaycastHit___destroy___0');
  _emscripten_bind_PxArray_PxRaycastHit___destroy___0 = Module['_emscripten_bind_PxArray_PxRaycastHit___destroy___0'] = createExportWrapper('emscripten_bind_PxArray_PxRaycastHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxReal_PxArray_PxReal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxReal_PxArray_PxReal_0');
  _emscripten_bind_PxArray_PxReal_PxArray_PxReal_0 = Module['_emscripten_bind_PxArray_PxReal_PxArray_PxReal_0'] = createExportWrapper('emscripten_bind_PxArray_PxReal_PxArray_PxReal_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxReal_PxArray_PxReal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxReal_PxArray_PxReal_1');
  _emscripten_bind_PxArray_PxReal_PxArray_PxReal_1 = Module['_emscripten_bind_PxArray_PxReal_PxArray_PxReal_1'] = createExportWrapper('emscripten_bind_PxArray_PxReal_PxArray_PxReal_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxReal_get_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxReal_get_1');
  _emscripten_bind_PxArray_PxReal_get_1 = Module['_emscripten_bind_PxArray_PxReal_get_1'] = createExportWrapper('emscripten_bind_PxArray_PxReal_get_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxReal_set_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxReal_set_2');
  _emscripten_bind_PxArray_PxReal_set_2 = Module['_emscripten_bind_PxArray_PxReal_set_2'] = createExportWrapper('emscripten_bind_PxArray_PxReal_set_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxReal_begin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxReal_begin_0');
  _emscripten_bind_PxArray_PxReal_begin_0 = Module['_emscripten_bind_PxArray_PxReal_begin_0'] = createExportWrapper('emscripten_bind_PxArray_PxReal_begin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxReal_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxReal_size_0');
  _emscripten_bind_PxArray_PxReal_size_0 = Module['_emscripten_bind_PxArray_PxReal_size_0'] = createExportWrapper('emscripten_bind_PxArray_PxReal_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxReal_pushBack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxReal_pushBack_1');
  _emscripten_bind_PxArray_PxReal_pushBack_1 = Module['_emscripten_bind_PxArray_PxReal_pushBack_1'] = createExportWrapper('emscripten_bind_PxArray_PxReal_pushBack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxReal_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxReal_clear_0');
  _emscripten_bind_PxArray_PxReal_clear_0 = Module['_emscripten_bind_PxArray_PxReal_clear_0'] = createExportWrapper('emscripten_bind_PxArray_PxReal_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxReal___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxReal___destroy___0');
  _emscripten_bind_PxArray_PxReal___destroy___0 = Module['_emscripten_bind_PxArray_PxReal___destroy___0'] = createExportWrapper('emscripten_bind_PxArray_PxReal___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_0');
  _emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_0 = Module['_emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_0'] = createExportWrapper('emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_1');
  _emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_1 = Module['_emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_1'] = createExportWrapper('emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxShapePtr_get_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxShapePtr_get_1');
  _emscripten_bind_PxArray_PxShapePtr_get_1 = Module['_emscripten_bind_PxArray_PxShapePtr_get_1'] = createExportWrapper('emscripten_bind_PxArray_PxShapePtr_get_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxShapePtr_set_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxShapePtr_set_2');
  _emscripten_bind_PxArray_PxShapePtr_set_2 = Module['_emscripten_bind_PxArray_PxShapePtr_set_2'] = createExportWrapper('emscripten_bind_PxArray_PxShapePtr_set_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxShapePtr_begin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxShapePtr_begin_0');
  _emscripten_bind_PxArray_PxShapePtr_begin_0 = Module['_emscripten_bind_PxArray_PxShapePtr_begin_0'] = createExportWrapper('emscripten_bind_PxArray_PxShapePtr_begin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxShapePtr_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxShapePtr_size_0');
  _emscripten_bind_PxArray_PxShapePtr_size_0 = Module['_emscripten_bind_PxArray_PxShapePtr_size_0'] = createExportWrapper('emscripten_bind_PxArray_PxShapePtr_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxShapePtr_pushBack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxShapePtr_pushBack_1');
  _emscripten_bind_PxArray_PxShapePtr_pushBack_1 = Module['_emscripten_bind_PxArray_PxShapePtr_pushBack_1'] = createExportWrapper('emscripten_bind_PxArray_PxShapePtr_pushBack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxShapePtr_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxShapePtr_clear_0');
  _emscripten_bind_PxArray_PxShapePtr_clear_0 = Module['_emscripten_bind_PxArray_PxShapePtr_clear_0'] = createExportWrapper('emscripten_bind_PxArray_PxShapePtr_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxShapePtr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxShapePtr___destroy___0');
  _emscripten_bind_PxArray_PxShapePtr___destroy___0 = Module['_emscripten_bind_PxArray_PxShapePtr___destroy___0'] = createExportWrapper('emscripten_bind_PxArray_PxShapePtr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_0');
  _emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_0 = Module['_emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_0'] = createExportWrapper('emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_1');
  _emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_1 = Module['_emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_1'] = createExportWrapper('emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxSweepHit_get_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxSweepHit_get_1');
  _emscripten_bind_PxArray_PxSweepHit_get_1 = Module['_emscripten_bind_PxArray_PxSweepHit_get_1'] = createExportWrapper('emscripten_bind_PxArray_PxSweepHit_get_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxSweepHit_set_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxSweepHit_set_2');
  _emscripten_bind_PxArray_PxSweepHit_set_2 = Module['_emscripten_bind_PxArray_PxSweepHit_set_2'] = createExportWrapper('emscripten_bind_PxArray_PxSweepHit_set_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxSweepHit_begin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxSweepHit_begin_0');
  _emscripten_bind_PxArray_PxSweepHit_begin_0 = Module['_emscripten_bind_PxArray_PxSweepHit_begin_0'] = createExportWrapper('emscripten_bind_PxArray_PxSweepHit_begin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxSweepHit_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxSweepHit_size_0');
  _emscripten_bind_PxArray_PxSweepHit_size_0 = Module['_emscripten_bind_PxArray_PxSweepHit_size_0'] = createExportWrapper('emscripten_bind_PxArray_PxSweepHit_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxSweepHit_pushBack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxSweepHit_pushBack_1');
  _emscripten_bind_PxArray_PxSweepHit_pushBack_1 = Module['_emscripten_bind_PxArray_PxSweepHit_pushBack_1'] = createExportWrapper('emscripten_bind_PxArray_PxSweepHit_pushBack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxSweepHit_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxSweepHit_clear_0');
  _emscripten_bind_PxArray_PxSweepHit_clear_0 = Module['_emscripten_bind_PxArray_PxSweepHit_clear_0'] = createExportWrapper('emscripten_bind_PxArray_PxSweepHit_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxSweepHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxSweepHit___destroy___0');
  _emscripten_bind_PxArray_PxSweepHit___destroy___0 = Module['_emscripten_bind_PxArray_PxSweepHit___destroy___0'] = createExportWrapper('emscripten_bind_PxArray_PxSweepHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU16_PxArray_PxU16_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU16_PxArray_PxU16_0');
  _emscripten_bind_PxArray_PxU16_PxArray_PxU16_0 = Module['_emscripten_bind_PxArray_PxU16_PxArray_PxU16_0'] = createExportWrapper('emscripten_bind_PxArray_PxU16_PxArray_PxU16_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU16_PxArray_PxU16_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU16_PxArray_PxU16_1');
  _emscripten_bind_PxArray_PxU16_PxArray_PxU16_1 = Module['_emscripten_bind_PxArray_PxU16_PxArray_PxU16_1'] = createExportWrapper('emscripten_bind_PxArray_PxU16_PxArray_PxU16_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU16_get_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU16_get_1');
  _emscripten_bind_PxArray_PxU16_get_1 = Module['_emscripten_bind_PxArray_PxU16_get_1'] = createExportWrapper('emscripten_bind_PxArray_PxU16_get_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU16_set_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU16_set_2');
  _emscripten_bind_PxArray_PxU16_set_2 = Module['_emscripten_bind_PxArray_PxU16_set_2'] = createExportWrapper('emscripten_bind_PxArray_PxU16_set_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU16_begin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU16_begin_0');
  _emscripten_bind_PxArray_PxU16_begin_0 = Module['_emscripten_bind_PxArray_PxU16_begin_0'] = createExportWrapper('emscripten_bind_PxArray_PxU16_begin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU16_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU16_size_0');
  _emscripten_bind_PxArray_PxU16_size_0 = Module['_emscripten_bind_PxArray_PxU16_size_0'] = createExportWrapper('emscripten_bind_PxArray_PxU16_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU16_pushBack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU16_pushBack_1');
  _emscripten_bind_PxArray_PxU16_pushBack_1 = Module['_emscripten_bind_PxArray_PxU16_pushBack_1'] = createExportWrapper('emscripten_bind_PxArray_PxU16_pushBack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU16_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU16_clear_0');
  _emscripten_bind_PxArray_PxU16_clear_0 = Module['_emscripten_bind_PxArray_PxU16_clear_0'] = createExportWrapper('emscripten_bind_PxArray_PxU16_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU16___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU16___destroy___0');
  _emscripten_bind_PxArray_PxU16___destroy___0 = Module['_emscripten_bind_PxArray_PxU16___destroy___0'] = createExportWrapper('emscripten_bind_PxArray_PxU16___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU32_PxArray_PxU32_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU32_PxArray_PxU32_0');
  _emscripten_bind_PxArray_PxU32_PxArray_PxU32_0 = Module['_emscripten_bind_PxArray_PxU32_PxArray_PxU32_0'] = createExportWrapper('emscripten_bind_PxArray_PxU32_PxArray_PxU32_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU32_PxArray_PxU32_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU32_PxArray_PxU32_1');
  _emscripten_bind_PxArray_PxU32_PxArray_PxU32_1 = Module['_emscripten_bind_PxArray_PxU32_PxArray_PxU32_1'] = createExportWrapper('emscripten_bind_PxArray_PxU32_PxArray_PxU32_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU32_get_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU32_get_1');
  _emscripten_bind_PxArray_PxU32_get_1 = Module['_emscripten_bind_PxArray_PxU32_get_1'] = createExportWrapper('emscripten_bind_PxArray_PxU32_get_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU32_set_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU32_set_2');
  _emscripten_bind_PxArray_PxU32_set_2 = Module['_emscripten_bind_PxArray_PxU32_set_2'] = createExportWrapper('emscripten_bind_PxArray_PxU32_set_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU32_begin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU32_begin_0');
  _emscripten_bind_PxArray_PxU32_begin_0 = Module['_emscripten_bind_PxArray_PxU32_begin_0'] = createExportWrapper('emscripten_bind_PxArray_PxU32_begin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU32_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU32_size_0');
  _emscripten_bind_PxArray_PxU32_size_0 = Module['_emscripten_bind_PxArray_PxU32_size_0'] = createExportWrapper('emscripten_bind_PxArray_PxU32_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU32_pushBack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU32_pushBack_1');
  _emscripten_bind_PxArray_PxU32_pushBack_1 = Module['_emscripten_bind_PxArray_PxU32_pushBack_1'] = createExportWrapper('emscripten_bind_PxArray_PxU32_pushBack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU32_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU32_clear_0');
  _emscripten_bind_PxArray_PxU32_clear_0 = Module['_emscripten_bind_PxArray_PxU32_clear_0'] = createExportWrapper('emscripten_bind_PxArray_PxU32_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU32___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU32___destroy___0');
  _emscripten_bind_PxArray_PxU32___destroy___0 = Module['_emscripten_bind_PxArray_PxU32___destroy___0'] = createExportWrapper('emscripten_bind_PxArray_PxU32___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU8_PxArray_PxU8_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU8_PxArray_PxU8_0');
  _emscripten_bind_PxArray_PxU8_PxArray_PxU8_0 = Module['_emscripten_bind_PxArray_PxU8_PxArray_PxU8_0'] = createExportWrapper('emscripten_bind_PxArray_PxU8_PxArray_PxU8_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU8_PxArray_PxU8_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU8_PxArray_PxU8_1');
  _emscripten_bind_PxArray_PxU8_PxArray_PxU8_1 = Module['_emscripten_bind_PxArray_PxU8_PxArray_PxU8_1'] = createExportWrapper('emscripten_bind_PxArray_PxU8_PxArray_PxU8_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU8_get_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU8_get_1');
  _emscripten_bind_PxArray_PxU8_get_1 = Module['_emscripten_bind_PxArray_PxU8_get_1'] = createExportWrapper('emscripten_bind_PxArray_PxU8_get_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU8_set_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU8_set_2');
  _emscripten_bind_PxArray_PxU8_set_2 = Module['_emscripten_bind_PxArray_PxU8_set_2'] = createExportWrapper('emscripten_bind_PxArray_PxU8_set_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU8_begin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU8_begin_0');
  _emscripten_bind_PxArray_PxU8_begin_0 = Module['_emscripten_bind_PxArray_PxU8_begin_0'] = createExportWrapper('emscripten_bind_PxArray_PxU8_begin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU8_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU8_size_0');
  _emscripten_bind_PxArray_PxU8_size_0 = Module['_emscripten_bind_PxArray_PxU8_size_0'] = createExportWrapper('emscripten_bind_PxArray_PxU8_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU8_pushBack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU8_pushBack_1');
  _emscripten_bind_PxArray_PxU8_pushBack_1 = Module['_emscripten_bind_PxArray_PxU8_pushBack_1'] = createExportWrapper('emscripten_bind_PxArray_PxU8_pushBack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU8_setFromBuffer_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU8_setFromBuffer_2');
  _emscripten_bind_PxArray_PxU8_setFromBuffer_2 = Module['_emscripten_bind_PxArray_PxU8_setFromBuffer_2'] = createExportWrapper('emscripten_bind_PxArray_PxU8_setFromBuffer_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU8_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU8_clear_0');
  _emscripten_bind_PxArray_PxU8_clear_0 = Module['_emscripten_bind_PxArray_PxU8_clear_0'] = createExportWrapper('emscripten_bind_PxArray_PxU8_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxU8___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxU8___destroy___0');
  _emscripten_bind_PxArray_PxU8___destroy___0 = Module['_emscripten_bind_PxArray_PxU8___destroy___0'] = createExportWrapper('emscripten_bind_PxArray_PxU8___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_0');
  _emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_0 = Module['_emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_0'] = createExportWrapper('emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_1');
  _emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_1 = Module['_emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_1'] = createExportWrapper('emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec3_get_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec3_get_1');
  _emscripten_bind_PxArray_PxVec3_get_1 = Module['_emscripten_bind_PxArray_PxVec3_get_1'] = createExportWrapper('emscripten_bind_PxArray_PxVec3_get_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec3_set_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec3_set_2');
  _emscripten_bind_PxArray_PxVec3_set_2 = Module['_emscripten_bind_PxArray_PxVec3_set_2'] = createExportWrapper('emscripten_bind_PxArray_PxVec3_set_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec3_begin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec3_begin_0');
  _emscripten_bind_PxArray_PxVec3_begin_0 = Module['_emscripten_bind_PxArray_PxVec3_begin_0'] = createExportWrapper('emscripten_bind_PxArray_PxVec3_begin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec3_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec3_size_0');
  _emscripten_bind_PxArray_PxVec3_size_0 = Module['_emscripten_bind_PxArray_PxVec3_size_0'] = createExportWrapper('emscripten_bind_PxArray_PxVec3_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec3_pushBack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec3_pushBack_1');
  _emscripten_bind_PxArray_PxVec3_pushBack_1 = Module['_emscripten_bind_PxArray_PxVec3_pushBack_1'] = createExportWrapper('emscripten_bind_PxArray_PxVec3_pushBack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec3_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec3_clear_0');
  _emscripten_bind_PxArray_PxVec3_clear_0 = Module['_emscripten_bind_PxArray_PxVec3_clear_0'] = createExportWrapper('emscripten_bind_PxArray_PxVec3_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec3___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec3___destroy___0');
  _emscripten_bind_PxArray_PxVec3___destroy___0 = Module['_emscripten_bind_PxArray_PxVec3___destroy___0'] = createExportWrapper('emscripten_bind_PxArray_PxVec3___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_0');
  _emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_0 = Module['_emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_0'] = createExportWrapper('emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_1');
  _emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_1 = Module['_emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_1'] = createExportWrapper('emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec4_get_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec4_get_1');
  _emscripten_bind_PxArray_PxVec4_get_1 = Module['_emscripten_bind_PxArray_PxVec4_get_1'] = createExportWrapper('emscripten_bind_PxArray_PxVec4_get_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec4_set_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec4_set_2');
  _emscripten_bind_PxArray_PxVec4_set_2 = Module['_emscripten_bind_PxArray_PxVec4_set_2'] = createExportWrapper('emscripten_bind_PxArray_PxVec4_set_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec4_begin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec4_begin_0');
  _emscripten_bind_PxArray_PxVec4_begin_0 = Module['_emscripten_bind_PxArray_PxVec4_begin_0'] = createExportWrapper('emscripten_bind_PxArray_PxVec4_begin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec4_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec4_size_0');
  _emscripten_bind_PxArray_PxVec4_size_0 = Module['_emscripten_bind_PxArray_PxVec4_size_0'] = createExportWrapper('emscripten_bind_PxArray_PxVec4_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec4_pushBack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec4_pushBack_1');
  _emscripten_bind_PxArray_PxVec4_pushBack_1 = Module['_emscripten_bind_PxArray_PxVec4_pushBack_1'] = createExportWrapper('emscripten_bind_PxArray_PxVec4_pushBack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec4_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec4_clear_0');
  _emscripten_bind_PxArray_PxVec4_clear_0 = Module['_emscripten_bind_PxArray_PxVec4_clear_0'] = createExportWrapper('emscripten_bind_PxArray_PxVec4_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArray_PxVec4___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArray_PxVec4___destroy___0');
  _emscripten_bind_PxArray_PxVec4___destroy___0 = Module['_emscripten_bind_PxArray_PxVec4___destroy___0'] = createExportWrapper('emscripten_bind_PxArray_PxVec4___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_setRestLength_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_setRestLength_1');
  _emscripten_bind_PxArticulationAttachment_setRestLength_1 = Module['_emscripten_bind_PxArticulationAttachment_setRestLength_1'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_setRestLength_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_getRestLength_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_getRestLength_0');
  _emscripten_bind_PxArticulationAttachment_getRestLength_0 = Module['_emscripten_bind_PxArticulationAttachment_getRestLength_0'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_getRestLength_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_setLimitParameters_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_setLimitParameters_1');
  _emscripten_bind_PxArticulationAttachment_setLimitParameters_1 = Module['_emscripten_bind_PxArticulationAttachment_setLimitParameters_1'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_setLimitParameters_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_getLimitParameters_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_getLimitParameters_0');
  _emscripten_bind_PxArticulationAttachment_getLimitParameters_0 = Module['_emscripten_bind_PxArticulationAttachment_getLimitParameters_0'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_getLimitParameters_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_setRelativeOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_setRelativeOffset_1');
  _emscripten_bind_PxArticulationAttachment_setRelativeOffset_1 = Module['_emscripten_bind_PxArticulationAttachment_setRelativeOffset_1'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_setRelativeOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_getRelativeOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_getRelativeOffset_0');
  _emscripten_bind_PxArticulationAttachment_getRelativeOffset_0 = Module['_emscripten_bind_PxArticulationAttachment_getRelativeOffset_0'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_getRelativeOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_setCoefficient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_setCoefficient_1');
  _emscripten_bind_PxArticulationAttachment_setCoefficient_1 = Module['_emscripten_bind_PxArticulationAttachment_setCoefficient_1'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_setCoefficient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_getCoefficient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_getCoefficient_0');
  _emscripten_bind_PxArticulationAttachment_getCoefficient_0 = Module['_emscripten_bind_PxArticulationAttachment_getCoefficient_0'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_getCoefficient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_getLink_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_getLink_0');
  _emscripten_bind_PxArticulationAttachment_getLink_0 = Module['_emscripten_bind_PxArticulationAttachment_getLink_0'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_getLink_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_getParent_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_getParent_0');
  _emscripten_bind_PxArticulationAttachment_getParent_0 = Module['_emscripten_bind_PxArticulationAttachment_getParent_0'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_getParent_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_isLeaf_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_isLeaf_0');
  _emscripten_bind_PxArticulationAttachment_isLeaf_0 = Module['_emscripten_bind_PxArticulationAttachment_isLeaf_0'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_isLeaf_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_getTendon_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_getTendon_0');
  _emscripten_bind_PxArticulationAttachment_getTendon_0 = Module['_emscripten_bind_PxArticulationAttachment_getTendon_0'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_getTendon_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_release_0');
  _emscripten_bind_PxArticulationAttachment_release_0 = Module['_emscripten_bind_PxArticulationAttachment_release_0'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_get_userData_0');
  _emscripten_bind_PxArticulationAttachment_get_userData_0 = Module['_emscripten_bind_PxArticulationAttachment_get_userData_0'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment_set_userData_1');
  _emscripten_bind_PxArticulationAttachment_set_userData_1 = Module['_emscripten_bind_PxArticulationAttachment_set_userData_1'] = createExportWrapper('emscripten_bind_PxArticulationAttachment_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationAttachment___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationAttachment___destroy___0');
  _emscripten_bind_PxArticulationAttachment___destroy___0 = Module['_emscripten_bind_PxArticulationAttachment___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationAttachment___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_release_0');
  _emscripten_bind_PxArticulationCache_release_0 = Module['_emscripten_bind_PxArticulationCache_release_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_externalForces_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_externalForces_0');
  _emscripten_bind_PxArticulationCache_get_externalForces_0 = Module['_emscripten_bind_PxArticulationCache_get_externalForces_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_externalForces_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_externalForces_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_externalForces_1');
  _emscripten_bind_PxArticulationCache_set_externalForces_1 = Module['_emscripten_bind_PxArticulationCache_set_externalForces_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_externalForces_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_denseJacobian_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_denseJacobian_0');
  _emscripten_bind_PxArticulationCache_get_denseJacobian_0 = Module['_emscripten_bind_PxArticulationCache_get_denseJacobian_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_denseJacobian_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_denseJacobian_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_denseJacobian_1');
  _emscripten_bind_PxArticulationCache_set_denseJacobian_1 = Module['_emscripten_bind_PxArticulationCache_set_denseJacobian_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_denseJacobian_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_massMatrix_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_massMatrix_0');
  _emscripten_bind_PxArticulationCache_get_massMatrix_0 = Module['_emscripten_bind_PxArticulationCache_get_massMatrix_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_massMatrix_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_massMatrix_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_massMatrix_1');
  _emscripten_bind_PxArticulationCache_set_massMatrix_1 = Module['_emscripten_bind_PxArticulationCache_set_massMatrix_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_massMatrix_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_jointVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_jointVelocity_0');
  _emscripten_bind_PxArticulationCache_get_jointVelocity_0 = Module['_emscripten_bind_PxArticulationCache_get_jointVelocity_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_jointVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_jointVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_jointVelocity_1');
  _emscripten_bind_PxArticulationCache_set_jointVelocity_1 = Module['_emscripten_bind_PxArticulationCache_set_jointVelocity_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_jointVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_jointAcceleration_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_jointAcceleration_0');
  _emscripten_bind_PxArticulationCache_get_jointAcceleration_0 = Module['_emscripten_bind_PxArticulationCache_get_jointAcceleration_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_jointAcceleration_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_jointAcceleration_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_jointAcceleration_1');
  _emscripten_bind_PxArticulationCache_set_jointAcceleration_1 = Module['_emscripten_bind_PxArticulationCache_set_jointAcceleration_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_jointAcceleration_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_jointPosition_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_jointPosition_0');
  _emscripten_bind_PxArticulationCache_get_jointPosition_0 = Module['_emscripten_bind_PxArticulationCache_get_jointPosition_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_jointPosition_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_jointPosition_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_jointPosition_1');
  _emscripten_bind_PxArticulationCache_set_jointPosition_1 = Module['_emscripten_bind_PxArticulationCache_set_jointPosition_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_jointPosition_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_jointForce_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_jointForce_0');
  _emscripten_bind_PxArticulationCache_get_jointForce_0 = Module['_emscripten_bind_PxArticulationCache_get_jointForce_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_jointForce_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_jointForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_jointForce_1');
  _emscripten_bind_PxArticulationCache_set_jointForce_1 = Module['_emscripten_bind_PxArticulationCache_set_jointForce_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_jointForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_linkVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_linkVelocity_0');
  _emscripten_bind_PxArticulationCache_get_linkVelocity_0 = Module['_emscripten_bind_PxArticulationCache_get_linkVelocity_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_linkVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_linkVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_linkVelocity_1');
  _emscripten_bind_PxArticulationCache_set_linkVelocity_1 = Module['_emscripten_bind_PxArticulationCache_set_linkVelocity_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_linkVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_linkAcceleration_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_linkAcceleration_0');
  _emscripten_bind_PxArticulationCache_get_linkAcceleration_0 = Module['_emscripten_bind_PxArticulationCache_get_linkAcceleration_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_linkAcceleration_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_linkAcceleration_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_linkAcceleration_1');
  _emscripten_bind_PxArticulationCache_set_linkAcceleration_1 = Module['_emscripten_bind_PxArticulationCache_set_linkAcceleration_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_linkAcceleration_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_linkIncomingJointForce_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_linkIncomingJointForce_0');
  _emscripten_bind_PxArticulationCache_get_linkIncomingJointForce_0 = Module['_emscripten_bind_PxArticulationCache_get_linkIncomingJointForce_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_linkIncomingJointForce_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_linkIncomingJointForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_linkIncomingJointForce_1');
  _emscripten_bind_PxArticulationCache_set_linkIncomingJointForce_1 = Module['_emscripten_bind_PxArticulationCache_set_linkIncomingJointForce_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_linkIncomingJointForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_rootLinkData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_rootLinkData_0');
  _emscripten_bind_PxArticulationCache_get_rootLinkData_0 = Module['_emscripten_bind_PxArticulationCache_get_rootLinkData_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_rootLinkData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_rootLinkData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_rootLinkData_1');
  _emscripten_bind_PxArticulationCache_set_rootLinkData_1 = Module['_emscripten_bind_PxArticulationCache_set_rootLinkData_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_rootLinkData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_coefficientMatrix_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_coefficientMatrix_0');
  _emscripten_bind_PxArticulationCache_get_coefficientMatrix_0 = Module['_emscripten_bind_PxArticulationCache_get_coefficientMatrix_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_coefficientMatrix_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_coefficientMatrix_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_coefficientMatrix_1');
  _emscripten_bind_PxArticulationCache_set_coefficientMatrix_1 = Module['_emscripten_bind_PxArticulationCache_set_coefficientMatrix_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_coefficientMatrix_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_lambda_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_lambda_0');
  _emscripten_bind_PxArticulationCache_get_lambda_0 = Module['_emscripten_bind_PxArticulationCache_get_lambda_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_lambda_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_lambda_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_lambda_1');
  _emscripten_bind_PxArticulationCache_set_lambda_1 = Module['_emscripten_bind_PxArticulationCache_set_lambda_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_lambda_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_scratchMemory_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_scratchMemory_0');
  _emscripten_bind_PxArticulationCache_get_scratchMemory_0 = Module['_emscripten_bind_PxArticulationCache_get_scratchMemory_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_scratchMemory_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_scratchMemory_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_scratchMemory_1');
  _emscripten_bind_PxArticulationCache_set_scratchMemory_1 = Module['_emscripten_bind_PxArticulationCache_set_scratchMemory_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_scratchMemory_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_scratchAllocator_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_scratchAllocator_0');
  _emscripten_bind_PxArticulationCache_get_scratchAllocator_0 = Module['_emscripten_bind_PxArticulationCache_get_scratchAllocator_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_scratchAllocator_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_scratchAllocator_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_scratchAllocator_1');
  _emscripten_bind_PxArticulationCache_set_scratchAllocator_1 = Module['_emscripten_bind_PxArticulationCache_set_scratchAllocator_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_scratchAllocator_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_get_version_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_get_version_0');
  _emscripten_bind_PxArticulationCache_get_version_0 = Module['_emscripten_bind_PxArticulationCache_get_version_0'] = createExportWrapper('emscripten_bind_PxArticulationCache_get_version_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache_set_version_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache_set_version_1');
  _emscripten_bind_PxArticulationCache_set_version_1 = Module['_emscripten_bind_PxArticulationCache_set_version_1'] = createExportWrapper('emscripten_bind_PxArticulationCache_set_version_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCache___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCache___destroy___0');
  _emscripten_bind_PxArticulationCache___destroy___0 = Module['_emscripten_bind_PxArticulationCache___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationCache___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCacheFlags_PxArticulationCacheFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCacheFlags_PxArticulationCacheFlags_1');
  _emscripten_bind_PxArticulationCacheFlags_PxArticulationCacheFlags_1 = Module['_emscripten_bind_PxArticulationCacheFlags_PxArticulationCacheFlags_1'] = createExportWrapper('emscripten_bind_PxArticulationCacheFlags_PxArticulationCacheFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCacheFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCacheFlags_isSet_1');
  _emscripten_bind_PxArticulationCacheFlags_isSet_1 = Module['_emscripten_bind_PxArticulationCacheFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxArticulationCacheFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCacheFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCacheFlags_raise_1');
  _emscripten_bind_PxArticulationCacheFlags_raise_1 = Module['_emscripten_bind_PxArticulationCacheFlags_raise_1'] = createExportWrapper('emscripten_bind_PxArticulationCacheFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCacheFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCacheFlags_clear_1');
  _emscripten_bind_PxArticulationCacheFlags_clear_1 = Module['_emscripten_bind_PxArticulationCacheFlags_clear_1'] = createExportWrapper('emscripten_bind_PxArticulationCacheFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationCacheFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationCacheFlags___destroy___0');
  _emscripten_bind_PxArticulationCacheFlags___destroy___0 = Module['_emscripten_bind_PxArticulationCacheFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationCacheFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationDrive_PxArticulationDrive_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationDrive_PxArticulationDrive_0');
  _emscripten_bind_PxArticulationDrive_PxArticulationDrive_0 = Module['_emscripten_bind_PxArticulationDrive_PxArticulationDrive_0'] = createExportWrapper('emscripten_bind_PxArticulationDrive_PxArticulationDrive_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArticulationDrive_PxArticulationDrive_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationDrive_PxArticulationDrive_4');
  _emscripten_bind_PxArticulationDrive_PxArticulationDrive_4 = Module['_emscripten_bind_PxArticulationDrive_PxArticulationDrive_4'] = createExportWrapper('emscripten_bind_PxArticulationDrive_PxArticulationDrive_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxArticulationDrive_get_stiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationDrive_get_stiffness_0');
  _emscripten_bind_PxArticulationDrive_get_stiffness_0 = Module['_emscripten_bind_PxArticulationDrive_get_stiffness_0'] = createExportWrapper('emscripten_bind_PxArticulationDrive_get_stiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationDrive_set_stiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationDrive_set_stiffness_1');
  _emscripten_bind_PxArticulationDrive_set_stiffness_1 = Module['_emscripten_bind_PxArticulationDrive_set_stiffness_1'] = createExportWrapper('emscripten_bind_PxArticulationDrive_set_stiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationDrive_get_damping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationDrive_get_damping_0');
  _emscripten_bind_PxArticulationDrive_get_damping_0 = Module['_emscripten_bind_PxArticulationDrive_get_damping_0'] = createExportWrapper('emscripten_bind_PxArticulationDrive_get_damping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationDrive_set_damping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationDrive_set_damping_1');
  _emscripten_bind_PxArticulationDrive_set_damping_1 = Module['_emscripten_bind_PxArticulationDrive_set_damping_1'] = createExportWrapper('emscripten_bind_PxArticulationDrive_set_damping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationDrive_get_maxForce_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationDrive_get_maxForce_0');
  _emscripten_bind_PxArticulationDrive_get_maxForce_0 = Module['_emscripten_bind_PxArticulationDrive_get_maxForce_0'] = createExportWrapper('emscripten_bind_PxArticulationDrive_get_maxForce_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationDrive_set_maxForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationDrive_set_maxForce_1');
  _emscripten_bind_PxArticulationDrive_set_maxForce_1 = Module['_emscripten_bind_PxArticulationDrive_set_maxForce_1'] = createExportWrapper('emscripten_bind_PxArticulationDrive_set_maxForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationDrive_get_driveType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationDrive_get_driveType_0');
  _emscripten_bind_PxArticulationDrive_get_driveType_0 = Module['_emscripten_bind_PxArticulationDrive_get_driveType_0'] = createExportWrapper('emscripten_bind_PxArticulationDrive_get_driveType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationDrive_set_driveType_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationDrive_set_driveType_1');
  _emscripten_bind_PxArticulationDrive_set_driveType_1 = Module['_emscripten_bind_PxArticulationDrive_set_driveType_1'] = createExportWrapper('emscripten_bind_PxArticulationDrive_set_driveType_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationDrive___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationDrive___destroy___0');
  _emscripten_bind_PxArticulationDrive___destroy___0 = Module['_emscripten_bind_PxArticulationDrive___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationDrive___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_createTendonJoint_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_createTendonJoint_5');
  _emscripten_bind_PxArticulationFixedTendon_createTendonJoint_5 = Module['_emscripten_bind_PxArticulationFixedTendon_createTendonJoint_5'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_createTendonJoint_5', 6);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_getNbTendonJoints_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_getNbTendonJoints_0');
  _emscripten_bind_PxArticulationFixedTendon_getNbTendonJoints_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getNbTendonJoints_0'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_getNbTendonJoints_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_setRestLength_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_setRestLength_1');
  _emscripten_bind_PxArticulationFixedTendon_setRestLength_1 = Module['_emscripten_bind_PxArticulationFixedTendon_setRestLength_1'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_setRestLength_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_getRestLength_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_getRestLength_0');
  _emscripten_bind_PxArticulationFixedTendon_getRestLength_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getRestLength_0'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_getRestLength_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_setLimitParameters_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_setLimitParameters_1');
  _emscripten_bind_PxArticulationFixedTendon_setLimitParameters_1 = Module['_emscripten_bind_PxArticulationFixedTendon_setLimitParameters_1'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_setLimitParameters_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_getLimitParameters_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_getLimitParameters_0');
  _emscripten_bind_PxArticulationFixedTendon_getLimitParameters_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getLimitParameters_0'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_getLimitParameters_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_setStiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_setStiffness_1');
  _emscripten_bind_PxArticulationFixedTendon_setStiffness_1 = Module['_emscripten_bind_PxArticulationFixedTendon_setStiffness_1'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_setStiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_getStiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_getStiffness_0');
  _emscripten_bind_PxArticulationFixedTendon_getStiffness_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getStiffness_0'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_getStiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_setDamping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_setDamping_1');
  _emscripten_bind_PxArticulationFixedTendon_setDamping_1 = Module['_emscripten_bind_PxArticulationFixedTendon_setDamping_1'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_setDamping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_getDamping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_getDamping_0');
  _emscripten_bind_PxArticulationFixedTendon_getDamping_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getDamping_0'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_getDamping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_setLimitStiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_setLimitStiffness_1');
  _emscripten_bind_PxArticulationFixedTendon_setLimitStiffness_1 = Module['_emscripten_bind_PxArticulationFixedTendon_setLimitStiffness_1'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_setLimitStiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_getLimitStiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_getLimitStiffness_0');
  _emscripten_bind_PxArticulationFixedTendon_getLimitStiffness_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getLimitStiffness_0'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_getLimitStiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_setOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_setOffset_1');
  _emscripten_bind_PxArticulationFixedTendon_setOffset_1 = Module['_emscripten_bind_PxArticulationFixedTendon_setOffset_1'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_setOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_setOffset_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_setOffset_2');
  _emscripten_bind_PxArticulationFixedTendon_setOffset_2 = Module['_emscripten_bind_PxArticulationFixedTendon_setOffset_2'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_setOffset_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_getOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_getOffset_0');
  _emscripten_bind_PxArticulationFixedTendon_getOffset_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getOffset_0'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_getOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_getArticulation_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_getArticulation_0');
  _emscripten_bind_PxArticulationFixedTendon_getArticulation_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getArticulation_0'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_getArticulation_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_release_0');
  _emscripten_bind_PxArticulationFixedTendon_release_0 = Module['_emscripten_bind_PxArticulationFixedTendon_release_0'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_getConcreteTypeName_0');
  _emscripten_bind_PxArticulationFixedTendon_getConcreteTypeName_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_getConcreteType_0');
  _emscripten_bind_PxArticulationFixedTendon_getConcreteType_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_setBaseFlag_2');
  _emscripten_bind_PxArticulationFixedTendon_setBaseFlag_2 = Module['_emscripten_bind_PxArticulationFixedTendon_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_setBaseFlags_1');
  _emscripten_bind_PxArticulationFixedTendon_setBaseFlags_1 = Module['_emscripten_bind_PxArticulationFixedTendon_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_getBaseFlags_0');
  _emscripten_bind_PxArticulationFixedTendon_getBaseFlags_0 = Module['_emscripten_bind_PxArticulationFixedTendon_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon_isReleasable_0');
  _emscripten_bind_PxArticulationFixedTendon_isReleasable_0 = Module['_emscripten_bind_PxArticulationFixedTendon_isReleasable_0'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFixedTendon___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFixedTendon___destroy___0');
  _emscripten_bind_PxArticulationFixedTendon___destroy___0 = Module['_emscripten_bind_PxArticulationFixedTendon___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationFixedTendon___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFlags_PxArticulationFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFlags_PxArticulationFlags_1');
  _emscripten_bind_PxArticulationFlags_PxArticulationFlags_1 = Module['_emscripten_bind_PxArticulationFlags_PxArticulationFlags_1'] = createExportWrapper('emscripten_bind_PxArticulationFlags_PxArticulationFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFlags_isSet_1');
  _emscripten_bind_PxArticulationFlags_isSet_1 = Module['_emscripten_bind_PxArticulationFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxArticulationFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFlags_raise_1');
  _emscripten_bind_PxArticulationFlags_raise_1 = Module['_emscripten_bind_PxArticulationFlags_raise_1'] = createExportWrapper('emscripten_bind_PxArticulationFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFlags_clear_1');
  _emscripten_bind_PxArticulationFlags_clear_1 = Module['_emscripten_bind_PxArticulationFlags_clear_1'] = createExportWrapper('emscripten_bind_PxArticulationFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationFlags___destroy___0');
  _emscripten_bind_PxArticulationFlags___destroy___0 = Module['_emscripten_bind_PxArticulationFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getParentArticulationLink_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getParentArticulationLink_0');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getParentArticulationLink_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getParentArticulationLink_0'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getParentArticulationLink_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setParentPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setParentPose_1');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setParentPose_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setParentPose_1'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setParentPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getParentPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getParentPose_0');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getParentPose_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getParentPose_0'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getParentPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getChildArticulationLink_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getChildArticulationLink_0');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getChildArticulationLink_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getChildArticulationLink_0'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getChildArticulationLink_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setChildPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setChildPose_1');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setChildPose_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setChildPose_1'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setChildPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getChildPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getChildPose_0');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getChildPose_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getChildPose_0'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getChildPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setJointType_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setJointType_1');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setJointType_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setJointType_1'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setJointType_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getJointType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getJointType_0');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getJointType_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getJointType_0'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getJointType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setMotion_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setMotion_2');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setMotion_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setMotion_2'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setMotion_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getMotion_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getMotion_1');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getMotion_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getMotion_1'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getMotion_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setLimitParams_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setLimitParams_2');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setLimitParams_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setLimitParams_2'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setLimitParams_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getLimitParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getLimitParams_1');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getLimitParams_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getLimitParams_1'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getLimitParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setDriveParams_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setDriveParams_2');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveParams_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveParams_2'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setDriveParams_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_2');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_2'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_3');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_3 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_3'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getDriveTarget_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getDriveTarget_1');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getDriveTarget_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getDriveTarget_1'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getDriveTarget_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_2');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_2'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_3');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_3 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_3'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getDriveVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getDriveVelocity_1');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getDriveVelocity_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getDriveVelocity_1'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getDriveVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setArmature_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setArmature_2');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setArmature_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setArmature_2'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setArmature_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getArmature_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getArmature_1');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getArmature_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getArmature_1'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getArmature_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setFrictionCoefficient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setFrictionCoefficient_1');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setFrictionCoefficient_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setFrictionCoefficient_1'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setFrictionCoefficient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getFrictionCoefficient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getFrictionCoefficient_0');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getFrictionCoefficient_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getFrictionCoefficient_0'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getFrictionCoefficient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setMaxJointVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setMaxJointVelocity_1');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setMaxJointVelocity_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setMaxJointVelocity_1'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setMaxJointVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getMaxJointVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getMaxJointVelocity_0');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getMaxJointVelocity_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getMaxJointVelocity_0'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getMaxJointVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setJointPosition_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setJointPosition_2');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setJointPosition_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setJointPosition_2'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setJointPosition_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getJointPosition_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getJointPosition_1');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getJointPosition_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getJointPosition_1'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getJointPosition_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setJointVelocity_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setJointVelocity_2');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setJointVelocity_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setJointVelocity_2'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setJointVelocity_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getJointVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getJointVelocity_1');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getJointVelocity_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getJointVelocity_1'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getJointVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_release_0');
  _emscripten_bind_PxArticulationJointReducedCoordinate_release_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_release_0'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteTypeName_0');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteTypeName_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteType_0');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteType_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlag_2');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlag_2 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlags_1');
  _emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlags_1 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_getBaseFlags_0');
  _emscripten_bind_PxArticulationJointReducedCoordinate_getBaseFlags_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate_isReleasable_0');
  _emscripten_bind_PxArticulationJointReducedCoordinate_isReleasable_0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate_isReleasable_0'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationJointReducedCoordinate___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationJointReducedCoordinate___destroy___0');
  _emscripten_bind_PxArticulationJointReducedCoordinate___destroy___0 = Module['_emscripten_bind_PxArticulationJointReducedCoordinate___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationJointReducedCoordinate___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationKinematicFlags_PxArticulationKinematicFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationKinematicFlags_PxArticulationKinematicFlags_1');
  _emscripten_bind_PxArticulationKinematicFlags_PxArticulationKinematicFlags_1 = Module['_emscripten_bind_PxArticulationKinematicFlags_PxArticulationKinematicFlags_1'] = createExportWrapper('emscripten_bind_PxArticulationKinematicFlags_PxArticulationKinematicFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationKinematicFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationKinematicFlags_isSet_1');
  _emscripten_bind_PxArticulationKinematicFlags_isSet_1 = Module['_emscripten_bind_PxArticulationKinematicFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxArticulationKinematicFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationKinematicFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationKinematicFlags_raise_1');
  _emscripten_bind_PxArticulationKinematicFlags_raise_1 = Module['_emscripten_bind_PxArticulationKinematicFlags_raise_1'] = createExportWrapper('emscripten_bind_PxArticulationKinematicFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationKinematicFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationKinematicFlags_clear_1');
  _emscripten_bind_PxArticulationKinematicFlags_clear_1 = Module['_emscripten_bind_PxArticulationKinematicFlags_clear_1'] = createExportWrapper('emscripten_bind_PxArticulationKinematicFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationKinematicFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationKinematicFlags___destroy___0');
  _emscripten_bind_PxArticulationKinematicFlags___destroy___0 = Module['_emscripten_bind_PxArticulationKinematicFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationKinematicFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLimit_PxArticulationLimit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLimit_PxArticulationLimit_0');
  _emscripten_bind_PxArticulationLimit_PxArticulationLimit_0 = Module['_emscripten_bind_PxArticulationLimit_PxArticulationLimit_0'] = createExportWrapper('emscripten_bind_PxArticulationLimit_PxArticulationLimit_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLimit_PxArticulationLimit_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLimit_PxArticulationLimit_2');
  _emscripten_bind_PxArticulationLimit_PxArticulationLimit_2 = Module['_emscripten_bind_PxArticulationLimit_PxArticulationLimit_2'] = createExportWrapper('emscripten_bind_PxArticulationLimit_PxArticulationLimit_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLimit_get_low_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLimit_get_low_0');
  _emscripten_bind_PxArticulationLimit_get_low_0 = Module['_emscripten_bind_PxArticulationLimit_get_low_0'] = createExportWrapper('emscripten_bind_PxArticulationLimit_get_low_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLimit_set_low_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLimit_set_low_1');
  _emscripten_bind_PxArticulationLimit_set_low_1 = Module['_emscripten_bind_PxArticulationLimit_set_low_1'] = createExportWrapper('emscripten_bind_PxArticulationLimit_set_low_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLimit_get_high_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLimit_get_high_0');
  _emscripten_bind_PxArticulationLimit_get_high_0 = Module['_emscripten_bind_PxArticulationLimit_get_high_0'] = createExportWrapper('emscripten_bind_PxArticulationLimit_get_high_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLimit_set_high_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLimit_set_high_1');
  _emscripten_bind_PxArticulationLimit_set_high_1 = Module['_emscripten_bind_PxArticulationLimit_set_high_1'] = createExportWrapper('emscripten_bind_PxArticulationLimit_set_high_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLimit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLimit___destroy___0');
  _emscripten_bind_PxArticulationLimit___destroy___0 = Module['_emscripten_bind_PxArticulationLimit___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationLimit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getArticulation_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getArticulation_0');
  _emscripten_bind_PxArticulationLink_getArticulation_0 = Module['_emscripten_bind_PxArticulationLink_getArticulation_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getArticulation_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getInboundJoint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getInboundJoint_0');
  _emscripten_bind_PxArticulationLink_getInboundJoint_0 = Module['_emscripten_bind_PxArticulationLink_getInboundJoint_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getInboundJoint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getInboundJointDof_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getInboundJointDof_0');
  _emscripten_bind_PxArticulationLink_getInboundJointDof_0 = Module['_emscripten_bind_PxArticulationLink_getInboundJointDof_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getInboundJointDof_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getNbChildren_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getNbChildren_0');
  _emscripten_bind_PxArticulationLink_getNbChildren_0 = Module['_emscripten_bind_PxArticulationLink_getNbChildren_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getNbChildren_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getLinkIndex_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getLinkIndex_0');
  _emscripten_bind_PxArticulationLink_getLinkIndex_0 = Module['_emscripten_bind_PxArticulationLink_getLinkIndex_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getLinkIndex_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setCfmScale_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setCfmScale_1');
  _emscripten_bind_PxArticulationLink_setCfmScale_1 = Module['_emscripten_bind_PxArticulationLink_setCfmScale_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setCfmScale_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getCfmScale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getCfmScale_0');
  _emscripten_bind_PxArticulationLink_getCfmScale_0 = Module['_emscripten_bind_PxArticulationLink_getCfmScale_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getCfmScale_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getType_0');
  _emscripten_bind_PxArticulationLink_getType_0 = Module['_emscripten_bind_PxArticulationLink_getType_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getScene_0');
  _emscripten_bind_PxArticulationLink_getScene_0 = Module['_emscripten_bind_PxArticulationLink_getScene_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setName_1');
  _emscripten_bind_PxArticulationLink_setName_1 = Module['_emscripten_bind_PxArticulationLink_setName_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getName_0');
  _emscripten_bind_PxArticulationLink_getName_0 = Module['_emscripten_bind_PxArticulationLink_getName_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getWorldBounds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getWorldBounds_0');
  _emscripten_bind_PxArticulationLink_getWorldBounds_0 = Module['_emscripten_bind_PxArticulationLink_getWorldBounds_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getWorldBounds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getWorldBounds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getWorldBounds_1');
  _emscripten_bind_PxArticulationLink_getWorldBounds_1 = Module['_emscripten_bind_PxArticulationLink_getWorldBounds_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_getWorldBounds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setActorFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setActorFlag_2');
  _emscripten_bind_PxArticulationLink_setActorFlag_2 = Module['_emscripten_bind_PxArticulationLink_setActorFlag_2'] = createExportWrapper('emscripten_bind_PxArticulationLink_setActorFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setActorFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setActorFlags_1');
  _emscripten_bind_PxArticulationLink_setActorFlags_1 = Module['_emscripten_bind_PxArticulationLink_setActorFlags_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setActorFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getActorFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getActorFlags_0');
  _emscripten_bind_PxArticulationLink_getActorFlags_0 = Module['_emscripten_bind_PxArticulationLink_getActorFlags_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getActorFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setDominanceGroup_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setDominanceGroup_1');
  _emscripten_bind_PxArticulationLink_setDominanceGroup_1 = Module['_emscripten_bind_PxArticulationLink_setDominanceGroup_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setDominanceGroup_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getDominanceGroup_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getDominanceGroup_0');
  _emscripten_bind_PxArticulationLink_getDominanceGroup_0 = Module['_emscripten_bind_PxArticulationLink_getDominanceGroup_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getDominanceGroup_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setOwnerClient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setOwnerClient_1');
  _emscripten_bind_PxArticulationLink_setOwnerClient_1 = Module['_emscripten_bind_PxArticulationLink_setOwnerClient_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setOwnerClient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getOwnerClient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getOwnerClient_0');
  _emscripten_bind_PxArticulationLink_getOwnerClient_0 = Module['_emscripten_bind_PxArticulationLink_getOwnerClient_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getOwnerClient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_release_0');
  _emscripten_bind_PxArticulationLink_release_0 = Module['_emscripten_bind_PxArticulationLink_release_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getConcreteTypeName_0');
  _emscripten_bind_PxArticulationLink_getConcreteTypeName_0 = Module['_emscripten_bind_PxArticulationLink_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getConcreteType_0');
  _emscripten_bind_PxArticulationLink_getConcreteType_0 = Module['_emscripten_bind_PxArticulationLink_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setBaseFlag_2');
  _emscripten_bind_PxArticulationLink_setBaseFlag_2 = Module['_emscripten_bind_PxArticulationLink_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxArticulationLink_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setBaseFlags_1');
  _emscripten_bind_PxArticulationLink_setBaseFlags_1 = Module['_emscripten_bind_PxArticulationLink_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getBaseFlags_0');
  _emscripten_bind_PxArticulationLink_getBaseFlags_0 = Module['_emscripten_bind_PxArticulationLink_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_isReleasable_0');
  _emscripten_bind_PxArticulationLink_isReleasable_0 = Module['_emscripten_bind_PxArticulationLink_isReleasable_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getGlobalPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getGlobalPose_0');
  _emscripten_bind_PxArticulationLink_getGlobalPose_0 = Module['_emscripten_bind_PxArticulationLink_getGlobalPose_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getGlobalPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setGlobalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setGlobalPose_1');
  _emscripten_bind_PxArticulationLink_setGlobalPose_1 = Module['_emscripten_bind_PxArticulationLink_setGlobalPose_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setGlobalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setGlobalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setGlobalPose_2');
  _emscripten_bind_PxArticulationLink_setGlobalPose_2 = Module['_emscripten_bind_PxArticulationLink_setGlobalPose_2'] = createExportWrapper('emscripten_bind_PxArticulationLink_setGlobalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_attachShape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_attachShape_1');
  _emscripten_bind_PxArticulationLink_attachShape_1 = Module['_emscripten_bind_PxArticulationLink_attachShape_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_attachShape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_detachShape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_detachShape_1');
  _emscripten_bind_PxArticulationLink_detachShape_1 = Module['_emscripten_bind_PxArticulationLink_detachShape_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_detachShape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_detachShape_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_detachShape_2');
  _emscripten_bind_PxArticulationLink_detachShape_2 = Module['_emscripten_bind_PxArticulationLink_detachShape_2'] = createExportWrapper('emscripten_bind_PxArticulationLink_detachShape_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getNbShapes_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getNbShapes_0');
  _emscripten_bind_PxArticulationLink_getNbShapes_0 = Module['_emscripten_bind_PxArticulationLink_getNbShapes_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getNbShapes_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getShapes_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getShapes_3');
  _emscripten_bind_PxArticulationLink_getShapes_3 = Module['_emscripten_bind_PxArticulationLink_getShapes_3'] = createExportWrapper('emscripten_bind_PxArticulationLink_getShapes_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getNbConstraints_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getNbConstraints_0');
  _emscripten_bind_PxArticulationLink_getNbConstraints_0 = Module['_emscripten_bind_PxArticulationLink_getNbConstraints_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getNbConstraints_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setCMassLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setCMassLocalPose_1');
  _emscripten_bind_PxArticulationLink_setCMassLocalPose_1 = Module['_emscripten_bind_PxArticulationLink_setCMassLocalPose_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setCMassLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getCMassLocalPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getCMassLocalPose_0');
  _emscripten_bind_PxArticulationLink_getCMassLocalPose_0 = Module['_emscripten_bind_PxArticulationLink_getCMassLocalPose_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getCMassLocalPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setMass_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setMass_1');
  _emscripten_bind_PxArticulationLink_setMass_1 = Module['_emscripten_bind_PxArticulationLink_setMass_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setMass_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getMass_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getMass_0');
  _emscripten_bind_PxArticulationLink_getMass_0 = Module['_emscripten_bind_PxArticulationLink_getMass_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getMass_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getInvMass_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getInvMass_0');
  _emscripten_bind_PxArticulationLink_getInvMass_0 = Module['_emscripten_bind_PxArticulationLink_getInvMass_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getInvMass_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setMassSpaceInertiaTensor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setMassSpaceInertiaTensor_1');
  _emscripten_bind_PxArticulationLink_setMassSpaceInertiaTensor_1 = Module['_emscripten_bind_PxArticulationLink_setMassSpaceInertiaTensor_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setMassSpaceInertiaTensor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getMassSpaceInertiaTensor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getMassSpaceInertiaTensor_0');
  _emscripten_bind_PxArticulationLink_getMassSpaceInertiaTensor_0 = Module['_emscripten_bind_PxArticulationLink_getMassSpaceInertiaTensor_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getMassSpaceInertiaTensor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getMassSpaceInvInertiaTensor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getMassSpaceInvInertiaTensor_0');
  _emscripten_bind_PxArticulationLink_getMassSpaceInvInertiaTensor_0 = Module['_emscripten_bind_PxArticulationLink_getMassSpaceInvInertiaTensor_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getMassSpaceInvInertiaTensor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setLinearDamping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setLinearDamping_1');
  _emscripten_bind_PxArticulationLink_setLinearDamping_1 = Module['_emscripten_bind_PxArticulationLink_setLinearDamping_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setLinearDamping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getLinearDamping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getLinearDamping_0');
  _emscripten_bind_PxArticulationLink_getLinearDamping_0 = Module['_emscripten_bind_PxArticulationLink_getLinearDamping_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getLinearDamping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setAngularDamping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setAngularDamping_1');
  _emscripten_bind_PxArticulationLink_setAngularDamping_1 = Module['_emscripten_bind_PxArticulationLink_setAngularDamping_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setAngularDamping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getAngularDamping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getAngularDamping_0');
  _emscripten_bind_PxArticulationLink_getAngularDamping_0 = Module['_emscripten_bind_PxArticulationLink_getAngularDamping_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getAngularDamping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getLinearVelocity_0');
  _emscripten_bind_PxArticulationLink_getLinearVelocity_0 = Module['_emscripten_bind_PxArticulationLink_getLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getAngularVelocity_0');
  _emscripten_bind_PxArticulationLink_getAngularVelocity_0 = Module['_emscripten_bind_PxArticulationLink_getAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setMaxLinearVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setMaxLinearVelocity_1');
  _emscripten_bind_PxArticulationLink_setMaxLinearVelocity_1 = Module['_emscripten_bind_PxArticulationLink_setMaxLinearVelocity_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setMaxLinearVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getMaxLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getMaxLinearVelocity_0');
  _emscripten_bind_PxArticulationLink_getMaxLinearVelocity_0 = Module['_emscripten_bind_PxArticulationLink_getMaxLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getMaxLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setMaxAngularVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setMaxAngularVelocity_1');
  _emscripten_bind_PxArticulationLink_setMaxAngularVelocity_1 = Module['_emscripten_bind_PxArticulationLink_setMaxAngularVelocity_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setMaxAngularVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getMaxAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getMaxAngularVelocity_0');
  _emscripten_bind_PxArticulationLink_getMaxAngularVelocity_0 = Module['_emscripten_bind_PxArticulationLink_getMaxAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getMaxAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_addForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_addForce_1');
  _emscripten_bind_PxArticulationLink_addForce_1 = Module['_emscripten_bind_PxArticulationLink_addForce_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_addForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_addForce_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_addForce_2');
  _emscripten_bind_PxArticulationLink_addForce_2 = Module['_emscripten_bind_PxArticulationLink_addForce_2'] = createExportWrapper('emscripten_bind_PxArticulationLink_addForce_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_addForce_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_addForce_3');
  _emscripten_bind_PxArticulationLink_addForce_3 = Module['_emscripten_bind_PxArticulationLink_addForce_3'] = createExportWrapper('emscripten_bind_PxArticulationLink_addForce_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_addTorque_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_addTorque_1');
  _emscripten_bind_PxArticulationLink_addTorque_1 = Module['_emscripten_bind_PxArticulationLink_addTorque_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_addTorque_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_addTorque_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_addTorque_2');
  _emscripten_bind_PxArticulationLink_addTorque_2 = Module['_emscripten_bind_PxArticulationLink_addTorque_2'] = createExportWrapper('emscripten_bind_PxArticulationLink_addTorque_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_addTorque_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_addTorque_3');
  _emscripten_bind_PxArticulationLink_addTorque_3 = Module['_emscripten_bind_PxArticulationLink_addTorque_3'] = createExportWrapper('emscripten_bind_PxArticulationLink_addTorque_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_clearForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_clearForce_1');
  _emscripten_bind_PxArticulationLink_clearForce_1 = Module['_emscripten_bind_PxArticulationLink_clearForce_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_clearForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_clearTorque_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_clearTorque_1');
  _emscripten_bind_PxArticulationLink_clearTorque_1 = Module['_emscripten_bind_PxArticulationLink_clearTorque_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_clearTorque_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setForceAndTorque_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setForceAndTorque_2');
  _emscripten_bind_PxArticulationLink_setForceAndTorque_2 = Module['_emscripten_bind_PxArticulationLink_setForceAndTorque_2'] = createExportWrapper('emscripten_bind_PxArticulationLink_setForceAndTorque_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setForceAndTorque_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setForceAndTorque_3');
  _emscripten_bind_PxArticulationLink_setForceAndTorque_3 = Module['_emscripten_bind_PxArticulationLink_setForceAndTorque_3'] = createExportWrapper('emscripten_bind_PxArticulationLink_setForceAndTorque_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setRigidBodyFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setRigidBodyFlag_2');
  _emscripten_bind_PxArticulationLink_setRigidBodyFlag_2 = Module['_emscripten_bind_PxArticulationLink_setRigidBodyFlag_2'] = createExportWrapper('emscripten_bind_PxArticulationLink_setRigidBodyFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setRigidBodyFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setRigidBodyFlags_1');
  _emscripten_bind_PxArticulationLink_setRigidBodyFlags_1 = Module['_emscripten_bind_PxArticulationLink_setRigidBodyFlags_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setRigidBodyFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getRigidBodyFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getRigidBodyFlags_0');
  _emscripten_bind_PxArticulationLink_getRigidBodyFlags_0 = Module['_emscripten_bind_PxArticulationLink_getRigidBodyFlags_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getRigidBodyFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setMinCCDAdvanceCoefficient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setMinCCDAdvanceCoefficient_1');
  _emscripten_bind_PxArticulationLink_setMinCCDAdvanceCoefficient_1 = Module['_emscripten_bind_PxArticulationLink_setMinCCDAdvanceCoefficient_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setMinCCDAdvanceCoefficient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getMinCCDAdvanceCoefficient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getMinCCDAdvanceCoefficient_0');
  _emscripten_bind_PxArticulationLink_getMinCCDAdvanceCoefficient_0 = Module['_emscripten_bind_PxArticulationLink_getMinCCDAdvanceCoefficient_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getMinCCDAdvanceCoefficient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setMaxDepenetrationVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setMaxDepenetrationVelocity_1');
  _emscripten_bind_PxArticulationLink_setMaxDepenetrationVelocity_1 = Module['_emscripten_bind_PxArticulationLink_setMaxDepenetrationVelocity_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setMaxDepenetrationVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getMaxDepenetrationVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getMaxDepenetrationVelocity_0');
  _emscripten_bind_PxArticulationLink_getMaxDepenetrationVelocity_0 = Module['_emscripten_bind_PxArticulationLink_getMaxDepenetrationVelocity_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getMaxDepenetrationVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setMaxContactImpulse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setMaxContactImpulse_1');
  _emscripten_bind_PxArticulationLink_setMaxContactImpulse_1 = Module['_emscripten_bind_PxArticulationLink_setMaxContactImpulse_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setMaxContactImpulse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getMaxContactImpulse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getMaxContactImpulse_0');
  _emscripten_bind_PxArticulationLink_getMaxContactImpulse_0 = Module['_emscripten_bind_PxArticulationLink_getMaxContactImpulse_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getMaxContactImpulse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_setContactSlopCoefficient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_setContactSlopCoefficient_1');
  _emscripten_bind_PxArticulationLink_setContactSlopCoefficient_1 = Module['_emscripten_bind_PxArticulationLink_setContactSlopCoefficient_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_setContactSlopCoefficient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_getContactSlopCoefficient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_getContactSlopCoefficient_0');
  _emscripten_bind_PxArticulationLink_getContactSlopCoefficient_0 = Module['_emscripten_bind_PxArticulationLink_getContactSlopCoefficient_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_getContactSlopCoefficient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_get_userData_0');
  _emscripten_bind_PxArticulationLink_get_userData_0 = Module['_emscripten_bind_PxArticulationLink_get_userData_0'] = createExportWrapper('emscripten_bind_PxArticulationLink_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationLink_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationLink_set_userData_1');
  _emscripten_bind_PxArticulationLink_set_userData_1 = Module['_emscripten_bind_PxArticulationLink_set_userData_1'] = createExportWrapper('emscripten_bind_PxArticulationLink_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getScene_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getScene_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getScene_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_1');
  _emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_2');
  _emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_2'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_isSleeping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_isSleeping_0');
  _emscripten_bind_PxArticulationReducedCoordinate_isSleeping_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_isSleeping_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_isSleeping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setSleepThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setSleepThreshold_1');
  _emscripten_bind_PxArticulationReducedCoordinate_setSleepThreshold_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setSleepThreshold_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setSleepThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getSleepThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getSleepThreshold_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getSleepThreshold_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getSleepThreshold_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getSleepThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setStabilizationThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setStabilizationThreshold_1');
  _emscripten_bind_PxArticulationReducedCoordinate_setStabilizationThreshold_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setStabilizationThreshold_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setStabilizationThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getStabilizationThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getStabilizationThreshold_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getStabilizationThreshold_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getStabilizationThreshold_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getStabilizationThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setWakeCounter_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setWakeCounter_1');
  _emscripten_bind_PxArticulationReducedCoordinate_setWakeCounter_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setWakeCounter_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setWakeCounter_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getWakeCounter_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getWakeCounter_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getWakeCounter_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getWakeCounter_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getWakeCounter_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_wakeUp_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_wakeUp_0');
  _emscripten_bind_PxArticulationReducedCoordinate_wakeUp_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_wakeUp_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_wakeUp_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_putToSleep_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_putToSleep_0');
  _emscripten_bind_PxArticulationReducedCoordinate_putToSleep_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_putToSleep_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_putToSleep_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_createLink_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_createLink_2');
  _emscripten_bind_PxArticulationReducedCoordinate_createLink_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_createLink_2'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_createLink_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getNbLinks_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getNbLinks_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getNbLinks_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getNbLinks_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getNbLinks_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getNbShapes_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getNbShapes_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getNbShapes_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getNbShapes_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getNbShapes_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setName_1');
  _emscripten_bind_PxArticulationReducedCoordinate_setName_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setName_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getName_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getName_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getName_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_1');
  _emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getAggregate_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getAggregate_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getAggregate_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getAggregate_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getAggregate_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlags_1');
  _emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlags_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlags_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlag_2');
  _emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlag_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlag_2'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getArticulationFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getArticulationFlags_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getArticulationFlags_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getArticulationFlags_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getArticulationFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getDofs_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getDofs_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getDofs_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getDofs_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getDofs_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_createCache_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_createCache_0');
  _emscripten_bind_PxArticulationReducedCoordinate_createCache_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_createCache_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_createCache_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getCacheDataSize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getCacheDataSize_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getCacheDataSize_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getCacheDataSize_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getCacheDataSize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_zeroCache_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_zeroCache_1');
  _emscripten_bind_PxArticulationReducedCoordinate_zeroCache_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_zeroCache_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_zeroCache_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_applyCache_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_applyCache_2');
  _emscripten_bind_PxArticulationReducedCoordinate_applyCache_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_applyCache_2'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_applyCache_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_applyCache_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_applyCache_3');
  _emscripten_bind_PxArticulationReducedCoordinate_applyCache_3 = Module['_emscripten_bind_PxArticulationReducedCoordinate_applyCache_3'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_applyCache_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_copyInternalStateToCache_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_copyInternalStateToCache_2');
  _emscripten_bind_PxArticulationReducedCoordinate_copyInternalStateToCache_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_copyInternalStateToCache_2'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_copyInternalStateToCache_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_commonInit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_commonInit_0');
  _emscripten_bind_PxArticulationReducedCoordinate_commonInit_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_commonInit_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_commonInit_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedGravityForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedGravityForce_1');
  _emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedGravityForce_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedGravityForce_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedGravityForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_computeGravityCompensation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_computeGravityCompensation_1');
  _emscripten_bind_PxArticulationReducedCoordinate_computeGravityCompensation_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeGravityCompensation_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_computeGravityCompensation_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisAndCentrifugalForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisAndCentrifugalForce_1');
  _emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisAndCentrifugalForce_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisAndCentrifugalForce_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisAndCentrifugalForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisCompensation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisCompensation_1');
  _emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisCompensation_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisCompensation_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisCompensation_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedExternalForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedExternalForce_1');
  _emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedExternalForce_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedExternalForce_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedExternalForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_computeJointAcceleration_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_computeJointAcceleration_1');
  _emscripten_bind_PxArticulationReducedCoordinate_computeJointAcceleration_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeJointAcceleration_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_computeJointAcceleration_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_computeJointForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_computeJointForce_1');
  _emscripten_bind_PxArticulationReducedCoordinate_computeJointForce_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeJointForce_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_computeJointForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_computeCoefficientMatrix_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_computeCoefficientMatrix_1');
  _emscripten_bind_PxArticulationReducedCoordinate_computeCoefficientMatrix_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeCoefficientMatrix_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_computeCoefficientMatrix_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedMassMatrix_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedMassMatrix_1');
  _emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedMassMatrix_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedMassMatrix_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedMassMatrix_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_computeMassMatrix_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_computeMassMatrix_1');
  _emscripten_bind_PxArticulationReducedCoordinate_computeMassMatrix_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeMassMatrix_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_computeMassMatrix_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_computeArticulationCOM_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_computeArticulationCOM_1');
  _emscripten_bind_PxArticulationReducedCoordinate_computeArticulationCOM_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeArticulationCOM_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_computeArticulationCOM_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_computeCentroidalMomentumMatrix_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_computeCentroidalMomentumMatrix_1');
  _emscripten_bind_PxArticulationReducedCoordinate_computeCentroidalMomentumMatrix_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_computeCentroidalMomentumMatrix_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_computeCentroidalMomentumMatrix_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_addLoopJoint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_addLoopJoint_1');
  _emscripten_bind_PxArticulationReducedCoordinate_addLoopJoint_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_addLoopJoint_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_addLoopJoint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_removeLoopJoint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_removeLoopJoint_1');
  _emscripten_bind_PxArticulationReducedCoordinate_removeLoopJoint_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_removeLoopJoint_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_removeLoopJoint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getNbLoopJoints_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getNbLoopJoints_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getNbLoopJoints_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getNbLoopJoints_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getNbLoopJoints_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getCoefficientMatrixSize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getCoefficientMatrixSize_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getCoefficientMatrixSize_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getCoefficientMatrixSize_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getCoefficientMatrixSize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_1');
  _emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_2');
  _emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_2'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getRootGlobalPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getRootGlobalPose_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getRootGlobalPose_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getRootGlobalPose_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getRootGlobalPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_1');
  _emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_2');
  _emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_2'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getRootLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getRootLinearVelocity_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getRootLinearVelocity_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getRootLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getRootLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_1');
  _emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_2');
  _emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_2'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getRootAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getRootAngularVelocity_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getRootAngularVelocity_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getRootAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getRootAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getLinkAcceleration_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getLinkAcceleration_1');
  _emscripten_bind_PxArticulationReducedCoordinate_getLinkAcceleration_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getLinkAcceleration_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getLinkAcceleration_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getGPUIndex_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getGPUIndex_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getGPUIndex_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getGPUIndex_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getGPUIndex_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_createSpatialTendon_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_createSpatialTendon_0');
  _emscripten_bind_PxArticulationReducedCoordinate_createSpatialTendon_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_createSpatialTendon_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_createSpatialTendon_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_createFixedTendon_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_createFixedTendon_0');
  _emscripten_bind_PxArticulationReducedCoordinate_createFixedTendon_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_createFixedTendon_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_createFixedTendon_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getNbSpatialTendons_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getNbSpatialTendons_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getNbSpatialTendons_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getNbSpatialTendons_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getNbSpatialTendons_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getNbFixedTendons_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getNbFixedTendons_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getNbFixedTendons_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getNbFixedTendons_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getNbFixedTendons_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_updateKinematic_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_updateKinematic_1');
  _emscripten_bind_PxArticulationReducedCoordinate_updateKinematic_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_updateKinematic_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_updateKinematic_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_release_0');
  _emscripten_bind_PxArticulationReducedCoordinate_release_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_release_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getConcreteTypeName_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getConcreteTypeName_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getConcreteType_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getConcreteType_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setBaseFlag_2');
  _emscripten_bind_PxArticulationReducedCoordinate_setBaseFlag_2 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_setBaseFlags_1');
  _emscripten_bind_PxArticulationReducedCoordinate_setBaseFlags_1 = Module['_emscripten_bind_PxArticulationReducedCoordinate_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_getBaseFlags_0');
  _emscripten_bind_PxArticulationReducedCoordinate_getBaseFlags_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate_isReleasable_0');
  _emscripten_bind_PxArticulationReducedCoordinate_isReleasable_0 = Module['_emscripten_bind_PxArticulationReducedCoordinate_isReleasable_0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationReducedCoordinate___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationReducedCoordinate___destroy___0');
  _emscripten_bind_PxArticulationReducedCoordinate___destroy___0 = Module['_emscripten_bind_PxArticulationReducedCoordinate___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationReducedCoordinate___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationRootLinkData_PxArticulationRootLinkData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationRootLinkData_PxArticulationRootLinkData_0');
  _emscripten_bind_PxArticulationRootLinkData_PxArticulationRootLinkData_0 = Module['_emscripten_bind_PxArticulationRootLinkData_PxArticulationRootLinkData_0'] = createExportWrapper('emscripten_bind_PxArticulationRootLinkData_PxArticulationRootLinkData_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxArticulationRootLinkData_get_transform_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationRootLinkData_get_transform_0');
  _emscripten_bind_PxArticulationRootLinkData_get_transform_0 = Module['_emscripten_bind_PxArticulationRootLinkData_get_transform_0'] = createExportWrapper('emscripten_bind_PxArticulationRootLinkData_get_transform_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationRootLinkData_set_transform_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationRootLinkData_set_transform_1');
  _emscripten_bind_PxArticulationRootLinkData_set_transform_1 = Module['_emscripten_bind_PxArticulationRootLinkData_set_transform_1'] = createExportWrapper('emscripten_bind_PxArticulationRootLinkData_set_transform_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationRootLinkData_get_worldLinVel_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationRootLinkData_get_worldLinVel_0');
  _emscripten_bind_PxArticulationRootLinkData_get_worldLinVel_0 = Module['_emscripten_bind_PxArticulationRootLinkData_get_worldLinVel_0'] = createExportWrapper('emscripten_bind_PxArticulationRootLinkData_get_worldLinVel_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationRootLinkData_set_worldLinVel_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationRootLinkData_set_worldLinVel_1');
  _emscripten_bind_PxArticulationRootLinkData_set_worldLinVel_1 = Module['_emscripten_bind_PxArticulationRootLinkData_set_worldLinVel_1'] = createExportWrapper('emscripten_bind_PxArticulationRootLinkData_set_worldLinVel_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationRootLinkData_get_worldAngVel_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationRootLinkData_get_worldAngVel_0');
  _emscripten_bind_PxArticulationRootLinkData_get_worldAngVel_0 = Module['_emscripten_bind_PxArticulationRootLinkData_get_worldAngVel_0'] = createExportWrapper('emscripten_bind_PxArticulationRootLinkData_get_worldAngVel_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationRootLinkData_set_worldAngVel_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationRootLinkData_set_worldAngVel_1');
  _emscripten_bind_PxArticulationRootLinkData_set_worldAngVel_1 = Module['_emscripten_bind_PxArticulationRootLinkData_set_worldAngVel_1'] = createExportWrapper('emscripten_bind_PxArticulationRootLinkData_set_worldAngVel_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationRootLinkData_get_worldLinAccel_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationRootLinkData_get_worldLinAccel_0');
  _emscripten_bind_PxArticulationRootLinkData_get_worldLinAccel_0 = Module['_emscripten_bind_PxArticulationRootLinkData_get_worldLinAccel_0'] = createExportWrapper('emscripten_bind_PxArticulationRootLinkData_get_worldLinAccel_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationRootLinkData_set_worldLinAccel_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationRootLinkData_set_worldLinAccel_1');
  _emscripten_bind_PxArticulationRootLinkData_set_worldLinAccel_1 = Module['_emscripten_bind_PxArticulationRootLinkData_set_worldLinAccel_1'] = createExportWrapper('emscripten_bind_PxArticulationRootLinkData_set_worldLinAccel_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationRootLinkData_get_worldAngAccel_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationRootLinkData_get_worldAngAccel_0');
  _emscripten_bind_PxArticulationRootLinkData_get_worldAngAccel_0 = Module['_emscripten_bind_PxArticulationRootLinkData_get_worldAngAccel_0'] = createExportWrapper('emscripten_bind_PxArticulationRootLinkData_get_worldAngAccel_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationRootLinkData_set_worldAngAccel_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationRootLinkData_set_worldAngAccel_1');
  _emscripten_bind_PxArticulationRootLinkData_set_worldAngAccel_1 = Module['_emscripten_bind_PxArticulationRootLinkData_set_worldAngAccel_1'] = createExportWrapper('emscripten_bind_PxArticulationRootLinkData_set_worldAngAccel_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationRootLinkData___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationRootLinkData___destroy___0');
  _emscripten_bind_PxArticulationRootLinkData___destroy___0 = Module['_emscripten_bind_PxArticulationRootLinkData___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationRootLinkData___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_createAttachment_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_createAttachment_4');
  _emscripten_bind_PxArticulationSpatialTendon_createAttachment_4 = Module['_emscripten_bind_PxArticulationSpatialTendon_createAttachment_4'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_createAttachment_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_getNbAttachments_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_getNbAttachments_0');
  _emscripten_bind_PxArticulationSpatialTendon_getNbAttachments_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getNbAttachments_0'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_getNbAttachments_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_setStiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_setStiffness_1');
  _emscripten_bind_PxArticulationSpatialTendon_setStiffness_1 = Module['_emscripten_bind_PxArticulationSpatialTendon_setStiffness_1'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_setStiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_getStiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_getStiffness_0');
  _emscripten_bind_PxArticulationSpatialTendon_getStiffness_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getStiffness_0'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_getStiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_setDamping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_setDamping_1');
  _emscripten_bind_PxArticulationSpatialTendon_setDamping_1 = Module['_emscripten_bind_PxArticulationSpatialTendon_setDamping_1'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_setDamping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_getDamping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_getDamping_0');
  _emscripten_bind_PxArticulationSpatialTendon_getDamping_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getDamping_0'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_getDamping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_setLimitStiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_setLimitStiffness_1');
  _emscripten_bind_PxArticulationSpatialTendon_setLimitStiffness_1 = Module['_emscripten_bind_PxArticulationSpatialTendon_setLimitStiffness_1'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_setLimitStiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_getLimitStiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_getLimitStiffness_0');
  _emscripten_bind_PxArticulationSpatialTendon_getLimitStiffness_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getLimitStiffness_0'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_getLimitStiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_setOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_setOffset_1');
  _emscripten_bind_PxArticulationSpatialTendon_setOffset_1 = Module['_emscripten_bind_PxArticulationSpatialTendon_setOffset_1'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_setOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_setOffset_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_setOffset_2');
  _emscripten_bind_PxArticulationSpatialTendon_setOffset_2 = Module['_emscripten_bind_PxArticulationSpatialTendon_setOffset_2'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_setOffset_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_getOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_getOffset_0');
  _emscripten_bind_PxArticulationSpatialTendon_getOffset_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getOffset_0'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_getOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_getArticulation_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_getArticulation_0');
  _emscripten_bind_PxArticulationSpatialTendon_getArticulation_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getArticulation_0'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_getArticulation_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_release_0');
  _emscripten_bind_PxArticulationSpatialTendon_release_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_release_0'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_getConcreteTypeName_0');
  _emscripten_bind_PxArticulationSpatialTendon_getConcreteTypeName_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_getConcreteType_0');
  _emscripten_bind_PxArticulationSpatialTendon_getConcreteType_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_setBaseFlag_2');
  _emscripten_bind_PxArticulationSpatialTendon_setBaseFlag_2 = Module['_emscripten_bind_PxArticulationSpatialTendon_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_setBaseFlags_1');
  _emscripten_bind_PxArticulationSpatialTendon_setBaseFlags_1 = Module['_emscripten_bind_PxArticulationSpatialTendon_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_getBaseFlags_0');
  _emscripten_bind_PxArticulationSpatialTendon_getBaseFlags_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon_isReleasable_0');
  _emscripten_bind_PxArticulationSpatialTendon_isReleasable_0 = Module['_emscripten_bind_PxArticulationSpatialTendon_isReleasable_0'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationSpatialTendon___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationSpatialTendon___destroy___0');
  _emscripten_bind_PxArticulationSpatialTendon___destroy___0 = Module['_emscripten_bind_PxArticulationSpatialTendon___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationSpatialTendon___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendonJoint_setCoefficient_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendonJoint_setCoefficient_3');
  _emscripten_bind_PxArticulationTendonJoint_setCoefficient_3 = Module['_emscripten_bind_PxArticulationTendonJoint_setCoefficient_3'] = createExportWrapper('emscripten_bind_PxArticulationTendonJoint_setCoefficient_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendonJoint_getLink_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendonJoint_getLink_0');
  _emscripten_bind_PxArticulationTendonJoint_getLink_0 = Module['_emscripten_bind_PxArticulationTendonJoint_getLink_0'] = createExportWrapper('emscripten_bind_PxArticulationTendonJoint_getLink_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendonJoint_getParent_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendonJoint_getParent_0');
  _emscripten_bind_PxArticulationTendonJoint_getParent_0 = Module['_emscripten_bind_PxArticulationTendonJoint_getParent_0'] = createExportWrapper('emscripten_bind_PxArticulationTendonJoint_getParent_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendonJoint_getTendon_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendonJoint_getTendon_0');
  _emscripten_bind_PxArticulationTendonJoint_getTendon_0 = Module['_emscripten_bind_PxArticulationTendonJoint_getTendon_0'] = createExportWrapper('emscripten_bind_PxArticulationTendonJoint_getTendon_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendonJoint_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendonJoint_release_0');
  _emscripten_bind_PxArticulationTendonJoint_release_0 = Module['_emscripten_bind_PxArticulationTendonJoint_release_0'] = createExportWrapper('emscripten_bind_PxArticulationTendonJoint_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendonJoint_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendonJoint_get_userData_0');
  _emscripten_bind_PxArticulationTendonJoint_get_userData_0 = Module['_emscripten_bind_PxArticulationTendonJoint_get_userData_0'] = createExportWrapper('emscripten_bind_PxArticulationTendonJoint_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendonJoint_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendonJoint_set_userData_1');
  _emscripten_bind_PxArticulationTendonJoint_set_userData_1 = Module['_emscripten_bind_PxArticulationTendonJoint_set_userData_1'] = createExportWrapper('emscripten_bind_PxArticulationTendonJoint_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendonJoint___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendonJoint___destroy___0');
  _emscripten_bind_PxArticulationTendonJoint___destroy___0 = Module['_emscripten_bind_PxArticulationTendonJoint___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationTendonJoint___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendonLimit_get_lowLimit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendonLimit_get_lowLimit_0');
  _emscripten_bind_PxArticulationTendonLimit_get_lowLimit_0 = Module['_emscripten_bind_PxArticulationTendonLimit_get_lowLimit_0'] = createExportWrapper('emscripten_bind_PxArticulationTendonLimit_get_lowLimit_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendonLimit_set_lowLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendonLimit_set_lowLimit_1');
  _emscripten_bind_PxArticulationTendonLimit_set_lowLimit_1 = Module['_emscripten_bind_PxArticulationTendonLimit_set_lowLimit_1'] = createExportWrapper('emscripten_bind_PxArticulationTendonLimit_set_lowLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendonLimit_get_highLimit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendonLimit_get_highLimit_0');
  _emscripten_bind_PxArticulationTendonLimit_get_highLimit_0 = Module['_emscripten_bind_PxArticulationTendonLimit_get_highLimit_0'] = createExportWrapper('emscripten_bind_PxArticulationTendonLimit_get_highLimit_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendonLimit_set_highLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendonLimit_set_highLimit_1');
  _emscripten_bind_PxArticulationTendonLimit_set_highLimit_1 = Module['_emscripten_bind_PxArticulationTendonLimit_set_highLimit_1'] = createExportWrapper('emscripten_bind_PxArticulationTendonLimit_set_highLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxArticulationTendonLimit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxArticulationTendonLimit___destroy___0');
  _emscripten_bind_PxArticulationTendonLimit___destroy___0 = Module['_emscripten_bind_PxArticulationTendonLimit___destroy___0'] = createExportWrapper('emscripten_bind_PxArticulationTendonLimit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBVH_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH_release_0');
  _emscripten_bind_PxBVH_release_0 = Module['_emscripten_bind_PxBVH_release_0'] = createExportWrapper('emscripten_bind_PxBVH_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBVH_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH_getConcreteTypeName_0');
  _emscripten_bind_PxBVH_getConcreteTypeName_0 = Module['_emscripten_bind_PxBVH_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxBVH_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBVH_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH_getConcreteType_0');
  _emscripten_bind_PxBVH_getConcreteType_0 = Module['_emscripten_bind_PxBVH_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxBVH_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBVH_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH_setBaseFlag_2');
  _emscripten_bind_PxBVH_setBaseFlag_2 = Module['_emscripten_bind_PxBVH_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxBVH_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxBVH_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH_setBaseFlags_1');
  _emscripten_bind_PxBVH_setBaseFlags_1 = Module['_emscripten_bind_PxBVH_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxBVH_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBVH_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH_getBaseFlags_0');
  _emscripten_bind_PxBVH_getBaseFlags_0 = Module['_emscripten_bind_PxBVH_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxBVH_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBVH_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH_isReleasable_0');
  _emscripten_bind_PxBVH_isReleasable_0 = Module['_emscripten_bind_PxBVH_isReleasable_0'] = createExportWrapper('emscripten_bind_PxBVH_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBVH33MidphaseDesc_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH33MidphaseDesc_setToDefault_0');
  _emscripten_bind_PxBVH33MidphaseDesc_setToDefault_0 = Module['_emscripten_bind_PxBVH33MidphaseDesc_setToDefault_0'] = createExportWrapper('emscripten_bind_PxBVH33MidphaseDesc_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBVH33MidphaseDesc_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH33MidphaseDesc_isValid_0');
  _emscripten_bind_PxBVH33MidphaseDesc_isValid_0 = Module['_emscripten_bind_PxBVH33MidphaseDesc_isValid_0'] = createExportWrapper('emscripten_bind_PxBVH33MidphaseDesc_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBVH33MidphaseDesc_get_meshSizePerformanceTradeOff_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH33MidphaseDesc_get_meshSizePerformanceTradeOff_0');
  _emscripten_bind_PxBVH33MidphaseDesc_get_meshSizePerformanceTradeOff_0 = Module['_emscripten_bind_PxBVH33MidphaseDesc_get_meshSizePerformanceTradeOff_0'] = createExportWrapper('emscripten_bind_PxBVH33MidphaseDesc_get_meshSizePerformanceTradeOff_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBVH33MidphaseDesc_set_meshSizePerformanceTradeOff_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH33MidphaseDesc_set_meshSizePerformanceTradeOff_1');
  _emscripten_bind_PxBVH33MidphaseDesc_set_meshSizePerformanceTradeOff_1 = Module['_emscripten_bind_PxBVH33MidphaseDesc_set_meshSizePerformanceTradeOff_1'] = createExportWrapper('emscripten_bind_PxBVH33MidphaseDesc_set_meshSizePerformanceTradeOff_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBVH33MidphaseDesc_get_meshCookingHint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH33MidphaseDesc_get_meshCookingHint_0');
  _emscripten_bind_PxBVH33MidphaseDesc_get_meshCookingHint_0 = Module['_emscripten_bind_PxBVH33MidphaseDesc_get_meshCookingHint_0'] = createExportWrapper('emscripten_bind_PxBVH33MidphaseDesc_get_meshCookingHint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBVH33MidphaseDesc_set_meshCookingHint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH33MidphaseDesc_set_meshCookingHint_1');
  _emscripten_bind_PxBVH33MidphaseDesc_set_meshCookingHint_1 = Module['_emscripten_bind_PxBVH33MidphaseDesc_set_meshCookingHint_1'] = createExportWrapper('emscripten_bind_PxBVH33MidphaseDesc_set_meshCookingHint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBVH33MidphaseDesc___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH33MidphaseDesc___destroy___0');
  _emscripten_bind_PxBVH33MidphaseDesc___destroy___0 = Module['_emscripten_bind_PxBVH33MidphaseDesc___destroy___0'] = createExportWrapper('emscripten_bind_PxBVH33MidphaseDesc___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBVH34MidphaseDesc_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH34MidphaseDesc_setToDefault_0');
  _emscripten_bind_PxBVH34MidphaseDesc_setToDefault_0 = Module['_emscripten_bind_PxBVH34MidphaseDesc_setToDefault_0'] = createExportWrapper('emscripten_bind_PxBVH34MidphaseDesc_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBVH34MidphaseDesc_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH34MidphaseDesc_isValid_0');
  _emscripten_bind_PxBVH34MidphaseDesc_isValid_0 = Module['_emscripten_bind_PxBVH34MidphaseDesc_isValid_0'] = createExportWrapper('emscripten_bind_PxBVH34MidphaseDesc_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBVH34MidphaseDesc_get_numPrimsPerLeaf_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH34MidphaseDesc_get_numPrimsPerLeaf_0');
  _emscripten_bind_PxBVH34MidphaseDesc_get_numPrimsPerLeaf_0 = Module['_emscripten_bind_PxBVH34MidphaseDesc_get_numPrimsPerLeaf_0'] = createExportWrapper('emscripten_bind_PxBVH34MidphaseDesc_get_numPrimsPerLeaf_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBVH34MidphaseDesc_set_numPrimsPerLeaf_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH34MidphaseDesc_set_numPrimsPerLeaf_1');
  _emscripten_bind_PxBVH34MidphaseDesc_set_numPrimsPerLeaf_1 = Module['_emscripten_bind_PxBVH34MidphaseDesc_set_numPrimsPerLeaf_1'] = createExportWrapper('emscripten_bind_PxBVH34MidphaseDesc_set_numPrimsPerLeaf_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBVH34MidphaseDesc___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBVH34MidphaseDesc___destroy___0');
  _emscripten_bind_PxBVH34MidphaseDesc___destroy___0 = Module['_emscripten_bind_PxBVH34MidphaseDesc___destroy___0'] = createExportWrapper('emscripten_bind_PxBVH34MidphaseDesc___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBaseFlags_PxBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseFlags_PxBaseFlags_1');
  _emscripten_bind_PxBaseFlags_PxBaseFlags_1 = Module['_emscripten_bind_PxBaseFlags_PxBaseFlags_1'] = createExportWrapper('emscripten_bind_PxBaseFlags_PxBaseFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxBaseFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseFlags_isSet_1');
  _emscripten_bind_PxBaseFlags_isSet_1 = Module['_emscripten_bind_PxBaseFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxBaseFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBaseFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseFlags_raise_1');
  _emscripten_bind_PxBaseFlags_raise_1 = Module['_emscripten_bind_PxBaseFlags_raise_1'] = createExportWrapper('emscripten_bind_PxBaseFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBaseFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseFlags_clear_1');
  _emscripten_bind_PxBaseFlags_clear_1 = Module['_emscripten_bind_PxBaseFlags_clear_1'] = createExportWrapper('emscripten_bind_PxBaseFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBaseFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseFlags___destroy___0');
  _emscripten_bind_PxBaseFlags___destroy___0 = Module['_emscripten_bind_PxBaseFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxBaseFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBaseTask___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBaseTask___destroy___0');
  _emscripten_bind_PxBaseTask___destroy___0 = Module['_emscripten_bind_PxBaseTask___destroy___0'] = createExportWrapper('emscripten_bind_PxBaseTask___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoundedData_PxBoundedData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoundedData_PxBoundedData_0');
  _emscripten_bind_PxBoundedData_PxBoundedData_0 = Module['_emscripten_bind_PxBoundedData_PxBoundedData_0'] = createExportWrapper('emscripten_bind_PxBoundedData_PxBoundedData_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxBoundedData_get_count_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoundedData_get_count_0');
  _emscripten_bind_PxBoundedData_get_count_0 = Module['_emscripten_bind_PxBoundedData_get_count_0'] = createExportWrapper('emscripten_bind_PxBoundedData_get_count_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoundedData_set_count_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoundedData_set_count_1');
  _emscripten_bind_PxBoundedData_set_count_1 = Module['_emscripten_bind_PxBoundedData_set_count_1'] = createExportWrapper('emscripten_bind_PxBoundedData_set_count_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoundedData_get_stride_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoundedData_get_stride_0');
  _emscripten_bind_PxBoundedData_get_stride_0 = Module['_emscripten_bind_PxBoundedData_get_stride_0'] = createExportWrapper('emscripten_bind_PxBoundedData_get_stride_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoundedData_set_stride_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoundedData_set_stride_1');
  _emscripten_bind_PxBoundedData_set_stride_1 = Module['_emscripten_bind_PxBoundedData_set_stride_1'] = createExportWrapper('emscripten_bind_PxBoundedData_set_stride_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoundedData_get_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoundedData_get_data_0');
  _emscripten_bind_PxBoundedData_get_data_0 = Module['_emscripten_bind_PxBoundedData_get_data_0'] = createExportWrapper('emscripten_bind_PxBoundedData_get_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoundedData_set_data_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoundedData_set_data_1');
  _emscripten_bind_PxBoundedData_set_data_1 = Module['_emscripten_bind_PxBoundedData_set_data_1'] = createExportWrapper('emscripten_bind_PxBoundedData_set_data_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoundedData___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoundedData___destroy___0');
  _emscripten_bind_PxBoundedData___destroy___0 = Module['_emscripten_bind_PxBoundedData___destroy___0'] = createExportWrapper('emscripten_bind_PxBoundedData___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_PxBounds3_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_PxBounds3_0');
  _emscripten_bind_PxBounds3_PxBounds3_0 = Module['_emscripten_bind_PxBounds3_PxBounds3_0'] = createExportWrapper('emscripten_bind_PxBounds3_PxBounds3_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_PxBounds3_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_PxBounds3_2');
  _emscripten_bind_PxBounds3_PxBounds3_2 = Module['_emscripten_bind_PxBounds3_PxBounds3_2'] = createExportWrapper('emscripten_bind_PxBounds3_PxBounds3_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_setEmpty_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_setEmpty_0');
  _emscripten_bind_PxBounds3_setEmpty_0 = Module['_emscripten_bind_PxBounds3_setEmpty_0'] = createExportWrapper('emscripten_bind_PxBounds3_setEmpty_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_setMaximal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_setMaximal_0');
  _emscripten_bind_PxBounds3_setMaximal_0 = Module['_emscripten_bind_PxBounds3_setMaximal_0'] = createExportWrapper('emscripten_bind_PxBounds3_setMaximal_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_include_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_include_1');
  _emscripten_bind_PxBounds3_include_1 = Module['_emscripten_bind_PxBounds3_include_1'] = createExportWrapper('emscripten_bind_PxBounds3_include_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_isEmpty_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_isEmpty_0');
  _emscripten_bind_PxBounds3_isEmpty_0 = Module['_emscripten_bind_PxBounds3_isEmpty_0'] = createExportWrapper('emscripten_bind_PxBounds3_isEmpty_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_intersects_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_intersects_1');
  _emscripten_bind_PxBounds3_intersects_1 = Module['_emscripten_bind_PxBounds3_intersects_1'] = createExportWrapper('emscripten_bind_PxBounds3_intersects_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_intersects1D_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_intersects1D_2');
  _emscripten_bind_PxBounds3_intersects1D_2 = Module['_emscripten_bind_PxBounds3_intersects1D_2'] = createExportWrapper('emscripten_bind_PxBounds3_intersects1D_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_contains_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_contains_1');
  _emscripten_bind_PxBounds3_contains_1 = Module['_emscripten_bind_PxBounds3_contains_1'] = createExportWrapper('emscripten_bind_PxBounds3_contains_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_isInside_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_isInside_1');
  _emscripten_bind_PxBounds3_isInside_1 = Module['_emscripten_bind_PxBounds3_isInside_1'] = createExportWrapper('emscripten_bind_PxBounds3_isInside_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_getCenter_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_getCenter_0');
  _emscripten_bind_PxBounds3_getCenter_0 = Module['_emscripten_bind_PxBounds3_getCenter_0'] = createExportWrapper('emscripten_bind_PxBounds3_getCenter_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_getDimensions_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_getDimensions_0');
  _emscripten_bind_PxBounds3_getDimensions_0 = Module['_emscripten_bind_PxBounds3_getDimensions_0'] = createExportWrapper('emscripten_bind_PxBounds3_getDimensions_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_getExtents_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_getExtents_0');
  _emscripten_bind_PxBounds3_getExtents_0 = Module['_emscripten_bind_PxBounds3_getExtents_0'] = createExportWrapper('emscripten_bind_PxBounds3_getExtents_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_scaleSafe_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_scaleSafe_1');
  _emscripten_bind_PxBounds3_scaleSafe_1 = Module['_emscripten_bind_PxBounds3_scaleSafe_1'] = createExportWrapper('emscripten_bind_PxBounds3_scaleSafe_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_scaleFast_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_scaleFast_1');
  _emscripten_bind_PxBounds3_scaleFast_1 = Module['_emscripten_bind_PxBounds3_scaleFast_1'] = createExportWrapper('emscripten_bind_PxBounds3_scaleFast_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_fattenSafe_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_fattenSafe_1');
  _emscripten_bind_PxBounds3_fattenSafe_1 = Module['_emscripten_bind_PxBounds3_fattenSafe_1'] = createExportWrapper('emscripten_bind_PxBounds3_fattenSafe_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_fattenFast_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_fattenFast_1');
  _emscripten_bind_PxBounds3_fattenFast_1 = Module['_emscripten_bind_PxBounds3_fattenFast_1'] = createExportWrapper('emscripten_bind_PxBounds3_fattenFast_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_isFinite_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_isFinite_0');
  _emscripten_bind_PxBounds3_isFinite_0 = Module['_emscripten_bind_PxBounds3_isFinite_0'] = createExportWrapper('emscripten_bind_PxBounds3_isFinite_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_isValid_0');
  _emscripten_bind_PxBounds3_isValid_0 = Module['_emscripten_bind_PxBounds3_isValid_0'] = createExportWrapper('emscripten_bind_PxBounds3_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_get_minimum_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_get_minimum_0');
  _emscripten_bind_PxBounds3_get_minimum_0 = Module['_emscripten_bind_PxBounds3_get_minimum_0'] = createExportWrapper('emscripten_bind_PxBounds3_get_minimum_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_set_minimum_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_set_minimum_1');
  _emscripten_bind_PxBounds3_set_minimum_1 = Module['_emscripten_bind_PxBounds3_set_minimum_1'] = createExportWrapper('emscripten_bind_PxBounds3_set_minimum_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_get_maximum_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_get_maximum_0');
  _emscripten_bind_PxBounds3_get_maximum_0 = Module['_emscripten_bind_PxBounds3_get_maximum_0'] = createExportWrapper('emscripten_bind_PxBounds3_get_maximum_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBounds3_set_maximum_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3_set_maximum_1');
  _emscripten_bind_PxBounds3_set_maximum_1 = Module['_emscripten_bind_PxBounds3_set_maximum_1'] = createExportWrapper('emscripten_bind_PxBounds3_set_maximum_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBounds3___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBounds3___destroy___0');
  _emscripten_bind_PxBounds3___destroy___0 = Module['_emscripten_bind_PxBounds3___destroy___0'] = createExportWrapper('emscripten_bind_PxBounds3___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getHalfHeight_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getHalfHeight_0');
  _emscripten_bind_PxBoxController_getHalfHeight_0 = Module['_emscripten_bind_PxBoxController_getHalfHeight_0'] = createExportWrapper('emscripten_bind_PxBoxController_getHalfHeight_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getHalfSideExtent_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getHalfSideExtent_0');
  _emscripten_bind_PxBoxController_getHalfSideExtent_0 = Module['_emscripten_bind_PxBoxController_getHalfSideExtent_0'] = createExportWrapper('emscripten_bind_PxBoxController_getHalfSideExtent_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getHalfForwardExtent_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getHalfForwardExtent_0');
  _emscripten_bind_PxBoxController_getHalfForwardExtent_0 = Module['_emscripten_bind_PxBoxController_getHalfForwardExtent_0'] = createExportWrapper('emscripten_bind_PxBoxController_getHalfForwardExtent_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_setHalfHeight_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_setHalfHeight_1');
  _emscripten_bind_PxBoxController_setHalfHeight_1 = Module['_emscripten_bind_PxBoxController_setHalfHeight_1'] = createExportWrapper('emscripten_bind_PxBoxController_setHalfHeight_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_setHalfSideExtent_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_setHalfSideExtent_1');
  _emscripten_bind_PxBoxController_setHalfSideExtent_1 = Module['_emscripten_bind_PxBoxController_setHalfSideExtent_1'] = createExportWrapper('emscripten_bind_PxBoxController_setHalfSideExtent_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_setHalfForwardExtent_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_setHalfForwardExtent_1');
  _emscripten_bind_PxBoxController_setHalfForwardExtent_1 = Module['_emscripten_bind_PxBoxController_setHalfForwardExtent_1'] = createExportWrapper('emscripten_bind_PxBoxController_setHalfForwardExtent_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getType_0');
  _emscripten_bind_PxBoxController_getType_0 = Module['_emscripten_bind_PxBoxController_getType_0'] = createExportWrapper('emscripten_bind_PxBoxController_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_release_0');
  _emscripten_bind_PxBoxController_release_0 = Module['_emscripten_bind_PxBoxController_release_0'] = createExportWrapper('emscripten_bind_PxBoxController_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_move_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_move_4');
  _emscripten_bind_PxBoxController_move_4 = Module['_emscripten_bind_PxBoxController_move_4'] = createExportWrapper('emscripten_bind_PxBoxController_move_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_move_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_move_5');
  _emscripten_bind_PxBoxController_move_5 = Module['_emscripten_bind_PxBoxController_move_5'] = createExportWrapper('emscripten_bind_PxBoxController_move_5', 6);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_setPosition_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_setPosition_1');
  _emscripten_bind_PxBoxController_setPosition_1 = Module['_emscripten_bind_PxBoxController_setPosition_1'] = createExportWrapper('emscripten_bind_PxBoxController_setPosition_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getPosition_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getPosition_0');
  _emscripten_bind_PxBoxController_getPosition_0 = Module['_emscripten_bind_PxBoxController_getPosition_0'] = createExportWrapper('emscripten_bind_PxBoxController_getPosition_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_setFootPosition_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_setFootPosition_1');
  _emscripten_bind_PxBoxController_setFootPosition_1 = Module['_emscripten_bind_PxBoxController_setFootPosition_1'] = createExportWrapper('emscripten_bind_PxBoxController_setFootPosition_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getFootPosition_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getFootPosition_0');
  _emscripten_bind_PxBoxController_getFootPosition_0 = Module['_emscripten_bind_PxBoxController_getFootPosition_0'] = createExportWrapper('emscripten_bind_PxBoxController_getFootPosition_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getActor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getActor_0');
  _emscripten_bind_PxBoxController_getActor_0 = Module['_emscripten_bind_PxBoxController_getActor_0'] = createExportWrapper('emscripten_bind_PxBoxController_getActor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_setStepOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_setStepOffset_1');
  _emscripten_bind_PxBoxController_setStepOffset_1 = Module['_emscripten_bind_PxBoxController_setStepOffset_1'] = createExportWrapper('emscripten_bind_PxBoxController_setStepOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getStepOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getStepOffset_0');
  _emscripten_bind_PxBoxController_getStepOffset_0 = Module['_emscripten_bind_PxBoxController_getStepOffset_0'] = createExportWrapper('emscripten_bind_PxBoxController_getStepOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_setNonWalkableMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_setNonWalkableMode_1');
  _emscripten_bind_PxBoxController_setNonWalkableMode_1 = Module['_emscripten_bind_PxBoxController_setNonWalkableMode_1'] = createExportWrapper('emscripten_bind_PxBoxController_setNonWalkableMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getNonWalkableMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getNonWalkableMode_0');
  _emscripten_bind_PxBoxController_getNonWalkableMode_0 = Module['_emscripten_bind_PxBoxController_getNonWalkableMode_0'] = createExportWrapper('emscripten_bind_PxBoxController_getNonWalkableMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getContactOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getContactOffset_0');
  _emscripten_bind_PxBoxController_getContactOffset_0 = Module['_emscripten_bind_PxBoxController_getContactOffset_0'] = createExportWrapper('emscripten_bind_PxBoxController_getContactOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_setContactOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_setContactOffset_1');
  _emscripten_bind_PxBoxController_setContactOffset_1 = Module['_emscripten_bind_PxBoxController_setContactOffset_1'] = createExportWrapper('emscripten_bind_PxBoxController_setContactOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getUpDirection_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getUpDirection_0');
  _emscripten_bind_PxBoxController_getUpDirection_0 = Module['_emscripten_bind_PxBoxController_getUpDirection_0'] = createExportWrapper('emscripten_bind_PxBoxController_getUpDirection_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_setUpDirection_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_setUpDirection_1');
  _emscripten_bind_PxBoxController_setUpDirection_1 = Module['_emscripten_bind_PxBoxController_setUpDirection_1'] = createExportWrapper('emscripten_bind_PxBoxController_setUpDirection_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getSlopeLimit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getSlopeLimit_0');
  _emscripten_bind_PxBoxController_getSlopeLimit_0 = Module['_emscripten_bind_PxBoxController_getSlopeLimit_0'] = createExportWrapper('emscripten_bind_PxBoxController_getSlopeLimit_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_setSlopeLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_setSlopeLimit_1');
  _emscripten_bind_PxBoxController_setSlopeLimit_1 = Module['_emscripten_bind_PxBoxController_setSlopeLimit_1'] = createExportWrapper('emscripten_bind_PxBoxController_setSlopeLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_invalidateCache_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_invalidateCache_0');
  _emscripten_bind_PxBoxController_invalidateCache_0 = Module['_emscripten_bind_PxBoxController_invalidateCache_0'] = createExportWrapper('emscripten_bind_PxBoxController_invalidateCache_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getScene_0');
  _emscripten_bind_PxBoxController_getScene_0 = Module['_emscripten_bind_PxBoxController_getScene_0'] = createExportWrapper('emscripten_bind_PxBoxController_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getUserData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getUserData_0');
  _emscripten_bind_PxBoxController_getUserData_0 = Module['_emscripten_bind_PxBoxController_getUserData_0'] = createExportWrapper('emscripten_bind_PxBoxController_getUserData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_setUserData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_setUserData_1');
  _emscripten_bind_PxBoxController_setUserData_1 = Module['_emscripten_bind_PxBoxController_setUserData_1'] = createExportWrapper('emscripten_bind_PxBoxController_setUserData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getState_1');
  _emscripten_bind_PxBoxController_getState_1 = Module['_emscripten_bind_PxBoxController_getState_1'] = createExportWrapper('emscripten_bind_PxBoxController_getState_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_getStats_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_getStats_1');
  _emscripten_bind_PxBoxController_getStats_1 = Module['_emscripten_bind_PxBoxController_getStats_1'] = createExportWrapper('emscripten_bind_PxBoxController_getStats_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxController_resize_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxController_resize_1');
  _emscripten_bind_PxBoxController_resize_1 = Module['_emscripten_bind_PxBoxController_resize_1'] = createExportWrapper('emscripten_bind_PxBoxController_resize_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_PxBoxControllerDesc_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_PxBoxControllerDesc_0');
  _emscripten_bind_PxBoxControllerDesc_PxBoxControllerDesc_0 = Module['_emscripten_bind_PxBoxControllerDesc_PxBoxControllerDesc_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_PxBoxControllerDesc_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_setToDefault_0');
  _emscripten_bind_PxBoxControllerDesc_setToDefault_0 = Module['_emscripten_bind_PxBoxControllerDesc_setToDefault_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_isValid_0');
  _emscripten_bind_PxBoxControllerDesc_isValid_0 = Module['_emscripten_bind_PxBoxControllerDesc_isValid_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_getType_0');
  _emscripten_bind_PxBoxControllerDesc_getType_0 = Module['_emscripten_bind_PxBoxControllerDesc_getType_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_halfHeight_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_halfHeight_0');
  _emscripten_bind_PxBoxControllerDesc_get_halfHeight_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_halfHeight_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_halfHeight_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_halfHeight_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_halfHeight_1');
  _emscripten_bind_PxBoxControllerDesc_set_halfHeight_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_halfHeight_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_halfHeight_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_halfSideExtent_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_halfSideExtent_0');
  _emscripten_bind_PxBoxControllerDesc_get_halfSideExtent_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_halfSideExtent_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_halfSideExtent_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_halfSideExtent_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_halfSideExtent_1');
  _emscripten_bind_PxBoxControllerDesc_set_halfSideExtent_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_halfSideExtent_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_halfSideExtent_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_halfForwardExtent_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_halfForwardExtent_0');
  _emscripten_bind_PxBoxControllerDesc_get_halfForwardExtent_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_halfForwardExtent_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_halfForwardExtent_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_halfForwardExtent_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_halfForwardExtent_1');
  _emscripten_bind_PxBoxControllerDesc_set_halfForwardExtent_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_halfForwardExtent_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_halfForwardExtent_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_position_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_position_0');
  _emscripten_bind_PxBoxControllerDesc_get_position_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_position_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_position_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_position_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_position_1');
  _emscripten_bind_PxBoxControllerDesc_set_position_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_position_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_position_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_upDirection_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_upDirection_0');
  _emscripten_bind_PxBoxControllerDesc_get_upDirection_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_upDirection_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_upDirection_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_upDirection_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_upDirection_1');
  _emscripten_bind_PxBoxControllerDesc_set_upDirection_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_upDirection_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_upDirection_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_slopeLimit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_slopeLimit_0');
  _emscripten_bind_PxBoxControllerDesc_get_slopeLimit_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_slopeLimit_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_slopeLimit_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_slopeLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_slopeLimit_1');
  _emscripten_bind_PxBoxControllerDesc_set_slopeLimit_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_slopeLimit_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_slopeLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_invisibleWallHeight_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_invisibleWallHeight_0');
  _emscripten_bind_PxBoxControllerDesc_get_invisibleWallHeight_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_invisibleWallHeight_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_invisibleWallHeight_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_invisibleWallHeight_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_invisibleWallHeight_1');
  _emscripten_bind_PxBoxControllerDesc_set_invisibleWallHeight_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_invisibleWallHeight_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_invisibleWallHeight_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_maxJumpHeight_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_maxJumpHeight_0');
  _emscripten_bind_PxBoxControllerDesc_get_maxJumpHeight_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_maxJumpHeight_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_maxJumpHeight_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_maxJumpHeight_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_maxJumpHeight_1');
  _emscripten_bind_PxBoxControllerDesc_set_maxJumpHeight_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_maxJumpHeight_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_maxJumpHeight_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_contactOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_contactOffset_0');
  _emscripten_bind_PxBoxControllerDesc_get_contactOffset_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_contactOffset_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_contactOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_contactOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_contactOffset_1');
  _emscripten_bind_PxBoxControllerDesc_set_contactOffset_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_contactOffset_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_contactOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_stepOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_stepOffset_0');
  _emscripten_bind_PxBoxControllerDesc_get_stepOffset_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_stepOffset_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_stepOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_stepOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_stepOffset_1');
  _emscripten_bind_PxBoxControllerDesc_set_stepOffset_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_stepOffset_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_stepOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_density_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_density_0');
  _emscripten_bind_PxBoxControllerDesc_get_density_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_density_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_density_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_density_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_density_1');
  _emscripten_bind_PxBoxControllerDesc_set_density_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_density_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_density_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_scaleCoeff_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_scaleCoeff_0');
  _emscripten_bind_PxBoxControllerDesc_get_scaleCoeff_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_scaleCoeff_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_scaleCoeff_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_scaleCoeff_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_scaleCoeff_1');
  _emscripten_bind_PxBoxControllerDesc_set_scaleCoeff_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_scaleCoeff_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_scaleCoeff_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_volumeGrowth_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_volumeGrowth_0');
  _emscripten_bind_PxBoxControllerDesc_get_volumeGrowth_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_volumeGrowth_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_volumeGrowth_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_volumeGrowth_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_volumeGrowth_1');
  _emscripten_bind_PxBoxControllerDesc_set_volumeGrowth_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_volumeGrowth_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_volumeGrowth_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_reportCallback_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_reportCallback_0');
  _emscripten_bind_PxBoxControllerDesc_get_reportCallback_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_reportCallback_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_reportCallback_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_reportCallback_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_reportCallback_1');
  _emscripten_bind_PxBoxControllerDesc_set_reportCallback_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_reportCallback_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_reportCallback_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_behaviorCallback_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_behaviorCallback_0');
  _emscripten_bind_PxBoxControllerDesc_get_behaviorCallback_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_behaviorCallback_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_behaviorCallback_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_behaviorCallback_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_behaviorCallback_1');
  _emscripten_bind_PxBoxControllerDesc_set_behaviorCallback_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_behaviorCallback_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_behaviorCallback_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_nonWalkableMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_nonWalkableMode_0');
  _emscripten_bind_PxBoxControllerDesc_get_nonWalkableMode_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_nonWalkableMode_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_nonWalkableMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_nonWalkableMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_nonWalkableMode_1');
  _emscripten_bind_PxBoxControllerDesc_set_nonWalkableMode_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_nonWalkableMode_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_nonWalkableMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_material_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_material_0');
  _emscripten_bind_PxBoxControllerDesc_get_material_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_material_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_material_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_material_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_material_1');
  _emscripten_bind_PxBoxControllerDesc_set_material_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_material_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_material_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_registerDeletionListener_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_registerDeletionListener_0');
  _emscripten_bind_PxBoxControllerDesc_get_registerDeletionListener_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_registerDeletionListener_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_registerDeletionListener_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_registerDeletionListener_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_registerDeletionListener_1');
  _emscripten_bind_PxBoxControllerDesc_set_registerDeletionListener_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_registerDeletionListener_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_registerDeletionListener_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_get_userData_0');
  _emscripten_bind_PxBoxControllerDesc_get_userData_0 = Module['_emscripten_bind_PxBoxControllerDesc_get_userData_0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc_set_userData_1');
  _emscripten_bind_PxBoxControllerDesc_set_userData_1 = Module['_emscripten_bind_PxBoxControllerDesc_set_userData_1'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxControllerDesc___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxControllerDesc___destroy___0');
  _emscripten_bind_PxBoxControllerDesc___destroy___0 = Module['_emscripten_bind_PxBoxControllerDesc___destroy___0'] = createExportWrapper('emscripten_bind_PxBoxControllerDesc___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxGeometry_PxBoxGeometry_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxGeometry_PxBoxGeometry_3');
  _emscripten_bind_PxBoxGeometry_PxBoxGeometry_3 = Module['_emscripten_bind_PxBoxGeometry_PxBoxGeometry_3'] = createExportWrapper('emscripten_bind_PxBoxGeometry_PxBoxGeometry_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxBoxGeometry_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxGeometry_getType_0');
  _emscripten_bind_PxBoxGeometry_getType_0 = Module['_emscripten_bind_PxBoxGeometry_getType_0'] = createExportWrapper('emscripten_bind_PxBoxGeometry_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxGeometry_get_halfExtents_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxGeometry_get_halfExtents_0');
  _emscripten_bind_PxBoxGeometry_get_halfExtents_0 = Module['_emscripten_bind_PxBoxGeometry_get_halfExtents_0'] = createExportWrapper('emscripten_bind_PxBoxGeometry_get_halfExtents_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxGeometry_set_halfExtents_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxGeometry_set_halfExtents_1');
  _emscripten_bind_PxBoxGeometry_set_halfExtents_1 = Module['_emscripten_bind_PxBoxGeometry_set_halfExtents_1'] = createExportWrapper('emscripten_bind_PxBoxGeometry_set_halfExtents_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxGeometry___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxGeometry___destroy___0');
  _emscripten_bind_PxBoxGeometry___destroy___0 = Module['_emscripten_bind_PxBoxGeometry___destroy___0'] = createExportWrapper('emscripten_bind_PxBoxGeometry___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxObstacle_PxBoxObstacle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxObstacle_PxBoxObstacle_0');
  _emscripten_bind_PxBoxObstacle_PxBoxObstacle_0 = Module['_emscripten_bind_PxBoxObstacle_PxBoxObstacle_0'] = createExportWrapper('emscripten_bind_PxBoxObstacle_PxBoxObstacle_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxBoxObstacle_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxObstacle_getType_0');
  _emscripten_bind_PxBoxObstacle_getType_0 = Module['_emscripten_bind_PxBoxObstacle_getType_0'] = createExportWrapper('emscripten_bind_PxBoxObstacle_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxObstacle_get_mHalfExtents_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxObstacle_get_mHalfExtents_0');
  _emscripten_bind_PxBoxObstacle_get_mHalfExtents_0 = Module['_emscripten_bind_PxBoxObstacle_get_mHalfExtents_0'] = createExportWrapper('emscripten_bind_PxBoxObstacle_get_mHalfExtents_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxObstacle_set_mHalfExtents_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxObstacle_set_mHalfExtents_1');
  _emscripten_bind_PxBoxObstacle_set_mHalfExtents_1 = Module['_emscripten_bind_PxBoxObstacle_set_mHalfExtents_1'] = createExportWrapper('emscripten_bind_PxBoxObstacle_set_mHalfExtents_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxObstacle_get_mUserData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxObstacle_get_mUserData_0');
  _emscripten_bind_PxBoxObstacle_get_mUserData_0 = Module['_emscripten_bind_PxBoxObstacle_get_mUserData_0'] = createExportWrapper('emscripten_bind_PxBoxObstacle_get_mUserData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxObstacle_set_mUserData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxObstacle_set_mUserData_1');
  _emscripten_bind_PxBoxObstacle_set_mUserData_1 = Module['_emscripten_bind_PxBoxObstacle_set_mUserData_1'] = createExportWrapper('emscripten_bind_PxBoxObstacle_set_mUserData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxObstacle_get_mPos_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxObstacle_get_mPos_0');
  _emscripten_bind_PxBoxObstacle_get_mPos_0 = Module['_emscripten_bind_PxBoxObstacle_get_mPos_0'] = createExportWrapper('emscripten_bind_PxBoxObstacle_get_mPos_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxObstacle_set_mPos_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxObstacle_set_mPos_1');
  _emscripten_bind_PxBoxObstacle_set_mPos_1 = Module['_emscripten_bind_PxBoxObstacle_set_mPos_1'] = createExportWrapper('emscripten_bind_PxBoxObstacle_set_mPos_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxObstacle_get_mRot_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxObstacle_get_mRot_0');
  _emscripten_bind_PxBoxObstacle_get_mRot_0 = Module['_emscripten_bind_PxBoxObstacle_get_mRot_0'] = createExportWrapper('emscripten_bind_PxBoxObstacle_get_mRot_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBoxObstacle_set_mRot_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxObstacle_set_mRot_1');
  _emscripten_bind_PxBoxObstacle_set_mRot_1 = Module['_emscripten_bind_PxBoxObstacle_set_mRot_1'] = createExportWrapper('emscripten_bind_PxBoxObstacle_set_mRot_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBoxObstacle___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBoxObstacle___destroy___0');
  _emscripten_bind_PxBoxObstacle___destroy___0 = Module['_emscripten_bind_PxBoxObstacle___destroy___0'] = createExportWrapper('emscripten_bind_PxBoxObstacle___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseCaps_PxBroadPhaseCaps_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseCaps_PxBroadPhaseCaps_0');
  _emscripten_bind_PxBroadPhaseCaps_PxBroadPhaseCaps_0 = Module['_emscripten_bind_PxBroadPhaseCaps_PxBroadPhaseCaps_0'] = createExportWrapper('emscripten_bind_PxBroadPhaseCaps_PxBroadPhaseCaps_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseCaps_get_mMaxNbRegions_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseCaps_get_mMaxNbRegions_0');
  _emscripten_bind_PxBroadPhaseCaps_get_mMaxNbRegions_0 = Module['_emscripten_bind_PxBroadPhaseCaps_get_mMaxNbRegions_0'] = createExportWrapper('emscripten_bind_PxBroadPhaseCaps_get_mMaxNbRegions_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseCaps_set_mMaxNbRegions_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseCaps_set_mMaxNbRegions_1');
  _emscripten_bind_PxBroadPhaseCaps_set_mMaxNbRegions_1 = Module['_emscripten_bind_PxBroadPhaseCaps_set_mMaxNbRegions_1'] = createExportWrapper('emscripten_bind_PxBroadPhaseCaps_set_mMaxNbRegions_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseCaps___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseCaps___destroy___0');
  _emscripten_bind_PxBroadPhaseCaps___destroy___0 = Module['_emscripten_bind_PxBroadPhaseCaps___destroy___0'] = createExportWrapper('emscripten_bind_PxBroadPhaseCaps___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegion_PxBroadPhaseRegion_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegion_PxBroadPhaseRegion_0');
  _emscripten_bind_PxBroadPhaseRegion_PxBroadPhaseRegion_0 = Module['_emscripten_bind_PxBroadPhaseRegion_PxBroadPhaseRegion_0'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegion_PxBroadPhaseRegion_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegion_get_mBounds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegion_get_mBounds_0');
  _emscripten_bind_PxBroadPhaseRegion_get_mBounds_0 = Module['_emscripten_bind_PxBroadPhaseRegion_get_mBounds_0'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegion_get_mBounds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegion_set_mBounds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegion_set_mBounds_1');
  _emscripten_bind_PxBroadPhaseRegion_set_mBounds_1 = Module['_emscripten_bind_PxBroadPhaseRegion_set_mBounds_1'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegion_set_mBounds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegion_get_mUserData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegion_get_mUserData_0');
  _emscripten_bind_PxBroadPhaseRegion_get_mUserData_0 = Module['_emscripten_bind_PxBroadPhaseRegion_get_mUserData_0'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegion_get_mUserData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegion_set_mUserData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegion_set_mUserData_1');
  _emscripten_bind_PxBroadPhaseRegion_set_mUserData_1 = Module['_emscripten_bind_PxBroadPhaseRegion_set_mUserData_1'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegion_set_mUserData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegion___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegion___destroy___0');
  _emscripten_bind_PxBroadPhaseRegion___destroy___0 = Module['_emscripten_bind_PxBroadPhaseRegion___destroy___0'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegion___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegionInfo_PxBroadPhaseRegionInfo_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegionInfo_PxBroadPhaseRegionInfo_0');
  _emscripten_bind_PxBroadPhaseRegionInfo_PxBroadPhaseRegionInfo_0 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_PxBroadPhaseRegionInfo_0'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegionInfo_PxBroadPhaseRegionInfo_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegionInfo_get_mRegion_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegionInfo_get_mRegion_0');
  _emscripten_bind_PxBroadPhaseRegionInfo_get_mRegion_0 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_get_mRegion_0'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegionInfo_get_mRegion_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegionInfo_set_mRegion_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegionInfo_set_mRegion_1');
  _emscripten_bind_PxBroadPhaseRegionInfo_set_mRegion_1 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_set_mRegion_1'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegionInfo_set_mRegion_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegionInfo_get_mNbStaticObjects_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegionInfo_get_mNbStaticObjects_0');
  _emscripten_bind_PxBroadPhaseRegionInfo_get_mNbStaticObjects_0 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_get_mNbStaticObjects_0'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegionInfo_get_mNbStaticObjects_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegionInfo_set_mNbStaticObjects_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegionInfo_set_mNbStaticObjects_1');
  _emscripten_bind_PxBroadPhaseRegionInfo_set_mNbStaticObjects_1 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_set_mNbStaticObjects_1'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegionInfo_set_mNbStaticObjects_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegionInfo_get_mNbDynamicObjects_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegionInfo_get_mNbDynamicObjects_0');
  _emscripten_bind_PxBroadPhaseRegionInfo_get_mNbDynamicObjects_0 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_get_mNbDynamicObjects_0'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegionInfo_get_mNbDynamicObjects_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegionInfo_set_mNbDynamicObjects_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegionInfo_set_mNbDynamicObjects_1');
  _emscripten_bind_PxBroadPhaseRegionInfo_set_mNbDynamicObjects_1 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_set_mNbDynamicObjects_1'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegionInfo_set_mNbDynamicObjects_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegionInfo_get_mActive_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegionInfo_get_mActive_0');
  _emscripten_bind_PxBroadPhaseRegionInfo_get_mActive_0 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_get_mActive_0'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegionInfo_get_mActive_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegionInfo_set_mActive_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegionInfo_set_mActive_1');
  _emscripten_bind_PxBroadPhaseRegionInfo_set_mActive_1 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_set_mActive_1'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegionInfo_set_mActive_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegionInfo_get_mOverlap_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegionInfo_get_mOverlap_0');
  _emscripten_bind_PxBroadPhaseRegionInfo_get_mOverlap_0 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_get_mOverlap_0'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegionInfo_get_mOverlap_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegionInfo_set_mOverlap_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegionInfo_set_mOverlap_1');
  _emscripten_bind_PxBroadPhaseRegionInfo_set_mOverlap_1 = Module['_emscripten_bind_PxBroadPhaseRegionInfo_set_mOverlap_1'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegionInfo_set_mOverlap_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxBroadPhaseRegionInfo___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxBroadPhaseRegionInfo___destroy___0');
  _emscripten_bind_PxBroadPhaseRegionInfo___destroy___0 = Module['_emscripten_bind_PxBroadPhaseRegionInfo___destroy___0'] = createExportWrapper('emscripten_bind_PxBroadPhaseRegionInfo___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getRadius_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getRadius_0');
  _emscripten_bind_PxCapsuleController_getRadius_0 = Module['_emscripten_bind_PxCapsuleController_getRadius_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_getRadius_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_setRadius_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_setRadius_1');
  _emscripten_bind_PxCapsuleController_setRadius_1 = Module['_emscripten_bind_PxCapsuleController_setRadius_1'] = createExportWrapper('emscripten_bind_PxCapsuleController_setRadius_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getHeight_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getHeight_0');
  _emscripten_bind_PxCapsuleController_getHeight_0 = Module['_emscripten_bind_PxCapsuleController_getHeight_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_getHeight_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_setHeight_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_setHeight_1');
  _emscripten_bind_PxCapsuleController_setHeight_1 = Module['_emscripten_bind_PxCapsuleController_setHeight_1'] = createExportWrapper('emscripten_bind_PxCapsuleController_setHeight_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getClimbingMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getClimbingMode_0');
  _emscripten_bind_PxCapsuleController_getClimbingMode_0 = Module['_emscripten_bind_PxCapsuleController_getClimbingMode_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_getClimbingMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_setClimbingMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_setClimbingMode_1');
  _emscripten_bind_PxCapsuleController_setClimbingMode_1 = Module['_emscripten_bind_PxCapsuleController_setClimbingMode_1'] = createExportWrapper('emscripten_bind_PxCapsuleController_setClimbingMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getType_0');
  _emscripten_bind_PxCapsuleController_getType_0 = Module['_emscripten_bind_PxCapsuleController_getType_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_release_0');
  _emscripten_bind_PxCapsuleController_release_0 = Module['_emscripten_bind_PxCapsuleController_release_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_move_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_move_4');
  _emscripten_bind_PxCapsuleController_move_4 = Module['_emscripten_bind_PxCapsuleController_move_4'] = createExportWrapper('emscripten_bind_PxCapsuleController_move_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_move_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_move_5');
  _emscripten_bind_PxCapsuleController_move_5 = Module['_emscripten_bind_PxCapsuleController_move_5'] = createExportWrapper('emscripten_bind_PxCapsuleController_move_5', 6);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_setPosition_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_setPosition_1');
  _emscripten_bind_PxCapsuleController_setPosition_1 = Module['_emscripten_bind_PxCapsuleController_setPosition_1'] = createExportWrapper('emscripten_bind_PxCapsuleController_setPosition_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getPosition_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getPosition_0');
  _emscripten_bind_PxCapsuleController_getPosition_0 = Module['_emscripten_bind_PxCapsuleController_getPosition_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_getPosition_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_setFootPosition_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_setFootPosition_1');
  _emscripten_bind_PxCapsuleController_setFootPosition_1 = Module['_emscripten_bind_PxCapsuleController_setFootPosition_1'] = createExportWrapper('emscripten_bind_PxCapsuleController_setFootPosition_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getFootPosition_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getFootPosition_0');
  _emscripten_bind_PxCapsuleController_getFootPosition_0 = Module['_emscripten_bind_PxCapsuleController_getFootPosition_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_getFootPosition_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getActor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getActor_0');
  _emscripten_bind_PxCapsuleController_getActor_0 = Module['_emscripten_bind_PxCapsuleController_getActor_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_getActor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_setStepOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_setStepOffset_1');
  _emscripten_bind_PxCapsuleController_setStepOffset_1 = Module['_emscripten_bind_PxCapsuleController_setStepOffset_1'] = createExportWrapper('emscripten_bind_PxCapsuleController_setStepOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getStepOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getStepOffset_0');
  _emscripten_bind_PxCapsuleController_getStepOffset_0 = Module['_emscripten_bind_PxCapsuleController_getStepOffset_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_getStepOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_setNonWalkableMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_setNonWalkableMode_1');
  _emscripten_bind_PxCapsuleController_setNonWalkableMode_1 = Module['_emscripten_bind_PxCapsuleController_setNonWalkableMode_1'] = createExportWrapper('emscripten_bind_PxCapsuleController_setNonWalkableMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getNonWalkableMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getNonWalkableMode_0');
  _emscripten_bind_PxCapsuleController_getNonWalkableMode_0 = Module['_emscripten_bind_PxCapsuleController_getNonWalkableMode_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_getNonWalkableMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getContactOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getContactOffset_0');
  _emscripten_bind_PxCapsuleController_getContactOffset_0 = Module['_emscripten_bind_PxCapsuleController_getContactOffset_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_getContactOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_setContactOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_setContactOffset_1');
  _emscripten_bind_PxCapsuleController_setContactOffset_1 = Module['_emscripten_bind_PxCapsuleController_setContactOffset_1'] = createExportWrapper('emscripten_bind_PxCapsuleController_setContactOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getUpDirection_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getUpDirection_0');
  _emscripten_bind_PxCapsuleController_getUpDirection_0 = Module['_emscripten_bind_PxCapsuleController_getUpDirection_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_getUpDirection_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_setUpDirection_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_setUpDirection_1');
  _emscripten_bind_PxCapsuleController_setUpDirection_1 = Module['_emscripten_bind_PxCapsuleController_setUpDirection_1'] = createExportWrapper('emscripten_bind_PxCapsuleController_setUpDirection_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getSlopeLimit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getSlopeLimit_0');
  _emscripten_bind_PxCapsuleController_getSlopeLimit_0 = Module['_emscripten_bind_PxCapsuleController_getSlopeLimit_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_getSlopeLimit_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_setSlopeLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_setSlopeLimit_1');
  _emscripten_bind_PxCapsuleController_setSlopeLimit_1 = Module['_emscripten_bind_PxCapsuleController_setSlopeLimit_1'] = createExportWrapper('emscripten_bind_PxCapsuleController_setSlopeLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_invalidateCache_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_invalidateCache_0');
  _emscripten_bind_PxCapsuleController_invalidateCache_0 = Module['_emscripten_bind_PxCapsuleController_invalidateCache_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_invalidateCache_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getScene_0');
  _emscripten_bind_PxCapsuleController_getScene_0 = Module['_emscripten_bind_PxCapsuleController_getScene_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getUserData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getUserData_0');
  _emscripten_bind_PxCapsuleController_getUserData_0 = Module['_emscripten_bind_PxCapsuleController_getUserData_0'] = createExportWrapper('emscripten_bind_PxCapsuleController_getUserData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_setUserData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_setUserData_1');
  _emscripten_bind_PxCapsuleController_setUserData_1 = Module['_emscripten_bind_PxCapsuleController_setUserData_1'] = createExportWrapper('emscripten_bind_PxCapsuleController_setUserData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getState_1');
  _emscripten_bind_PxCapsuleController_getState_1 = Module['_emscripten_bind_PxCapsuleController_getState_1'] = createExportWrapper('emscripten_bind_PxCapsuleController_getState_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_getStats_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_getStats_1');
  _emscripten_bind_PxCapsuleController_getStats_1 = Module['_emscripten_bind_PxCapsuleController_getStats_1'] = createExportWrapper('emscripten_bind_PxCapsuleController_getStats_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleController_resize_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleController_resize_1');
  _emscripten_bind_PxCapsuleController_resize_1 = Module['_emscripten_bind_PxCapsuleController_resize_1'] = createExportWrapper('emscripten_bind_PxCapsuleController_resize_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_PxCapsuleControllerDesc_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_PxCapsuleControllerDesc_0');
  _emscripten_bind_PxCapsuleControllerDesc_PxCapsuleControllerDesc_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_PxCapsuleControllerDesc_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_PxCapsuleControllerDesc_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_setToDefault_0');
  _emscripten_bind_PxCapsuleControllerDesc_setToDefault_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_setToDefault_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_isValid_0');
  _emscripten_bind_PxCapsuleControllerDesc_isValid_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_isValid_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_getType_0');
  _emscripten_bind_PxCapsuleControllerDesc_getType_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_getType_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_radius_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_radius_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_radius_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_radius_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_radius_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_radius_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_radius_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_radius_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_radius_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_radius_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_height_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_height_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_height_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_height_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_height_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_height_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_height_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_height_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_height_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_height_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_climbingMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_climbingMode_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_climbingMode_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_climbingMode_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_climbingMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_climbingMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_climbingMode_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_climbingMode_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_climbingMode_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_climbingMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_position_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_position_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_position_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_position_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_position_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_position_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_position_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_position_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_position_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_position_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_upDirection_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_upDirection_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_upDirection_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_upDirection_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_upDirection_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_upDirection_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_upDirection_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_upDirection_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_upDirection_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_upDirection_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_slopeLimit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_slopeLimit_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_slopeLimit_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_slopeLimit_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_slopeLimit_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_slopeLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_slopeLimit_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_slopeLimit_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_slopeLimit_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_slopeLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_invisibleWallHeight_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_invisibleWallHeight_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_invisibleWallHeight_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_invisibleWallHeight_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_invisibleWallHeight_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_invisibleWallHeight_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_invisibleWallHeight_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_invisibleWallHeight_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_invisibleWallHeight_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_invisibleWallHeight_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_maxJumpHeight_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_maxJumpHeight_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_maxJumpHeight_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_maxJumpHeight_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_maxJumpHeight_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_maxJumpHeight_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_maxJumpHeight_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_maxJumpHeight_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_maxJumpHeight_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_maxJumpHeight_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_contactOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_contactOffset_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_contactOffset_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_contactOffset_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_contactOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_contactOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_contactOffset_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_contactOffset_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_contactOffset_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_contactOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_stepOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_stepOffset_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_stepOffset_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_stepOffset_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_stepOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_stepOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_stepOffset_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_stepOffset_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_stepOffset_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_stepOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_density_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_density_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_density_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_density_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_density_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_density_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_density_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_density_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_density_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_density_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_scaleCoeff_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_scaleCoeff_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_scaleCoeff_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_scaleCoeff_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_scaleCoeff_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_scaleCoeff_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_scaleCoeff_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_scaleCoeff_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_scaleCoeff_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_scaleCoeff_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_volumeGrowth_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_volumeGrowth_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_volumeGrowth_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_volumeGrowth_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_volumeGrowth_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_volumeGrowth_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_volumeGrowth_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_volumeGrowth_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_volumeGrowth_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_volumeGrowth_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_reportCallback_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_reportCallback_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_reportCallback_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_reportCallback_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_reportCallback_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_reportCallback_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_reportCallback_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_reportCallback_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_reportCallback_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_reportCallback_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_behaviorCallback_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_behaviorCallback_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_behaviorCallback_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_behaviorCallback_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_behaviorCallback_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_behaviorCallback_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_behaviorCallback_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_behaviorCallback_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_behaviorCallback_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_behaviorCallback_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_nonWalkableMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_nonWalkableMode_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_nonWalkableMode_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_nonWalkableMode_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_nonWalkableMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_nonWalkableMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_nonWalkableMode_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_nonWalkableMode_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_nonWalkableMode_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_nonWalkableMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_material_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_material_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_material_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_material_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_material_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_material_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_material_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_material_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_material_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_material_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_registerDeletionListener_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_registerDeletionListener_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_registerDeletionListener_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_registerDeletionListener_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_registerDeletionListener_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_registerDeletionListener_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_registerDeletionListener_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_registerDeletionListener_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_registerDeletionListener_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_registerDeletionListener_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_get_userData_0');
  _emscripten_bind_PxCapsuleControllerDesc_get_userData_0 = Module['_emscripten_bind_PxCapsuleControllerDesc_get_userData_0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc_set_userData_1');
  _emscripten_bind_PxCapsuleControllerDesc_set_userData_1 = Module['_emscripten_bind_PxCapsuleControllerDesc_set_userData_1'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleControllerDesc___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleControllerDesc___destroy___0');
  _emscripten_bind_PxCapsuleControllerDesc___destroy___0 = Module['_emscripten_bind_PxCapsuleControllerDesc___destroy___0'] = createExportWrapper('emscripten_bind_PxCapsuleControllerDesc___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleGeometry_PxCapsuleGeometry_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleGeometry_PxCapsuleGeometry_2');
  _emscripten_bind_PxCapsuleGeometry_PxCapsuleGeometry_2 = Module['_emscripten_bind_PxCapsuleGeometry_PxCapsuleGeometry_2'] = createExportWrapper('emscripten_bind_PxCapsuleGeometry_PxCapsuleGeometry_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleGeometry_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleGeometry_getType_0');
  _emscripten_bind_PxCapsuleGeometry_getType_0 = Module['_emscripten_bind_PxCapsuleGeometry_getType_0'] = createExportWrapper('emscripten_bind_PxCapsuleGeometry_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleGeometry_get_radius_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleGeometry_get_radius_0');
  _emscripten_bind_PxCapsuleGeometry_get_radius_0 = Module['_emscripten_bind_PxCapsuleGeometry_get_radius_0'] = createExportWrapper('emscripten_bind_PxCapsuleGeometry_get_radius_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleGeometry_set_radius_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleGeometry_set_radius_1');
  _emscripten_bind_PxCapsuleGeometry_set_radius_1 = Module['_emscripten_bind_PxCapsuleGeometry_set_radius_1'] = createExportWrapper('emscripten_bind_PxCapsuleGeometry_set_radius_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleGeometry_get_halfHeight_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleGeometry_get_halfHeight_0');
  _emscripten_bind_PxCapsuleGeometry_get_halfHeight_0 = Module['_emscripten_bind_PxCapsuleGeometry_get_halfHeight_0'] = createExportWrapper('emscripten_bind_PxCapsuleGeometry_get_halfHeight_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleGeometry_set_halfHeight_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleGeometry_set_halfHeight_1');
  _emscripten_bind_PxCapsuleGeometry_set_halfHeight_1 = Module['_emscripten_bind_PxCapsuleGeometry_set_halfHeight_1'] = createExportWrapper('emscripten_bind_PxCapsuleGeometry_set_halfHeight_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleGeometry___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleGeometry___destroy___0');
  _emscripten_bind_PxCapsuleGeometry___destroy___0 = Module['_emscripten_bind_PxCapsuleGeometry___destroy___0'] = createExportWrapper('emscripten_bind_PxCapsuleGeometry___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleObstacle_PxCapsuleObstacle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleObstacle_PxCapsuleObstacle_0');
  _emscripten_bind_PxCapsuleObstacle_PxCapsuleObstacle_0 = Module['_emscripten_bind_PxCapsuleObstacle_PxCapsuleObstacle_0'] = createExportWrapper('emscripten_bind_PxCapsuleObstacle_PxCapsuleObstacle_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleObstacle_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleObstacle_getType_0');
  _emscripten_bind_PxCapsuleObstacle_getType_0 = Module['_emscripten_bind_PxCapsuleObstacle_getType_0'] = createExportWrapper('emscripten_bind_PxCapsuleObstacle_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleObstacle_get_mHalfHeight_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleObstacle_get_mHalfHeight_0');
  _emscripten_bind_PxCapsuleObstacle_get_mHalfHeight_0 = Module['_emscripten_bind_PxCapsuleObstacle_get_mHalfHeight_0'] = createExportWrapper('emscripten_bind_PxCapsuleObstacle_get_mHalfHeight_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleObstacle_set_mHalfHeight_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleObstacle_set_mHalfHeight_1');
  _emscripten_bind_PxCapsuleObstacle_set_mHalfHeight_1 = Module['_emscripten_bind_PxCapsuleObstacle_set_mHalfHeight_1'] = createExportWrapper('emscripten_bind_PxCapsuleObstacle_set_mHalfHeight_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleObstacle_get_mRadius_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleObstacle_get_mRadius_0');
  _emscripten_bind_PxCapsuleObstacle_get_mRadius_0 = Module['_emscripten_bind_PxCapsuleObstacle_get_mRadius_0'] = createExportWrapper('emscripten_bind_PxCapsuleObstacle_get_mRadius_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleObstacle_set_mRadius_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleObstacle_set_mRadius_1');
  _emscripten_bind_PxCapsuleObstacle_set_mRadius_1 = Module['_emscripten_bind_PxCapsuleObstacle_set_mRadius_1'] = createExportWrapper('emscripten_bind_PxCapsuleObstacle_set_mRadius_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleObstacle_get_mUserData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleObstacle_get_mUserData_0');
  _emscripten_bind_PxCapsuleObstacle_get_mUserData_0 = Module['_emscripten_bind_PxCapsuleObstacle_get_mUserData_0'] = createExportWrapper('emscripten_bind_PxCapsuleObstacle_get_mUserData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleObstacle_set_mUserData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleObstacle_set_mUserData_1');
  _emscripten_bind_PxCapsuleObstacle_set_mUserData_1 = Module['_emscripten_bind_PxCapsuleObstacle_set_mUserData_1'] = createExportWrapper('emscripten_bind_PxCapsuleObstacle_set_mUserData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleObstacle_get_mPos_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleObstacle_get_mPos_0');
  _emscripten_bind_PxCapsuleObstacle_get_mPos_0 = Module['_emscripten_bind_PxCapsuleObstacle_get_mPos_0'] = createExportWrapper('emscripten_bind_PxCapsuleObstacle_get_mPos_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleObstacle_set_mPos_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleObstacle_set_mPos_1');
  _emscripten_bind_PxCapsuleObstacle_set_mPos_1 = Module['_emscripten_bind_PxCapsuleObstacle_set_mPos_1'] = createExportWrapper('emscripten_bind_PxCapsuleObstacle_set_mPos_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleObstacle_get_mRot_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleObstacle_get_mRot_0');
  _emscripten_bind_PxCapsuleObstacle_get_mRot_0 = Module['_emscripten_bind_PxCapsuleObstacle_get_mRot_0'] = createExportWrapper('emscripten_bind_PxCapsuleObstacle_get_mRot_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleObstacle_set_mRot_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleObstacle_set_mRot_1');
  _emscripten_bind_PxCapsuleObstacle_set_mRot_1 = Module['_emscripten_bind_PxCapsuleObstacle_set_mRot_1'] = createExportWrapper('emscripten_bind_PxCapsuleObstacle_set_mRot_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCapsuleObstacle___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCapsuleObstacle___destroy___0');
  _emscripten_bind_PxCapsuleObstacle___destroy___0 = Module['_emscripten_bind_PxCapsuleObstacle___destroy___0'] = createExportWrapper('emscripten_bind_PxCapsuleObstacle___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCollection_add_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollection_add_1');
  _emscripten_bind_PxCollection_add_1 = Module['_emscripten_bind_PxCollection_add_1'] = createExportWrapper('emscripten_bind_PxCollection_add_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCollection_add_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollection_add_2');
  _emscripten_bind_PxCollection_add_2 = Module['_emscripten_bind_PxCollection_add_2'] = createExportWrapper('emscripten_bind_PxCollection_add_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxCollection_remove_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollection_remove_1');
  _emscripten_bind_PxCollection_remove_1 = Module['_emscripten_bind_PxCollection_remove_1'] = createExportWrapper('emscripten_bind_PxCollection_remove_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCollection_contains_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollection_contains_1');
  _emscripten_bind_PxCollection_contains_1 = Module['_emscripten_bind_PxCollection_contains_1'] = createExportWrapper('emscripten_bind_PxCollection_contains_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCollection_addId_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollection_addId_2');
  _emscripten_bind_PxCollection_addId_2 = Module['_emscripten_bind_PxCollection_addId_2'] = createExportWrapper('emscripten_bind_PxCollection_addId_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxCollection_removeId_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollection_removeId_1');
  _emscripten_bind_PxCollection_removeId_1 = Module['_emscripten_bind_PxCollection_removeId_1'] = createExportWrapper('emscripten_bind_PxCollection_removeId_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCollection_getNbObjects_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollection_getNbObjects_0');
  _emscripten_bind_PxCollection_getNbObjects_0 = Module['_emscripten_bind_PxCollection_getNbObjects_0'] = createExportWrapper('emscripten_bind_PxCollection_getNbObjects_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCollection_getObject_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollection_getObject_1');
  _emscripten_bind_PxCollection_getObject_1 = Module['_emscripten_bind_PxCollection_getObject_1'] = createExportWrapper('emscripten_bind_PxCollection_getObject_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCollection_find_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollection_find_1');
  _emscripten_bind_PxCollection_find_1 = Module['_emscripten_bind_PxCollection_find_1'] = createExportWrapper('emscripten_bind_PxCollection_find_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCollection_getNbIds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollection_getNbIds_0');
  _emscripten_bind_PxCollection_getNbIds_0 = Module['_emscripten_bind_PxCollection_getNbIds_0'] = createExportWrapper('emscripten_bind_PxCollection_getNbIds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCollection_getId_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollection_getId_1');
  _emscripten_bind_PxCollection_getId_1 = Module['_emscripten_bind_PxCollection_getId_1'] = createExportWrapper('emscripten_bind_PxCollection_getId_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCollection_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollection_release_0');
  _emscripten_bind_PxCollection_release_0 = Module['_emscripten_bind_PxCollection_release_0'] = createExportWrapper('emscripten_bind_PxCollection_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCollectionExt_releaseObjects_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollectionExt_releaseObjects_1');
  _emscripten_bind_PxCollectionExt_releaseObjects_1 = Module['_emscripten_bind_PxCollectionExt_releaseObjects_1'] = createExportWrapper('emscripten_bind_PxCollectionExt_releaseObjects_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxCollectionExt_releaseObjects_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollectionExt_releaseObjects_2');
  _emscripten_bind_PxCollectionExt_releaseObjects_2 = Module['_emscripten_bind_PxCollectionExt_releaseObjects_2'] = createExportWrapper('emscripten_bind_PxCollectionExt_releaseObjects_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxCollectionExt_remove_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollectionExt_remove_2');
  _emscripten_bind_PxCollectionExt_remove_2 = Module['_emscripten_bind_PxCollectionExt_remove_2'] = createExportWrapper('emscripten_bind_PxCollectionExt_remove_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxCollectionExt_remove_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollectionExt_remove_3');
  _emscripten_bind_PxCollectionExt_remove_3 = Module['_emscripten_bind_PxCollectionExt_remove_3'] = createExportWrapper('emscripten_bind_PxCollectionExt_remove_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxCollectionExt_createCollection_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollectionExt_createCollection_1');
  _emscripten_bind_PxCollectionExt_createCollection_1 = Module['_emscripten_bind_PxCollectionExt_createCollection_1'] = createExportWrapper('emscripten_bind_PxCollectionExt_createCollection_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxCollectionExt___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCollectionExt___destroy___0');
  _emscripten_bind_PxCollectionExt___destroy___0 = Module['_emscripten_bind_PxCollectionExt___destroy___0'] = createExportWrapper('emscripten_bind_PxCollectionExt___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_getScene_0');
  _emscripten_bind_PxConstraint_getScene_0 = Module['_emscripten_bind_PxConstraint_getScene_0'] = createExportWrapper('emscripten_bind_PxConstraint_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_setActors_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_setActors_2');
  _emscripten_bind_PxConstraint_setActors_2 = Module['_emscripten_bind_PxConstraint_setActors_2'] = createExportWrapper('emscripten_bind_PxConstraint_setActors_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_markDirty_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_markDirty_0');
  _emscripten_bind_PxConstraint_markDirty_0 = Module['_emscripten_bind_PxConstraint_markDirty_0'] = createExportWrapper('emscripten_bind_PxConstraint_markDirty_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_setFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_setFlags_1');
  _emscripten_bind_PxConstraint_setFlags_1 = Module['_emscripten_bind_PxConstraint_setFlags_1'] = createExportWrapper('emscripten_bind_PxConstraint_setFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_getFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_getFlags_0');
  _emscripten_bind_PxConstraint_getFlags_0 = Module['_emscripten_bind_PxConstraint_getFlags_0'] = createExportWrapper('emscripten_bind_PxConstraint_getFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_setFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_setFlag_2');
  _emscripten_bind_PxConstraint_setFlag_2 = Module['_emscripten_bind_PxConstraint_setFlag_2'] = createExportWrapper('emscripten_bind_PxConstraint_setFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_getForce_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_getForce_2');
  _emscripten_bind_PxConstraint_getForce_2 = Module['_emscripten_bind_PxConstraint_getForce_2'] = createExportWrapper('emscripten_bind_PxConstraint_getForce_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_isValid_0');
  _emscripten_bind_PxConstraint_isValid_0 = Module['_emscripten_bind_PxConstraint_isValid_0'] = createExportWrapper('emscripten_bind_PxConstraint_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_setBreakForce_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_setBreakForce_2');
  _emscripten_bind_PxConstraint_setBreakForce_2 = Module['_emscripten_bind_PxConstraint_setBreakForce_2'] = createExportWrapper('emscripten_bind_PxConstraint_setBreakForce_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_setMinResponseThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_setMinResponseThreshold_1');
  _emscripten_bind_PxConstraint_setMinResponseThreshold_1 = Module['_emscripten_bind_PxConstraint_setMinResponseThreshold_1'] = createExportWrapper('emscripten_bind_PxConstraint_setMinResponseThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_getMinResponseThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_getMinResponseThreshold_0');
  _emscripten_bind_PxConstraint_getMinResponseThreshold_0 = Module['_emscripten_bind_PxConstraint_getMinResponseThreshold_0'] = createExportWrapper('emscripten_bind_PxConstraint_getMinResponseThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_release_0');
  _emscripten_bind_PxConstraint_release_0 = Module['_emscripten_bind_PxConstraint_release_0'] = createExportWrapper('emscripten_bind_PxConstraint_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_getConcreteTypeName_0');
  _emscripten_bind_PxConstraint_getConcreteTypeName_0 = Module['_emscripten_bind_PxConstraint_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxConstraint_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_getConcreteType_0');
  _emscripten_bind_PxConstraint_getConcreteType_0 = Module['_emscripten_bind_PxConstraint_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxConstraint_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_setBaseFlag_2');
  _emscripten_bind_PxConstraint_setBaseFlag_2 = Module['_emscripten_bind_PxConstraint_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxConstraint_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_setBaseFlags_1');
  _emscripten_bind_PxConstraint_setBaseFlags_1 = Module['_emscripten_bind_PxConstraint_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxConstraint_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_getBaseFlags_0');
  _emscripten_bind_PxConstraint_getBaseFlags_0 = Module['_emscripten_bind_PxConstraint_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxConstraint_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraint_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraint_isReleasable_0');
  _emscripten_bind_PxConstraint_isReleasable_0 = Module['_emscripten_bind_PxConstraint_isReleasable_0'] = createExportWrapper('emscripten_bind_PxConstraint_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraintFlags_PxConstraintFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintFlags_PxConstraintFlags_1');
  _emscripten_bind_PxConstraintFlags_PxConstraintFlags_1 = Module['_emscripten_bind_PxConstraintFlags_PxConstraintFlags_1'] = createExportWrapper('emscripten_bind_PxConstraintFlags_PxConstraintFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraintFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintFlags_isSet_1');
  _emscripten_bind_PxConstraintFlags_isSet_1 = Module['_emscripten_bind_PxConstraintFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxConstraintFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConstraintFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintFlags_raise_1');
  _emscripten_bind_PxConstraintFlags_raise_1 = Module['_emscripten_bind_PxConstraintFlags_raise_1'] = createExportWrapper('emscripten_bind_PxConstraintFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConstraintFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintFlags_clear_1');
  _emscripten_bind_PxConstraintFlags_clear_1 = Module['_emscripten_bind_PxConstraintFlags_clear_1'] = createExportWrapper('emscripten_bind_PxConstraintFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConstraintFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintFlags___destroy___0');
  _emscripten_bind_PxConstraintFlags___destroy___0 = Module['_emscripten_bind_PxConstraintFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxConstraintFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraintInfo_get_constraint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintInfo_get_constraint_0');
  _emscripten_bind_PxConstraintInfo_get_constraint_0 = Module['_emscripten_bind_PxConstraintInfo_get_constraint_0'] = createExportWrapper('emscripten_bind_PxConstraintInfo_get_constraint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraintInfo_set_constraint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintInfo_set_constraint_1');
  _emscripten_bind_PxConstraintInfo_set_constraint_1 = Module['_emscripten_bind_PxConstraintInfo_set_constraint_1'] = createExportWrapper('emscripten_bind_PxConstraintInfo_set_constraint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConstraintInfo_get_externalReference_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintInfo_get_externalReference_0');
  _emscripten_bind_PxConstraintInfo_get_externalReference_0 = Module['_emscripten_bind_PxConstraintInfo_get_externalReference_0'] = createExportWrapper('emscripten_bind_PxConstraintInfo_get_externalReference_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraintInfo_set_externalReference_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintInfo_set_externalReference_1');
  _emscripten_bind_PxConstraintInfo_set_externalReference_1 = Module['_emscripten_bind_PxConstraintInfo_set_externalReference_1'] = createExportWrapper('emscripten_bind_PxConstraintInfo_set_externalReference_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConstraintInfo_get_type_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintInfo_get_type_0');
  _emscripten_bind_PxConstraintInfo_get_type_0 = Module['_emscripten_bind_PxConstraintInfo_get_type_0'] = createExportWrapper('emscripten_bind_PxConstraintInfo_get_type_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraintInfo_set_type_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintInfo_set_type_1');
  _emscripten_bind_PxConstraintInfo_set_type_1 = Module['_emscripten_bind_PxConstraintInfo_set_type_1'] = createExportWrapper('emscripten_bind_PxConstraintInfo_set_type_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConstraintInfo___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintInfo___destroy___0');
  _emscripten_bind_PxConstraintInfo___destroy___0 = Module['_emscripten_bind_PxConstraintInfo___destroy___0'] = createExportWrapper('emscripten_bind_PxConstraintInfo___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConstraintSolverPrep___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConstraintSolverPrep___destroy___0');
  _emscripten_bind_PxConstraintSolverPrep___destroy___0 = Module['_emscripten_bind_PxConstraintSolverPrep___destroy___0'] = createExportWrapper('emscripten_bind_PxConstraintSolverPrep___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactBuffer_reset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactBuffer_reset_0');
  _emscripten_bind_PxContactBuffer_reset_0 = Module['_emscripten_bind_PxContactBuffer_reset_0'] = createExportWrapper('emscripten_bind_PxContactBuffer_reset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactBuffer_contact_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactBuffer_contact_1');
  _emscripten_bind_PxContactBuffer_contact_1 = Module['_emscripten_bind_PxContactBuffer_contact_1'] = createExportWrapper('emscripten_bind_PxContactBuffer_contact_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactBuffer_contact_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactBuffer_contact_3');
  _emscripten_bind_PxContactBuffer_contact_3 = Module['_emscripten_bind_PxContactBuffer_contact_3'] = createExportWrapper('emscripten_bind_PxContactBuffer_contact_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxContactBuffer_contact_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactBuffer_contact_4');
  _emscripten_bind_PxContactBuffer_contact_4 = Module['_emscripten_bind_PxContactBuffer_contact_4'] = createExportWrapper('emscripten_bind_PxContactBuffer_contact_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxContactBuffer_get_contacts_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactBuffer_get_contacts_1');
  _emscripten_bind_PxContactBuffer_get_contacts_1 = Module['_emscripten_bind_PxContactBuffer_get_contacts_1'] = createExportWrapper('emscripten_bind_PxContactBuffer_get_contacts_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactBuffer_set_contacts_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactBuffer_set_contacts_2');
  _emscripten_bind_PxContactBuffer_set_contacts_2 = Module['_emscripten_bind_PxContactBuffer_set_contacts_2'] = createExportWrapper('emscripten_bind_PxContactBuffer_set_contacts_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxContactBuffer_get_count_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactBuffer_get_count_0');
  _emscripten_bind_PxContactBuffer_get_count_0 = Module['_emscripten_bind_PxContactBuffer_get_count_0'] = createExportWrapper('emscripten_bind_PxContactBuffer_get_count_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactBuffer_set_count_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactBuffer_set_count_1');
  _emscripten_bind_PxContactBuffer_set_count_1 = Module['_emscripten_bind_PxContactBuffer_set_count_1'] = createExportWrapper('emscripten_bind_PxContactBuffer_set_count_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactBuffer_get_pad_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactBuffer_get_pad_0');
  _emscripten_bind_PxContactBuffer_get_pad_0 = Module['_emscripten_bind_PxContactBuffer_get_pad_0'] = createExportWrapper('emscripten_bind_PxContactBuffer_get_pad_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactBuffer_set_pad_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactBuffer_set_pad_1');
  _emscripten_bind_PxContactBuffer_set_pad_1 = Module['_emscripten_bind_PxContactBuffer_set_pad_1'] = createExportWrapper('emscripten_bind_PxContactBuffer_set_pad_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactBuffer_get_MAX_CONTACTS_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactBuffer_get_MAX_CONTACTS_0');
  _emscripten_bind_PxContactBuffer_get_MAX_CONTACTS_0 = Module['_emscripten_bind_PxContactBuffer_get_MAX_CONTACTS_0'] = createExportWrapper('emscripten_bind_PxContactBuffer_get_MAX_CONTACTS_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactBuffer___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactBuffer___destroy___0');
  _emscripten_bind_PxContactBuffer___destroy___0 = Module['_emscripten_bind_PxContactBuffer___destroy___0'] = createExportWrapper('emscripten_bind_PxContactBuffer___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPair_extractContacts_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPair_extractContacts_2');
  _emscripten_bind_PxContactPair_extractContacts_2 = Module['_emscripten_bind_PxContactPair_extractContacts_2'] = createExportWrapper('emscripten_bind_PxContactPair_extractContacts_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxContactPair_get_shapes_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPair_get_shapes_1');
  _emscripten_bind_PxContactPair_get_shapes_1 = Module['_emscripten_bind_PxContactPair_get_shapes_1'] = createExportWrapper('emscripten_bind_PxContactPair_get_shapes_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPair_set_shapes_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPair_set_shapes_2');
  _emscripten_bind_PxContactPair_set_shapes_2 = Module['_emscripten_bind_PxContactPair_set_shapes_2'] = createExportWrapper('emscripten_bind_PxContactPair_set_shapes_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxContactPair_get_contactCount_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPair_get_contactCount_0');
  _emscripten_bind_PxContactPair_get_contactCount_0 = Module['_emscripten_bind_PxContactPair_get_contactCount_0'] = createExportWrapper('emscripten_bind_PxContactPair_get_contactCount_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPair_set_contactCount_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPair_set_contactCount_1');
  _emscripten_bind_PxContactPair_set_contactCount_1 = Module['_emscripten_bind_PxContactPair_set_contactCount_1'] = createExportWrapper('emscripten_bind_PxContactPair_set_contactCount_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPair_get_patchCount_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPair_get_patchCount_0');
  _emscripten_bind_PxContactPair_get_patchCount_0 = Module['_emscripten_bind_PxContactPair_get_patchCount_0'] = createExportWrapper('emscripten_bind_PxContactPair_get_patchCount_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPair_set_patchCount_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPair_set_patchCount_1');
  _emscripten_bind_PxContactPair_set_patchCount_1 = Module['_emscripten_bind_PxContactPair_set_patchCount_1'] = createExportWrapper('emscripten_bind_PxContactPair_set_patchCount_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPair_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPair_get_flags_0');
  _emscripten_bind_PxContactPair_get_flags_0 = Module['_emscripten_bind_PxContactPair_get_flags_0'] = createExportWrapper('emscripten_bind_PxContactPair_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPair_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPair_set_flags_1');
  _emscripten_bind_PxContactPair_set_flags_1 = Module['_emscripten_bind_PxContactPair_set_flags_1'] = createExportWrapper('emscripten_bind_PxContactPair_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPair_get_events_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPair_get_events_0');
  _emscripten_bind_PxContactPair_get_events_0 = Module['_emscripten_bind_PxContactPair_get_events_0'] = createExportWrapper('emscripten_bind_PxContactPair_get_events_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPair_set_events_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPair_set_events_1');
  _emscripten_bind_PxContactPair_set_events_1 = Module['_emscripten_bind_PxContactPair_set_events_1'] = createExportWrapper('emscripten_bind_PxContactPair_set_events_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPair___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPair___destroy___0');
  _emscripten_bind_PxContactPair___destroy___0 = Module['_emscripten_bind_PxContactPair___destroy___0'] = createExportWrapper('emscripten_bind_PxContactPair___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairFlags_PxContactPairFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairFlags_PxContactPairFlags_1');
  _emscripten_bind_PxContactPairFlags_PxContactPairFlags_1 = Module['_emscripten_bind_PxContactPairFlags_PxContactPairFlags_1'] = createExportWrapper('emscripten_bind_PxContactPairFlags_PxContactPairFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairFlags_isSet_1');
  _emscripten_bind_PxContactPairFlags_isSet_1 = Module['_emscripten_bind_PxContactPairFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxContactPairFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairFlags_raise_1');
  _emscripten_bind_PxContactPairFlags_raise_1 = Module['_emscripten_bind_PxContactPairFlags_raise_1'] = createExportWrapper('emscripten_bind_PxContactPairFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairFlags_clear_1');
  _emscripten_bind_PxContactPairFlags_clear_1 = Module['_emscripten_bind_PxContactPairFlags_clear_1'] = createExportWrapper('emscripten_bind_PxContactPairFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairFlags___destroy___0');
  _emscripten_bind_PxContactPairFlags___destroy___0 = Module['_emscripten_bind_PxContactPairFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxContactPairFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairHeader_get_actors_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairHeader_get_actors_1');
  _emscripten_bind_PxContactPairHeader_get_actors_1 = Module['_emscripten_bind_PxContactPairHeader_get_actors_1'] = createExportWrapper('emscripten_bind_PxContactPairHeader_get_actors_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairHeader_set_actors_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairHeader_set_actors_2');
  _emscripten_bind_PxContactPairHeader_set_actors_2 = Module['_emscripten_bind_PxContactPairHeader_set_actors_2'] = createExportWrapper('emscripten_bind_PxContactPairHeader_set_actors_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxContactPairHeader_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairHeader_get_flags_0');
  _emscripten_bind_PxContactPairHeader_get_flags_0 = Module['_emscripten_bind_PxContactPairHeader_get_flags_0'] = createExportWrapper('emscripten_bind_PxContactPairHeader_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairHeader_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairHeader_set_flags_1');
  _emscripten_bind_PxContactPairHeader_set_flags_1 = Module['_emscripten_bind_PxContactPairHeader_set_flags_1'] = createExportWrapper('emscripten_bind_PxContactPairHeader_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairHeader_get_pairs_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairHeader_get_pairs_0');
  _emscripten_bind_PxContactPairHeader_get_pairs_0 = Module['_emscripten_bind_PxContactPairHeader_get_pairs_0'] = createExportWrapper('emscripten_bind_PxContactPairHeader_get_pairs_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairHeader_set_pairs_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairHeader_set_pairs_1');
  _emscripten_bind_PxContactPairHeader_set_pairs_1 = Module['_emscripten_bind_PxContactPairHeader_set_pairs_1'] = createExportWrapper('emscripten_bind_PxContactPairHeader_set_pairs_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairHeader_get_nbPairs_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairHeader_get_nbPairs_0');
  _emscripten_bind_PxContactPairHeader_get_nbPairs_0 = Module['_emscripten_bind_PxContactPairHeader_get_nbPairs_0'] = createExportWrapper('emscripten_bind_PxContactPairHeader_get_nbPairs_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairHeader_set_nbPairs_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairHeader_set_nbPairs_1');
  _emscripten_bind_PxContactPairHeader_set_nbPairs_1 = Module['_emscripten_bind_PxContactPairHeader_set_nbPairs_1'] = createExportWrapper('emscripten_bind_PxContactPairHeader_set_nbPairs_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairHeader___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairHeader___destroy___0');
  _emscripten_bind_PxContactPairHeader___destroy___0 = Module['_emscripten_bind_PxContactPairHeader___destroy___0'] = createExportWrapper('emscripten_bind_PxContactPairHeader___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairHeaderFlags_PxContactPairHeaderFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairHeaderFlags_PxContactPairHeaderFlags_1');
  _emscripten_bind_PxContactPairHeaderFlags_PxContactPairHeaderFlags_1 = Module['_emscripten_bind_PxContactPairHeaderFlags_PxContactPairHeaderFlags_1'] = createExportWrapper('emscripten_bind_PxContactPairHeaderFlags_PxContactPairHeaderFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairHeaderFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairHeaderFlags_isSet_1');
  _emscripten_bind_PxContactPairHeaderFlags_isSet_1 = Module['_emscripten_bind_PxContactPairHeaderFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxContactPairHeaderFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairHeaderFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairHeaderFlags_raise_1');
  _emscripten_bind_PxContactPairHeaderFlags_raise_1 = Module['_emscripten_bind_PxContactPairHeaderFlags_raise_1'] = createExportWrapper('emscripten_bind_PxContactPairHeaderFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairHeaderFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairHeaderFlags_clear_1');
  _emscripten_bind_PxContactPairHeaderFlags_clear_1 = Module['_emscripten_bind_PxContactPairHeaderFlags_clear_1'] = createExportWrapper('emscripten_bind_PxContactPairHeaderFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairHeaderFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairHeaderFlags___destroy___0');
  _emscripten_bind_PxContactPairHeaderFlags___destroy___0 = Module['_emscripten_bind_PxContactPairHeaderFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxContactPairHeaderFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairPoint_get_position_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairPoint_get_position_0');
  _emscripten_bind_PxContactPairPoint_get_position_0 = Module['_emscripten_bind_PxContactPairPoint_get_position_0'] = createExportWrapper('emscripten_bind_PxContactPairPoint_get_position_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairPoint_set_position_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairPoint_set_position_1');
  _emscripten_bind_PxContactPairPoint_set_position_1 = Module['_emscripten_bind_PxContactPairPoint_set_position_1'] = createExportWrapper('emscripten_bind_PxContactPairPoint_set_position_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairPoint_get_separation_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairPoint_get_separation_0');
  _emscripten_bind_PxContactPairPoint_get_separation_0 = Module['_emscripten_bind_PxContactPairPoint_get_separation_0'] = createExportWrapper('emscripten_bind_PxContactPairPoint_get_separation_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairPoint_set_separation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairPoint_set_separation_1');
  _emscripten_bind_PxContactPairPoint_set_separation_1 = Module['_emscripten_bind_PxContactPairPoint_set_separation_1'] = createExportWrapper('emscripten_bind_PxContactPairPoint_set_separation_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairPoint_get_normal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairPoint_get_normal_0');
  _emscripten_bind_PxContactPairPoint_get_normal_0 = Module['_emscripten_bind_PxContactPairPoint_get_normal_0'] = createExportWrapper('emscripten_bind_PxContactPairPoint_get_normal_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairPoint_set_normal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairPoint_set_normal_1');
  _emscripten_bind_PxContactPairPoint_set_normal_1 = Module['_emscripten_bind_PxContactPairPoint_set_normal_1'] = createExportWrapper('emscripten_bind_PxContactPairPoint_set_normal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairPoint_get_internalFaceIndex0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairPoint_get_internalFaceIndex0_0');
  _emscripten_bind_PxContactPairPoint_get_internalFaceIndex0_0 = Module['_emscripten_bind_PxContactPairPoint_get_internalFaceIndex0_0'] = createExportWrapper('emscripten_bind_PxContactPairPoint_get_internalFaceIndex0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairPoint_set_internalFaceIndex0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairPoint_set_internalFaceIndex0_1');
  _emscripten_bind_PxContactPairPoint_set_internalFaceIndex0_1 = Module['_emscripten_bind_PxContactPairPoint_set_internalFaceIndex0_1'] = createExportWrapper('emscripten_bind_PxContactPairPoint_set_internalFaceIndex0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairPoint_get_impulse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairPoint_get_impulse_0');
  _emscripten_bind_PxContactPairPoint_get_impulse_0 = Module['_emscripten_bind_PxContactPairPoint_get_impulse_0'] = createExportWrapper('emscripten_bind_PxContactPairPoint_get_impulse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairPoint_set_impulse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairPoint_set_impulse_1');
  _emscripten_bind_PxContactPairPoint_set_impulse_1 = Module['_emscripten_bind_PxContactPairPoint_set_impulse_1'] = createExportWrapper('emscripten_bind_PxContactPairPoint_set_impulse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairPoint_get_internalFaceIndex1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairPoint_get_internalFaceIndex1_0');
  _emscripten_bind_PxContactPairPoint_get_internalFaceIndex1_0 = Module['_emscripten_bind_PxContactPairPoint_get_internalFaceIndex1_0'] = createExportWrapper('emscripten_bind_PxContactPairPoint_get_internalFaceIndex1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPairPoint_set_internalFaceIndex1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairPoint_set_internalFaceIndex1_1');
  _emscripten_bind_PxContactPairPoint_set_internalFaceIndex1_1 = Module['_emscripten_bind_PxContactPairPoint_set_internalFaceIndex1_1'] = createExportWrapper('emscripten_bind_PxContactPairPoint_set_internalFaceIndex1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPairPoint___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPairPoint___destroy___0');
  _emscripten_bind_PxContactPairPoint___destroy___0 = Module['_emscripten_bind_PxContactPairPoint___destroy___0'] = createExportWrapper('emscripten_bind_PxContactPairPoint___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_PxContactPoint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_PxContactPoint_0');
  _emscripten_bind_PxContactPoint_PxContactPoint_0 = Module['_emscripten_bind_PxContactPoint_PxContactPoint_0'] = createExportWrapper('emscripten_bind_PxContactPoint_PxContactPoint_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_get_normal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_get_normal_0');
  _emscripten_bind_PxContactPoint_get_normal_0 = Module['_emscripten_bind_PxContactPoint_get_normal_0'] = createExportWrapper('emscripten_bind_PxContactPoint_get_normal_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_set_normal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_set_normal_1');
  _emscripten_bind_PxContactPoint_set_normal_1 = Module['_emscripten_bind_PxContactPoint_set_normal_1'] = createExportWrapper('emscripten_bind_PxContactPoint_set_normal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_get_point_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_get_point_0');
  _emscripten_bind_PxContactPoint_get_point_0 = Module['_emscripten_bind_PxContactPoint_get_point_0'] = createExportWrapper('emscripten_bind_PxContactPoint_get_point_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_set_point_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_set_point_1');
  _emscripten_bind_PxContactPoint_set_point_1 = Module['_emscripten_bind_PxContactPoint_set_point_1'] = createExportWrapper('emscripten_bind_PxContactPoint_set_point_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_get_targetVel_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_get_targetVel_0');
  _emscripten_bind_PxContactPoint_get_targetVel_0 = Module['_emscripten_bind_PxContactPoint_get_targetVel_0'] = createExportWrapper('emscripten_bind_PxContactPoint_get_targetVel_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_set_targetVel_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_set_targetVel_1');
  _emscripten_bind_PxContactPoint_set_targetVel_1 = Module['_emscripten_bind_PxContactPoint_set_targetVel_1'] = createExportWrapper('emscripten_bind_PxContactPoint_set_targetVel_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_get_separation_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_get_separation_0');
  _emscripten_bind_PxContactPoint_get_separation_0 = Module['_emscripten_bind_PxContactPoint_get_separation_0'] = createExportWrapper('emscripten_bind_PxContactPoint_get_separation_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_set_separation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_set_separation_1');
  _emscripten_bind_PxContactPoint_set_separation_1 = Module['_emscripten_bind_PxContactPoint_set_separation_1'] = createExportWrapper('emscripten_bind_PxContactPoint_set_separation_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_get_maxImpulse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_get_maxImpulse_0');
  _emscripten_bind_PxContactPoint_get_maxImpulse_0 = Module['_emscripten_bind_PxContactPoint_get_maxImpulse_0'] = createExportWrapper('emscripten_bind_PxContactPoint_get_maxImpulse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_set_maxImpulse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_set_maxImpulse_1');
  _emscripten_bind_PxContactPoint_set_maxImpulse_1 = Module['_emscripten_bind_PxContactPoint_set_maxImpulse_1'] = createExportWrapper('emscripten_bind_PxContactPoint_set_maxImpulse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_get_staticFriction_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_get_staticFriction_0');
  _emscripten_bind_PxContactPoint_get_staticFriction_0 = Module['_emscripten_bind_PxContactPoint_get_staticFriction_0'] = createExportWrapper('emscripten_bind_PxContactPoint_get_staticFriction_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_set_staticFriction_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_set_staticFriction_1');
  _emscripten_bind_PxContactPoint_set_staticFriction_1 = Module['_emscripten_bind_PxContactPoint_set_staticFriction_1'] = createExportWrapper('emscripten_bind_PxContactPoint_set_staticFriction_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_get_materialFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_get_materialFlags_0');
  _emscripten_bind_PxContactPoint_get_materialFlags_0 = Module['_emscripten_bind_PxContactPoint_get_materialFlags_0'] = createExportWrapper('emscripten_bind_PxContactPoint_get_materialFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_set_materialFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_set_materialFlags_1');
  _emscripten_bind_PxContactPoint_set_materialFlags_1 = Module['_emscripten_bind_PxContactPoint_set_materialFlags_1'] = createExportWrapper('emscripten_bind_PxContactPoint_set_materialFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_get_internalFaceIndex1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_get_internalFaceIndex1_0');
  _emscripten_bind_PxContactPoint_get_internalFaceIndex1_0 = Module['_emscripten_bind_PxContactPoint_get_internalFaceIndex1_0'] = createExportWrapper('emscripten_bind_PxContactPoint_get_internalFaceIndex1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_set_internalFaceIndex1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_set_internalFaceIndex1_1');
  _emscripten_bind_PxContactPoint_set_internalFaceIndex1_1 = Module['_emscripten_bind_PxContactPoint_set_internalFaceIndex1_1'] = createExportWrapper('emscripten_bind_PxContactPoint_set_internalFaceIndex1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_get_dynamicFriction_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_get_dynamicFriction_0');
  _emscripten_bind_PxContactPoint_get_dynamicFriction_0 = Module['_emscripten_bind_PxContactPoint_get_dynamicFriction_0'] = createExportWrapper('emscripten_bind_PxContactPoint_get_dynamicFriction_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_set_dynamicFriction_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_set_dynamicFriction_1');
  _emscripten_bind_PxContactPoint_set_dynamicFriction_1 = Module['_emscripten_bind_PxContactPoint_set_dynamicFriction_1'] = createExportWrapper('emscripten_bind_PxContactPoint_set_dynamicFriction_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_get_restitution_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_get_restitution_0');
  _emscripten_bind_PxContactPoint_get_restitution_0 = Module['_emscripten_bind_PxContactPoint_get_restitution_0'] = createExportWrapper('emscripten_bind_PxContactPoint_get_restitution_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_set_restitution_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_set_restitution_1');
  _emscripten_bind_PxContactPoint_set_restitution_1 = Module['_emscripten_bind_PxContactPoint_set_restitution_1'] = createExportWrapper('emscripten_bind_PxContactPoint_set_restitution_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_get_damping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_get_damping_0');
  _emscripten_bind_PxContactPoint_get_damping_0 = Module['_emscripten_bind_PxContactPoint_get_damping_0'] = createExportWrapper('emscripten_bind_PxContactPoint_get_damping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint_set_damping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint_set_damping_1');
  _emscripten_bind_PxContactPoint_set_damping_1 = Module['_emscripten_bind_PxContactPoint_set_damping_1'] = createExportWrapper('emscripten_bind_PxContactPoint_set_damping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxContactPoint___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxContactPoint___destroy___0');
  _emscripten_bind_PxContactPoint___destroy___0 = Module['_emscripten_bind_PxContactPoint___destroy___0'] = createExportWrapper('emscripten_bind_PxContactPoint___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerBehaviorCallbackImpl_PxControllerBehaviorCallbackImpl_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerBehaviorCallbackImpl_PxControllerBehaviorCallbackImpl_0');
  _emscripten_bind_PxControllerBehaviorCallbackImpl_PxControllerBehaviorCallbackImpl_0 = Module['_emscripten_bind_PxControllerBehaviorCallbackImpl_PxControllerBehaviorCallbackImpl_0'] = createExportWrapper('emscripten_bind_PxControllerBehaviorCallbackImpl_PxControllerBehaviorCallbackImpl_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxControllerBehaviorCallbackImpl_getShapeBehaviorFlags_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerBehaviorCallbackImpl_getShapeBehaviorFlags_2');
  _emscripten_bind_PxControllerBehaviorCallbackImpl_getShapeBehaviorFlags_2 = Module['_emscripten_bind_PxControllerBehaviorCallbackImpl_getShapeBehaviorFlags_2'] = createExportWrapper('emscripten_bind_PxControllerBehaviorCallbackImpl_getShapeBehaviorFlags_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxControllerBehaviorCallbackImpl_getControllerBehaviorFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerBehaviorCallbackImpl_getControllerBehaviorFlags_1');
  _emscripten_bind_PxControllerBehaviorCallbackImpl_getControllerBehaviorFlags_1 = Module['_emscripten_bind_PxControllerBehaviorCallbackImpl_getControllerBehaviorFlags_1'] = createExportWrapper('emscripten_bind_PxControllerBehaviorCallbackImpl_getControllerBehaviorFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerBehaviorCallbackImpl_getObstacleBehaviorFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerBehaviorCallbackImpl_getObstacleBehaviorFlags_1');
  _emscripten_bind_PxControllerBehaviorCallbackImpl_getObstacleBehaviorFlags_1 = Module['_emscripten_bind_PxControllerBehaviorCallbackImpl_getObstacleBehaviorFlags_1'] = createExportWrapper('emscripten_bind_PxControllerBehaviorCallbackImpl_getObstacleBehaviorFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerBehaviorCallbackImpl___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerBehaviorCallbackImpl___destroy___0');
  _emscripten_bind_PxControllerBehaviorCallbackImpl___destroy___0 = Module['_emscripten_bind_PxControllerBehaviorCallbackImpl___destroy___0'] = createExportWrapper('emscripten_bind_PxControllerBehaviorCallbackImpl___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerBehaviorFlags_PxControllerBehaviorFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerBehaviorFlags_PxControllerBehaviorFlags_1');
  _emscripten_bind_PxControllerBehaviorFlags_PxControllerBehaviorFlags_1 = Module['_emscripten_bind_PxControllerBehaviorFlags_PxControllerBehaviorFlags_1'] = createExportWrapper('emscripten_bind_PxControllerBehaviorFlags_PxControllerBehaviorFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerBehaviorFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerBehaviorFlags_isSet_1');
  _emscripten_bind_PxControllerBehaviorFlags_isSet_1 = Module['_emscripten_bind_PxControllerBehaviorFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxControllerBehaviorFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerBehaviorFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerBehaviorFlags_raise_1');
  _emscripten_bind_PxControllerBehaviorFlags_raise_1 = Module['_emscripten_bind_PxControllerBehaviorFlags_raise_1'] = createExportWrapper('emscripten_bind_PxControllerBehaviorFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerBehaviorFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerBehaviorFlags_clear_1');
  _emscripten_bind_PxControllerBehaviorFlags_clear_1 = Module['_emscripten_bind_PxControllerBehaviorFlags_clear_1'] = createExportWrapper('emscripten_bind_PxControllerBehaviorFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerBehaviorFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerBehaviorFlags___destroy___0');
  _emscripten_bind_PxControllerBehaviorFlags___destroy___0 = Module['_emscripten_bind_PxControllerBehaviorFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxControllerBehaviorFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerCollisionFlags_PxControllerCollisionFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerCollisionFlags_PxControllerCollisionFlags_1');
  _emscripten_bind_PxControllerCollisionFlags_PxControllerCollisionFlags_1 = Module['_emscripten_bind_PxControllerCollisionFlags_PxControllerCollisionFlags_1'] = createExportWrapper('emscripten_bind_PxControllerCollisionFlags_PxControllerCollisionFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerCollisionFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerCollisionFlags_isSet_1');
  _emscripten_bind_PxControllerCollisionFlags_isSet_1 = Module['_emscripten_bind_PxControllerCollisionFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxControllerCollisionFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerCollisionFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerCollisionFlags_raise_1');
  _emscripten_bind_PxControllerCollisionFlags_raise_1 = Module['_emscripten_bind_PxControllerCollisionFlags_raise_1'] = createExportWrapper('emscripten_bind_PxControllerCollisionFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerCollisionFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerCollisionFlags_clear_1');
  _emscripten_bind_PxControllerCollisionFlags_clear_1 = Module['_emscripten_bind_PxControllerCollisionFlags_clear_1'] = createExportWrapper('emscripten_bind_PxControllerCollisionFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerCollisionFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerCollisionFlags___destroy___0');
  _emscripten_bind_PxControllerCollisionFlags___destroy___0 = Module['_emscripten_bind_PxControllerCollisionFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxControllerCollisionFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilterCallbackImpl_PxControllerFilterCallbackImpl_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilterCallbackImpl_PxControllerFilterCallbackImpl_0');
  _emscripten_bind_PxControllerFilterCallbackImpl_PxControllerFilterCallbackImpl_0 = Module['_emscripten_bind_PxControllerFilterCallbackImpl_PxControllerFilterCallbackImpl_0'] = createExportWrapper('emscripten_bind_PxControllerFilterCallbackImpl_PxControllerFilterCallbackImpl_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilterCallbackImpl_filter_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilterCallbackImpl_filter_2');
  _emscripten_bind_PxControllerFilterCallbackImpl_filter_2 = Module['_emscripten_bind_PxControllerFilterCallbackImpl_filter_2'] = createExportWrapper('emscripten_bind_PxControllerFilterCallbackImpl_filter_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilterCallbackImpl___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilterCallbackImpl___destroy___0');
  _emscripten_bind_PxControllerFilterCallbackImpl___destroy___0 = Module['_emscripten_bind_PxControllerFilterCallbackImpl___destroy___0'] = createExportWrapper('emscripten_bind_PxControllerFilterCallbackImpl___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilters_PxControllerFilters_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilters_PxControllerFilters_0');
  _emscripten_bind_PxControllerFilters_PxControllerFilters_0 = Module['_emscripten_bind_PxControllerFilters_PxControllerFilters_0'] = createExportWrapper('emscripten_bind_PxControllerFilters_PxControllerFilters_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilters_PxControllerFilters_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilters_PxControllerFilters_1');
  _emscripten_bind_PxControllerFilters_PxControllerFilters_1 = Module['_emscripten_bind_PxControllerFilters_PxControllerFilters_1'] = createExportWrapper('emscripten_bind_PxControllerFilters_PxControllerFilters_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilters_get_mFilterData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilters_get_mFilterData_0');
  _emscripten_bind_PxControllerFilters_get_mFilterData_0 = Module['_emscripten_bind_PxControllerFilters_get_mFilterData_0'] = createExportWrapper('emscripten_bind_PxControllerFilters_get_mFilterData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilters_set_mFilterData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilters_set_mFilterData_1');
  _emscripten_bind_PxControllerFilters_set_mFilterData_1 = Module['_emscripten_bind_PxControllerFilters_set_mFilterData_1'] = createExportWrapper('emscripten_bind_PxControllerFilters_set_mFilterData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilters_get_mFilterCallback_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilters_get_mFilterCallback_0');
  _emscripten_bind_PxControllerFilters_get_mFilterCallback_0 = Module['_emscripten_bind_PxControllerFilters_get_mFilterCallback_0'] = createExportWrapper('emscripten_bind_PxControllerFilters_get_mFilterCallback_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilters_set_mFilterCallback_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilters_set_mFilterCallback_1');
  _emscripten_bind_PxControllerFilters_set_mFilterCallback_1 = Module['_emscripten_bind_PxControllerFilters_set_mFilterCallback_1'] = createExportWrapper('emscripten_bind_PxControllerFilters_set_mFilterCallback_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilters_get_mFilterFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilters_get_mFilterFlags_0');
  _emscripten_bind_PxControllerFilters_get_mFilterFlags_0 = Module['_emscripten_bind_PxControllerFilters_get_mFilterFlags_0'] = createExportWrapper('emscripten_bind_PxControllerFilters_get_mFilterFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilters_set_mFilterFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilters_set_mFilterFlags_1');
  _emscripten_bind_PxControllerFilters_set_mFilterFlags_1 = Module['_emscripten_bind_PxControllerFilters_set_mFilterFlags_1'] = createExportWrapper('emscripten_bind_PxControllerFilters_set_mFilterFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilters_get_mCCTFilterCallback_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilters_get_mCCTFilterCallback_0');
  _emscripten_bind_PxControllerFilters_get_mCCTFilterCallback_0 = Module['_emscripten_bind_PxControllerFilters_get_mCCTFilterCallback_0'] = createExportWrapper('emscripten_bind_PxControllerFilters_get_mCCTFilterCallback_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilters_set_mCCTFilterCallback_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilters_set_mCCTFilterCallback_1');
  _emscripten_bind_PxControllerFilters_set_mCCTFilterCallback_1 = Module['_emscripten_bind_PxControllerFilters_set_mCCTFilterCallback_1'] = createExportWrapper('emscripten_bind_PxControllerFilters_set_mCCTFilterCallback_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerFilters___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerFilters___destroy___0');
  _emscripten_bind_PxControllerFilters___destroy___0 = Module['_emscripten_bind_PxControllerFilters___destroy___0'] = createExportWrapper('emscripten_bind_PxControllerFilters___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_release_0');
  _emscripten_bind_PxControllerManager_release_0 = Module['_emscripten_bind_PxControllerManager_release_0'] = createExportWrapper('emscripten_bind_PxControllerManager_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_getScene_0');
  _emscripten_bind_PxControllerManager_getScene_0 = Module['_emscripten_bind_PxControllerManager_getScene_0'] = createExportWrapper('emscripten_bind_PxControllerManager_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_getNbControllers_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_getNbControllers_0');
  _emscripten_bind_PxControllerManager_getNbControllers_0 = Module['_emscripten_bind_PxControllerManager_getNbControllers_0'] = createExportWrapper('emscripten_bind_PxControllerManager_getNbControllers_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_getController_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_getController_1');
  _emscripten_bind_PxControllerManager_getController_1 = Module['_emscripten_bind_PxControllerManager_getController_1'] = createExportWrapper('emscripten_bind_PxControllerManager_getController_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_createController_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_createController_1');
  _emscripten_bind_PxControllerManager_createController_1 = Module['_emscripten_bind_PxControllerManager_createController_1'] = createExportWrapper('emscripten_bind_PxControllerManager_createController_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_purgeControllers_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_purgeControllers_0');
  _emscripten_bind_PxControllerManager_purgeControllers_0 = Module['_emscripten_bind_PxControllerManager_purgeControllers_0'] = createExportWrapper('emscripten_bind_PxControllerManager_purgeControllers_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_getNbObstacleContexts_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_getNbObstacleContexts_0');
  _emscripten_bind_PxControllerManager_getNbObstacleContexts_0 = Module['_emscripten_bind_PxControllerManager_getNbObstacleContexts_0'] = createExportWrapper('emscripten_bind_PxControllerManager_getNbObstacleContexts_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_getObstacleContext_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_getObstacleContext_1');
  _emscripten_bind_PxControllerManager_getObstacleContext_1 = Module['_emscripten_bind_PxControllerManager_getObstacleContext_1'] = createExportWrapper('emscripten_bind_PxControllerManager_getObstacleContext_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_createObstacleContext_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_createObstacleContext_0');
  _emscripten_bind_PxControllerManager_createObstacleContext_0 = Module['_emscripten_bind_PxControllerManager_createObstacleContext_0'] = createExportWrapper('emscripten_bind_PxControllerManager_createObstacleContext_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_computeInteractions_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_computeInteractions_1');
  _emscripten_bind_PxControllerManager_computeInteractions_1 = Module['_emscripten_bind_PxControllerManager_computeInteractions_1'] = createExportWrapper('emscripten_bind_PxControllerManager_computeInteractions_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_setTessellation_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_setTessellation_2');
  _emscripten_bind_PxControllerManager_setTessellation_2 = Module['_emscripten_bind_PxControllerManager_setTessellation_2'] = createExportWrapper('emscripten_bind_PxControllerManager_setTessellation_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_setOverlapRecoveryModule_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_setOverlapRecoveryModule_1');
  _emscripten_bind_PxControllerManager_setOverlapRecoveryModule_1 = Module['_emscripten_bind_PxControllerManager_setOverlapRecoveryModule_1'] = createExportWrapper('emscripten_bind_PxControllerManager_setOverlapRecoveryModule_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_setPreciseSweeps_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_setPreciseSweeps_1');
  _emscripten_bind_PxControllerManager_setPreciseSweeps_1 = Module['_emscripten_bind_PxControllerManager_setPreciseSweeps_1'] = createExportWrapper('emscripten_bind_PxControllerManager_setPreciseSweeps_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_setPreventVerticalSlidingAgainstCeiling_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_setPreventVerticalSlidingAgainstCeiling_1');
  _emscripten_bind_PxControllerManager_setPreventVerticalSlidingAgainstCeiling_1 = Module['_emscripten_bind_PxControllerManager_setPreventVerticalSlidingAgainstCeiling_1'] = createExportWrapper('emscripten_bind_PxControllerManager_setPreventVerticalSlidingAgainstCeiling_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerManager_shiftOrigin_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerManager_shiftOrigin_1');
  _emscripten_bind_PxControllerManager_shiftOrigin_1 = Module['_emscripten_bind_PxControllerManager_shiftOrigin_1'] = createExportWrapper('emscripten_bind_PxControllerManager_shiftOrigin_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerObstacleHit_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerObstacleHit_get_userData_0');
  _emscripten_bind_PxControllerObstacleHit_get_userData_0 = Module['_emscripten_bind_PxControllerObstacleHit_get_userData_0'] = createExportWrapper('emscripten_bind_PxControllerObstacleHit_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerObstacleHit_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerObstacleHit_set_userData_1');
  _emscripten_bind_PxControllerObstacleHit_set_userData_1 = Module['_emscripten_bind_PxControllerObstacleHit_set_userData_1'] = createExportWrapper('emscripten_bind_PxControllerObstacleHit_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerObstacleHit_get_controller_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerObstacleHit_get_controller_0');
  _emscripten_bind_PxControllerObstacleHit_get_controller_0 = Module['_emscripten_bind_PxControllerObstacleHit_get_controller_0'] = createExportWrapper('emscripten_bind_PxControllerObstacleHit_get_controller_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerObstacleHit_set_controller_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerObstacleHit_set_controller_1');
  _emscripten_bind_PxControllerObstacleHit_set_controller_1 = Module['_emscripten_bind_PxControllerObstacleHit_set_controller_1'] = createExportWrapper('emscripten_bind_PxControllerObstacleHit_set_controller_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerObstacleHit_get_worldPos_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerObstacleHit_get_worldPos_0');
  _emscripten_bind_PxControllerObstacleHit_get_worldPos_0 = Module['_emscripten_bind_PxControllerObstacleHit_get_worldPos_0'] = createExportWrapper('emscripten_bind_PxControllerObstacleHit_get_worldPos_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerObstacleHit_set_worldPos_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerObstacleHit_set_worldPos_1');
  _emscripten_bind_PxControllerObstacleHit_set_worldPos_1 = Module['_emscripten_bind_PxControllerObstacleHit_set_worldPos_1'] = createExportWrapper('emscripten_bind_PxControllerObstacleHit_set_worldPos_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerObstacleHit_get_worldNormal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerObstacleHit_get_worldNormal_0');
  _emscripten_bind_PxControllerObstacleHit_get_worldNormal_0 = Module['_emscripten_bind_PxControllerObstacleHit_get_worldNormal_0'] = createExportWrapper('emscripten_bind_PxControllerObstacleHit_get_worldNormal_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerObstacleHit_set_worldNormal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerObstacleHit_set_worldNormal_1');
  _emscripten_bind_PxControllerObstacleHit_set_worldNormal_1 = Module['_emscripten_bind_PxControllerObstacleHit_set_worldNormal_1'] = createExportWrapper('emscripten_bind_PxControllerObstacleHit_set_worldNormal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerObstacleHit_get_dir_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerObstacleHit_get_dir_0');
  _emscripten_bind_PxControllerObstacleHit_get_dir_0 = Module['_emscripten_bind_PxControllerObstacleHit_get_dir_0'] = createExportWrapper('emscripten_bind_PxControllerObstacleHit_get_dir_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerObstacleHit_set_dir_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerObstacleHit_set_dir_1');
  _emscripten_bind_PxControllerObstacleHit_set_dir_1 = Module['_emscripten_bind_PxControllerObstacleHit_set_dir_1'] = createExportWrapper('emscripten_bind_PxControllerObstacleHit_set_dir_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerObstacleHit_get_length_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerObstacleHit_get_length_0');
  _emscripten_bind_PxControllerObstacleHit_get_length_0 = Module['_emscripten_bind_PxControllerObstacleHit_get_length_0'] = createExportWrapper('emscripten_bind_PxControllerObstacleHit_get_length_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerObstacleHit_set_length_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerObstacleHit_set_length_1');
  _emscripten_bind_PxControllerObstacleHit_set_length_1 = Module['_emscripten_bind_PxControllerObstacleHit_set_length_1'] = createExportWrapper('emscripten_bind_PxControllerObstacleHit_set_length_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerObstacleHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerObstacleHit___destroy___0');
  _emscripten_bind_PxControllerObstacleHit___destroy___0 = Module['_emscripten_bind_PxControllerObstacleHit___destroy___0'] = createExportWrapper('emscripten_bind_PxControllerObstacleHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_get_shape_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_get_shape_0');
  _emscripten_bind_PxControllerShapeHit_get_shape_0 = Module['_emscripten_bind_PxControllerShapeHit_get_shape_0'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_get_shape_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_set_shape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_set_shape_1');
  _emscripten_bind_PxControllerShapeHit_set_shape_1 = Module['_emscripten_bind_PxControllerShapeHit_set_shape_1'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_set_shape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_get_actor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_get_actor_0');
  _emscripten_bind_PxControllerShapeHit_get_actor_0 = Module['_emscripten_bind_PxControllerShapeHit_get_actor_0'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_get_actor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_set_actor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_set_actor_1');
  _emscripten_bind_PxControllerShapeHit_set_actor_1 = Module['_emscripten_bind_PxControllerShapeHit_set_actor_1'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_set_actor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_get_triangleIndex_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_get_triangleIndex_0');
  _emscripten_bind_PxControllerShapeHit_get_triangleIndex_0 = Module['_emscripten_bind_PxControllerShapeHit_get_triangleIndex_0'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_get_triangleIndex_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_set_triangleIndex_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_set_triangleIndex_1');
  _emscripten_bind_PxControllerShapeHit_set_triangleIndex_1 = Module['_emscripten_bind_PxControllerShapeHit_set_triangleIndex_1'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_set_triangleIndex_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_get_controller_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_get_controller_0');
  _emscripten_bind_PxControllerShapeHit_get_controller_0 = Module['_emscripten_bind_PxControllerShapeHit_get_controller_0'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_get_controller_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_set_controller_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_set_controller_1');
  _emscripten_bind_PxControllerShapeHit_set_controller_1 = Module['_emscripten_bind_PxControllerShapeHit_set_controller_1'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_set_controller_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_get_worldPos_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_get_worldPos_0');
  _emscripten_bind_PxControllerShapeHit_get_worldPos_0 = Module['_emscripten_bind_PxControllerShapeHit_get_worldPos_0'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_get_worldPos_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_set_worldPos_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_set_worldPos_1');
  _emscripten_bind_PxControllerShapeHit_set_worldPos_1 = Module['_emscripten_bind_PxControllerShapeHit_set_worldPos_1'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_set_worldPos_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_get_worldNormal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_get_worldNormal_0');
  _emscripten_bind_PxControllerShapeHit_get_worldNormal_0 = Module['_emscripten_bind_PxControllerShapeHit_get_worldNormal_0'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_get_worldNormal_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_set_worldNormal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_set_worldNormal_1');
  _emscripten_bind_PxControllerShapeHit_set_worldNormal_1 = Module['_emscripten_bind_PxControllerShapeHit_set_worldNormal_1'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_set_worldNormal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_get_dir_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_get_dir_0');
  _emscripten_bind_PxControllerShapeHit_get_dir_0 = Module['_emscripten_bind_PxControllerShapeHit_get_dir_0'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_get_dir_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_set_dir_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_set_dir_1');
  _emscripten_bind_PxControllerShapeHit_set_dir_1 = Module['_emscripten_bind_PxControllerShapeHit_set_dir_1'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_set_dir_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_get_length_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_get_length_0');
  _emscripten_bind_PxControllerShapeHit_get_length_0 = Module['_emscripten_bind_PxControllerShapeHit_get_length_0'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_get_length_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit_set_length_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit_set_length_1');
  _emscripten_bind_PxControllerShapeHit_set_length_1 = Module['_emscripten_bind_PxControllerShapeHit_set_length_1'] = createExportWrapper('emscripten_bind_PxControllerShapeHit_set_length_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerShapeHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerShapeHit___destroy___0');
  _emscripten_bind_PxControllerShapeHit___destroy___0 = Module['_emscripten_bind_PxControllerShapeHit___destroy___0'] = createExportWrapper('emscripten_bind_PxControllerShapeHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_PxControllerState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_PxControllerState_0');
  _emscripten_bind_PxControllerState_PxControllerState_0 = Module['_emscripten_bind_PxControllerState_PxControllerState_0'] = createExportWrapper('emscripten_bind_PxControllerState_PxControllerState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_get_deltaXP_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_get_deltaXP_0');
  _emscripten_bind_PxControllerState_get_deltaXP_0 = Module['_emscripten_bind_PxControllerState_get_deltaXP_0'] = createExportWrapper('emscripten_bind_PxControllerState_get_deltaXP_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_set_deltaXP_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_set_deltaXP_1');
  _emscripten_bind_PxControllerState_set_deltaXP_1 = Module['_emscripten_bind_PxControllerState_set_deltaXP_1'] = createExportWrapper('emscripten_bind_PxControllerState_set_deltaXP_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_get_touchedShape_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_get_touchedShape_0');
  _emscripten_bind_PxControllerState_get_touchedShape_0 = Module['_emscripten_bind_PxControllerState_get_touchedShape_0'] = createExportWrapper('emscripten_bind_PxControllerState_get_touchedShape_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_set_touchedShape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_set_touchedShape_1');
  _emscripten_bind_PxControllerState_set_touchedShape_1 = Module['_emscripten_bind_PxControllerState_set_touchedShape_1'] = createExportWrapper('emscripten_bind_PxControllerState_set_touchedShape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_get_touchedActor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_get_touchedActor_0');
  _emscripten_bind_PxControllerState_get_touchedActor_0 = Module['_emscripten_bind_PxControllerState_get_touchedActor_0'] = createExportWrapper('emscripten_bind_PxControllerState_get_touchedActor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_set_touchedActor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_set_touchedActor_1');
  _emscripten_bind_PxControllerState_set_touchedActor_1 = Module['_emscripten_bind_PxControllerState_set_touchedActor_1'] = createExportWrapper('emscripten_bind_PxControllerState_set_touchedActor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_get_touchedObstacleHandle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_get_touchedObstacleHandle_0');
  _emscripten_bind_PxControllerState_get_touchedObstacleHandle_0 = Module['_emscripten_bind_PxControllerState_get_touchedObstacleHandle_0'] = createExportWrapper('emscripten_bind_PxControllerState_get_touchedObstacleHandle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_set_touchedObstacleHandle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_set_touchedObstacleHandle_1');
  _emscripten_bind_PxControllerState_set_touchedObstacleHandle_1 = Module['_emscripten_bind_PxControllerState_set_touchedObstacleHandle_1'] = createExportWrapper('emscripten_bind_PxControllerState_set_touchedObstacleHandle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_get_collisionFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_get_collisionFlags_0');
  _emscripten_bind_PxControllerState_get_collisionFlags_0 = Module['_emscripten_bind_PxControllerState_get_collisionFlags_0'] = createExportWrapper('emscripten_bind_PxControllerState_get_collisionFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_set_collisionFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_set_collisionFlags_1');
  _emscripten_bind_PxControllerState_set_collisionFlags_1 = Module['_emscripten_bind_PxControllerState_set_collisionFlags_1'] = createExportWrapper('emscripten_bind_PxControllerState_set_collisionFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_get_standOnAnotherCCT_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_get_standOnAnotherCCT_0');
  _emscripten_bind_PxControllerState_get_standOnAnotherCCT_0 = Module['_emscripten_bind_PxControllerState_get_standOnAnotherCCT_0'] = createExportWrapper('emscripten_bind_PxControllerState_get_standOnAnotherCCT_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_set_standOnAnotherCCT_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_set_standOnAnotherCCT_1');
  _emscripten_bind_PxControllerState_set_standOnAnotherCCT_1 = Module['_emscripten_bind_PxControllerState_set_standOnAnotherCCT_1'] = createExportWrapper('emscripten_bind_PxControllerState_set_standOnAnotherCCT_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_get_standOnObstacle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_get_standOnObstacle_0');
  _emscripten_bind_PxControllerState_get_standOnObstacle_0 = Module['_emscripten_bind_PxControllerState_get_standOnObstacle_0'] = createExportWrapper('emscripten_bind_PxControllerState_get_standOnObstacle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_set_standOnObstacle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_set_standOnObstacle_1');
  _emscripten_bind_PxControllerState_set_standOnObstacle_1 = Module['_emscripten_bind_PxControllerState_set_standOnObstacle_1'] = createExportWrapper('emscripten_bind_PxControllerState_set_standOnObstacle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_get_isMovingUp_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_get_isMovingUp_0');
  _emscripten_bind_PxControllerState_get_isMovingUp_0 = Module['_emscripten_bind_PxControllerState_get_isMovingUp_0'] = createExportWrapper('emscripten_bind_PxControllerState_get_isMovingUp_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerState_set_isMovingUp_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState_set_isMovingUp_1');
  _emscripten_bind_PxControllerState_set_isMovingUp_1 = Module['_emscripten_bind_PxControllerState_set_isMovingUp_1'] = createExportWrapper('emscripten_bind_PxControllerState_set_isMovingUp_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerState___destroy___0');
  _emscripten_bind_PxControllerState___destroy___0 = Module['_emscripten_bind_PxControllerState___destroy___0'] = createExportWrapper('emscripten_bind_PxControllerState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerStats_get_nbIterations_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerStats_get_nbIterations_0');
  _emscripten_bind_PxControllerStats_get_nbIterations_0 = Module['_emscripten_bind_PxControllerStats_get_nbIterations_0'] = createExportWrapper('emscripten_bind_PxControllerStats_get_nbIterations_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerStats_set_nbIterations_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerStats_set_nbIterations_1');
  _emscripten_bind_PxControllerStats_set_nbIterations_1 = Module['_emscripten_bind_PxControllerStats_set_nbIterations_1'] = createExportWrapper('emscripten_bind_PxControllerStats_set_nbIterations_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerStats_get_nbFullUpdates_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerStats_get_nbFullUpdates_0');
  _emscripten_bind_PxControllerStats_get_nbFullUpdates_0 = Module['_emscripten_bind_PxControllerStats_get_nbFullUpdates_0'] = createExportWrapper('emscripten_bind_PxControllerStats_get_nbFullUpdates_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerStats_set_nbFullUpdates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerStats_set_nbFullUpdates_1');
  _emscripten_bind_PxControllerStats_set_nbFullUpdates_1 = Module['_emscripten_bind_PxControllerStats_set_nbFullUpdates_1'] = createExportWrapper('emscripten_bind_PxControllerStats_set_nbFullUpdates_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerStats_get_nbPartialUpdates_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerStats_get_nbPartialUpdates_0');
  _emscripten_bind_PxControllerStats_get_nbPartialUpdates_0 = Module['_emscripten_bind_PxControllerStats_get_nbPartialUpdates_0'] = createExportWrapper('emscripten_bind_PxControllerStats_get_nbPartialUpdates_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerStats_set_nbPartialUpdates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerStats_set_nbPartialUpdates_1');
  _emscripten_bind_PxControllerStats_set_nbPartialUpdates_1 = Module['_emscripten_bind_PxControllerStats_set_nbPartialUpdates_1'] = createExportWrapper('emscripten_bind_PxControllerStats_set_nbPartialUpdates_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerStats_get_nbTessellation_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerStats_get_nbTessellation_0');
  _emscripten_bind_PxControllerStats_get_nbTessellation_0 = Module['_emscripten_bind_PxControllerStats_get_nbTessellation_0'] = createExportWrapper('emscripten_bind_PxControllerStats_get_nbTessellation_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllerStats_set_nbTessellation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerStats_set_nbTessellation_1');
  _emscripten_bind_PxControllerStats_set_nbTessellation_1 = Module['_emscripten_bind_PxControllerStats_set_nbTessellation_1'] = createExportWrapper('emscripten_bind_PxControllerStats_set_nbTessellation_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllerStats___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllerStats___destroy___0');
  _emscripten_bind_PxControllerStats___destroy___0 = Module['_emscripten_bind_PxControllerStats___destroy___0'] = createExportWrapper('emscripten_bind_PxControllerStats___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllersHit_get_other_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllersHit_get_other_0');
  _emscripten_bind_PxControllersHit_get_other_0 = Module['_emscripten_bind_PxControllersHit_get_other_0'] = createExportWrapper('emscripten_bind_PxControllersHit_get_other_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllersHit_set_other_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllersHit_set_other_1');
  _emscripten_bind_PxControllersHit_set_other_1 = Module['_emscripten_bind_PxControllersHit_set_other_1'] = createExportWrapper('emscripten_bind_PxControllersHit_set_other_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllersHit_get_controller_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllersHit_get_controller_0');
  _emscripten_bind_PxControllersHit_get_controller_0 = Module['_emscripten_bind_PxControllersHit_get_controller_0'] = createExportWrapper('emscripten_bind_PxControllersHit_get_controller_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllersHit_set_controller_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllersHit_set_controller_1');
  _emscripten_bind_PxControllersHit_set_controller_1 = Module['_emscripten_bind_PxControllersHit_set_controller_1'] = createExportWrapper('emscripten_bind_PxControllersHit_set_controller_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllersHit_get_worldPos_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllersHit_get_worldPos_0');
  _emscripten_bind_PxControllersHit_get_worldPos_0 = Module['_emscripten_bind_PxControllersHit_get_worldPos_0'] = createExportWrapper('emscripten_bind_PxControllersHit_get_worldPos_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllersHit_set_worldPos_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllersHit_set_worldPos_1');
  _emscripten_bind_PxControllersHit_set_worldPos_1 = Module['_emscripten_bind_PxControllersHit_set_worldPos_1'] = createExportWrapper('emscripten_bind_PxControllersHit_set_worldPos_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllersHit_get_worldNormal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllersHit_get_worldNormal_0');
  _emscripten_bind_PxControllersHit_get_worldNormal_0 = Module['_emscripten_bind_PxControllersHit_get_worldNormal_0'] = createExportWrapper('emscripten_bind_PxControllersHit_get_worldNormal_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllersHit_set_worldNormal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllersHit_set_worldNormal_1');
  _emscripten_bind_PxControllersHit_set_worldNormal_1 = Module['_emscripten_bind_PxControllersHit_set_worldNormal_1'] = createExportWrapper('emscripten_bind_PxControllersHit_set_worldNormal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllersHit_get_dir_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllersHit_get_dir_0');
  _emscripten_bind_PxControllersHit_get_dir_0 = Module['_emscripten_bind_PxControllersHit_get_dir_0'] = createExportWrapper('emscripten_bind_PxControllersHit_get_dir_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllersHit_set_dir_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllersHit_set_dir_1');
  _emscripten_bind_PxControllersHit_set_dir_1 = Module['_emscripten_bind_PxControllersHit_set_dir_1'] = createExportWrapper('emscripten_bind_PxControllersHit_set_dir_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllersHit_get_length_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllersHit_get_length_0');
  _emscripten_bind_PxControllersHit_get_length_0 = Module['_emscripten_bind_PxControllersHit_get_length_0'] = createExportWrapper('emscripten_bind_PxControllersHit_get_length_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxControllersHit_set_length_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllersHit_set_length_1');
  _emscripten_bind_PxControllersHit_set_length_1 = Module['_emscripten_bind_PxControllersHit_set_length_1'] = createExportWrapper('emscripten_bind_PxControllersHit_set_length_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxControllersHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxControllersHit___destroy___0');
  _emscripten_bind_PxControllersHit___destroy___0 = Module['_emscripten_bind_PxControllersHit___destroy___0'] = createExportWrapper('emscripten_bind_PxControllersHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreBox_PxConvexCoreBox_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreBox_PxConvexCoreBox_3');
  _emscripten_bind_PxConvexCoreBox_PxConvexCoreBox_3 = Module['_emscripten_bind_PxConvexCoreBox_PxConvexCoreBox_3'] = createExportWrapper('emscripten_bind_PxConvexCoreBox_PxConvexCoreBox_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreBox_get_extents_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreBox_get_extents_0');
  _emscripten_bind_PxConvexCoreBox_get_extents_0 = Module['_emscripten_bind_PxConvexCoreBox_get_extents_0'] = createExportWrapper('emscripten_bind_PxConvexCoreBox_get_extents_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreBox_set_extents_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreBox_set_extents_1');
  _emscripten_bind_PxConvexCoreBox_set_extents_1 = Module['_emscripten_bind_PxConvexCoreBox_set_extents_1'] = createExportWrapper('emscripten_bind_PxConvexCoreBox_set_extents_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreBox___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreBox___destroy___0');
  _emscripten_bind_PxConvexCoreBox___destroy___0 = Module['_emscripten_bind_PxConvexCoreBox___destroy___0'] = createExportWrapper('emscripten_bind_PxConvexCoreBox___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreCone_PxConvexCoreCone_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreCone_PxConvexCoreCone_2');
  _emscripten_bind_PxConvexCoreCone_PxConvexCoreCone_2 = Module['_emscripten_bind_PxConvexCoreCone_PxConvexCoreCone_2'] = createExportWrapper('emscripten_bind_PxConvexCoreCone_PxConvexCoreCone_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreCone_get_height_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreCone_get_height_0');
  _emscripten_bind_PxConvexCoreCone_get_height_0 = Module['_emscripten_bind_PxConvexCoreCone_get_height_0'] = createExportWrapper('emscripten_bind_PxConvexCoreCone_get_height_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreCone_set_height_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreCone_set_height_1');
  _emscripten_bind_PxConvexCoreCone_set_height_1 = Module['_emscripten_bind_PxConvexCoreCone_set_height_1'] = createExportWrapper('emscripten_bind_PxConvexCoreCone_set_height_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreCone_get_radius_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreCone_get_radius_0');
  _emscripten_bind_PxConvexCoreCone_get_radius_0 = Module['_emscripten_bind_PxConvexCoreCone_get_radius_0'] = createExportWrapper('emscripten_bind_PxConvexCoreCone_get_radius_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreCone_set_radius_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreCone_set_radius_1');
  _emscripten_bind_PxConvexCoreCone_set_radius_1 = Module['_emscripten_bind_PxConvexCoreCone_set_radius_1'] = createExportWrapper('emscripten_bind_PxConvexCoreCone_set_radius_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreCone___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreCone___destroy___0');
  _emscripten_bind_PxConvexCoreCone___destroy___0 = Module['_emscripten_bind_PxConvexCoreCone___destroy___0'] = createExportWrapper('emscripten_bind_PxConvexCoreCone___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreCylinder_PxConvexCoreCylinder_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreCylinder_PxConvexCoreCylinder_2');
  _emscripten_bind_PxConvexCoreCylinder_PxConvexCoreCylinder_2 = Module['_emscripten_bind_PxConvexCoreCylinder_PxConvexCoreCylinder_2'] = createExportWrapper('emscripten_bind_PxConvexCoreCylinder_PxConvexCoreCylinder_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreCylinder_get_height_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreCylinder_get_height_0');
  _emscripten_bind_PxConvexCoreCylinder_get_height_0 = Module['_emscripten_bind_PxConvexCoreCylinder_get_height_0'] = createExportWrapper('emscripten_bind_PxConvexCoreCylinder_get_height_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreCylinder_set_height_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreCylinder_set_height_1');
  _emscripten_bind_PxConvexCoreCylinder_set_height_1 = Module['_emscripten_bind_PxConvexCoreCylinder_set_height_1'] = createExportWrapper('emscripten_bind_PxConvexCoreCylinder_set_height_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreCylinder_get_radius_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreCylinder_get_radius_0');
  _emscripten_bind_PxConvexCoreCylinder_get_radius_0 = Module['_emscripten_bind_PxConvexCoreCylinder_get_radius_0'] = createExportWrapper('emscripten_bind_PxConvexCoreCylinder_get_radius_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreCylinder_set_radius_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreCylinder_set_radius_1');
  _emscripten_bind_PxConvexCoreCylinder_set_radius_1 = Module['_emscripten_bind_PxConvexCoreCylinder_set_radius_1'] = createExportWrapper('emscripten_bind_PxConvexCoreCylinder_set_radius_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreCylinder___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreCylinder___destroy___0');
  _emscripten_bind_PxConvexCoreCylinder___destroy___0 = Module['_emscripten_bind_PxConvexCoreCylinder___destroy___0'] = createExportWrapper('emscripten_bind_PxConvexCoreCylinder___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreEllipsoid_PxConvexCoreEllipsoid_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreEllipsoid_PxConvexCoreEllipsoid_3');
  _emscripten_bind_PxConvexCoreEllipsoid_PxConvexCoreEllipsoid_3 = Module['_emscripten_bind_PxConvexCoreEllipsoid_PxConvexCoreEllipsoid_3'] = createExportWrapper('emscripten_bind_PxConvexCoreEllipsoid_PxConvexCoreEllipsoid_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreEllipsoid_get_radii_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreEllipsoid_get_radii_0');
  _emscripten_bind_PxConvexCoreEllipsoid_get_radii_0 = Module['_emscripten_bind_PxConvexCoreEllipsoid_get_radii_0'] = createExportWrapper('emscripten_bind_PxConvexCoreEllipsoid_get_radii_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreEllipsoid_set_radii_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreEllipsoid_set_radii_1');
  _emscripten_bind_PxConvexCoreEllipsoid_set_radii_1 = Module['_emscripten_bind_PxConvexCoreEllipsoid_set_radii_1'] = createExportWrapper('emscripten_bind_PxConvexCoreEllipsoid_set_radii_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreEllipsoid___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreEllipsoid___destroy___0');
  _emscripten_bind_PxConvexCoreEllipsoid___destroy___0 = Module['_emscripten_bind_PxConvexCoreEllipsoid___destroy___0'] = createExportWrapper('emscripten_bind_PxConvexCoreEllipsoid___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreGeometry_getCoreType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreGeometry_getCoreType_0');
  _emscripten_bind_PxConvexCoreGeometry_getCoreType_0 = Module['_emscripten_bind_PxConvexCoreGeometry_getCoreType_0'] = createExportWrapper('emscripten_bind_PxConvexCoreGeometry_getCoreType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreGeometry_getCoreData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreGeometry_getCoreData_0');
  _emscripten_bind_PxConvexCoreGeometry_getCoreData_0 = Module['_emscripten_bind_PxConvexCoreGeometry_getCoreData_0'] = createExportWrapper('emscripten_bind_PxConvexCoreGeometry_getCoreData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreGeometry_getMargin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreGeometry_getMargin_0');
  _emscripten_bind_PxConvexCoreGeometry_getMargin_0 = Module['_emscripten_bind_PxConvexCoreGeometry_getMargin_0'] = createExportWrapper('emscripten_bind_PxConvexCoreGeometry_getMargin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreGeometry_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreGeometry_isValid_0');
  _emscripten_bind_PxConvexCoreGeometry_isValid_0 = Module['_emscripten_bind_PxConvexCoreGeometry_isValid_0'] = createExportWrapper('emscripten_bind_PxConvexCoreGeometry_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreGeometry_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreGeometry_getType_0');
  _emscripten_bind_PxConvexCoreGeometry_getType_0 = Module['_emscripten_bind_PxConvexCoreGeometry_getType_0'] = createExportWrapper('emscripten_bind_PxConvexCoreGeometry_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreGeometry___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreGeometry___destroy___0');
  _emscripten_bind_PxConvexCoreGeometry___destroy___0 = Module['_emscripten_bind_PxConvexCoreGeometry___destroy___0'] = createExportWrapper('emscripten_bind_PxConvexCoreGeometry___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreGeometryFactory_createFromBox_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreGeometryFactory_createFromBox_2');
  _emscripten_bind_PxConvexCoreGeometryFactory_createFromBox_2 = Module['_emscripten_bind_PxConvexCoreGeometryFactory_createFromBox_2'] = createExportWrapper('emscripten_bind_PxConvexCoreGeometryFactory_createFromBox_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreGeometryFactory_createFromCone_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreGeometryFactory_createFromCone_2');
  _emscripten_bind_PxConvexCoreGeometryFactory_createFromCone_2 = Module['_emscripten_bind_PxConvexCoreGeometryFactory_createFromCone_2'] = createExportWrapper('emscripten_bind_PxConvexCoreGeometryFactory_createFromCone_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreGeometryFactory_createFromCylinder_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreGeometryFactory_createFromCylinder_2');
  _emscripten_bind_PxConvexCoreGeometryFactory_createFromCylinder_2 = Module['_emscripten_bind_PxConvexCoreGeometryFactory_createFromCylinder_2'] = createExportWrapper('emscripten_bind_PxConvexCoreGeometryFactory_createFromCylinder_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreGeometryFactory_createFromEllipsoid_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreGeometryFactory_createFromEllipsoid_2');
  _emscripten_bind_PxConvexCoreGeometryFactory_createFromEllipsoid_2 = Module['_emscripten_bind_PxConvexCoreGeometryFactory_createFromEllipsoid_2'] = createExportWrapper('emscripten_bind_PxConvexCoreGeometryFactory_createFromEllipsoid_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreGeometryFactory_createFromPoint_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreGeometryFactory_createFromPoint_2');
  _emscripten_bind_PxConvexCoreGeometryFactory_createFromPoint_2 = Module['_emscripten_bind_PxConvexCoreGeometryFactory_createFromPoint_2'] = createExportWrapper('emscripten_bind_PxConvexCoreGeometryFactory_createFromPoint_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreGeometryFactory_createFromSegment_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreGeometryFactory_createFromSegment_2');
  _emscripten_bind_PxConvexCoreGeometryFactory_createFromSegment_2 = Module['_emscripten_bind_PxConvexCoreGeometryFactory_createFromSegment_2'] = createExportWrapper('emscripten_bind_PxConvexCoreGeometryFactory_createFromSegment_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreGeometryFactory___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreGeometryFactory___destroy___0');
  _emscripten_bind_PxConvexCoreGeometryFactory___destroy___0 = Module['_emscripten_bind_PxConvexCoreGeometryFactory___destroy___0'] = createExportWrapper('emscripten_bind_PxConvexCoreGeometryFactory___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCorePoint_PxConvexCorePoint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCorePoint_PxConvexCorePoint_0');
  _emscripten_bind_PxConvexCorePoint_PxConvexCorePoint_0 = Module['_emscripten_bind_PxConvexCorePoint_PxConvexCorePoint_0'] = createExportWrapper('emscripten_bind_PxConvexCorePoint_PxConvexCorePoint_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxConvexCorePoint___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCorePoint___destroy___0');
  _emscripten_bind_PxConvexCorePoint___destroy___0 = Module['_emscripten_bind_PxConvexCorePoint___destroy___0'] = createExportWrapper('emscripten_bind_PxConvexCorePoint___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreSegment_PxConvexCoreSegment_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreSegment_PxConvexCoreSegment_1');
  _emscripten_bind_PxConvexCoreSegment_PxConvexCoreSegment_1 = Module['_emscripten_bind_PxConvexCoreSegment_PxConvexCoreSegment_1'] = createExportWrapper('emscripten_bind_PxConvexCoreSegment_PxConvexCoreSegment_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreSegment_get_length_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreSegment_get_length_0');
  _emscripten_bind_PxConvexCoreSegment_get_length_0 = Module['_emscripten_bind_PxConvexCoreSegment_get_length_0'] = createExportWrapper('emscripten_bind_PxConvexCoreSegment_get_length_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreSegment_set_length_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreSegment_set_length_1');
  _emscripten_bind_PxConvexCoreSegment_set_length_1 = Module['_emscripten_bind_PxConvexCoreSegment_set_length_1'] = createExportWrapper('emscripten_bind_PxConvexCoreSegment_set_length_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexCoreSegment___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexCoreSegment___destroy___0');
  _emscripten_bind_PxConvexCoreSegment___destroy___0 = Module['_emscripten_bind_PxConvexCoreSegment___destroy___0'] = createExportWrapper('emscripten_bind_PxConvexCoreSegment___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexFlags_PxConvexFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexFlags_PxConvexFlags_1');
  _emscripten_bind_PxConvexFlags_PxConvexFlags_1 = Module['_emscripten_bind_PxConvexFlags_PxConvexFlags_1'] = createExportWrapper('emscripten_bind_PxConvexFlags_PxConvexFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexFlags_isSet_1');
  _emscripten_bind_PxConvexFlags_isSet_1 = Module['_emscripten_bind_PxConvexFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxConvexFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexFlags_raise_1');
  _emscripten_bind_PxConvexFlags_raise_1 = Module['_emscripten_bind_PxConvexFlags_raise_1'] = createExportWrapper('emscripten_bind_PxConvexFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexFlags_clear_1');
  _emscripten_bind_PxConvexFlags_clear_1 = Module['_emscripten_bind_PxConvexFlags_clear_1'] = createExportWrapper('emscripten_bind_PxConvexFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexFlags___destroy___0');
  _emscripten_bind_PxConvexFlags___destroy___0 = Module['_emscripten_bind_PxConvexFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxConvexFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_getNbVertices_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_getNbVertices_0');
  _emscripten_bind_PxConvexMesh_getNbVertices_0 = Module['_emscripten_bind_PxConvexMesh_getNbVertices_0'] = createExportWrapper('emscripten_bind_PxConvexMesh_getNbVertices_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_getVertices_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_getVertices_0');
  _emscripten_bind_PxConvexMesh_getVertices_0 = Module['_emscripten_bind_PxConvexMesh_getVertices_0'] = createExportWrapper('emscripten_bind_PxConvexMesh_getVertices_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_getIndexBuffer_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_getIndexBuffer_0');
  _emscripten_bind_PxConvexMesh_getIndexBuffer_0 = Module['_emscripten_bind_PxConvexMesh_getIndexBuffer_0'] = createExportWrapper('emscripten_bind_PxConvexMesh_getIndexBuffer_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_getNbPolygons_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_getNbPolygons_0');
  _emscripten_bind_PxConvexMesh_getNbPolygons_0 = Module['_emscripten_bind_PxConvexMesh_getNbPolygons_0'] = createExportWrapper('emscripten_bind_PxConvexMesh_getNbPolygons_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_getPolygonData_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_getPolygonData_2');
  _emscripten_bind_PxConvexMesh_getPolygonData_2 = Module['_emscripten_bind_PxConvexMesh_getPolygonData_2'] = createExportWrapper('emscripten_bind_PxConvexMesh_getPolygonData_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_getLocalBounds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_getLocalBounds_0');
  _emscripten_bind_PxConvexMesh_getLocalBounds_0 = Module['_emscripten_bind_PxConvexMesh_getLocalBounds_0'] = createExportWrapper('emscripten_bind_PxConvexMesh_getLocalBounds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_isGpuCompatible_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_isGpuCompatible_0');
  _emscripten_bind_PxConvexMesh_isGpuCompatible_0 = Module['_emscripten_bind_PxConvexMesh_isGpuCompatible_0'] = createExportWrapper('emscripten_bind_PxConvexMesh_isGpuCompatible_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_release_0');
  _emscripten_bind_PxConvexMesh_release_0 = Module['_emscripten_bind_PxConvexMesh_release_0'] = createExportWrapper('emscripten_bind_PxConvexMesh_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_getConcreteTypeName_0');
  _emscripten_bind_PxConvexMesh_getConcreteTypeName_0 = Module['_emscripten_bind_PxConvexMesh_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxConvexMesh_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_getConcreteType_0');
  _emscripten_bind_PxConvexMesh_getConcreteType_0 = Module['_emscripten_bind_PxConvexMesh_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxConvexMesh_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_setBaseFlag_2');
  _emscripten_bind_PxConvexMesh_setBaseFlag_2 = Module['_emscripten_bind_PxConvexMesh_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxConvexMesh_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_setBaseFlags_1');
  _emscripten_bind_PxConvexMesh_setBaseFlags_1 = Module['_emscripten_bind_PxConvexMesh_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxConvexMesh_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_getBaseFlags_0');
  _emscripten_bind_PxConvexMesh_getBaseFlags_0 = Module['_emscripten_bind_PxConvexMesh_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxConvexMesh_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_isReleasable_0');
  _emscripten_bind_PxConvexMesh_isReleasable_0 = Module['_emscripten_bind_PxConvexMesh_isReleasable_0'] = createExportWrapper('emscripten_bind_PxConvexMesh_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_getReferenceCount_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_getReferenceCount_0');
  _emscripten_bind_PxConvexMesh_getReferenceCount_0 = Module['_emscripten_bind_PxConvexMesh_getReferenceCount_0'] = createExportWrapper('emscripten_bind_PxConvexMesh_getReferenceCount_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMesh_acquireReference_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMesh_acquireReference_0');
  _emscripten_bind_PxConvexMesh_acquireReference_0 = Module['_emscripten_bind_PxConvexMesh_acquireReference_0'] = createExportWrapper('emscripten_bind_PxConvexMesh_acquireReference_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshDesc_PxConvexMeshDesc_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshDesc_PxConvexMeshDesc_0');
  _emscripten_bind_PxConvexMeshDesc_PxConvexMeshDesc_0 = Module['_emscripten_bind_PxConvexMeshDesc_PxConvexMeshDesc_0'] = createExportWrapper('emscripten_bind_PxConvexMeshDesc_PxConvexMeshDesc_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshDesc_get_points_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshDesc_get_points_0');
  _emscripten_bind_PxConvexMeshDesc_get_points_0 = Module['_emscripten_bind_PxConvexMeshDesc_get_points_0'] = createExportWrapper('emscripten_bind_PxConvexMeshDesc_get_points_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshDesc_set_points_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshDesc_set_points_1');
  _emscripten_bind_PxConvexMeshDesc_set_points_1 = Module['_emscripten_bind_PxConvexMeshDesc_set_points_1'] = createExportWrapper('emscripten_bind_PxConvexMeshDesc_set_points_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshDesc_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshDesc_get_flags_0');
  _emscripten_bind_PxConvexMeshDesc_get_flags_0 = Module['_emscripten_bind_PxConvexMeshDesc_get_flags_0'] = createExportWrapper('emscripten_bind_PxConvexMeshDesc_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshDesc_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshDesc_set_flags_1');
  _emscripten_bind_PxConvexMeshDesc_set_flags_1 = Module['_emscripten_bind_PxConvexMeshDesc_set_flags_1'] = createExportWrapper('emscripten_bind_PxConvexMeshDesc_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshDesc___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshDesc___destroy___0');
  _emscripten_bind_PxConvexMeshDesc___destroy___0 = Module['_emscripten_bind_PxConvexMeshDesc___destroy___0'] = createExportWrapper('emscripten_bind_PxConvexMeshDesc___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_1');
  _emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_1 = Module['_emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_1'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_2');
  _emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_2 = Module['_emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_2'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_3');
  _emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_3 = Module['_emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_3'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometry_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometry_getType_0');
  _emscripten_bind_PxConvexMeshGeometry_getType_0 = Module['_emscripten_bind_PxConvexMeshGeometry_getType_0'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometry_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometry_get_scale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometry_get_scale_0');
  _emscripten_bind_PxConvexMeshGeometry_get_scale_0 = Module['_emscripten_bind_PxConvexMeshGeometry_get_scale_0'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometry_get_scale_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometry_set_scale_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometry_set_scale_1');
  _emscripten_bind_PxConvexMeshGeometry_set_scale_1 = Module['_emscripten_bind_PxConvexMeshGeometry_set_scale_1'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometry_set_scale_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometry_get_convexMesh_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometry_get_convexMesh_0');
  _emscripten_bind_PxConvexMeshGeometry_get_convexMesh_0 = Module['_emscripten_bind_PxConvexMeshGeometry_get_convexMesh_0'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometry_get_convexMesh_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometry_set_convexMesh_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometry_set_convexMesh_1');
  _emscripten_bind_PxConvexMeshGeometry_set_convexMesh_1 = Module['_emscripten_bind_PxConvexMeshGeometry_set_convexMesh_1'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometry_set_convexMesh_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometry_get_meshFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometry_get_meshFlags_0');
  _emscripten_bind_PxConvexMeshGeometry_get_meshFlags_0 = Module['_emscripten_bind_PxConvexMeshGeometry_get_meshFlags_0'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometry_get_meshFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometry_set_meshFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometry_set_meshFlags_1');
  _emscripten_bind_PxConvexMeshGeometry_set_meshFlags_1 = Module['_emscripten_bind_PxConvexMeshGeometry_set_meshFlags_1'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometry_set_meshFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometry___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometry___destroy___0');
  _emscripten_bind_PxConvexMeshGeometry___destroy___0 = Module['_emscripten_bind_PxConvexMeshGeometry___destroy___0'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometry___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometryFlags_PxConvexMeshGeometryFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometryFlags_PxConvexMeshGeometryFlags_1');
  _emscripten_bind_PxConvexMeshGeometryFlags_PxConvexMeshGeometryFlags_1 = Module['_emscripten_bind_PxConvexMeshGeometryFlags_PxConvexMeshGeometryFlags_1'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometryFlags_PxConvexMeshGeometryFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometryFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometryFlags_isSet_1');
  _emscripten_bind_PxConvexMeshGeometryFlags_isSet_1 = Module['_emscripten_bind_PxConvexMeshGeometryFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometryFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometryFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometryFlags_raise_1');
  _emscripten_bind_PxConvexMeshGeometryFlags_raise_1 = Module['_emscripten_bind_PxConvexMeshGeometryFlags_raise_1'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometryFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometryFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometryFlags_clear_1');
  _emscripten_bind_PxConvexMeshGeometryFlags_clear_1 = Module['_emscripten_bind_PxConvexMeshGeometryFlags_clear_1'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometryFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxConvexMeshGeometryFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxConvexMeshGeometryFlags___destroy___0');
  _emscripten_bind_PxConvexMeshGeometryFlags___destroy___0 = Module['_emscripten_bind_PxConvexMeshGeometryFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxConvexMeshGeometryFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_PxCookingParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_PxCookingParams_1');
  _emscripten_bind_PxCookingParams_PxCookingParams_1 = Module['_emscripten_bind_PxCookingParams_PxCookingParams_1'] = createExportWrapper('emscripten_bind_PxCookingParams_PxCookingParams_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_get_areaTestEpsilon_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_get_areaTestEpsilon_0');
  _emscripten_bind_PxCookingParams_get_areaTestEpsilon_0 = Module['_emscripten_bind_PxCookingParams_get_areaTestEpsilon_0'] = createExportWrapper('emscripten_bind_PxCookingParams_get_areaTestEpsilon_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_set_areaTestEpsilon_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_set_areaTestEpsilon_1');
  _emscripten_bind_PxCookingParams_set_areaTestEpsilon_1 = Module['_emscripten_bind_PxCookingParams_set_areaTestEpsilon_1'] = createExportWrapper('emscripten_bind_PxCookingParams_set_areaTestEpsilon_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_get_planeTolerance_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_get_planeTolerance_0');
  _emscripten_bind_PxCookingParams_get_planeTolerance_0 = Module['_emscripten_bind_PxCookingParams_get_planeTolerance_0'] = createExportWrapper('emscripten_bind_PxCookingParams_get_planeTolerance_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_set_planeTolerance_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_set_planeTolerance_1');
  _emscripten_bind_PxCookingParams_set_planeTolerance_1 = Module['_emscripten_bind_PxCookingParams_set_planeTolerance_1'] = createExportWrapper('emscripten_bind_PxCookingParams_set_planeTolerance_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_get_convexMeshCookingType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_get_convexMeshCookingType_0');
  _emscripten_bind_PxCookingParams_get_convexMeshCookingType_0 = Module['_emscripten_bind_PxCookingParams_get_convexMeshCookingType_0'] = createExportWrapper('emscripten_bind_PxCookingParams_get_convexMeshCookingType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_set_convexMeshCookingType_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_set_convexMeshCookingType_1');
  _emscripten_bind_PxCookingParams_set_convexMeshCookingType_1 = Module['_emscripten_bind_PxCookingParams_set_convexMeshCookingType_1'] = createExportWrapper('emscripten_bind_PxCookingParams_set_convexMeshCookingType_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_get_suppressTriangleMeshRemapTable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_get_suppressTriangleMeshRemapTable_0');
  _emscripten_bind_PxCookingParams_get_suppressTriangleMeshRemapTable_0 = Module['_emscripten_bind_PxCookingParams_get_suppressTriangleMeshRemapTable_0'] = createExportWrapper('emscripten_bind_PxCookingParams_get_suppressTriangleMeshRemapTable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_set_suppressTriangleMeshRemapTable_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_set_suppressTriangleMeshRemapTable_1');
  _emscripten_bind_PxCookingParams_set_suppressTriangleMeshRemapTable_1 = Module['_emscripten_bind_PxCookingParams_set_suppressTriangleMeshRemapTable_1'] = createExportWrapper('emscripten_bind_PxCookingParams_set_suppressTriangleMeshRemapTable_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_get_buildTriangleAdjacencies_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_get_buildTriangleAdjacencies_0');
  _emscripten_bind_PxCookingParams_get_buildTriangleAdjacencies_0 = Module['_emscripten_bind_PxCookingParams_get_buildTriangleAdjacencies_0'] = createExportWrapper('emscripten_bind_PxCookingParams_get_buildTriangleAdjacencies_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_set_buildTriangleAdjacencies_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_set_buildTriangleAdjacencies_1');
  _emscripten_bind_PxCookingParams_set_buildTriangleAdjacencies_1 = Module['_emscripten_bind_PxCookingParams_set_buildTriangleAdjacencies_1'] = createExportWrapper('emscripten_bind_PxCookingParams_set_buildTriangleAdjacencies_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_get_buildGPUData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_get_buildGPUData_0');
  _emscripten_bind_PxCookingParams_get_buildGPUData_0 = Module['_emscripten_bind_PxCookingParams_get_buildGPUData_0'] = createExportWrapper('emscripten_bind_PxCookingParams_get_buildGPUData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_set_buildGPUData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_set_buildGPUData_1');
  _emscripten_bind_PxCookingParams_set_buildGPUData_1 = Module['_emscripten_bind_PxCookingParams_set_buildGPUData_1'] = createExportWrapper('emscripten_bind_PxCookingParams_set_buildGPUData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_get_scale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_get_scale_0');
  _emscripten_bind_PxCookingParams_get_scale_0 = Module['_emscripten_bind_PxCookingParams_get_scale_0'] = createExportWrapper('emscripten_bind_PxCookingParams_get_scale_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_set_scale_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_set_scale_1');
  _emscripten_bind_PxCookingParams_set_scale_1 = Module['_emscripten_bind_PxCookingParams_set_scale_1'] = createExportWrapper('emscripten_bind_PxCookingParams_set_scale_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_get_meshPreprocessParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_get_meshPreprocessParams_0');
  _emscripten_bind_PxCookingParams_get_meshPreprocessParams_0 = Module['_emscripten_bind_PxCookingParams_get_meshPreprocessParams_0'] = createExportWrapper('emscripten_bind_PxCookingParams_get_meshPreprocessParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_set_meshPreprocessParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_set_meshPreprocessParams_1');
  _emscripten_bind_PxCookingParams_set_meshPreprocessParams_1 = Module['_emscripten_bind_PxCookingParams_set_meshPreprocessParams_1'] = createExportWrapper('emscripten_bind_PxCookingParams_set_meshPreprocessParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_get_meshWeldTolerance_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_get_meshWeldTolerance_0');
  _emscripten_bind_PxCookingParams_get_meshWeldTolerance_0 = Module['_emscripten_bind_PxCookingParams_get_meshWeldTolerance_0'] = createExportWrapper('emscripten_bind_PxCookingParams_get_meshWeldTolerance_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_set_meshWeldTolerance_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_set_meshWeldTolerance_1');
  _emscripten_bind_PxCookingParams_set_meshWeldTolerance_1 = Module['_emscripten_bind_PxCookingParams_set_meshWeldTolerance_1'] = createExportWrapper('emscripten_bind_PxCookingParams_set_meshWeldTolerance_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_get_midphaseDesc_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_get_midphaseDesc_0');
  _emscripten_bind_PxCookingParams_get_midphaseDesc_0 = Module['_emscripten_bind_PxCookingParams_get_midphaseDesc_0'] = createExportWrapper('emscripten_bind_PxCookingParams_get_midphaseDesc_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_set_midphaseDesc_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_set_midphaseDesc_1');
  _emscripten_bind_PxCookingParams_set_midphaseDesc_1 = Module['_emscripten_bind_PxCookingParams_set_midphaseDesc_1'] = createExportWrapper('emscripten_bind_PxCookingParams_set_midphaseDesc_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_get_gaussMapLimit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_get_gaussMapLimit_0');
  _emscripten_bind_PxCookingParams_get_gaussMapLimit_0 = Module['_emscripten_bind_PxCookingParams_get_gaussMapLimit_0'] = createExportWrapper('emscripten_bind_PxCookingParams_get_gaussMapLimit_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams_set_gaussMapLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams_set_gaussMapLimit_1');
  _emscripten_bind_PxCookingParams_set_gaussMapLimit_1 = Module['_emscripten_bind_PxCookingParams_set_gaussMapLimit_1'] = createExportWrapper('emscripten_bind_PxCookingParams_set_gaussMapLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxCookingParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxCookingParams___destroy___0');
  _emscripten_bind_PxCookingParams___destroy___0 = Module['_emscripten_bind_PxCookingParams___destroy___0'] = createExportWrapper('emscripten_bind_PxCookingParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setMotion_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setMotion_2');
  _emscripten_bind_PxD6Joint_setMotion_2 = Module['_emscripten_bind_PxD6Joint_setMotion_2'] = createExportWrapper('emscripten_bind_PxD6Joint_setMotion_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getMotion_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getMotion_1');
  _emscripten_bind_PxD6Joint_getMotion_1 = Module['_emscripten_bind_PxD6Joint_getMotion_1'] = createExportWrapper('emscripten_bind_PxD6Joint_getMotion_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getTwistAngle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getTwistAngle_0');
  _emscripten_bind_PxD6Joint_getTwistAngle_0 = Module['_emscripten_bind_PxD6Joint_getTwistAngle_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getTwistAngle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getSwingYAngle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getSwingYAngle_0');
  _emscripten_bind_PxD6Joint_getSwingYAngle_0 = Module['_emscripten_bind_PxD6Joint_getSwingYAngle_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getSwingYAngle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getSwingZAngle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getSwingZAngle_0');
  _emscripten_bind_PxD6Joint_getSwingZAngle_0 = Module['_emscripten_bind_PxD6Joint_getSwingZAngle_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getSwingZAngle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setDistanceLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setDistanceLimit_1');
  _emscripten_bind_PxD6Joint_setDistanceLimit_1 = Module['_emscripten_bind_PxD6Joint_setDistanceLimit_1'] = createExportWrapper('emscripten_bind_PxD6Joint_setDistanceLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setLinearLimit_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setLinearLimit_2');
  _emscripten_bind_PxD6Joint_setLinearLimit_2 = Module['_emscripten_bind_PxD6Joint_setLinearLimit_2'] = createExportWrapper('emscripten_bind_PxD6Joint_setLinearLimit_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setTwistLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setTwistLimit_1');
  _emscripten_bind_PxD6Joint_setTwistLimit_1 = Module['_emscripten_bind_PxD6Joint_setTwistLimit_1'] = createExportWrapper('emscripten_bind_PxD6Joint_setTwistLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setSwingLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setSwingLimit_1');
  _emscripten_bind_PxD6Joint_setSwingLimit_1 = Module['_emscripten_bind_PxD6Joint_setSwingLimit_1'] = createExportWrapper('emscripten_bind_PxD6Joint_setSwingLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setPyramidSwingLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setPyramidSwingLimit_1');
  _emscripten_bind_PxD6Joint_setPyramidSwingLimit_1 = Module['_emscripten_bind_PxD6Joint_setPyramidSwingLimit_1'] = createExportWrapper('emscripten_bind_PxD6Joint_setPyramidSwingLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setDrive_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setDrive_2');
  _emscripten_bind_PxD6Joint_setDrive_2 = Module['_emscripten_bind_PxD6Joint_setDrive_2'] = createExportWrapper('emscripten_bind_PxD6Joint_setDrive_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getDrive_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getDrive_1');
  _emscripten_bind_PxD6Joint_getDrive_1 = Module['_emscripten_bind_PxD6Joint_getDrive_1'] = createExportWrapper('emscripten_bind_PxD6Joint_getDrive_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setDrivePosition_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setDrivePosition_1');
  _emscripten_bind_PxD6Joint_setDrivePosition_1 = Module['_emscripten_bind_PxD6Joint_setDrivePosition_1'] = createExportWrapper('emscripten_bind_PxD6Joint_setDrivePosition_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setDrivePosition_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setDrivePosition_2');
  _emscripten_bind_PxD6Joint_setDrivePosition_2 = Module['_emscripten_bind_PxD6Joint_setDrivePosition_2'] = createExportWrapper('emscripten_bind_PxD6Joint_setDrivePosition_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getDrivePosition_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getDrivePosition_0');
  _emscripten_bind_PxD6Joint_getDrivePosition_0 = Module['_emscripten_bind_PxD6Joint_getDrivePosition_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getDrivePosition_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setDriveVelocity_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setDriveVelocity_2');
  _emscripten_bind_PxD6Joint_setDriveVelocity_2 = Module['_emscripten_bind_PxD6Joint_setDriveVelocity_2'] = createExportWrapper('emscripten_bind_PxD6Joint_setDriveVelocity_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getDriveVelocity_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getDriveVelocity_2');
  _emscripten_bind_PxD6Joint_getDriveVelocity_2 = Module['_emscripten_bind_PxD6Joint_getDriveVelocity_2'] = createExportWrapper('emscripten_bind_PxD6Joint_getDriveVelocity_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setAngularDriveConfig_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setAngularDriveConfig_1');
  _emscripten_bind_PxD6Joint_setAngularDriveConfig_1 = Module['_emscripten_bind_PxD6Joint_setAngularDriveConfig_1'] = createExportWrapper('emscripten_bind_PxD6Joint_setAngularDriveConfig_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getAngularDriveConfig_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getAngularDriveConfig_0');
  _emscripten_bind_PxD6Joint_getAngularDriveConfig_0 = Module['_emscripten_bind_PxD6Joint_getAngularDriveConfig_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getAngularDriveConfig_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_release_0');
  _emscripten_bind_PxD6Joint_release_0 = Module['_emscripten_bind_PxD6Joint_release_0'] = createExportWrapper('emscripten_bind_PxD6Joint_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getConcreteTypeName_0');
  _emscripten_bind_PxD6Joint_getConcreteTypeName_0 = Module['_emscripten_bind_PxD6Joint_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getConcreteType_0');
  _emscripten_bind_PxD6Joint_getConcreteType_0 = Module['_emscripten_bind_PxD6Joint_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setBaseFlag_2');
  _emscripten_bind_PxD6Joint_setBaseFlag_2 = Module['_emscripten_bind_PxD6Joint_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxD6Joint_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setBaseFlags_1');
  _emscripten_bind_PxD6Joint_setBaseFlags_1 = Module['_emscripten_bind_PxD6Joint_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxD6Joint_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getBaseFlags_0');
  _emscripten_bind_PxD6Joint_getBaseFlags_0 = Module['_emscripten_bind_PxD6Joint_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_isReleasable_0');
  _emscripten_bind_PxD6Joint_isReleasable_0 = Module['_emscripten_bind_PxD6Joint_isReleasable_0'] = createExportWrapper('emscripten_bind_PxD6Joint_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setActors_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setActors_2');
  _emscripten_bind_PxD6Joint_setActors_2 = Module['_emscripten_bind_PxD6Joint_setActors_2'] = createExportWrapper('emscripten_bind_PxD6Joint_setActors_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setLocalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setLocalPose_2');
  _emscripten_bind_PxD6Joint_setLocalPose_2 = Module['_emscripten_bind_PxD6Joint_setLocalPose_2'] = createExportWrapper('emscripten_bind_PxD6Joint_setLocalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getLocalPose_1');
  _emscripten_bind_PxD6Joint_getLocalPose_1 = Module['_emscripten_bind_PxD6Joint_getLocalPose_1'] = createExportWrapper('emscripten_bind_PxD6Joint_getLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getRelativeTransform_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getRelativeTransform_0');
  _emscripten_bind_PxD6Joint_getRelativeTransform_0 = Module['_emscripten_bind_PxD6Joint_getRelativeTransform_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getRelativeTransform_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getRelativeLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getRelativeLinearVelocity_0');
  _emscripten_bind_PxD6Joint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxD6Joint_getRelativeLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getRelativeLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getRelativeAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getRelativeAngularVelocity_0');
  _emscripten_bind_PxD6Joint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxD6Joint_getRelativeAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getRelativeAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setBreakForce_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setBreakForce_2');
  _emscripten_bind_PxD6Joint_setBreakForce_2 = Module['_emscripten_bind_PxD6Joint_setBreakForce_2'] = createExportWrapper('emscripten_bind_PxD6Joint_setBreakForce_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setConstraintFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setConstraintFlags_1');
  _emscripten_bind_PxD6Joint_setConstraintFlags_1 = Module['_emscripten_bind_PxD6Joint_setConstraintFlags_1'] = createExportWrapper('emscripten_bind_PxD6Joint_setConstraintFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setConstraintFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setConstraintFlag_2');
  _emscripten_bind_PxD6Joint_setConstraintFlag_2 = Module['_emscripten_bind_PxD6Joint_setConstraintFlag_2'] = createExportWrapper('emscripten_bind_PxD6Joint_setConstraintFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getConstraintFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getConstraintFlags_0');
  _emscripten_bind_PxD6Joint_getConstraintFlags_0 = Module['_emscripten_bind_PxD6Joint_getConstraintFlags_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getConstraintFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setInvMassScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setInvMassScale0_1');
  _emscripten_bind_PxD6Joint_setInvMassScale0_1 = Module['_emscripten_bind_PxD6Joint_setInvMassScale0_1'] = createExportWrapper('emscripten_bind_PxD6Joint_setInvMassScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getInvMassScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getInvMassScale0_0');
  _emscripten_bind_PxD6Joint_getInvMassScale0_0 = Module['_emscripten_bind_PxD6Joint_getInvMassScale0_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getInvMassScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setInvMassScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setInvMassScale1_1');
  _emscripten_bind_PxD6Joint_setInvMassScale1_1 = Module['_emscripten_bind_PxD6Joint_setInvMassScale1_1'] = createExportWrapper('emscripten_bind_PxD6Joint_setInvMassScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getInvMassScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getInvMassScale1_0');
  _emscripten_bind_PxD6Joint_getInvMassScale1_0 = Module['_emscripten_bind_PxD6Joint_getInvMassScale1_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getInvMassScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setInvInertiaScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setInvInertiaScale0_1');
  _emscripten_bind_PxD6Joint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxD6Joint_setInvInertiaScale0_1'] = createExportWrapper('emscripten_bind_PxD6Joint_setInvInertiaScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getInvInertiaScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getInvInertiaScale0_0');
  _emscripten_bind_PxD6Joint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxD6Joint_getInvInertiaScale0_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getInvInertiaScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setInvInertiaScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setInvInertiaScale1_1');
  _emscripten_bind_PxD6Joint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxD6Joint_setInvInertiaScale1_1'] = createExportWrapper('emscripten_bind_PxD6Joint_setInvInertiaScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getInvInertiaScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getInvInertiaScale1_0');
  _emscripten_bind_PxD6Joint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxD6Joint_getInvInertiaScale1_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getInvInertiaScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getConstraint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getConstraint_0');
  _emscripten_bind_PxD6Joint_getConstraint_0 = Module['_emscripten_bind_PxD6Joint_getConstraint_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getConstraint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_setName_1');
  _emscripten_bind_PxD6Joint_setName_1 = Module['_emscripten_bind_PxD6Joint_setName_1'] = createExportWrapper('emscripten_bind_PxD6Joint_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getName_0');
  _emscripten_bind_PxD6Joint_getName_0 = Module['_emscripten_bind_PxD6Joint_getName_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_getScene_0');
  _emscripten_bind_PxD6Joint_getScene_0 = Module['_emscripten_bind_PxD6Joint_getScene_0'] = createExportWrapper('emscripten_bind_PxD6Joint_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_get_userData_0');
  _emscripten_bind_PxD6Joint_get_userData_0 = Module['_emscripten_bind_PxD6Joint_get_userData_0'] = createExportWrapper('emscripten_bind_PxD6Joint_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint_set_userData_1');
  _emscripten_bind_PxD6Joint_set_userData_1 = Module['_emscripten_bind_PxD6Joint_set_userData_1'] = createExportWrapper('emscripten_bind_PxD6Joint_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6Joint___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6Joint___destroy___0');
  _emscripten_bind_PxD6Joint___destroy___0 = Module['_emscripten_bind_PxD6Joint___destroy___0'] = createExportWrapper('emscripten_bind_PxD6Joint___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDrive_PxD6JointDrive_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDrive_PxD6JointDrive_0');
  _emscripten_bind_PxD6JointDrive_PxD6JointDrive_0 = Module['_emscripten_bind_PxD6JointDrive_PxD6JointDrive_0'] = createExportWrapper('emscripten_bind_PxD6JointDrive_PxD6JointDrive_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDrive_PxD6JointDrive_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDrive_PxD6JointDrive_3');
  _emscripten_bind_PxD6JointDrive_PxD6JointDrive_3 = Module['_emscripten_bind_PxD6JointDrive_PxD6JointDrive_3'] = createExportWrapper('emscripten_bind_PxD6JointDrive_PxD6JointDrive_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDrive_PxD6JointDrive_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDrive_PxD6JointDrive_4');
  _emscripten_bind_PxD6JointDrive_PxD6JointDrive_4 = Module['_emscripten_bind_PxD6JointDrive_PxD6JointDrive_4'] = createExportWrapper('emscripten_bind_PxD6JointDrive_PxD6JointDrive_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDrive_get_forceLimit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDrive_get_forceLimit_0');
  _emscripten_bind_PxD6JointDrive_get_forceLimit_0 = Module['_emscripten_bind_PxD6JointDrive_get_forceLimit_0'] = createExportWrapper('emscripten_bind_PxD6JointDrive_get_forceLimit_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDrive_set_forceLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDrive_set_forceLimit_1');
  _emscripten_bind_PxD6JointDrive_set_forceLimit_1 = Module['_emscripten_bind_PxD6JointDrive_set_forceLimit_1'] = createExportWrapper('emscripten_bind_PxD6JointDrive_set_forceLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDrive_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDrive_get_flags_0');
  _emscripten_bind_PxD6JointDrive_get_flags_0 = Module['_emscripten_bind_PxD6JointDrive_get_flags_0'] = createExportWrapper('emscripten_bind_PxD6JointDrive_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDrive_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDrive_set_flags_1');
  _emscripten_bind_PxD6JointDrive_set_flags_1 = Module['_emscripten_bind_PxD6JointDrive_set_flags_1'] = createExportWrapper('emscripten_bind_PxD6JointDrive_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDrive_get_stiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDrive_get_stiffness_0');
  _emscripten_bind_PxD6JointDrive_get_stiffness_0 = Module['_emscripten_bind_PxD6JointDrive_get_stiffness_0'] = createExportWrapper('emscripten_bind_PxD6JointDrive_get_stiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDrive_set_stiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDrive_set_stiffness_1');
  _emscripten_bind_PxD6JointDrive_set_stiffness_1 = Module['_emscripten_bind_PxD6JointDrive_set_stiffness_1'] = createExportWrapper('emscripten_bind_PxD6JointDrive_set_stiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDrive_get_damping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDrive_get_damping_0');
  _emscripten_bind_PxD6JointDrive_get_damping_0 = Module['_emscripten_bind_PxD6JointDrive_get_damping_0'] = createExportWrapper('emscripten_bind_PxD6JointDrive_get_damping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDrive_set_damping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDrive_set_damping_1');
  _emscripten_bind_PxD6JointDrive_set_damping_1 = Module['_emscripten_bind_PxD6JointDrive_set_damping_1'] = createExportWrapper('emscripten_bind_PxD6JointDrive_set_damping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDrive___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDrive___destroy___0');
  _emscripten_bind_PxD6JointDrive___destroy___0 = Module['_emscripten_bind_PxD6JointDrive___destroy___0'] = createExportWrapper('emscripten_bind_PxD6JointDrive___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDriveFlags_PxD6JointDriveFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDriveFlags_PxD6JointDriveFlags_1');
  _emscripten_bind_PxD6JointDriveFlags_PxD6JointDriveFlags_1 = Module['_emscripten_bind_PxD6JointDriveFlags_PxD6JointDriveFlags_1'] = createExportWrapper('emscripten_bind_PxD6JointDriveFlags_PxD6JointDriveFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDriveFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDriveFlags_isSet_1');
  _emscripten_bind_PxD6JointDriveFlags_isSet_1 = Module['_emscripten_bind_PxD6JointDriveFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxD6JointDriveFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDriveFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDriveFlags_raise_1');
  _emscripten_bind_PxD6JointDriveFlags_raise_1 = Module['_emscripten_bind_PxD6JointDriveFlags_raise_1'] = createExportWrapper('emscripten_bind_PxD6JointDriveFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDriveFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDriveFlags_clear_1');
  _emscripten_bind_PxD6JointDriveFlags_clear_1 = Module['_emscripten_bind_PxD6JointDriveFlags_clear_1'] = createExportWrapper('emscripten_bind_PxD6JointDriveFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxD6JointDriveFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxD6JointDriveFlags___destroy___0');
  _emscripten_bind_PxD6JointDriveFlags___destroy___0 = Module['_emscripten_bind_PxD6JointDriveFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxD6JointDriveFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDebugLine_get_pos0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugLine_get_pos0_0');
  _emscripten_bind_PxDebugLine_get_pos0_0 = Module['_emscripten_bind_PxDebugLine_get_pos0_0'] = createExportWrapper('emscripten_bind_PxDebugLine_get_pos0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDebugLine_set_pos0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugLine_set_pos0_1');
  _emscripten_bind_PxDebugLine_set_pos0_1 = Module['_emscripten_bind_PxDebugLine_set_pos0_1'] = createExportWrapper('emscripten_bind_PxDebugLine_set_pos0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDebugLine_get_color0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugLine_get_color0_0');
  _emscripten_bind_PxDebugLine_get_color0_0 = Module['_emscripten_bind_PxDebugLine_get_color0_0'] = createExportWrapper('emscripten_bind_PxDebugLine_get_color0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDebugLine_set_color0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugLine_set_color0_1');
  _emscripten_bind_PxDebugLine_set_color0_1 = Module['_emscripten_bind_PxDebugLine_set_color0_1'] = createExportWrapper('emscripten_bind_PxDebugLine_set_color0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDebugLine_get_pos1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugLine_get_pos1_0');
  _emscripten_bind_PxDebugLine_get_pos1_0 = Module['_emscripten_bind_PxDebugLine_get_pos1_0'] = createExportWrapper('emscripten_bind_PxDebugLine_get_pos1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDebugLine_set_pos1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugLine_set_pos1_1');
  _emscripten_bind_PxDebugLine_set_pos1_1 = Module['_emscripten_bind_PxDebugLine_set_pos1_1'] = createExportWrapper('emscripten_bind_PxDebugLine_set_pos1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDebugLine_get_color1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugLine_get_color1_0');
  _emscripten_bind_PxDebugLine_get_color1_0 = Module['_emscripten_bind_PxDebugLine_get_color1_0'] = createExportWrapper('emscripten_bind_PxDebugLine_get_color1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDebugLine_set_color1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugLine_set_color1_1');
  _emscripten_bind_PxDebugLine_set_color1_1 = Module['_emscripten_bind_PxDebugLine_set_color1_1'] = createExportWrapper('emscripten_bind_PxDebugLine_set_color1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDebugPoint_get_pos_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugPoint_get_pos_0');
  _emscripten_bind_PxDebugPoint_get_pos_0 = Module['_emscripten_bind_PxDebugPoint_get_pos_0'] = createExportWrapper('emscripten_bind_PxDebugPoint_get_pos_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDebugPoint_set_pos_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugPoint_set_pos_1');
  _emscripten_bind_PxDebugPoint_set_pos_1 = Module['_emscripten_bind_PxDebugPoint_set_pos_1'] = createExportWrapper('emscripten_bind_PxDebugPoint_set_pos_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDebugPoint_get_color_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugPoint_get_color_0');
  _emscripten_bind_PxDebugPoint_get_color_0 = Module['_emscripten_bind_PxDebugPoint_get_color_0'] = createExportWrapper('emscripten_bind_PxDebugPoint_get_color_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDebugPoint_set_color_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugPoint_set_color_1');
  _emscripten_bind_PxDebugPoint_set_color_1 = Module['_emscripten_bind_PxDebugPoint_set_color_1'] = createExportWrapper('emscripten_bind_PxDebugPoint_set_color_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDebugTriangle_get_pos0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugTriangle_get_pos0_0');
  _emscripten_bind_PxDebugTriangle_get_pos0_0 = Module['_emscripten_bind_PxDebugTriangle_get_pos0_0'] = createExportWrapper('emscripten_bind_PxDebugTriangle_get_pos0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDebugTriangle_set_pos0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugTriangle_set_pos0_1');
  _emscripten_bind_PxDebugTriangle_set_pos0_1 = Module['_emscripten_bind_PxDebugTriangle_set_pos0_1'] = createExportWrapper('emscripten_bind_PxDebugTriangle_set_pos0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDebugTriangle_get_color0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugTriangle_get_color0_0');
  _emscripten_bind_PxDebugTriangle_get_color0_0 = Module['_emscripten_bind_PxDebugTriangle_get_color0_0'] = createExportWrapper('emscripten_bind_PxDebugTriangle_get_color0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDebugTriangle_set_color0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugTriangle_set_color0_1');
  _emscripten_bind_PxDebugTriangle_set_color0_1 = Module['_emscripten_bind_PxDebugTriangle_set_color0_1'] = createExportWrapper('emscripten_bind_PxDebugTriangle_set_color0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDebugTriangle_get_pos1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugTriangle_get_pos1_0');
  _emscripten_bind_PxDebugTriangle_get_pos1_0 = Module['_emscripten_bind_PxDebugTriangle_get_pos1_0'] = createExportWrapper('emscripten_bind_PxDebugTriangle_get_pos1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDebugTriangle_set_pos1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugTriangle_set_pos1_1');
  _emscripten_bind_PxDebugTriangle_set_pos1_1 = Module['_emscripten_bind_PxDebugTriangle_set_pos1_1'] = createExportWrapper('emscripten_bind_PxDebugTriangle_set_pos1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDebugTriangle_get_color1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugTriangle_get_color1_0');
  _emscripten_bind_PxDebugTriangle_get_color1_0 = Module['_emscripten_bind_PxDebugTriangle_get_color1_0'] = createExportWrapper('emscripten_bind_PxDebugTriangle_get_color1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDebugTriangle_set_color1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugTriangle_set_color1_1');
  _emscripten_bind_PxDebugTriangle_set_color1_1 = Module['_emscripten_bind_PxDebugTriangle_set_color1_1'] = createExportWrapper('emscripten_bind_PxDebugTriangle_set_color1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDebugTriangle_get_pos2_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugTriangle_get_pos2_0');
  _emscripten_bind_PxDebugTriangle_get_pos2_0 = Module['_emscripten_bind_PxDebugTriangle_get_pos2_0'] = createExportWrapper('emscripten_bind_PxDebugTriangle_get_pos2_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDebugTriangle_set_pos2_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugTriangle_set_pos2_1');
  _emscripten_bind_PxDebugTriangle_set_pos2_1 = Module['_emscripten_bind_PxDebugTriangle_set_pos2_1'] = createExportWrapper('emscripten_bind_PxDebugTriangle_set_pos2_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDebugTriangle_get_color2_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugTriangle_get_color2_0');
  _emscripten_bind_PxDebugTriangle_get_color2_0 = Module['_emscripten_bind_PxDebugTriangle_get_color2_0'] = createExportWrapper('emscripten_bind_PxDebugTriangle_get_color2_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDebugTriangle_set_color2_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDebugTriangle_set_color2_1');
  _emscripten_bind_PxDebugTriangle_set_color2_1 = Module['_emscripten_bind_PxDebugTriangle_set_color2_1'] = createExportWrapper('emscripten_bind_PxDebugTriangle_set_color2_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDefaultAllocator_PxDefaultAllocator_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultAllocator_PxDefaultAllocator_0');
  _emscripten_bind_PxDefaultAllocator_PxDefaultAllocator_0 = Module['_emscripten_bind_PxDefaultAllocator_PxDefaultAllocator_0'] = createExportWrapper('emscripten_bind_PxDefaultAllocator_PxDefaultAllocator_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxDefaultAllocator___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultAllocator___destroy___0');
  _emscripten_bind_PxDefaultAllocator___destroy___0 = Module['_emscripten_bind_PxDefaultAllocator___destroy___0'] = createExportWrapper('emscripten_bind_PxDefaultAllocator___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDefaultCpuDispatcher___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultCpuDispatcher___destroy___0');
  _emscripten_bind_PxDefaultCpuDispatcher___destroy___0 = Module['_emscripten_bind_PxDefaultCpuDispatcher___destroy___0'] = createExportWrapper('emscripten_bind_PxDefaultCpuDispatcher___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDefaultErrorCallback_PxDefaultErrorCallback_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultErrorCallback_PxDefaultErrorCallback_0');
  _emscripten_bind_PxDefaultErrorCallback_PxDefaultErrorCallback_0 = Module['_emscripten_bind_PxDefaultErrorCallback_PxDefaultErrorCallback_0'] = createExportWrapper('emscripten_bind_PxDefaultErrorCallback_PxDefaultErrorCallback_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxDefaultErrorCallback_reportError_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultErrorCallback_reportError_4');
  _emscripten_bind_PxDefaultErrorCallback_reportError_4 = Module['_emscripten_bind_PxDefaultErrorCallback_reportError_4'] = createExportWrapper('emscripten_bind_PxDefaultErrorCallback_reportError_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxDefaultErrorCallback___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultErrorCallback___destroy___0');
  _emscripten_bind_PxDefaultErrorCallback___destroy___0 = Module['_emscripten_bind_PxDefaultErrorCallback___destroy___0'] = createExportWrapper('emscripten_bind_PxDefaultErrorCallback___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDefaultMemoryInputData_PxDefaultMemoryInputData_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultMemoryInputData_PxDefaultMemoryInputData_2');
  _emscripten_bind_PxDefaultMemoryInputData_PxDefaultMemoryInputData_2 = Module['_emscripten_bind_PxDefaultMemoryInputData_PxDefaultMemoryInputData_2'] = createExportWrapper('emscripten_bind_PxDefaultMemoryInputData_PxDefaultMemoryInputData_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxDefaultMemoryInputData_read_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultMemoryInputData_read_2');
  _emscripten_bind_PxDefaultMemoryInputData_read_2 = Module['_emscripten_bind_PxDefaultMemoryInputData_read_2'] = createExportWrapper('emscripten_bind_PxDefaultMemoryInputData_read_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxDefaultMemoryInputData_getLength_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultMemoryInputData_getLength_0');
  _emscripten_bind_PxDefaultMemoryInputData_getLength_0 = Module['_emscripten_bind_PxDefaultMemoryInputData_getLength_0'] = createExportWrapper('emscripten_bind_PxDefaultMemoryInputData_getLength_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDefaultMemoryInputData_seek_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultMemoryInputData_seek_1');
  _emscripten_bind_PxDefaultMemoryInputData_seek_1 = Module['_emscripten_bind_PxDefaultMemoryInputData_seek_1'] = createExportWrapper('emscripten_bind_PxDefaultMemoryInputData_seek_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDefaultMemoryInputData_tell_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultMemoryInputData_tell_0');
  _emscripten_bind_PxDefaultMemoryInputData_tell_0 = Module['_emscripten_bind_PxDefaultMemoryInputData_tell_0'] = createExportWrapper('emscripten_bind_PxDefaultMemoryInputData_tell_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDefaultMemoryInputData___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultMemoryInputData___destroy___0');
  _emscripten_bind_PxDefaultMemoryInputData___destroy___0 = Module['_emscripten_bind_PxDefaultMemoryInputData___destroy___0'] = createExportWrapper('emscripten_bind_PxDefaultMemoryInputData___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDefaultMemoryOutputStream_PxDefaultMemoryOutputStream_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultMemoryOutputStream_PxDefaultMemoryOutputStream_0');
  _emscripten_bind_PxDefaultMemoryOutputStream_PxDefaultMemoryOutputStream_0 = Module['_emscripten_bind_PxDefaultMemoryOutputStream_PxDefaultMemoryOutputStream_0'] = createExportWrapper('emscripten_bind_PxDefaultMemoryOutputStream_PxDefaultMemoryOutputStream_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxDefaultMemoryOutputStream_write_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultMemoryOutputStream_write_2');
  _emscripten_bind_PxDefaultMemoryOutputStream_write_2 = Module['_emscripten_bind_PxDefaultMemoryOutputStream_write_2'] = createExportWrapper('emscripten_bind_PxDefaultMemoryOutputStream_write_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxDefaultMemoryOutputStream_getSize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultMemoryOutputStream_getSize_0');
  _emscripten_bind_PxDefaultMemoryOutputStream_getSize_0 = Module['_emscripten_bind_PxDefaultMemoryOutputStream_getSize_0'] = createExportWrapper('emscripten_bind_PxDefaultMemoryOutputStream_getSize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDefaultMemoryOutputStream_getData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultMemoryOutputStream_getData_0');
  _emscripten_bind_PxDefaultMemoryOutputStream_getData_0 = Module['_emscripten_bind_PxDefaultMemoryOutputStream_getData_0'] = createExportWrapper('emscripten_bind_PxDefaultMemoryOutputStream_getData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDefaultMemoryOutputStream___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDefaultMemoryOutputStream___destroy___0');
  _emscripten_bind_PxDefaultMemoryOutputStream___destroy___0 = Module['_emscripten_bind_PxDefaultMemoryOutputStream___destroy___0'] = createExportWrapper('emscripten_bind_PxDefaultMemoryOutputStream___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDim3_PxDim3_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDim3_PxDim3_0');
  _emscripten_bind_PxDim3_PxDim3_0 = Module['_emscripten_bind_PxDim3_PxDim3_0'] = createExportWrapper('emscripten_bind_PxDim3_PxDim3_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxDim3_get_x_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDim3_get_x_0');
  _emscripten_bind_PxDim3_get_x_0 = Module['_emscripten_bind_PxDim3_get_x_0'] = createExportWrapper('emscripten_bind_PxDim3_get_x_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDim3_set_x_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDim3_set_x_1');
  _emscripten_bind_PxDim3_set_x_1 = Module['_emscripten_bind_PxDim3_set_x_1'] = createExportWrapper('emscripten_bind_PxDim3_set_x_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDim3_get_y_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDim3_get_y_0');
  _emscripten_bind_PxDim3_get_y_0 = Module['_emscripten_bind_PxDim3_get_y_0'] = createExportWrapper('emscripten_bind_PxDim3_get_y_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDim3_set_y_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDim3_set_y_1');
  _emscripten_bind_PxDim3_set_y_1 = Module['_emscripten_bind_PxDim3_set_y_1'] = createExportWrapper('emscripten_bind_PxDim3_set_y_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDim3_get_z_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDim3_get_z_0');
  _emscripten_bind_PxDim3_get_z_0 = Module['_emscripten_bind_PxDim3_get_z_0'] = createExportWrapper('emscripten_bind_PxDim3_get_z_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDim3_set_z_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDim3_set_z_1');
  _emscripten_bind_PxDim3_set_z_1 = Module['_emscripten_bind_PxDim3_set_z_1'] = createExportWrapper('emscripten_bind_PxDim3_set_z_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDim3___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDim3___destroy___0');
  _emscripten_bind_PxDim3___destroy___0 = Module['_emscripten_bind_PxDim3___destroy___0'] = createExportWrapper('emscripten_bind_PxDim3___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getDistance_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getDistance_0');
  _emscripten_bind_PxDistanceJoint_getDistance_0 = Module['_emscripten_bind_PxDistanceJoint_getDistance_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getDistance_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setMinDistance_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setMinDistance_1');
  _emscripten_bind_PxDistanceJoint_setMinDistance_1 = Module['_emscripten_bind_PxDistanceJoint_setMinDistance_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setMinDistance_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getMinDistance_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getMinDistance_0');
  _emscripten_bind_PxDistanceJoint_getMinDistance_0 = Module['_emscripten_bind_PxDistanceJoint_getMinDistance_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getMinDistance_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setMaxDistance_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setMaxDistance_1');
  _emscripten_bind_PxDistanceJoint_setMaxDistance_1 = Module['_emscripten_bind_PxDistanceJoint_setMaxDistance_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setMaxDistance_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getMaxDistance_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getMaxDistance_0');
  _emscripten_bind_PxDistanceJoint_getMaxDistance_0 = Module['_emscripten_bind_PxDistanceJoint_getMaxDistance_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getMaxDistance_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setTolerance_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setTolerance_1');
  _emscripten_bind_PxDistanceJoint_setTolerance_1 = Module['_emscripten_bind_PxDistanceJoint_setTolerance_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setTolerance_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getTolerance_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getTolerance_0');
  _emscripten_bind_PxDistanceJoint_getTolerance_0 = Module['_emscripten_bind_PxDistanceJoint_getTolerance_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getTolerance_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setStiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setStiffness_1');
  _emscripten_bind_PxDistanceJoint_setStiffness_1 = Module['_emscripten_bind_PxDistanceJoint_setStiffness_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setStiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getStiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getStiffness_0');
  _emscripten_bind_PxDistanceJoint_getStiffness_0 = Module['_emscripten_bind_PxDistanceJoint_getStiffness_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getStiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setDamping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setDamping_1');
  _emscripten_bind_PxDistanceJoint_setDamping_1 = Module['_emscripten_bind_PxDistanceJoint_setDamping_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setDamping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getDamping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getDamping_0');
  _emscripten_bind_PxDistanceJoint_getDamping_0 = Module['_emscripten_bind_PxDistanceJoint_getDamping_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getDamping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setDistanceJointFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setDistanceJointFlags_1');
  _emscripten_bind_PxDistanceJoint_setDistanceJointFlags_1 = Module['_emscripten_bind_PxDistanceJoint_setDistanceJointFlags_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setDistanceJointFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setDistanceJointFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setDistanceJointFlag_2');
  _emscripten_bind_PxDistanceJoint_setDistanceJointFlag_2 = Module['_emscripten_bind_PxDistanceJoint_setDistanceJointFlag_2'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setDistanceJointFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getDistanceJointFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getDistanceJointFlags_0');
  _emscripten_bind_PxDistanceJoint_getDistanceJointFlags_0 = Module['_emscripten_bind_PxDistanceJoint_getDistanceJointFlags_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getDistanceJointFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_release_0');
  _emscripten_bind_PxDistanceJoint_release_0 = Module['_emscripten_bind_PxDistanceJoint_release_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getConcreteTypeName_0');
  _emscripten_bind_PxDistanceJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxDistanceJoint_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getConcreteType_0');
  _emscripten_bind_PxDistanceJoint_getConcreteType_0 = Module['_emscripten_bind_PxDistanceJoint_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setBaseFlag_2');
  _emscripten_bind_PxDistanceJoint_setBaseFlag_2 = Module['_emscripten_bind_PxDistanceJoint_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setBaseFlags_1');
  _emscripten_bind_PxDistanceJoint_setBaseFlags_1 = Module['_emscripten_bind_PxDistanceJoint_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getBaseFlags_0');
  _emscripten_bind_PxDistanceJoint_getBaseFlags_0 = Module['_emscripten_bind_PxDistanceJoint_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_isReleasable_0');
  _emscripten_bind_PxDistanceJoint_isReleasable_0 = Module['_emscripten_bind_PxDistanceJoint_isReleasable_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setActors_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setActors_2');
  _emscripten_bind_PxDistanceJoint_setActors_2 = Module['_emscripten_bind_PxDistanceJoint_setActors_2'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setActors_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setLocalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setLocalPose_2');
  _emscripten_bind_PxDistanceJoint_setLocalPose_2 = Module['_emscripten_bind_PxDistanceJoint_setLocalPose_2'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setLocalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getLocalPose_1');
  _emscripten_bind_PxDistanceJoint_getLocalPose_1 = Module['_emscripten_bind_PxDistanceJoint_getLocalPose_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getRelativeTransform_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getRelativeTransform_0');
  _emscripten_bind_PxDistanceJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxDistanceJoint_getRelativeTransform_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getRelativeTransform_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getRelativeLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getRelativeLinearVelocity_0');
  _emscripten_bind_PxDistanceJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxDistanceJoint_getRelativeLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getRelativeLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getRelativeAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getRelativeAngularVelocity_0');
  _emscripten_bind_PxDistanceJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxDistanceJoint_getRelativeAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getRelativeAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setBreakForce_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setBreakForce_2');
  _emscripten_bind_PxDistanceJoint_setBreakForce_2 = Module['_emscripten_bind_PxDistanceJoint_setBreakForce_2'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setBreakForce_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setConstraintFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setConstraintFlags_1');
  _emscripten_bind_PxDistanceJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxDistanceJoint_setConstraintFlags_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setConstraintFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setConstraintFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setConstraintFlag_2');
  _emscripten_bind_PxDistanceJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxDistanceJoint_setConstraintFlag_2'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setConstraintFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getConstraintFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getConstraintFlags_0');
  _emscripten_bind_PxDistanceJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxDistanceJoint_getConstraintFlags_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getConstraintFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setInvMassScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setInvMassScale0_1');
  _emscripten_bind_PxDistanceJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxDistanceJoint_setInvMassScale0_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setInvMassScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getInvMassScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getInvMassScale0_0');
  _emscripten_bind_PxDistanceJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxDistanceJoint_getInvMassScale0_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getInvMassScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setInvMassScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setInvMassScale1_1');
  _emscripten_bind_PxDistanceJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxDistanceJoint_setInvMassScale1_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setInvMassScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getInvMassScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getInvMassScale1_0');
  _emscripten_bind_PxDistanceJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxDistanceJoint_getInvMassScale1_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getInvMassScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setInvInertiaScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setInvInertiaScale0_1');
  _emscripten_bind_PxDistanceJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxDistanceJoint_setInvInertiaScale0_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setInvInertiaScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getInvInertiaScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getInvInertiaScale0_0');
  _emscripten_bind_PxDistanceJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxDistanceJoint_getInvInertiaScale0_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getInvInertiaScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setInvInertiaScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setInvInertiaScale1_1');
  _emscripten_bind_PxDistanceJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxDistanceJoint_setInvInertiaScale1_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setInvInertiaScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getInvInertiaScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getInvInertiaScale1_0');
  _emscripten_bind_PxDistanceJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxDistanceJoint_getInvInertiaScale1_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getInvInertiaScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getConstraint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getConstraint_0');
  _emscripten_bind_PxDistanceJoint_getConstraint_0 = Module['_emscripten_bind_PxDistanceJoint_getConstraint_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getConstraint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_setName_1');
  _emscripten_bind_PxDistanceJoint_setName_1 = Module['_emscripten_bind_PxDistanceJoint_setName_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getName_0');
  _emscripten_bind_PxDistanceJoint_getName_0 = Module['_emscripten_bind_PxDistanceJoint_getName_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_getScene_0');
  _emscripten_bind_PxDistanceJoint_getScene_0 = Module['_emscripten_bind_PxDistanceJoint_getScene_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_get_userData_0');
  _emscripten_bind_PxDistanceJoint_get_userData_0 = Module['_emscripten_bind_PxDistanceJoint_get_userData_0'] = createExportWrapper('emscripten_bind_PxDistanceJoint_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint_set_userData_1');
  _emscripten_bind_PxDistanceJoint_set_userData_1 = Module['_emscripten_bind_PxDistanceJoint_set_userData_1'] = createExportWrapper('emscripten_bind_PxDistanceJoint_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJoint___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJoint___destroy___0');
  _emscripten_bind_PxDistanceJoint___destroy___0 = Module['_emscripten_bind_PxDistanceJoint___destroy___0'] = createExportWrapper('emscripten_bind_PxDistanceJoint___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJointFlags_PxDistanceJointFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJointFlags_PxDistanceJointFlags_1');
  _emscripten_bind_PxDistanceJointFlags_PxDistanceJointFlags_1 = Module['_emscripten_bind_PxDistanceJointFlags_PxDistanceJointFlags_1'] = createExportWrapper('emscripten_bind_PxDistanceJointFlags_PxDistanceJointFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJointFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJointFlags_isSet_1');
  _emscripten_bind_PxDistanceJointFlags_isSet_1 = Module['_emscripten_bind_PxDistanceJointFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxDistanceJointFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJointFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJointFlags_raise_1');
  _emscripten_bind_PxDistanceJointFlags_raise_1 = Module['_emscripten_bind_PxDistanceJointFlags_raise_1'] = createExportWrapper('emscripten_bind_PxDistanceJointFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJointFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJointFlags_clear_1');
  _emscripten_bind_PxDistanceJointFlags_clear_1 = Module['_emscripten_bind_PxDistanceJointFlags_clear_1'] = createExportWrapper('emscripten_bind_PxDistanceJointFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDistanceJointFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDistanceJointFlags___destroy___0');
  _emscripten_bind_PxDistanceJointFlags___destroy___0 = Module['_emscripten_bind_PxDistanceJointFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxDistanceJointFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDominanceGroupPair_PxDominanceGroupPair_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDominanceGroupPair_PxDominanceGroupPair_2');
  _emscripten_bind_PxDominanceGroupPair_PxDominanceGroupPair_2 = Module['_emscripten_bind_PxDominanceGroupPair_PxDominanceGroupPair_2'] = createExportWrapper('emscripten_bind_PxDominanceGroupPair_PxDominanceGroupPair_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxDominanceGroupPair_get_dominance0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDominanceGroupPair_get_dominance0_0');
  _emscripten_bind_PxDominanceGroupPair_get_dominance0_0 = Module['_emscripten_bind_PxDominanceGroupPair_get_dominance0_0'] = createExportWrapper('emscripten_bind_PxDominanceGroupPair_get_dominance0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDominanceGroupPair_set_dominance0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDominanceGroupPair_set_dominance0_1');
  _emscripten_bind_PxDominanceGroupPair_set_dominance0_1 = Module['_emscripten_bind_PxDominanceGroupPair_set_dominance0_1'] = createExportWrapper('emscripten_bind_PxDominanceGroupPair_set_dominance0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDominanceGroupPair_get_dominance1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDominanceGroupPair_get_dominance1_0');
  _emscripten_bind_PxDominanceGroupPair_get_dominance1_0 = Module['_emscripten_bind_PxDominanceGroupPair_get_dominance1_0'] = createExportWrapper('emscripten_bind_PxDominanceGroupPair_get_dominance1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxDominanceGroupPair_set_dominance1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDominanceGroupPair_set_dominance1_1');
  _emscripten_bind_PxDominanceGroupPair_set_dominance1_1 = Module['_emscripten_bind_PxDominanceGroupPair_set_dominance1_1'] = createExportWrapper('emscripten_bind_PxDominanceGroupPair_set_dominance1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxDominanceGroupPair___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxDominanceGroupPair___destroy___0');
  _emscripten_bind_PxDominanceGroupPair___destroy___0 = Module['_emscripten_bind_PxDominanceGroupPair___destroy___0'] = createExportWrapper('emscripten_bind_PxDominanceGroupPair___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxErrorCallbackImpl_PxErrorCallbackImpl_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxErrorCallbackImpl_PxErrorCallbackImpl_0');
  _emscripten_bind_PxErrorCallbackImpl_PxErrorCallbackImpl_0 = Module['_emscripten_bind_PxErrorCallbackImpl_PxErrorCallbackImpl_0'] = createExportWrapper('emscripten_bind_PxErrorCallbackImpl_PxErrorCallbackImpl_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxErrorCallbackImpl_reportError_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxErrorCallbackImpl_reportError_4');
  _emscripten_bind_PxErrorCallbackImpl_reportError_4 = Module['_emscripten_bind_PxErrorCallbackImpl_reportError_4'] = createExportWrapper('emscripten_bind_PxErrorCallbackImpl_reportError_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxErrorCallbackImpl___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxErrorCallbackImpl___destroy___0');
  _emscripten_bind_PxErrorCallbackImpl___destroy___0 = Module['_emscripten_bind_PxErrorCallbackImpl___destroy___0'] = createExportWrapper('emscripten_bind_PxErrorCallbackImpl___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxExtendedVec3_PxExtendedVec3_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxExtendedVec3_PxExtendedVec3_0');
  _emscripten_bind_PxExtendedVec3_PxExtendedVec3_0 = Module['_emscripten_bind_PxExtendedVec3_PxExtendedVec3_0'] = createExportWrapper('emscripten_bind_PxExtendedVec3_PxExtendedVec3_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxExtendedVec3_PxExtendedVec3_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxExtendedVec3_PxExtendedVec3_3');
  _emscripten_bind_PxExtendedVec3_PxExtendedVec3_3 = Module['_emscripten_bind_PxExtendedVec3_PxExtendedVec3_3'] = createExportWrapper('emscripten_bind_PxExtendedVec3_PxExtendedVec3_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxExtendedVec3_get_x_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxExtendedVec3_get_x_0');
  _emscripten_bind_PxExtendedVec3_get_x_0 = Module['_emscripten_bind_PxExtendedVec3_get_x_0'] = createExportWrapper('emscripten_bind_PxExtendedVec3_get_x_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxExtendedVec3_set_x_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxExtendedVec3_set_x_1');
  _emscripten_bind_PxExtendedVec3_set_x_1 = Module['_emscripten_bind_PxExtendedVec3_set_x_1'] = createExportWrapper('emscripten_bind_PxExtendedVec3_set_x_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxExtendedVec3_get_y_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxExtendedVec3_get_y_0');
  _emscripten_bind_PxExtendedVec3_get_y_0 = Module['_emscripten_bind_PxExtendedVec3_get_y_0'] = createExportWrapper('emscripten_bind_PxExtendedVec3_get_y_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxExtendedVec3_set_y_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxExtendedVec3_set_y_1');
  _emscripten_bind_PxExtendedVec3_set_y_1 = Module['_emscripten_bind_PxExtendedVec3_set_y_1'] = createExportWrapper('emscripten_bind_PxExtendedVec3_set_y_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxExtendedVec3_get_z_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxExtendedVec3_get_z_0');
  _emscripten_bind_PxExtendedVec3_get_z_0 = Module['_emscripten_bind_PxExtendedVec3_get_z_0'] = createExportWrapper('emscripten_bind_PxExtendedVec3_get_z_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxExtendedVec3_set_z_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxExtendedVec3_set_z_1');
  _emscripten_bind_PxExtendedVec3_set_z_1 = Module['_emscripten_bind_PxExtendedVec3_set_z_1'] = createExportWrapper('emscripten_bind_PxExtendedVec3_set_z_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxExtendedVec3___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxExtendedVec3___destroy___0');
  _emscripten_bind_PxExtendedVec3___destroy___0 = Module['_emscripten_bind_PxExtendedVec3___destroy___0'] = createExportWrapper('emscripten_bind_PxExtendedVec3___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxExtensionTopLevelFunctions_CreatePlane_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxExtensionTopLevelFunctions_CreatePlane_4');
  _emscripten_bind_PxExtensionTopLevelFunctions_CreatePlane_4 = Module['_emscripten_bind_PxExtensionTopLevelFunctions_CreatePlane_4'] = createExportWrapper('emscripten_bind_PxExtensionTopLevelFunctions_CreatePlane_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxFilterData_PxFilterData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFilterData_PxFilterData_0');
  _emscripten_bind_PxFilterData_PxFilterData_0 = Module['_emscripten_bind_PxFilterData_PxFilterData_0'] = createExportWrapper('emscripten_bind_PxFilterData_PxFilterData_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxFilterData_PxFilterData_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFilterData_PxFilterData_4');
  _emscripten_bind_PxFilterData_PxFilterData_4 = Module['_emscripten_bind_PxFilterData_PxFilterData_4'] = createExportWrapper('emscripten_bind_PxFilterData_PxFilterData_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxFilterData_get_word0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFilterData_get_word0_0');
  _emscripten_bind_PxFilterData_get_word0_0 = Module['_emscripten_bind_PxFilterData_get_word0_0'] = createExportWrapper('emscripten_bind_PxFilterData_get_word0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFilterData_set_word0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFilterData_set_word0_1');
  _emscripten_bind_PxFilterData_set_word0_1 = Module['_emscripten_bind_PxFilterData_set_word0_1'] = createExportWrapper('emscripten_bind_PxFilterData_set_word0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxFilterData_get_word1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFilterData_get_word1_0');
  _emscripten_bind_PxFilterData_get_word1_0 = Module['_emscripten_bind_PxFilterData_get_word1_0'] = createExportWrapper('emscripten_bind_PxFilterData_get_word1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFilterData_set_word1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFilterData_set_word1_1');
  _emscripten_bind_PxFilterData_set_word1_1 = Module['_emscripten_bind_PxFilterData_set_word1_1'] = createExportWrapper('emscripten_bind_PxFilterData_set_word1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxFilterData_get_word2_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFilterData_get_word2_0');
  _emscripten_bind_PxFilterData_get_word2_0 = Module['_emscripten_bind_PxFilterData_get_word2_0'] = createExportWrapper('emscripten_bind_PxFilterData_get_word2_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFilterData_set_word2_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFilterData_set_word2_1');
  _emscripten_bind_PxFilterData_set_word2_1 = Module['_emscripten_bind_PxFilterData_set_word2_1'] = createExportWrapper('emscripten_bind_PxFilterData_set_word2_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxFilterData_get_word3_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFilterData_get_word3_0');
  _emscripten_bind_PxFilterData_get_word3_0 = Module['_emscripten_bind_PxFilterData_get_word3_0'] = createExportWrapper('emscripten_bind_PxFilterData_get_word3_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFilterData_set_word3_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFilterData_set_word3_1');
  _emscripten_bind_PxFilterData_set_word3_1 = Module['_emscripten_bind_PxFilterData_set_word3_1'] = createExportWrapper('emscripten_bind_PxFilterData_set_word3_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxFilterData___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFilterData___destroy___0');
  _emscripten_bind_PxFilterData___destroy___0 = Module['_emscripten_bind_PxFilterData___destroy___0'] = createExportWrapper('emscripten_bind_PxFilterData___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_release_0');
  _emscripten_bind_PxFixedJoint_release_0 = Module['_emscripten_bind_PxFixedJoint_release_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getConcreteTypeName_0');
  _emscripten_bind_PxFixedJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxFixedJoint_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getConcreteType_0');
  _emscripten_bind_PxFixedJoint_getConcreteType_0 = Module['_emscripten_bind_PxFixedJoint_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_setBaseFlag_2');
  _emscripten_bind_PxFixedJoint_setBaseFlag_2 = Module['_emscripten_bind_PxFixedJoint_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxFixedJoint_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_setBaseFlags_1');
  _emscripten_bind_PxFixedJoint_setBaseFlags_1 = Module['_emscripten_bind_PxFixedJoint_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxFixedJoint_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getBaseFlags_0');
  _emscripten_bind_PxFixedJoint_getBaseFlags_0 = Module['_emscripten_bind_PxFixedJoint_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_isReleasable_0');
  _emscripten_bind_PxFixedJoint_isReleasable_0 = Module['_emscripten_bind_PxFixedJoint_isReleasable_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_setActors_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_setActors_2');
  _emscripten_bind_PxFixedJoint_setActors_2 = Module['_emscripten_bind_PxFixedJoint_setActors_2'] = createExportWrapper('emscripten_bind_PxFixedJoint_setActors_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_setLocalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_setLocalPose_2');
  _emscripten_bind_PxFixedJoint_setLocalPose_2 = Module['_emscripten_bind_PxFixedJoint_setLocalPose_2'] = createExportWrapper('emscripten_bind_PxFixedJoint_setLocalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getLocalPose_1');
  _emscripten_bind_PxFixedJoint_getLocalPose_1 = Module['_emscripten_bind_PxFixedJoint_getLocalPose_1'] = createExportWrapper('emscripten_bind_PxFixedJoint_getLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getRelativeTransform_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getRelativeTransform_0');
  _emscripten_bind_PxFixedJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxFixedJoint_getRelativeTransform_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_getRelativeTransform_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getRelativeLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getRelativeLinearVelocity_0');
  _emscripten_bind_PxFixedJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxFixedJoint_getRelativeLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_getRelativeLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getRelativeAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getRelativeAngularVelocity_0');
  _emscripten_bind_PxFixedJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxFixedJoint_getRelativeAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_getRelativeAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_setBreakForce_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_setBreakForce_2');
  _emscripten_bind_PxFixedJoint_setBreakForce_2 = Module['_emscripten_bind_PxFixedJoint_setBreakForce_2'] = createExportWrapper('emscripten_bind_PxFixedJoint_setBreakForce_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_setConstraintFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_setConstraintFlags_1');
  _emscripten_bind_PxFixedJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxFixedJoint_setConstraintFlags_1'] = createExportWrapper('emscripten_bind_PxFixedJoint_setConstraintFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_setConstraintFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_setConstraintFlag_2');
  _emscripten_bind_PxFixedJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxFixedJoint_setConstraintFlag_2'] = createExportWrapper('emscripten_bind_PxFixedJoint_setConstraintFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getConstraintFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getConstraintFlags_0');
  _emscripten_bind_PxFixedJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxFixedJoint_getConstraintFlags_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_getConstraintFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_setInvMassScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_setInvMassScale0_1');
  _emscripten_bind_PxFixedJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxFixedJoint_setInvMassScale0_1'] = createExportWrapper('emscripten_bind_PxFixedJoint_setInvMassScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getInvMassScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getInvMassScale0_0');
  _emscripten_bind_PxFixedJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxFixedJoint_getInvMassScale0_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_getInvMassScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_setInvMassScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_setInvMassScale1_1');
  _emscripten_bind_PxFixedJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxFixedJoint_setInvMassScale1_1'] = createExportWrapper('emscripten_bind_PxFixedJoint_setInvMassScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getInvMassScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getInvMassScale1_0');
  _emscripten_bind_PxFixedJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxFixedJoint_getInvMassScale1_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_getInvMassScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_setInvInertiaScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_setInvInertiaScale0_1');
  _emscripten_bind_PxFixedJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxFixedJoint_setInvInertiaScale0_1'] = createExportWrapper('emscripten_bind_PxFixedJoint_setInvInertiaScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getInvInertiaScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getInvInertiaScale0_0');
  _emscripten_bind_PxFixedJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxFixedJoint_getInvInertiaScale0_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_getInvInertiaScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_setInvInertiaScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_setInvInertiaScale1_1');
  _emscripten_bind_PxFixedJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxFixedJoint_setInvInertiaScale1_1'] = createExportWrapper('emscripten_bind_PxFixedJoint_setInvInertiaScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getInvInertiaScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getInvInertiaScale1_0');
  _emscripten_bind_PxFixedJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxFixedJoint_getInvInertiaScale1_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_getInvInertiaScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getConstraint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getConstraint_0');
  _emscripten_bind_PxFixedJoint_getConstraint_0 = Module['_emscripten_bind_PxFixedJoint_getConstraint_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_getConstraint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_setName_1');
  _emscripten_bind_PxFixedJoint_setName_1 = Module['_emscripten_bind_PxFixedJoint_setName_1'] = createExportWrapper('emscripten_bind_PxFixedJoint_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getName_0');
  _emscripten_bind_PxFixedJoint_getName_0 = Module['_emscripten_bind_PxFixedJoint_getName_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_getScene_0');
  _emscripten_bind_PxFixedJoint_getScene_0 = Module['_emscripten_bind_PxFixedJoint_getScene_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_get_userData_0');
  _emscripten_bind_PxFixedJoint_get_userData_0 = Module['_emscripten_bind_PxFixedJoint_get_userData_0'] = createExportWrapper('emscripten_bind_PxFixedJoint_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint_set_userData_1');
  _emscripten_bind_PxFixedJoint_set_userData_1 = Module['_emscripten_bind_PxFixedJoint_set_userData_1'] = createExportWrapper('emscripten_bind_PxFixedJoint_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxFixedJoint___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFixedJoint___destroy___0');
  _emscripten_bind_PxFixedJoint___destroy___0 = Module['_emscripten_bind_PxFixedJoint___destroy___0'] = createExportWrapper('emscripten_bind_PxFixedJoint___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxFoundation_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxFoundation_release_0');
  _emscripten_bind_PxFoundation_release_0 = Module['_emscripten_bind_PxFoundation_release_0'] = createExportWrapper('emscripten_bind_PxFoundation_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_setHinges_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_setHinges_2');
  _emscripten_bind_PxGearJoint_setHinges_2 = Module['_emscripten_bind_PxGearJoint_setHinges_2'] = createExportWrapper('emscripten_bind_PxGearJoint_setHinges_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_setGearRatio_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_setGearRatio_1');
  _emscripten_bind_PxGearJoint_setGearRatio_1 = Module['_emscripten_bind_PxGearJoint_setGearRatio_1'] = createExportWrapper('emscripten_bind_PxGearJoint_setGearRatio_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getGearRatio_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getGearRatio_0');
  _emscripten_bind_PxGearJoint_getGearRatio_0 = Module['_emscripten_bind_PxGearJoint_getGearRatio_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getGearRatio_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_release_0');
  _emscripten_bind_PxGearJoint_release_0 = Module['_emscripten_bind_PxGearJoint_release_0'] = createExportWrapper('emscripten_bind_PxGearJoint_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getConcreteTypeName_0');
  _emscripten_bind_PxGearJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxGearJoint_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getConcreteType_0');
  _emscripten_bind_PxGearJoint_getConcreteType_0 = Module['_emscripten_bind_PxGearJoint_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_setBaseFlag_2');
  _emscripten_bind_PxGearJoint_setBaseFlag_2 = Module['_emscripten_bind_PxGearJoint_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxGearJoint_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_setBaseFlags_1');
  _emscripten_bind_PxGearJoint_setBaseFlags_1 = Module['_emscripten_bind_PxGearJoint_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxGearJoint_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getBaseFlags_0');
  _emscripten_bind_PxGearJoint_getBaseFlags_0 = Module['_emscripten_bind_PxGearJoint_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_isReleasable_0');
  _emscripten_bind_PxGearJoint_isReleasable_0 = Module['_emscripten_bind_PxGearJoint_isReleasable_0'] = createExportWrapper('emscripten_bind_PxGearJoint_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_setActors_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_setActors_2');
  _emscripten_bind_PxGearJoint_setActors_2 = Module['_emscripten_bind_PxGearJoint_setActors_2'] = createExportWrapper('emscripten_bind_PxGearJoint_setActors_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_setLocalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_setLocalPose_2');
  _emscripten_bind_PxGearJoint_setLocalPose_2 = Module['_emscripten_bind_PxGearJoint_setLocalPose_2'] = createExportWrapper('emscripten_bind_PxGearJoint_setLocalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getLocalPose_1');
  _emscripten_bind_PxGearJoint_getLocalPose_1 = Module['_emscripten_bind_PxGearJoint_getLocalPose_1'] = createExportWrapper('emscripten_bind_PxGearJoint_getLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getRelativeTransform_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getRelativeTransform_0');
  _emscripten_bind_PxGearJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxGearJoint_getRelativeTransform_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getRelativeTransform_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getRelativeLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getRelativeLinearVelocity_0');
  _emscripten_bind_PxGearJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxGearJoint_getRelativeLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getRelativeLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getRelativeAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getRelativeAngularVelocity_0');
  _emscripten_bind_PxGearJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxGearJoint_getRelativeAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getRelativeAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_setBreakForce_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_setBreakForce_2');
  _emscripten_bind_PxGearJoint_setBreakForce_2 = Module['_emscripten_bind_PxGearJoint_setBreakForce_2'] = createExportWrapper('emscripten_bind_PxGearJoint_setBreakForce_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_setConstraintFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_setConstraintFlags_1');
  _emscripten_bind_PxGearJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxGearJoint_setConstraintFlags_1'] = createExportWrapper('emscripten_bind_PxGearJoint_setConstraintFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_setConstraintFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_setConstraintFlag_2');
  _emscripten_bind_PxGearJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxGearJoint_setConstraintFlag_2'] = createExportWrapper('emscripten_bind_PxGearJoint_setConstraintFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getConstraintFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getConstraintFlags_0');
  _emscripten_bind_PxGearJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxGearJoint_getConstraintFlags_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getConstraintFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_setInvMassScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_setInvMassScale0_1');
  _emscripten_bind_PxGearJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxGearJoint_setInvMassScale0_1'] = createExportWrapper('emscripten_bind_PxGearJoint_setInvMassScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getInvMassScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getInvMassScale0_0');
  _emscripten_bind_PxGearJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxGearJoint_getInvMassScale0_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getInvMassScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_setInvMassScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_setInvMassScale1_1');
  _emscripten_bind_PxGearJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxGearJoint_setInvMassScale1_1'] = createExportWrapper('emscripten_bind_PxGearJoint_setInvMassScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getInvMassScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getInvMassScale1_0');
  _emscripten_bind_PxGearJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxGearJoint_getInvMassScale1_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getInvMassScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_setInvInertiaScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_setInvInertiaScale0_1');
  _emscripten_bind_PxGearJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxGearJoint_setInvInertiaScale0_1'] = createExportWrapper('emscripten_bind_PxGearJoint_setInvInertiaScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getInvInertiaScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getInvInertiaScale0_0');
  _emscripten_bind_PxGearJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxGearJoint_getInvInertiaScale0_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getInvInertiaScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_setInvInertiaScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_setInvInertiaScale1_1');
  _emscripten_bind_PxGearJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxGearJoint_setInvInertiaScale1_1'] = createExportWrapper('emscripten_bind_PxGearJoint_setInvInertiaScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getInvInertiaScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getInvInertiaScale1_0');
  _emscripten_bind_PxGearJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxGearJoint_getInvInertiaScale1_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getInvInertiaScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getConstraint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getConstraint_0');
  _emscripten_bind_PxGearJoint_getConstraint_0 = Module['_emscripten_bind_PxGearJoint_getConstraint_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getConstraint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_setName_1');
  _emscripten_bind_PxGearJoint_setName_1 = Module['_emscripten_bind_PxGearJoint_setName_1'] = createExportWrapper('emscripten_bind_PxGearJoint_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getName_0');
  _emscripten_bind_PxGearJoint_getName_0 = Module['_emscripten_bind_PxGearJoint_getName_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_getScene_0');
  _emscripten_bind_PxGearJoint_getScene_0 = Module['_emscripten_bind_PxGearJoint_getScene_0'] = createExportWrapper('emscripten_bind_PxGearJoint_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_get_userData_0');
  _emscripten_bind_PxGearJoint_get_userData_0 = Module['_emscripten_bind_PxGearJoint_get_userData_0'] = createExportWrapper('emscripten_bind_PxGearJoint_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint_set_userData_1');
  _emscripten_bind_PxGearJoint_set_userData_1 = Module['_emscripten_bind_PxGearJoint_set_userData_1'] = createExportWrapper('emscripten_bind_PxGearJoint_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGearJoint___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGearJoint___destroy___0');
  _emscripten_bind_PxGearJoint___destroy___0 = Module['_emscripten_bind_PxGearJoint___destroy___0'] = createExportWrapper('emscripten_bind_PxGearJoint___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeometryHolder_PxGeometryHolder_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryHolder_PxGeometryHolder_0');
  _emscripten_bind_PxGeometryHolder_PxGeometryHolder_0 = Module['_emscripten_bind_PxGeometryHolder_PxGeometryHolder_0'] = createExportWrapper('emscripten_bind_PxGeometryHolder_PxGeometryHolder_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxGeometryHolder_PxGeometryHolder_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryHolder_PxGeometryHolder_1');
  _emscripten_bind_PxGeometryHolder_PxGeometryHolder_1 = Module['_emscripten_bind_PxGeometryHolder_PxGeometryHolder_1'] = createExportWrapper('emscripten_bind_PxGeometryHolder_PxGeometryHolder_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeometryHolder_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryHolder_getType_0');
  _emscripten_bind_PxGeometryHolder_getType_0 = Module['_emscripten_bind_PxGeometryHolder_getType_0'] = createExportWrapper('emscripten_bind_PxGeometryHolder_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeometryHolder_sphere_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryHolder_sphere_0');
  _emscripten_bind_PxGeometryHolder_sphere_0 = Module['_emscripten_bind_PxGeometryHolder_sphere_0'] = createExportWrapper('emscripten_bind_PxGeometryHolder_sphere_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeometryHolder_plane_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryHolder_plane_0');
  _emscripten_bind_PxGeometryHolder_plane_0 = Module['_emscripten_bind_PxGeometryHolder_plane_0'] = createExportWrapper('emscripten_bind_PxGeometryHolder_plane_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeometryHolder_capsule_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryHolder_capsule_0');
  _emscripten_bind_PxGeometryHolder_capsule_0 = Module['_emscripten_bind_PxGeometryHolder_capsule_0'] = createExportWrapper('emscripten_bind_PxGeometryHolder_capsule_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeometryHolder_box_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryHolder_box_0');
  _emscripten_bind_PxGeometryHolder_box_0 = Module['_emscripten_bind_PxGeometryHolder_box_0'] = createExportWrapper('emscripten_bind_PxGeometryHolder_box_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeometryHolder_convexMesh_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryHolder_convexMesh_0');
  _emscripten_bind_PxGeometryHolder_convexMesh_0 = Module['_emscripten_bind_PxGeometryHolder_convexMesh_0'] = createExportWrapper('emscripten_bind_PxGeometryHolder_convexMesh_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeometryHolder_triangleMesh_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryHolder_triangleMesh_0');
  _emscripten_bind_PxGeometryHolder_triangleMesh_0 = Module['_emscripten_bind_PxGeometryHolder_triangleMesh_0'] = createExportWrapper('emscripten_bind_PxGeometryHolder_triangleMesh_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeometryHolder_heightField_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryHolder_heightField_0');
  _emscripten_bind_PxGeometryHolder_heightField_0 = Module['_emscripten_bind_PxGeometryHolder_heightField_0'] = createExportWrapper('emscripten_bind_PxGeometryHolder_heightField_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeometryHolder_storeAny_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryHolder_storeAny_1');
  _emscripten_bind_PxGeometryHolder_storeAny_1 = Module['_emscripten_bind_PxGeometryHolder_storeAny_1'] = createExportWrapper('emscripten_bind_PxGeometryHolder_storeAny_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGeometryHolder___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryHolder___destroy___0');
  _emscripten_bind_PxGeometryHolder___destroy___0 = Module['_emscripten_bind_PxGeometryHolder___destroy___0'] = createExportWrapper('emscripten_bind_PxGeometryHolder___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeometryQuery_sweep_7'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryQuery_sweep_7');
  _emscripten_bind_PxGeometryQuery_sweep_7 = Module['_emscripten_bind_PxGeometryQuery_sweep_7'] = createExportWrapper('emscripten_bind_PxGeometryQuery_sweep_7', 7);
  assert(typeof wasmExports['emscripten_bind_PxGeometryQuery_sweep_8'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryQuery_sweep_8');
  _emscripten_bind_PxGeometryQuery_sweep_8 = Module['_emscripten_bind_PxGeometryQuery_sweep_8'] = createExportWrapper('emscripten_bind_PxGeometryQuery_sweep_8', 8);
  assert(typeof wasmExports['emscripten_bind_PxGeometryQuery_sweep_9'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryQuery_sweep_9');
  _emscripten_bind_PxGeometryQuery_sweep_9 = Module['_emscripten_bind_PxGeometryQuery_sweep_9'] = createExportWrapper('emscripten_bind_PxGeometryQuery_sweep_9', 9);
  assert(typeof wasmExports['emscripten_bind_PxGeometryQuery_overlap_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryQuery_overlap_4');
  _emscripten_bind_PxGeometryQuery_overlap_4 = Module['_emscripten_bind_PxGeometryQuery_overlap_4'] = createExportWrapper('emscripten_bind_PxGeometryQuery_overlap_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxGeometryQuery_raycast_8'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryQuery_raycast_8');
  _emscripten_bind_PxGeometryQuery_raycast_8 = Module['_emscripten_bind_PxGeometryQuery_raycast_8'] = createExportWrapper('emscripten_bind_PxGeometryQuery_raycast_8', 8);
  assert(typeof wasmExports['emscripten_bind_PxGeometryQuery_pointDistance_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryQuery_pointDistance_3');
  _emscripten_bind_PxGeometryQuery_pointDistance_3 = Module['_emscripten_bind_PxGeometryQuery_pointDistance_3'] = createExportWrapper('emscripten_bind_PxGeometryQuery_pointDistance_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxGeometryQuery_pointDistance_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryQuery_pointDistance_4');
  _emscripten_bind_PxGeometryQuery_pointDistance_4 = Module['_emscripten_bind_PxGeometryQuery_pointDistance_4'] = createExportWrapper('emscripten_bind_PxGeometryQuery_pointDistance_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxGeometryQuery_computeGeomBounds_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryQuery_computeGeomBounds_3');
  _emscripten_bind_PxGeometryQuery_computeGeomBounds_3 = Module['_emscripten_bind_PxGeometryQuery_computeGeomBounds_3'] = createExportWrapper('emscripten_bind_PxGeometryQuery_computeGeomBounds_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxGeometryQuery_computeGeomBounds_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryQuery_computeGeomBounds_4');
  _emscripten_bind_PxGeometryQuery_computeGeomBounds_4 = Module['_emscripten_bind_PxGeometryQuery_computeGeomBounds_4'] = createExportWrapper('emscripten_bind_PxGeometryQuery_computeGeomBounds_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxGeometryQuery_isValid_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryQuery_isValid_1');
  _emscripten_bind_PxGeometryQuery_isValid_1 = Module['_emscripten_bind_PxGeometryQuery_isValid_1'] = createExportWrapper('emscripten_bind_PxGeometryQuery_isValid_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxGeometryQuery___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGeometryQuery___destroy___0');
  _emscripten_bind_PxGeometryQuery___destroy___0 = Module['_emscripten_bind_PxGeometryQuery___destroy___0'] = createExportWrapper('emscripten_bind_PxGeometryQuery___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuery_proximityInfo_7'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuery_proximityInfo_7');
  _emscripten_bind_PxGjkQuery_proximityInfo_7 = Module['_emscripten_bind_PxGjkQuery_proximityInfo_7'] = createExportWrapper('emscripten_bind_PxGjkQuery_proximityInfo_7', 7);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuery_raycast_6'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuery_raycast_6');
  _emscripten_bind_PxGjkQuery_raycast_6 = Module['_emscripten_bind_PxGjkQuery_raycast_6'] = createExportWrapper('emscripten_bind_PxGjkQuery_raycast_6', 6);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuery_overlap_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuery_overlap_4');
  _emscripten_bind_PxGjkQuery_overlap_4 = Module['_emscripten_bind_PxGjkQuery_overlap_4'] = createExportWrapper('emscripten_bind_PxGjkQuery_overlap_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuery_sweep_7'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuery_sweep_7');
  _emscripten_bind_PxGjkQuery_sweep_7 = Module['_emscripten_bind_PxGjkQuery_sweep_7'] = createExportWrapper('emscripten_bind_PxGjkQuery_sweep_7', 7);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuery___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuery___destroy___0');
  _emscripten_bind_PxGjkQuery___destroy___0 = Module['_emscripten_bind_PxGjkQuery___destroy___0'] = createExportWrapper('emscripten_bind_PxGjkQuery___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryExt_generateContacts_7'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryExt_generateContacts_7');
  _emscripten_bind_PxGjkQueryExt_generateContacts_7 = Module['_emscripten_bind_PxGjkQueryExt_generateContacts_7'] = createExportWrapper('emscripten_bind_PxGjkQueryExt_generateContacts_7', 7);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryExt___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryExt___destroy___0');
  _emscripten_bind_PxGjkQueryExt___destroy___0 = Module['_emscripten_bind_PxGjkQueryExt___destroy___0'] = createExportWrapper('emscripten_bind_PxGjkQueryExt___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryProximityInfoResult_PxGjkQueryProximityInfoResult_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryProximityInfoResult_PxGjkQueryProximityInfoResult_0');
  _emscripten_bind_PxGjkQueryProximityInfoResult_PxGjkQueryProximityInfoResult_0 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_PxGjkQueryProximityInfoResult_0'] = createExportWrapper('emscripten_bind_PxGjkQueryProximityInfoResult_PxGjkQueryProximityInfoResult_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryProximityInfoResult_get_success_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryProximityInfoResult_get_success_0');
  _emscripten_bind_PxGjkQueryProximityInfoResult_get_success_0 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_get_success_0'] = createExportWrapper('emscripten_bind_PxGjkQueryProximityInfoResult_get_success_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryProximityInfoResult_set_success_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryProximityInfoResult_set_success_1');
  _emscripten_bind_PxGjkQueryProximityInfoResult_set_success_1 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_set_success_1'] = createExportWrapper('emscripten_bind_PxGjkQueryProximityInfoResult_set_success_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryProximityInfoResult_get_pointA_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryProximityInfoResult_get_pointA_0');
  _emscripten_bind_PxGjkQueryProximityInfoResult_get_pointA_0 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_get_pointA_0'] = createExportWrapper('emscripten_bind_PxGjkQueryProximityInfoResult_get_pointA_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryProximityInfoResult_set_pointA_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryProximityInfoResult_set_pointA_1');
  _emscripten_bind_PxGjkQueryProximityInfoResult_set_pointA_1 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_set_pointA_1'] = createExportWrapper('emscripten_bind_PxGjkQueryProximityInfoResult_set_pointA_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryProximityInfoResult_get_pointB_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryProximityInfoResult_get_pointB_0');
  _emscripten_bind_PxGjkQueryProximityInfoResult_get_pointB_0 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_get_pointB_0'] = createExportWrapper('emscripten_bind_PxGjkQueryProximityInfoResult_get_pointB_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryProximityInfoResult_set_pointB_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryProximityInfoResult_set_pointB_1');
  _emscripten_bind_PxGjkQueryProximityInfoResult_set_pointB_1 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_set_pointB_1'] = createExportWrapper('emscripten_bind_PxGjkQueryProximityInfoResult_set_pointB_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryProximityInfoResult_get_separatingAxis_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryProximityInfoResult_get_separatingAxis_0');
  _emscripten_bind_PxGjkQueryProximityInfoResult_get_separatingAxis_0 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_get_separatingAxis_0'] = createExportWrapper('emscripten_bind_PxGjkQueryProximityInfoResult_get_separatingAxis_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryProximityInfoResult_set_separatingAxis_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryProximityInfoResult_set_separatingAxis_1');
  _emscripten_bind_PxGjkQueryProximityInfoResult_set_separatingAxis_1 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_set_separatingAxis_1'] = createExportWrapper('emscripten_bind_PxGjkQueryProximityInfoResult_set_separatingAxis_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryProximityInfoResult_get_separation_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryProximityInfoResult_get_separation_0');
  _emscripten_bind_PxGjkQueryProximityInfoResult_get_separation_0 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_get_separation_0'] = createExportWrapper('emscripten_bind_PxGjkQueryProximityInfoResult_get_separation_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryProximityInfoResult_set_separation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryProximityInfoResult_set_separation_1');
  _emscripten_bind_PxGjkQueryProximityInfoResult_set_separation_1 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult_set_separation_1'] = createExportWrapper('emscripten_bind_PxGjkQueryProximityInfoResult_set_separation_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryProximityInfoResult___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryProximityInfoResult___destroy___0');
  _emscripten_bind_PxGjkQueryProximityInfoResult___destroy___0 = Module['_emscripten_bind_PxGjkQueryProximityInfoResult___destroy___0'] = createExportWrapper('emscripten_bind_PxGjkQueryProximityInfoResult___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryRaycastResult_PxGjkQueryRaycastResult_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryRaycastResult_PxGjkQueryRaycastResult_0');
  _emscripten_bind_PxGjkQueryRaycastResult_PxGjkQueryRaycastResult_0 = Module['_emscripten_bind_PxGjkQueryRaycastResult_PxGjkQueryRaycastResult_0'] = createExportWrapper('emscripten_bind_PxGjkQueryRaycastResult_PxGjkQueryRaycastResult_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryRaycastResult_get_success_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryRaycastResult_get_success_0');
  _emscripten_bind_PxGjkQueryRaycastResult_get_success_0 = Module['_emscripten_bind_PxGjkQueryRaycastResult_get_success_0'] = createExportWrapper('emscripten_bind_PxGjkQueryRaycastResult_get_success_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryRaycastResult_set_success_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryRaycastResult_set_success_1');
  _emscripten_bind_PxGjkQueryRaycastResult_set_success_1 = Module['_emscripten_bind_PxGjkQueryRaycastResult_set_success_1'] = createExportWrapper('emscripten_bind_PxGjkQueryRaycastResult_set_success_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryRaycastResult_get_t_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryRaycastResult_get_t_0');
  _emscripten_bind_PxGjkQueryRaycastResult_get_t_0 = Module['_emscripten_bind_PxGjkQueryRaycastResult_get_t_0'] = createExportWrapper('emscripten_bind_PxGjkQueryRaycastResult_get_t_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryRaycastResult_set_t_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryRaycastResult_set_t_1');
  _emscripten_bind_PxGjkQueryRaycastResult_set_t_1 = Module['_emscripten_bind_PxGjkQueryRaycastResult_set_t_1'] = createExportWrapper('emscripten_bind_PxGjkQueryRaycastResult_set_t_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryRaycastResult_get_n_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryRaycastResult_get_n_0');
  _emscripten_bind_PxGjkQueryRaycastResult_get_n_0 = Module['_emscripten_bind_PxGjkQueryRaycastResult_get_n_0'] = createExportWrapper('emscripten_bind_PxGjkQueryRaycastResult_get_n_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryRaycastResult_set_n_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryRaycastResult_set_n_1');
  _emscripten_bind_PxGjkQueryRaycastResult_set_n_1 = Module['_emscripten_bind_PxGjkQueryRaycastResult_set_n_1'] = createExportWrapper('emscripten_bind_PxGjkQueryRaycastResult_set_n_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryRaycastResult_get_p_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryRaycastResult_get_p_0');
  _emscripten_bind_PxGjkQueryRaycastResult_get_p_0 = Module['_emscripten_bind_PxGjkQueryRaycastResult_get_p_0'] = createExportWrapper('emscripten_bind_PxGjkQueryRaycastResult_get_p_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryRaycastResult_set_p_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryRaycastResult_set_p_1');
  _emscripten_bind_PxGjkQueryRaycastResult_set_p_1 = Module['_emscripten_bind_PxGjkQueryRaycastResult_set_p_1'] = createExportWrapper('emscripten_bind_PxGjkQueryRaycastResult_set_p_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGjkQueryRaycastResult___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQueryRaycastResult___destroy___0');
  _emscripten_bind_PxGjkQueryRaycastResult___destroy___0 = Module['_emscripten_bind_PxGjkQueryRaycastResult___destroy___0'] = createExportWrapper('emscripten_bind_PxGjkQueryRaycastResult___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuerySweepResult_PxGjkQuerySweepResult_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuerySweepResult_PxGjkQuerySweepResult_0');
  _emscripten_bind_PxGjkQuerySweepResult_PxGjkQuerySweepResult_0 = Module['_emscripten_bind_PxGjkQuerySweepResult_PxGjkQuerySweepResult_0'] = createExportWrapper('emscripten_bind_PxGjkQuerySweepResult_PxGjkQuerySweepResult_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuerySweepResult_get_success_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuerySweepResult_get_success_0');
  _emscripten_bind_PxGjkQuerySweepResult_get_success_0 = Module['_emscripten_bind_PxGjkQuerySweepResult_get_success_0'] = createExportWrapper('emscripten_bind_PxGjkQuerySweepResult_get_success_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuerySweepResult_set_success_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuerySweepResult_set_success_1');
  _emscripten_bind_PxGjkQuerySweepResult_set_success_1 = Module['_emscripten_bind_PxGjkQuerySweepResult_set_success_1'] = createExportWrapper('emscripten_bind_PxGjkQuerySweepResult_set_success_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuerySweepResult_get_t_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuerySweepResult_get_t_0');
  _emscripten_bind_PxGjkQuerySweepResult_get_t_0 = Module['_emscripten_bind_PxGjkQuerySweepResult_get_t_0'] = createExportWrapper('emscripten_bind_PxGjkQuerySweepResult_get_t_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuerySweepResult_set_t_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuerySweepResult_set_t_1');
  _emscripten_bind_PxGjkQuerySweepResult_set_t_1 = Module['_emscripten_bind_PxGjkQuerySweepResult_set_t_1'] = createExportWrapper('emscripten_bind_PxGjkQuerySweepResult_set_t_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuerySweepResult_get_n_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuerySweepResult_get_n_0');
  _emscripten_bind_PxGjkQuerySweepResult_get_n_0 = Module['_emscripten_bind_PxGjkQuerySweepResult_get_n_0'] = createExportWrapper('emscripten_bind_PxGjkQuerySweepResult_get_n_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuerySweepResult_set_n_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuerySweepResult_set_n_1');
  _emscripten_bind_PxGjkQuerySweepResult_set_n_1 = Module['_emscripten_bind_PxGjkQuerySweepResult_set_n_1'] = createExportWrapper('emscripten_bind_PxGjkQuerySweepResult_set_n_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuerySweepResult_get_p_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuerySweepResult_get_p_0');
  _emscripten_bind_PxGjkQuerySweepResult_get_p_0 = Module['_emscripten_bind_PxGjkQuerySweepResult_get_p_0'] = createExportWrapper('emscripten_bind_PxGjkQuerySweepResult_get_p_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuerySweepResult_set_p_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuerySweepResult_set_p_1');
  _emscripten_bind_PxGjkQuerySweepResult_set_p_1 = Module['_emscripten_bind_PxGjkQuerySweepResult_set_p_1'] = createExportWrapper('emscripten_bind_PxGjkQuerySweepResult_set_p_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxGjkQuerySweepResult___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxGjkQuerySweepResult___destroy___0');
  _emscripten_bind_PxGjkQuerySweepResult___destroy___0 = Module['_emscripten_bind_PxGjkQuerySweepResult___destroy___0'] = createExportWrapper('emscripten_bind_PxGjkQuerySweepResult___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_saveCells_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_saveCells_2');
  _emscripten_bind_PxHeightField_saveCells_2 = Module['_emscripten_bind_PxHeightField_saveCells_2'] = createExportWrapper('emscripten_bind_PxHeightField_saveCells_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_modifySamples_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_modifySamples_3');
  _emscripten_bind_PxHeightField_modifySamples_3 = Module['_emscripten_bind_PxHeightField_modifySamples_3'] = createExportWrapper('emscripten_bind_PxHeightField_modifySamples_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_modifySamples_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_modifySamples_4');
  _emscripten_bind_PxHeightField_modifySamples_4 = Module['_emscripten_bind_PxHeightField_modifySamples_4'] = createExportWrapper('emscripten_bind_PxHeightField_modifySamples_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getNbRows_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getNbRows_0');
  _emscripten_bind_PxHeightField_getNbRows_0 = Module['_emscripten_bind_PxHeightField_getNbRows_0'] = createExportWrapper('emscripten_bind_PxHeightField_getNbRows_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getNbColumns_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getNbColumns_0');
  _emscripten_bind_PxHeightField_getNbColumns_0 = Module['_emscripten_bind_PxHeightField_getNbColumns_0'] = createExportWrapper('emscripten_bind_PxHeightField_getNbColumns_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getFormat_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getFormat_0');
  _emscripten_bind_PxHeightField_getFormat_0 = Module['_emscripten_bind_PxHeightField_getFormat_0'] = createExportWrapper('emscripten_bind_PxHeightField_getFormat_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getSampleStride_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getSampleStride_0');
  _emscripten_bind_PxHeightField_getSampleStride_0 = Module['_emscripten_bind_PxHeightField_getSampleStride_0'] = createExportWrapper('emscripten_bind_PxHeightField_getSampleStride_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getConvexEdgeThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getConvexEdgeThreshold_0');
  _emscripten_bind_PxHeightField_getConvexEdgeThreshold_0 = Module['_emscripten_bind_PxHeightField_getConvexEdgeThreshold_0'] = createExportWrapper('emscripten_bind_PxHeightField_getConvexEdgeThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getFlags_0');
  _emscripten_bind_PxHeightField_getFlags_0 = Module['_emscripten_bind_PxHeightField_getFlags_0'] = createExportWrapper('emscripten_bind_PxHeightField_getFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getHeight_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getHeight_2');
  _emscripten_bind_PxHeightField_getHeight_2 = Module['_emscripten_bind_PxHeightField_getHeight_2'] = createExportWrapper('emscripten_bind_PxHeightField_getHeight_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getTriangleMaterialIndex_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getTriangleMaterialIndex_1');
  _emscripten_bind_PxHeightField_getTriangleMaterialIndex_1 = Module['_emscripten_bind_PxHeightField_getTriangleMaterialIndex_1'] = createExportWrapper('emscripten_bind_PxHeightField_getTriangleMaterialIndex_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getTriangleNormal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getTriangleNormal_1');
  _emscripten_bind_PxHeightField_getTriangleNormal_1 = Module['_emscripten_bind_PxHeightField_getTriangleNormal_1'] = createExportWrapper('emscripten_bind_PxHeightField_getTriangleNormal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getSample_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getSample_2');
  _emscripten_bind_PxHeightField_getSample_2 = Module['_emscripten_bind_PxHeightField_getSample_2'] = createExportWrapper('emscripten_bind_PxHeightField_getSample_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getTimestamp_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getTimestamp_0');
  _emscripten_bind_PxHeightField_getTimestamp_0 = Module['_emscripten_bind_PxHeightField_getTimestamp_0'] = createExportWrapper('emscripten_bind_PxHeightField_getTimestamp_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_release_0');
  _emscripten_bind_PxHeightField_release_0 = Module['_emscripten_bind_PxHeightField_release_0'] = createExportWrapper('emscripten_bind_PxHeightField_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getConcreteTypeName_0');
  _emscripten_bind_PxHeightField_getConcreteTypeName_0 = Module['_emscripten_bind_PxHeightField_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxHeightField_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getConcreteType_0');
  _emscripten_bind_PxHeightField_getConcreteType_0 = Module['_emscripten_bind_PxHeightField_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxHeightField_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_setBaseFlag_2');
  _emscripten_bind_PxHeightField_setBaseFlag_2 = Module['_emscripten_bind_PxHeightField_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxHeightField_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_setBaseFlags_1');
  _emscripten_bind_PxHeightField_setBaseFlags_1 = Module['_emscripten_bind_PxHeightField_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxHeightField_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getBaseFlags_0');
  _emscripten_bind_PxHeightField_getBaseFlags_0 = Module['_emscripten_bind_PxHeightField_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxHeightField_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_isReleasable_0');
  _emscripten_bind_PxHeightField_isReleasable_0 = Module['_emscripten_bind_PxHeightField_isReleasable_0'] = createExportWrapper('emscripten_bind_PxHeightField_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_getReferenceCount_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_getReferenceCount_0');
  _emscripten_bind_PxHeightField_getReferenceCount_0 = Module['_emscripten_bind_PxHeightField_getReferenceCount_0'] = createExportWrapper('emscripten_bind_PxHeightField_getReferenceCount_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightField_acquireReference_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightField_acquireReference_0');
  _emscripten_bind_PxHeightField_acquireReference_0 = Module['_emscripten_bind_PxHeightField_acquireReference_0'] = createExportWrapper('emscripten_bind_PxHeightField_acquireReference_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_PxHeightFieldDesc_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_PxHeightFieldDesc_0');
  _emscripten_bind_PxHeightFieldDesc_PxHeightFieldDesc_0 = Module['_emscripten_bind_PxHeightFieldDesc_PxHeightFieldDesc_0'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_PxHeightFieldDesc_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_setToDefault_0');
  _emscripten_bind_PxHeightFieldDesc_setToDefault_0 = Module['_emscripten_bind_PxHeightFieldDesc_setToDefault_0'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_isValid_0');
  _emscripten_bind_PxHeightFieldDesc_isValid_0 = Module['_emscripten_bind_PxHeightFieldDesc_isValid_0'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_get_nbRows_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_get_nbRows_0');
  _emscripten_bind_PxHeightFieldDesc_get_nbRows_0 = Module['_emscripten_bind_PxHeightFieldDesc_get_nbRows_0'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_get_nbRows_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_set_nbRows_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_set_nbRows_1');
  _emscripten_bind_PxHeightFieldDesc_set_nbRows_1 = Module['_emscripten_bind_PxHeightFieldDesc_set_nbRows_1'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_set_nbRows_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_get_nbColumns_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_get_nbColumns_0');
  _emscripten_bind_PxHeightFieldDesc_get_nbColumns_0 = Module['_emscripten_bind_PxHeightFieldDesc_get_nbColumns_0'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_get_nbColumns_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_set_nbColumns_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_set_nbColumns_1');
  _emscripten_bind_PxHeightFieldDesc_set_nbColumns_1 = Module['_emscripten_bind_PxHeightFieldDesc_set_nbColumns_1'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_set_nbColumns_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_get_format_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_get_format_0');
  _emscripten_bind_PxHeightFieldDesc_get_format_0 = Module['_emscripten_bind_PxHeightFieldDesc_get_format_0'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_get_format_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_set_format_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_set_format_1');
  _emscripten_bind_PxHeightFieldDesc_set_format_1 = Module['_emscripten_bind_PxHeightFieldDesc_set_format_1'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_set_format_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_get_samples_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_get_samples_0');
  _emscripten_bind_PxHeightFieldDesc_get_samples_0 = Module['_emscripten_bind_PxHeightFieldDesc_get_samples_0'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_get_samples_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_set_samples_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_set_samples_1');
  _emscripten_bind_PxHeightFieldDesc_set_samples_1 = Module['_emscripten_bind_PxHeightFieldDesc_set_samples_1'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_set_samples_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_get_convexEdgeThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_get_convexEdgeThreshold_0');
  _emscripten_bind_PxHeightFieldDesc_get_convexEdgeThreshold_0 = Module['_emscripten_bind_PxHeightFieldDesc_get_convexEdgeThreshold_0'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_get_convexEdgeThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_set_convexEdgeThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_set_convexEdgeThreshold_1');
  _emscripten_bind_PxHeightFieldDesc_set_convexEdgeThreshold_1 = Module['_emscripten_bind_PxHeightFieldDesc_set_convexEdgeThreshold_1'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_set_convexEdgeThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_get_flags_0');
  _emscripten_bind_PxHeightFieldDesc_get_flags_0 = Module['_emscripten_bind_PxHeightFieldDesc_get_flags_0'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc_set_flags_1');
  _emscripten_bind_PxHeightFieldDesc_set_flags_1 = Module['_emscripten_bind_PxHeightFieldDesc_set_flags_1'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldDesc___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldDesc___destroy___0');
  _emscripten_bind_PxHeightFieldDesc___destroy___0 = Module['_emscripten_bind_PxHeightFieldDesc___destroy___0'] = createExportWrapper('emscripten_bind_PxHeightFieldDesc___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldFlags_PxHeightFieldFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldFlags_PxHeightFieldFlags_1');
  _emscripten_bind_PxHeightFieldFlags_PxHeightFieldFlags_1 = Module['_emscripten_bind_PxHeightFieldFlags_PxHeightFieldFlags_1'] = createExportWrapper('emscripten_bind_PxHeightFieldFlags_PxHeightFieldFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldFlags_isSet_1');
  _emscripten_bind_PxHeightFieldFlags_isSet_1 = Module['_emscripten_bind_PxHeightFieldFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxHeightFieldFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldFlags_raise_1');
  _emscripten_bind_PxHeightFieldFlags_raise_1 = Module['_emscripten_bind_PxHeightFieldFlags_raise_1'] = createExportWrapper('emscripten_bind_PxHeightFieldFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldFlags_clear_1');
  _emscripten_bind_PxHeightFieldFlags_clear_1 = Module['_emscripten_bind_PxHeightFieldFlags_clear_1'] = createExportWrapper('emscripten_bind_PxHeightFieldFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldFlags___destroy___0');
  _emscripten_bind_PxHeightFieldFlags___destroy___0 = Module['_emscripten_bind_PxHeightFieldFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxHeightFieldFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_0');
  _emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_0 = Module['_emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_0'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_5');
  _emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_5 = Module['_emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_5'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry_isValid_0');
  _emscripten_bind_PxHeightFieldGeometry_isValid_0 = Module['_emscripten_bind_PxHeightFieldGeometry_isValid_0'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry_getType_0');
  _emscripten_bind_PxHeightFieldGeometry_getType_0 = Module['_emscripten_bind_PxHeightFieldGeometry_getType_0'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry_get_heightField_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry_get_heightField_0');
  _emscripten_bind_PxHeightFieldGeometry_get_heightField_0 = Module['_emscripten_bind_PxHeightFieldGeometry_get_heightField_0'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry_get_heightField_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry_set_heightField_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry_set_heightField_1');
  _emscripten_bind_PxHeightFieldGeometry_set_heightField_1 = Module['_emscripten_bind_PxHeightFieldGeometry_set_heightField_1'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry_set_heightField_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry_get_heightScale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry_get_heightScale_0');
  _emscripten_bind_PxHeightFieldGeometry_get_heightScale_0 = Module['_emscripten_bind_PxHeightFieldGeometry_get_heightScale_0'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry_get_heightScale_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry_set_heightScale_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry_set_heightScale_1');
  _emscripten_bind_PxHeightFieldGeometry_set_heightScale_1 = Module['_emscripten_bind_PxHeightFieldGeometry_set_heightScale_1'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry_set_heightScale_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry_get_rowScale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry_get_rowScale_0');
  _emscripten_bind_PxHeightFieldGeometry_get_rowScale_0 = Module['_emscripten_bind_PxHeightFieldGeometry_get_rowScale_0'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry_get_rowScale_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry_set_rowScale_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry_set_rowScale_1');
  _emscripten_bind_PxHeightFieldGeometry_set_rowScale_1 = Module['_emscripten_bind_PxHeightFieldGeometry_set_rowScale_1'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry_set_rowScale_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry_get_columnScale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry_get_columnScale_0');
  _emscripten_bind_PxHeightFieldGeometry_get_columnScale_0 = Module['_emscripten_bind_PxHeightFieldGeometry_get_columnScale_0'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry_get_columnScale_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry_set_columnScale_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry_set_columnScale_1');
  _emscripten_bind_PxHeightFieldGeometry_set_columnScale_1 = Module['_emscripten_bind_PxHeightFieldGeometry_set_columnScale_1'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry_set_columnScale_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry_get_heightFieldFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry_get_heightFieldFlags_0');
  _emscripten_bind_PxHeightFieldGeometry_get_heightFieldFlags_0 = Module['_emscripten_bind_PxHeightFieldGeometry_get_heightFieldFlags_0'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry_get_heightFieldFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry_set_heightFieldFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry_set_heightFieldFlags_1');
  _emscripten_bind_PxHeightFieldGeometry_set_heightFieldFlags_1 = Module['_emscripten_bind_PxHeightFieldGeometry_set_heightFieldFlags_1'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry_set_heightFieldFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldGeometry___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldGeometry___destroy___0');
  _emscripten_bind_PxHeightFieldGeometry___destroy___0 = Module['_emscripten_bind_PxHeightFieldGeometry___destroy___0'] = createExportWrapper('emscripten_bind_PxHeightFieldGeometry___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldSample_PxHeightFieldSample_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldSample_PxHeightFieldSample_0');
  _emscripten_bind_PxHeightFieldSample_PxHeightFieldSample_0 = Module['_emscripten_bind_PxHeightFieldSample_PxHeightFieldSample_0'] = createExportWrapper('emscripten_bind_PxHeightFieldSample_PxHeightFieldSample_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldSample_tessFlag_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldSample_tessFlag_0');
  _emscripten_bind_PxHeightFieldSample_tessFlag_0 = Module['_emscripten_bind_PxHeightFieldSample_tessFlag_0'] = createExportWrapper('emscripten_bind_PxHeightFieldSample_tessFlag_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldSample_clearTessFlag_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldSample_clearTessFlag_0');
  _emscripten_bind_PxHeightFieldSample_clearTessFlag_0 = Module['_emscripten_bind_PxHeightFieldSample_clearTessFlag_0'] = createExportWrapper('emscripten_bind_PxHeightFieldSample_clearTessFlag_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldSample_setTessFlag_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldSample_setTessFlag_0');
  _emscripten_bind_PxHeightFieldSample_setTessFlag_0 = Module['_emscripten_bind_PxHeightFieldSample_setTessFlag_0'] = createExportWrapper('emscripten_bind_PxHeightFieldSample_setTessFlag_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldSample_get_height_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldSample_get_height_0');
  _emscripten_bind_PxHeightFieldSample_get_height_0 = Module['_emscripten_bind_PxHeightFieldSample_get_height_0'] = createExportWrapper('emscripten_bind_PxHeightFieldSample_get_height_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldSample_set_height_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldSample_set_height_1');
  _emscripten_bind_PxHeightFieldSample_set_height_1 = Module['_emscripten_bind_PxHeightFieldSample_set_height_1'] = createExportWrapper('emscripten_bind_PxHeightFieldSample_set_height_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldSample_get_materialIndex0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldSample_get_materialIndex0_0');
  _emscripten_bind_PxHeightFieldSample_get_materialIndex0_0 = Module['_emscripten_bind_PxHeightFieldSample_get_materialIndex0_0'] = createExportWrapper('emscripten_bind_PxHeightFieldSample_get_materialIndex0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldSample_set_materialIndex0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldSample_set_materialIndex0_1');
  _emscripten_bind_PxHeightFieldSample_set_materialIndex0_1 = Module['_emscripten_bind_PxHeightFieldSample_set_materialIndex0_1'] = createExportWrapper('emscripten_bind_PxHeightFieldSample_set_materialIndex0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldSample_get_materialIndex1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldSample_get_materialIndex1_0');
  _emscripten_bind_PxHeightFieldSample_get_materialIndex1_0 = Module['_emscripten_bind_PxHeightFieldSample_get_materialIndex1_0'] = createExportWrapper('emscripten_bind_PxHeightFieldSample_get_materialIndex1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldSample_set_materialIndex1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldSample_set_materialIndex1_1');
  _emscripten_bind_PxHeightFieldSample_set_materialIndex1_1 = Module['_emscripten_bind_PxHeightFieldSample_set_materialIndex1_1'] = createExportWrapper('emscripten_bind_PxHeightFieldSample_set_materialIndex1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHeightFieldSample___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHeightFieldSample___destroy___0');
  _emscripten_bind_PxHeightFieldSample___destroy___0 = Module['_emscripten_bind_PxHeightFieldSample___destroy___0'] = createExportWrapper('emscripten_bind_PxHeightFieldSample___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHitFlags_PxHitFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHitFlags_PxHitFlags_1');
  _emscripten_bind_PxHitFlags_PxHitFlags_1 = Module['_emscripten_bind_PxHitFlags_PxHitFlags_1'] = createExportWrapper('emscripten_bind_PxHitFlags_PxHitFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxHitFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHitFlags_isSet_1');
  _emscripten_bind_PxHitFlags_isSet_1 = Module['_emscripten_bind_PxHitFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxHitFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHitFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHitFlags_raise_1');
  _emscripten_bind_PxHitFlags_raise_1 = Module['_emscripten_bind_PxHitFlags_raise_1'] = createExportWrapper('emscripten_bind_PxHitFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHitFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHitFlags_clear_1');
  _emscripten_bind_PxHitFlags_clear_1 = Module['_emscripten_bind_PxHitFlags_clear_1'] = createExportWrapper('emscripten_bind_PxHitFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHitFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHitFlags___destroy___0');
  _emscripten_bind_PxHitFlags___destroy___0 = Module['_emscripten_bind_PxHitFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxHitFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHullPolygon_PxHullPolygon_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHullPolygon_PxHullPolygon_0');
  _emscripten_bind_PxHullPolygon_PxHullPolygon_0 = Module['_emscripten_bind_PxHullPolygon_PxHullPolygon_0'] = createExportWrapper('emscripten_bind_PxHullPolygon_PxHullPolygon_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxHullPolygon_get_mPlane_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHullPolygon_get_mPlane_1');
  _emscripten_bind_PxHullPolygon_get_mPlane_1 = Module['_emscripten_bind_PxHullPolygon_get_mPlane_1'] = createExportWrapper('emscripten_bind_PxHullPolygon_get_mPlane_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHullPolygon_set_mPlane_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHullPolygon_set_mPlane_2');
  _emscripten_bind_PxHullPolygon_set_mPlane_2 = Module['_emscripten_bind_PxHullPolygon_set_mPlane_2'] = createExportWrapper('emscripten_bind_PxHullPolygon_set_mPlane_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxHullPolygon_get_mNbVerts_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHullPolygon_get_mNbVerts_0');
  _emscripten_bind_PxHullPolygon_get_mNbVerts_0 = Module['_emscripten_bind_PxHullPolygon_get_mNbVerts_0'] = createExportWrapper('emscripten_bind_PxHullPolygon_get_mNbVerts_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHullPolygon_set_mNbVerts_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHullPolygon_set_mNbVerts_1');
  _emscripten_bind_PxHullPolygon_set_mNbVerts_1 = Module['_emscripten_bind_PxHullPolygon_set_mNbVerts_1'] = createExportWrapper('emscripten_bind_PxHullPolygon_set_mNbVerts_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHullPolygon_get_mIndexBase_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHullPolygon_get_mIndexBase_0');
  _emscripten_bind_PxHullPolygon_get_mIndexBase_0 = Module['_emscripten_bind_PxHullPolygon_get_mIndexBase_0'] = createExportWrapper('emscripten_bind_PxHullPolygon_get_mIndexBase_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxHullPolygon_set_mIndexBase_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHullPolygon_set_mIndexBase_1');
  _emscripten_bind_PxHullPolygon_set_mIndexBase_1 = Module['_emscripten_bind_PxHullPolygon_set_mIndexBase_1'] = createExportWrapper('emscripten_bind_PxHullPolygon_set_mIndexBase_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxHullPolygon___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxHullPolygon___destroy___0');
  _emscripten_bind_PxHullPolygon___destroy___0 = Module['_emscripten_bind_PxHullPolygon___destroy___0'] = createExportWrapper('emscripten_bind_PxHullPolygon___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxI32Ptr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxI32Ptr___destroy___0');
  _emscripten_bind_PxI32Ptr___destroy___0 = Module['_emscripten_bind_PxI32Ptr___destroy___0'] = createExportWrapper('emscripten_bind_PxI32Ptr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_2');
  _emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_2 = Module['_emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_2'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_3');
  _emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_3 = Module['_emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_3'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_isValid_0');
  _emscripten_bind_PxJointAngularLimitPair_isValid_0 = Module['_emscripten_bind_PxJointAngularLimitPair_isValid_0'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_isSoft_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_isSoft_0');
  _emscripten_bind_PxJointAngularLimitPair_isSoft_0 = Module['_emscripten_bind_PxJointAngularLimitPair_isSoft_0'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_isSoft_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_get_upper_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_get_upper_0');
  _emscripten_bind_PxJointAngularLimitPair_get_upper_0 = Module['_emscripten_bind_PxJointAngularLimitPair_get_upper_0'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_get_upper_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_set_upper_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_set_upper_1');
  _emscripten_bind_PxJointAngularLimitPair_set_upper_1 = Module['_emscripten_bind_PxJointAngularLimitPair_set_upper_1'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_set_upper_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_get_lower_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_get_lower_0');
  _emscripten_bind_PxJointAngularLimitPair_get_lower_0 = Module['_emscripten_bind_PxJointAngularLimitPair_get_lower_0'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_get_lower_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_set_lower_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_set_lower_1');
  _emscripten_bind_PxJointAngularLimitPair_set_lower_1 = Module['_emscripten_bind_PxJointAngularLimitPair_set_lower_1'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_set_lower_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_get_restitution_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_get_restitution_0');
  _emscripten_bind_PxJointAngularLimitPair_get_restitution_0 = Module['_emscripten_bind_PxJointAngularLimitPair_get_restitution_0'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_get_restitution_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_set_restitution_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_set_restitution_1');
  _emscripten_bind_PxJointAngularLimitPair_set_restitution_1 = Module['_emscripten_bind_PxJointAngularLimitPair_set_restitution_1'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_set_restitution_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_get_bounceThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_get_bounceThreshold_0');
  _emscripten_bind_PxJointAngularLimitPair_get_bounceThreshold_0 = Module['_emscripten_bind_PxJointAngularLimitPair_get_bounceThreshold_0'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_get_bounceThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_set_bounceThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_set_bounceThreshold_1');
  _emscripten_bind_PxJointAngularLimitPair_set_bounceThreshold_1 = Module['_emscripten_bind_PxJointAngularLimitPair_set_bounceThreshold_1'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_set_bounceThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_get_stiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_get_stiffness_0');
  _emscripten_bind_PxJointAngularLimitPair_get_stiffness_0 = Module['_emscripten_bind_PxJointAngularLimitPair_get_stiffness_0'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_get_stiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_set_stiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_set_stiffness_1');
  _emscripten_bind_PxJointAngularLimitPair_set_stiffness_1 = Module['_emscripten_bind_PxJointAngularLimitPair_set_stiffness_1'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_set_stiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_get_damping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_get_damping_0');
  _emscripten_bind_PxJointAngularLimitPair_get_damping_0 = Module['_emscripten_bind_PxJointAngularLimitPair_get_damping_0'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_get_damping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair_set_damping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair_set_damping_1');
  _emscripten_bind_PxJointAngularLimitPair_set_damping_1 = Module['_emscripten_bind_PxJointAngularLimitPair_set_damping_1'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair_set_damping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointAngularLimitPair___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointAngularLimitPair___destroy___0');
  _emscripten_bind_PxJointAngularLimitPair___destroy___0 = Module['_emscripten_bind_PxJointAngularLimitPair___destroy___0'] = createExportWrapper('emscripten_bind_PxJointAngularLimitPair___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_PxJointLimitCone_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_PxJointLimitCone_2');
  _emscripten_bind_PxJointLimitCone_PxJointLimitCone_2 = Module['_emscripten_bind_PxJointLimitCone_PxJointLimitCone_2'] = createExportWrapper('emscripten_bind_PxJointLimitCone_PxJointLimitCone_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_PxJointLimitCone_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_PxJointLimitCone_3');
  _emscripten_bind_PxJointLimitCone_PxJointLimitCone_3 = Module['_emscripten_bind_PxJointLimitCone_PxJointLimitCone_3'] = createExportWrapper('emscripten_bind_PxJointLimitCone_PxJointLimitCone_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_isValid_0');
  _emscripten_bind_PxJointLimitCone_isValid_0 = Module['_emscripten_bind_PxJointLimitCone_isValid_0'] = createExportWrapper('emscripten_bind_PxJointLimitCone_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_isSoft_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_isSoft_0');
  _emscripten_bind_PxJointLimitCone_isSoft_0 = Module['_emscripten_bind_PxJointLimitCone_isSoft_0'] = createExportWrapper('emscripten_bind_PxJointLimitCone_isSoft_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_get_yAngle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_get_yAngle_0');
  _emscripten_bind_PxJointLimitCone_get_yAngle_0 = Module['_emscripten_bind_PxJointLimitCone_get_yAngle_0'] = createExportWrapper('emscripten_bind_PxJointLimitCone_get_yAngle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_set_yAngle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_set_yAngle_1');
  _emscripten_bind_PxJointLimitCone_set_yAngle_1 = Module['_emscripten_bind_PxJointLimitCone_set_yAngle_1'] = createExportWrapper('emscripten_bind_PxJointLimitCone_set_yAngle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_get_zAngle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_get_zAngle_0');
  _emscripten_bind_PxJointLimitCone_get_zAngle_0 = Module['_emscripten_bind_PxJointLimitCone_get_zAngle_0'] = createExportWrapper('emscripten_bind_PxJointLimitCone_get_zAngle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_set_zAngle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_set_zAngle_1');
  _emscripten_bind_PxJointLimitCone_set_zAngle_1 = Module['_emscripten_bind_PxJointLimitCone_set_zAngle_1'] = createExportWrapper('emscripten_bind_PxJointLimitCone_set_zAngle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_get_restitution_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_get_restitution_0');
  _emscripten_bind_PxJointLimitCone_get_restitution_0 = Module['_emscripten_bind_PxJointLimitCone_get_restitution_0'] = createExportWrapper('emscripten_bind_PxJointLimitCone_get_restitution_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_set_restitution_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_set_restitution_1');
  _emscripten_bind_PxJointLimitCone_set_restitution_1 = Module['_emscripten_bind_PxJointLimitCone_set_restitution_1'] = createExportWrapper('emscripten_bind_PxJointLimitCone_set_restitution_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_get_bounceThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_get_bounceThreshold_0');
  _emscripten_bind_PxJointLimitCone_get_bounceThreshold_0 = Module['_emscripten_bind_PxJointLimitCone_get_bounceThreshold_0'] = createExportWrapper('emscripten_bind_PxJointLimitCone_get_bounceThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_set_bounceThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_set_bounceThreshold_1');
  _emscripten_bind_PxJointLimitCone_set_bounceThreshold_1 = Module['_emscripten_bind_PxJointLimitCone_set_bounceThreshold_1'] = createExportWrapper('emscripten_bind_PxJointLimitCone_set_bounceThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_get_stiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_get_stiffness_0');
  _emscripten_bind_PxJointLimitCone_get_stiffness_0 = Module['_emscripten_bind_PxJointLimitCone_get_stiffness_0'] = createExportWrapper('emscripten_bind_PxJointLimitCone_get_stiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_set_stiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_set_stiffness_1');
  _emscripten_bind_PxJointLimitCone_set_stiffness_1 = Module['_emscripten_bind_PxJointLimitCone_set_stiffness_1'] = createExportWrapper('emscripten_bind_PxJointLimitCone_set_stiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_get_damping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_get_damping_0');
  _emscripten_bind_PxJointLimitCone_get_damping_0 = Module['_emscripten_bind_PxJointLimitCone_get_damping_0'] = createExportWrapper('emscripten_bind_PxJointLimitCone_get_damping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone_set_damping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone_set_damping_1');
  _emscripten_bind_PxJointLimitCone_set_damping_1 = Module['_emscripten_bind_PxJointLimitCone_set_damping_1'] = createExportWrapper('emscripten_bind_PxJointLimitCone_set_damping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitCone___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitCone___destroy___0');
  _emscripten_bind_PxJointLimitCone___destroy___0 = Module['_emscripten_bind_PxJointLimitCone___destroy___0'] = createExportWrapper('emscripten_bind_PxJointLimitCone___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_4');
  _emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_4 = Module['_emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_4'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_5');
  _emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_5 = Module['_emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_5'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_isValid_0');
  _emscripten_bind_PxJointLimitPyramid_isValid_0 = Module['_emscripten_bind_PxJointLimitPyramid_isValid_0'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_isSoft_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_isSoft_0');
  _emscripten_bind_PxJointLimitPyramid_isSoft_0 = Module['_emscripten_bind_PxJointLimitPyramid_isSoft_0'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_isSoft_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_get_yAngleMin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_get_yAngleMin_0');
  _emscripten_bind_PxJointLimitPyramid_get_yAngleMin_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_yAngleMin_0'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_get_yAngleMin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_set_yAngleMin_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_set_yAngleMin_1');
  _emscripten_bind_PxJointLimitPyramid_set_yAngleMin_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_yAngleMin_1'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_set_yAngleMin_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_get_yAngleMax_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_get_yAngleMax_0');
  _emscripten_bind_PxJointLimitPyramid_get_yAngleMax_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_yAngleMax_0'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_get_yAngleMax_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_set_yAngleMax_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_set_yAngleMax_1');
  _emscripten_bind_PxJointLimitPyramid_set_yAngleMax_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_yAngleMax_1'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_set_yAngleMax_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_get_zAngleMin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_get_zAngleMin_0');
  _emscripten_bind_PxJointLimitPyramid_get_zAngleMin_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_zAngleMin_0'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_get_zAngleMin_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_set_zAngleMin_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_set_zAngleMin_1');
  _emscripten_bind_PxJointLimitPyramid_set_zAngleMin_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_zAngleMin_1'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_set_zAngleMin_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_get_zAngleMax_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_get_zAngleMax_0');
  _emscripten_bind_PxJointLimitPyramid_get_zAngleMax_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_zAngleMax_0'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_get_zAngleMax_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_set_zAngleMax_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_set_zAngleMax_1');
  _emscripten_bind_PxJointLimitPyramid_set_zAngleMax_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_zAngleMax_1'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_set_zAngleMax_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_get_restitution_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_get_restitution_0');
  _emscripten_bind_PxJointLimitPyramid_get_restitution_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_restitution_0'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_get_restitution_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_set_restitution_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_set_restitution_1');
  _emscripten_bind_PxJointLimitPyramid_set_restitution_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_restitution_1'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_set_restitution_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_get_bounceThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_get_bounceThreshold_0');
  _emscripten_bind_PxJointLimitPyramid_get_bounceThreshold_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_bounceThreshold_0'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_get_bounceThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_set_bounceThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_set_bounceThreshold_1');
  _emscripten_bind_PxJointLimitPyramid_set_bounceThreshold_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_bounceThreshold_1'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_set_bounceThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_get_stiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_get_stiffness_0');
  _emscripten_bind_PxJointLimitPyramid_get_stiffness_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_stiffness_0'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_get_stiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_set_stiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_set_stiffness_1');
  _emscripten_bind_PxJointLimitPyramid_set_stiffness_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_stiffness_1'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_set_stiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_get_damping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_get_damping_0');
  _emscripten_bind_PxJointLimitPyramid_get_damping_0 = Module['_emscripten_bind_PxJointLimitPyramid_get_damping_0'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_get_damping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid_set_damping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid_set_damping_1');
  _emscripten_bind_PxJointLimitPyramid_set_damping_1 = Module['_emscripten_bind_PxJointLimitPyramid_set_damping_1'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid_set_damping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLimitPyramid___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLimitPyramid___destroy___0');
  _emscripten_bind_PxJointLimitPyramid___destroy___0 = Module['_emscripten_bind_PxJointLimitPyramid___destroy___0'] = createExportWrapper('emscripten_bind_PxJointLimitPyramid___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimit_PxJointLinearLimit_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimit_PxJointLinearLimit_2');
  _emscripten_bind_PxJointLinearLimit_PxJointLinearLimit_2 = Module['_emscripten_bind_PxJointLinearLimit_PxJointLinearLimit_2'] = createExportWrapper('emscripten_bind_PxJointLinearLimit_PxJointLinearLimit_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimit_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimit_isValid_0');
  _emscripten_bind_PxJointLinearLimit_isValid_0 = Module['_emscripten_bind_PxJointLinearLimit_isValid_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimit_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimit_isSoft_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimit_isSoft_0');
  _emscripten_bind_PxJointLinearLimit_isSoft_0 = Module['_emscripten_bind_PxJointLinearLimit_isSoft_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimit_isSoft_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimit_get_value_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimit_get_value_0');
  _emscripten_bind_PxJointLinearLimit_get_value_0 = Module['_emscripten_bind_PxJointLinearLimit_get_value_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimit_get_value_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimit_set_value_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimit_set_value_1');
  _emscripten_bind_PxJointLinearLimit_set_value_1 = Module['_emscripten_bind_PxJointLinearLimit_set_value_1'] = createExportWrapper('emscripten_bind_PxJointLinearLimit_set_value_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimit_get_restitution_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimit_get_restitution_0');
  _emscripten_bind_PxJointLinearLimit_get_restitution_0 = Module['_emscripten_bind_PxJointLinearLimit_get_restitution_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimit_get_restitution_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimit_set_restitution_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimit_set_restitution_1');
  _emscripten_bind_PxJointLinearLimit_set_restitution_1 = Module['_emscripten_bind_PxJointLinearLimit_set_restitution_1'] = createExportWrapper('emscripten_bind_PxJointLinearLimit_set_restitution_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimit_get_bounceThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimit_get_bounceThreshold_0');
  _emscripten_bind_PxJointLinearLimit_get_bounceThreshold_0 = Module['_emscripten_bind_PxJointLinearLimit_get_bounceThreshold_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimit_get_bounceThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimit_set_bounceThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimit_set_bounceThreshold_1');
  _emscripten_bind_PxJointLinearLimit_set_bounceThreshold_1 = Module['_emscripten_bind_PxJointLinearLimit_set_bounceThreshold_1'] = createExportWrapper('emscripten_bind_PxJointLinearLimit_set_bounceThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimit_get_stiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimit_get_stiffness_0');
  _emscripten_bind_PxJointLinearLimit_get_stiffness_0 = Module['_emscripten_bind_PxJointLinearLimit_get_stiffness_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimit_get_stiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimit_set_stiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimit_set_stiffness_1');
  _emscripten_bind_PxJointLinearLimit_set_stiffness_1 = Module['_emscripten_bind_PxJointLinearLimit_set_stiffness_1'] = createExportWrapper('emscripten_bind_PxJointLinearLimit_set_stiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimit_get_damping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimit_get_damping_0');
  _emscripten_bind_PxJointLinearLimit_get_damping_0 = Module['_emscripten_bind_PxJointLinearLimit_get_damping_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimit_get_damping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimit_set_damping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimit_set_damping_1');
  _emscripten_bind_PxJointLinearLimit_set_damping_1 = Module['_emscripten_bind_PxJointLinearLimit_set_damping_1'] = createExportWrapper('emscripten_bind_PxJointLinearLimit_set_damping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimit___destroy___0');
  _emscripten_bind_PxJointLinearLimit___destroy___0 = Module['_emscripten_bind_PxJointLinearLimit___destroy___0'] = createExportWrapper('emscripten_bind_PxJointLinearLimit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_PxJointLinearLimitPair_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_PxJointLinearLimitPair_3');
  _emscripten_bind_PxJointLinearLimitPair_PxJointLinearLimitPair_3 = Module['_emscripten_bind_PxJointLinearLimitPair_PxJointLinearLimitPair_3'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_PxJointLinearLimitPair_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_isValid_0');
  _emscripten_bind_PxJointLinearLimitPair_isValid_0 = Module['_emscripten_bind_PxJointLinearLimitPair_isValid_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_isSoft_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_isSoft_0');
  _emscripten_bind_PxJointLinearLimitPair_isSoft_0 = Module['_emscripten_bind_PxJointLinearLimitPair_isSoft_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_isSoft_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_get_upper_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_get_upper_0');
  _emscripten_bind_PxJointLinearLimitPair_get_upper_0 = Module['_emscripten_bind_PxJointLinearLimitPair_get_upper_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_get_upper_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_set_upper_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_set_upper_1');
  _emscripten_bind_PxJointLinearLimitPair_set_upper_1 = Module['_emscripten_bind_PxJointLinearLimitPair_set_upper_1'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_set_upper_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_get_lower_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_get_lower_0');
  _emscripten_bind_PxJointLinearLimitPair_get_lower_0 = Module['_emscripten_bind_PxJointLinearLimitPair_get_lower_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_get_lower_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_set_lower_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_set_lower_1');
  _emscripten_bind_PxJointLinearLimitPair_set_lower_1 = Module['_emscripten_bind_PxJointLinearLimitPair_set_lower_1'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_set_lower_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_get_restitution_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_get_restitution_0');
  _emscripten_bind_PxJointLinearLimitPair_get_restitution_0 = Module['_emscripten_bind_PxJointLinearLimitPair_get_restitution_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_get_restitution_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_set_restitution_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_set_restitution_1');
  _emscripten_bind_PxJointLinearLimitPair_set_restitution_1 = Module['_emscripten_bind_PxJointLinearLimitPair_set_restitution_1'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_set_restitution_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_get_bounceThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_get_bounceThreshold_0');
  _emscripten_bind_PxJointLinearLimitPair_get_bounceThreshold_0 = Module['_emscripten_bind_PxJointLinearLimitPair_get_bounceThreshold_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_get_bounceThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_set_bounceThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_set_bounceThreshold_1');
  _emscripten_bind_PxJointLinearLimitPair_set_bounceThreshold_1 = Module['_emscripten_bind_PxJointLinearLimitPair_set_bounceThreshold_1'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_set_bounceThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_get_stiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_get_stiffness_0');
  _emscripten_bind_PxJointLinearLimitPair_get_stiffness_0 = Module['_emscripten_bind_PxJointLinearLimitPair_get_stiffness_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_get_stiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_set_stiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_set_stiffness_1');
  _emscripten_bind_PxJointLinearLimitPair_set_stiffness_1 = Module['_emscripten_bind_PxJointLinearLimitPair_set_stiffness_1'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_set_stiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_get_damping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_get_damping_0');
  _emscripten_bind_PxJointLinearLimitPair_get_damping_0 = Module['_emscripten_bind_PxJointLinearLimitPair_get_damping_0'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_get_damping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair_set_damping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair_set_damping_1');
  _emscripten_bind_PxJointLinearLimitPair_set_damping_1 = Module['_emscripten_bind_PxJointLinearLimitPair_set_damping_1'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair_set_damping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxJointLinearLimitPair___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxJointLinearLimitPair___destroy___0');
  _emscripten_bind_PxJointLinearLimitPair___destroy___0 = Module['_emscripten_bind_PxJointLinearLimitPair___destroy___0'] = createExportWrapper('emscripten_bind_PxJointLinearLimitPair___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_PxMassProperties_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_PxMassProperties_0');
  _emscripten_bind_PxMassProperties_PxMassProperties_0 = Module['_emscripten_bind_PxMassProperties_PxMassProperties_0'] = createExportWrapper('emscripten_bind_PxMassProperties_PxMassProperties_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_PxMassProperties_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_PxMassProperties_1');
  _emscripten_bind_PxMassProperties_PxMassProperties_1 = Module['_emscripten_bind_PxMassProperties_PxMassProperties_1'] = createExportWrapper('emscripten_bind_PxMassProperties_PxMassProperties_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_PxMassProperties_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_PxMassProperties_3');
  _emscripten_bind_PxMassProperties_PxMassProperties_3 = Module['_emscripten_bind_PxMassProperties_PxMassProperties_3'] = createExportWrapper('emscripten_bind_PxMassProperties_PxMassProperties_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_translate_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_translate_1');
  _emscripten_bind_PxMassProperties_translate_1 = Module['_emscripten_bind_PxMassProperties_translate_1'] = createExportWrapper('emscripten_bind_PxMassProperties_translate_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_getMassSpaceInertia_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_getMassSpaceInertia_2');
  _emscripten_bind_PxMassProperties_getMassSpaceInertia_2 = Module['_emscripten_bind_PxMassProperties_getMassSpaceInertia_2'] = createExportWrapper('emscripten_bind_PxMassProperties_getMassSpaceInertia_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_translateInertia_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_translateInertia_3');
  _emscripten_bind_PxMassProperties_translateInertia_3 = Module['_emscripten_bind_PxMassProperties_translateInertia_3'] = createExportWrapper('emscripten_bind_PxMassProperties_translateInertia_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_rotateInertia_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_rotateInertia_2');
  _emscripten_bind_PxMassProperties_rotateInertia_2 = Module['_emscripten_bind_PxMassProperties_rotateInertia_2'] = createExportWrapper('emscripten_bind_PxMassProperties_rotateInertia_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_scaleInertia_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_scaleInertia_3');
  _emscripten_bind_PxMassProperties_scaleInertia_3 = Module['_emscripten_bind_PxMassProperties_scaleInertia_3'] = createExportWrapper('emscripten_bind_PxMassProperties_scaleInertia_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_sum_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_sum_3');
  _emscripten_bind_PxMassProperties_sum_3 = Module['_emscripten_bind_PxMassProperties_sum_3'] = createExportWrapper('emscripten_bind_PxMassProperties_sum_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_get_inertiaTensor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_get_inertiaTensor_0');
  _emscripten_bind_PxMassProperties_get_inertiaTensor_0 = Module['_emscripten_bind_PxMassProperties_get_inertiaTensor_0'] = createExportWrapper('emscripten_bind_PxMassProperties_get_inertiaTensor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_set_inertiaTensor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_set_inertiaTensor_1');
  _emscripten_bind_PxMassProperties_set_inertiaTensor_1 = Module['_emscripten_bind_PxMassProperties_set_inertiaTensor_1'] = createExportWrapper('emscripten_bind_PxMassProperties_set_inertiaTensor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_get_centerOfMass_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_get_centerOfMass_0');
  _emscripten_bind_PxMassProperties_get_centerOfMass_0 = Module['_emscripten_bind_PxMassProperties_get_centerOfMass_0'] = createExportWrapper('emscripten_bind_PxMassProperties_get_centerOfMass_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_set_centerOfMass_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_set_centerOfMass_1');
  _emscripten_bind_PxMassProperties_set_centerOfMass_1 = Module['_emscripten_bind_PxMassProperties_set_centerOfMass_1'] = createExportWrapper('emscripten_bind_PxMassProperties_set_centerOfMass_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_get_mass_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_get_mass_0');
  _emscripten_bind_PxMassProperties_get_mass_0 = Module['_emscripten_bind_PxMassProperties_get_mass_0'] = createExportWrapper('emscripten_bind_PxMassProperties_get_mass_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties_set_mass_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties_set_mass_1');
  _emscripten_bind_PxMassProperties_set_mass_1 = Module['_emscripten_bind_PxMassProperties_set_mass_1'] = createExportWrapper('emscripten_bind_PxMassProperties_set_mass_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMassProperties___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMassProperties___destroy___0');
  _emscripten_bind_PxMassProperties___destroy___0 = Module['_emscripten_bind_PxMassProperties___destroy___0'] = createExportWrapper('emscripten_bind_PxMassProperties___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMat33_PxMat33_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33_PxMat33_0');
  _emscripten_bind_PxMat33_PxMat33_0 = Module['_emscripten_bind_PxMat33_PxMat33_0'] = createExportWrapper('emscripten_bind_PxMat33_PxMat33_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxMat33_PxMat33_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33_PxMat33_1');
  _emscripten_bind_PxMat33_PxMat33_1 = Module['_emscripten_bind_PxMat33_PxMat33_1'] = createExportWrapper('emscripten_bind_PxMat33_PxMat33_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxMat33_PxMat33_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33_PxMat33_3');
  _emscripten_bind_PxMat33_PxMat33_3 = Module['_emscripten_bind_PxMat33_PxMat33_3'] = createExportWrapper('emscripten_bind_PxMat33_PxMat33_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxMat33_getTranspose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33_getTranspose_0');
  _emscripten_bind_PxMat33_getTranspose_0 = Module['_emscripten_bind_PxMat33_getTranspose_0'] = createExportWrapper('emscripten_bind_PxMat33_getTranspose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMat33_getInverse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33_getInverse_0');
  _emscripten_bind_PxMat33_getInverse_0 = Module['_emscripten_bind_PxMat33_getInverse_0'] = createExportWrapper('emscripten_bind_PxMat33_getInverse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMat33_getDeterminant_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33_getDeterminant_0');
  _emscripten_bind_PxMat33_getDeterminant_0 = Module['_emscripten_bind_PxMat33_getDeterminant_0'] = createExportWrapper('emscripten_bind_PxMat33_getDeterminant_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMat33_transform_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33_transform_1');
  _emscripten_bind_PxMat33_transform_1 = Module['_emscripten_bind_PxMat33_transform_1'] = createExportWrapper('emscripten_bind_PxMat33_transform_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMat33_transformTranspose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33_transformTranspose_1');
  _emscripten_bind_PxMat33_transformTranspose_1 = Module['_emscripten_bind_PxMat33_transformTranspose_1'] = createExportWrapper('emscripten_bind_PxMat33_transformTranspose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMat33_get_column0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33_get_column0_0');
  _emscripten_bind_PxMat33_get_column0_0 = Module['_emscripten_bind_PxMat33_get_column0_0'] = createExportWrapper('emscripten_bind_PxMat33_get_column0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMat33_set_column0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33_set_column0_1');
  _emscripten_bind_PxMat33_set_column0_1 = Module['_emscripten_bind_PxMat33_set_column0_1'] = createExportWrapper('emscripten_bind_PxMat33_set_column0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMat33_get_column1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33_get_column1_0');
  _emscripten_bind_PxMat33_get_column1_0 = Module['_emscripten_bind_PxMat33_get_column1_0'] = createExportWrapper('emscripten_bind_PxMat33_get_column1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMat33_set_column1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33_set_column1_1');
  _emscripten_bind_PxMat33_set_column1_1 = Module['_emscripten_bind_PxMat33_set_column1_1'] = createExportWrapper('emscripten_bind_PxMat33_set_column1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMat33_get_column2_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33_get_column2_0');
  _emscripten_bind_PxMat33_get_column2_0 = Module['_emscripten_bind_PxMat33_get_column2_0'] = createExportWrapper('emscripten_bind_PxMat33_get_column2_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMat33_set_column2_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33_set_column2_1');
  _emscripten_bind_PxMat33_set_column2_1 = Module['_emscripten_bind_PxMat33_set_column2_1'] = createExportWrapper('emscripten_bind_PxMat33_set_column2_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMat33___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMat33___destroy___0');
  _emscripten_bind_PxMat33___destroy___0 = Module['_emscripten_bind_PxMat33___destroy___0'] = createExportWrapper('emscripten_bind_PxMat33___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_setDynamicFriction_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_setDynamicFriction_1');
  _emscripten_bind_PxMaterial_setDynamicFriction_1 = Module['_emscripten_bind_PxMaterial_setDynamicFriction_1'] = createExportWrapper('emscripten_bind_PxMaterial_setDynamicFriction_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_getDynamicFriction_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_getDynamicFriction_0');
  _emscripten_bind_PxMaterial_getDynamicFriction_0 = Module['_emscripten_bind_PxMaterial_getDynamicFriction_0'] = createExportWrapper('emscripten_bind_PxMaterial_getDynamicFriction_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_setStaticFriction_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_setStaticFriction_1');
  _emscripten_bind_PxMaterial_setStaticFriction_1 = Module['_emscripten_bind_PxMaterial_setStaticFriction_1'] = createExportWrapper('emscripten_bind_PxMaterial_setStaticFriction_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_getStaticFriction_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_getStaticFriction_0');
  _emscripten_bind_PxMaterial_getStaticFriction_0 = Module['_emscripten_bind_PxMaterial_getStaticFriction_0'] = createExportWrapper('emscripten_bind_PxMaterial_getStaticFriction_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_setRestitution_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_setRestitution_1');
  _emscripten_bind_PxMaterial_setRestitution_1 = Module['_emscripten_bind_PxMaterial_setRestitution_1'] = createExportWrapper('emscripten_bind_PxMaterial_setRestitution_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_getRestitution_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_getRestitution_0');
  _emscripten_bind_PxMaterial_getRestitution_0 = Module['_emscripten_bind_PxMaterial_getRestitution_0'] = createExportWrapper('emscripten_bind_PxMaterial_getRestitution_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_setFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_setFlag_2');
  _emscripten_bind_PxMaterial_setFlag_2 = Module['_emscripten_bind_PxMaterial_setFlag_2'] = createExportWrapper('emscripten_bind_PxMaterial_setFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_setFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_setFlags_1');
  _emscripten_bind_PxMaterial_setFlags_1 = Module['_emscripten_bind_PxMaterial_setFlags_1'] = createExportWrapper('emscripten_bind_PxMaterial_setFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_getFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_getFlags_0');
  _emscripten_bind_PxMaterial_getFlags_0 = Module['_emscripten_bind_PxMaterial_getFlags_0'] = createExportWrapper('emscripten_bind_PxMaterial_getFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_setFrictionCombineMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_setFrictionCombineMode_1');
  _emscripten_bind_PxMaterial_setFrictionCombineMode_1 = Module['_emscripten_bind_PxMaterial_setFrictionCombineMode_1'] = createExportWrapper('emscripten_bind_PxMaterial_setFrictionCombineMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_getFrictionCombineMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_getFrictionCombineMode_0');
  _emscripten_bind_PxMaterial_getFrictionCombineMode_0 = Module['_emscripten_bind_PxMaterial_getFrictionCombineMode_0'] = createExportWrapper('emscripten_bind_PxMaterial_getFrictionCombineMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_setRestitutionCombineMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_setRestitutionCombineMode_1');
  _emscripten_bind_PxMaterial_setRestitutionCombineMode_1 = Module['_emscripten_bind_PxMaterial_setRestitutionCombineMode_1'] = createExportWrapper('emscripten_bind_PxMaterial_setRestitutionCombineMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_getRestitutionCombineMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_getRestitutionCombineMode_0');
  _emscripten_bind_PxMaterial_getRestitutionCombineMode_0 = Module['_emscripten_bind_PxMaterial_getRestitutionCombineMode_0'] = createExportWrapper('emscripten_bind_PxMaterial_getRestitutionCombineMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_release_0');
  _emscripten_bind_PxMaterial_release_0 = Module['_emscripten_bind_PxMaterial_release_0'] = createExportWrapper('emscripten_bind_PxMaterial_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_getConcreteTypeName_0');
  _emscripten_bind_PxMaterial_getConcreteTypeName_0 = Module['_emscripten_bind_PxMaterial_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxMaterial_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_getConcreteType_0');
  _emscripten_bind_PxMaterial_getConcreteType_0 = Module['_emscripten_bind_PxMaterial_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxMaterial_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_setBaseFlag_2');
  _emscripten_bind_PxMaterial_setBaseFlag_2 = Module['_emscripten_bind_PxMaterial_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxMaterial_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_setBaseFlags_1');
  _emscripten_bind_PxMaterial_setBaseFlags_1 = Module['_emscripten_bind_PxMaterial_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxMaterial_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_getBaseFlags_0');
  _emscripten_bind_PxMaterial_getBaseFlags_0 = Module['_emscripten_bind_PxMaterial_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxMaterial_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_isReleasable_0');
  _emscripten_bind_PxMaterial_isReleasable_0 = Module['_emscripten_bind_PxMaterial_isReleasable_0'] = createExportWrapper('emscripten_bind_PxMaterial_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_getReferenceCount_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_getReferenceCount_0');
  _emscripten_bind_PxMaterial_getReferenceCount_0 = Module['_emscripten_bind_PxMaterial_getReferenceCount_0'] = createExportWrapper('emscripten_bind_PxMaterial_getReferenceCount_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_acquireReference_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_acquireReference_0');
  _emscripten_bind_PxMaterial_acquireReference_0 = Module['_emscripten_bind_PxMaterial_acquireReference_0'] = createExportWrapper('emscripten_bind_PxMaterial_acquireReference_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_get_userData_0');
  _emscripten_bind_PxMaterial_get_userData_0 = Module['_emscripten_bind_PxMaterial_get_userData_0'] = createExportWrapper('emscripten_bind_PxMaterial_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterial_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterial_set_userData_1');
  _emscripten_bind_PxMaterial_set_userData_1 = Module['_emscripten_bind_PxMaterial_set_userData_1'] = createExportWrapper('emscripten_bind_PxMaterial_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMaterialConstPtr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterialConstPtr___destroy___0');
  _emscripten_bind_PxMaterialConstPtr___destroy___0 = Module['_emscripten_bind_PxMaterialConstPtr___destroy___0'] = createExportWrapper('emscripten_bind_PxMaterialConstPtr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterialFlags_PxMaterialFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterialFlags_PxMaterialFlags_1');
  _emscripten_bind_PxMaterialFlags_PxMaterialFlags_1 = Module['_emscripten_bind_PxMaterialFlags_PxMaterialFlags_1'] = createExportWrapper('emscripten_bind_PxMaterialFlags_PxMaterialFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterialFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterialFlags_isSet_1');
  _emscripten_bind_PxMaterialFlags_isSet_1 = Module['_emscripten_bind_PxMaterialFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxMaterialFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMaterialFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterialFlags_raise_1');
  _emscripten_bind_PxMaterialFlags_raise_1 = Module['_emscripten_bind_PxMaterialFlags_raise_1'] = createExportWrapper('emscripten_bind_PxMaterialFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMaterialFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterialFlags_clear_1');
  _emscripten_bind_PxMaterialFlags_clear_1 = Module['_emscripten_bind_PxMaterialFlags_clear_1'] = createExportWrapper('emscripten_bind_PxMaterialFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMaterialFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterialFlags___destroy___0');
  _emscripten_bind_PxMaterialFlags___destroy___0 = Module['_emscripten_bind_PxMaterialFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxMaterialFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMaterialPtr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMaterialPtr___destroy___0');
  _emscripten_bind_PxMaterialPtr___destroy___0 = Module['_emscripten_bind_PxMaterialPtr___destroy___0'] = createExportWrapper('emscripten_bind_PxMaterialPtr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMeshFlags_PxMeshFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshFlags_PxMeshFlags_1');
  _emscripten_bind_PxMeshFlags_PxMeshFlags_1 = Module['_emscripten_bind_PxMeshFlags_PxMeshFlags_1'] = createExportWrapper('emscripten_bind_PxMeshFlags_PxMeshFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxMeshFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshFlags_isSet_1');
  _emscripten_bind_PxMeshFlags_isSet_1 = Module['_emscripten_bind_PxMeshFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxMeshFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMeshFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshFlags_raise_1');
  _emscripten_bind_PxMeshFlags_raise_1 = Module['_emscripten_bind_PxMeshFlags_raise_1'] = createExportWrapper('emscripten_bind_PxMeshFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMeshFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshFlags_clear_1');
  _emscripten_bind_PxMeshFlags_clear_1 = Module['_emscripten_bind_PxMeshFlags_clear_1'] = createExportWrapper('emscripten_bind_PxMeshFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMeshFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshFlags___destroy___0');
  _emscripten_bind_PxMeshFlags___destroy___0 = Module['_emscripten_bind_PxMeshFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxMeshFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMeshGeometryFlags_PxMeshGeometryFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshGeometryFlags_PxMeshGeometryFlags_1');
  _emscripten_bind_PxMeshGeometryFlags_PxMeshGeometryFlags_1 = Module['_emscripten_bind_PxMeshGeometryFlags_PxMeshGeometryFlags_1'] = createExportWrapper('emscripten_bind_PxMeshGeometryFlags_PxMeshGeometryFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxMeshGeometryFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshGeometryFlags_isSet_1');
  _emscripten_bind_PxMeshGeometryFlags_isSet_1 = Module['_emscripten_bind_PxMeshGeometryFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxMeshGeometryFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMeshGeometryFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshGeometryFlags_raise_1');
  _emscripten_bind_PxMeshGeometryFlags_raise_1 = Module['_emscripten_bind_PxMeshGeometryFlags_raise_1'] = createExportWrapper('emscripten_bind_PxMeshGeometryFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMeshGeometryFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshGeometryFlags_clear_1');
  _emscripten_bind_PxMeshGeometryFlags_clear_1 = Module['_emscripten_bind_PxMeshGeometryFlags_clear_1'] = createExportWrapper('emscripten_bind_PxMeshGeometryFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMeshGeometryFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshGeometryFlags___destroy___0');
  _emscripten_bind_PxMeshGeometryFlags___destroy___0 = Module['_emscripten_bind_PxMeshGeometryFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxMeshGeometryFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMeshOverlapUtil_PxMeshOverlapUtil_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshOverlapUtil_PxMeshOverlapUtil_0');
  _emscripten_bind_PxMeshOverlapUtil_PxMeshOverlapUtil_0 = Module['_emscripten_bind_PxMeshOverlapUtil_PxMeshOverlapUtil_0'] = createExportWrapper('emscripten_bind_PxMeshOverlapUtil_PxMeshOverlapUtil_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxMeshOverlapUtil_findOverlap_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshOverlapUtil_findOverlap_4');
  _emscripten_bind_PxMeshOverlapUtil_findOverlap_4 = Module['_emscripten_bind_PxMeshOverlapUtil_findOverlap_4'] = createExportWrapper('emscripten_bind_PxMeshOverlapUtil_findOverlap_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxMeshOverlapUtil_getResults_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshOverlapUtil_getResults_0');
  _emscripten_bind_PxMeshOverlapUtil_getResults_0 = Module['_emscripten_bind_PxMeshOverlapUtil_getResults_0'] = createExportWrapper('emscripten_bind_PxMeshOverlapUtil_getResults_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMeshOverlapUtil_getNbResults_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshOverlapUtil_getNbResults_0');
  _emscripten_bind_PxMeshOverlapUtil_getNbResults_0 = Module['_emscripten_bind_PxMeshOverlapUtil_getNbResults_0'] = createExportWrapper('emscripten_bind_PxMeshOverlapUtil_getNbResults_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMeshOverlapUtil___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshOverlapUtil___destroy___0');
  _emscripten_bind_PxMeshOverlapUtil___destroy___0 = Module['_emscripten_bind_PxMeshOverlapUtil___destroy___0'] = createExportWrapper('emscripten_bind_PxMeshOverlapUtil___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMeshPreprocessingFlags_PxMeshPreprocessingFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshPreprocessingFlags_PxMeshPreprocessingFlags_1');
  _emscripten_bind_PxMeshPreprocessingFlags_PxMeshPreprocessingFlags_1 = Module['_emscripten_bind_PxMeshPreprocessingFlags_PxMeshPreprocessingFlags_1'] = createExportWrapper('emscripten_bind_PxMeshPreprocessingFlags_PxMeshPreprocessingFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxMeshPreprocessingFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshPreprocessingFlags_isSet_1');
  _emscripten_bind_PxMeshPreprocessingFlags_isSet_1 = Module['_emscripten_bind_PxMeshPreprocessingFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxMeshPreprocessingFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMeshPreprocessingFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshPreprocessingFlags_raise_1');
  _emscripten_bind_PxMeshPreprocessingFlags_raise_1 = Module['_emscripten_bind_PxMeshPreprocessingFlags_raise_1'] = createExportWrapper('emscripten_bind_PxMeshPreprocessingFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMeshPreprocessingFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshPreprocessingFlags_clear_1');
  _emscripten_bind_PxMeshPreprocessingFlags_clear_1 = Module['_emscripten_bind_PxMeshPreprocessingFlags_clear_1'] = createExportWrapper('emscripten_bind_PxMeshPreprocessingFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMeshPreprocessingFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshPreprocessingFlags___destroy___0');
  _emscripten_bind_PxMeshPreprocessingFlags___destroy___0 = Module['_emscripten_bind_PxMeshPreprocessingFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxMeshPreprocessingFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMeshScale_PxMeshScale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshScale_PxMeshScale_0');
  _emscripten_bind_PxMeshScale_PxMeshScale_0 = Module['_emscripten_bind_PxMeshScale_PxMeshScale_0'] = createExportWrapper('emscripten_bind_PxMeshScale_PxMeshScale_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxMeshScale_PxMeshScale_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshScale_PxMeshScale_1');
  _emscripten_bind_PxMeshScale_PxMeshScale_1 = Module['_emscripten_bind_PxMeshScale_PxMeshScale_1'] = createExportWrapper('emscripten_bind_PxMeshScale_PxMeshScale_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxMeshScale_PxMeshScale_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshScale_PxMeshScale_2');
  _emscripten_bind_PxMeshScale_PxMeshScale_2 = Module['_emscripten_bind_PxMeshScale_PxMeshScale_2'] = createExportWrapper('emscripten_bind_PxMeshScale_PxMeshScale_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxMeshScale___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMeshScale___destroy___0');
  _emscripten_bind_PxMeshScale___destroy___0 = Module['_emscripten_bind_PxMeshScale___destroy___0'] = createExportWrapper('emscripten_bind_PxMeshScale___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMidphaseDesc_PxMidphaseDesc_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMidphaseDesc_PxMidphaseDesc_0');
  _emscripten_bind_PxMidphaseDesc_PxMidphaseDesc_0 = Module['_emscripten_bind_PxMidphaseDesc_PxMidphaseDesc_0'] = createExportWrapper('emscripten_bind_PxMidphaseDesc_PxMidphaseDesc_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxMidphaseDesc_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMidphaseDesc_getType_0');
  _emscripten_bind_PxMidphaseDesc_getType_0 = Module['_emscripten_bind_PxMidphaseDesc_getType_0'] = createExportWrapper('emscripten_bind_PxMidphaseDesc_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMidphaseDesc_setToDefault_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMidphaseDesc_setToDefault_1');
  _emscripten_bind_PxMidphaseDesc_setToDefault_1 = Module['_emscripten_bind_PxMidphaseDesc_setToDefault_1'] = createExportWrapper('emscripten_bind_PxMidphaseDesc_setToDefault_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMidphaseDesc_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMidphaseDesc_isValid_0');
  _emscripten_bind_PxMidphaseDesc_isValid_0 = Module['_emscripten_bind_PxMidphaseDesc_isValid_0'] = createExportWrapper('emscripten_bind_PxMidphaseDesc_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMidphaseDesc_get_mBVH33Desc_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMidphaseDesc_get_mBVH33Desc_0');
  _emscripten_bind_PxMidphaseDesc_get_mBVH33Desc_0 = Module['_emscripten_bind_PxMidphaseDesc_get_mBVH33Desc_0'] = createExportWrapper('emscripten_bind_PxMidphaseDesc_get_mBVH33Desc_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMidphaseDesc_set_mBVH33Desc_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMidphaseDesc_set_mBVH33Desc_1');
  _emscripten_bind_PxMidphaseDesc_set_mBVH33Desc_1 = Module['_emscripten_bind_PxMidphaseDesc_set_mBVH33Desc_1'] = createExportWrapper('emscripten_bind_PxMidphaseDesc_set_mBVH33Desc_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMidphaseDesc_get_mBVH34Desc_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMidphaseDesc_get_mBVH34Desc_0');
  _emscripten_bind_PxMidphaseDesc_get_mBVH34Desc_0 = Module['_emscripten_bind_PxMidphaseDesc_get_mBVH34Desc_0'] = createExportWrapper('emscripten_bind_PxMidphaseDesc_get_mBVH34Desc_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxMidphaseDesc_set_mBVH34Desc_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMidphaseDesc_set_mBVH34Desc_1');
  _emscripten_bind_PxMidphaseDesc_set_mBVH34Desc_1 = Module['_emscripten_bind_PxMidphaseDesc_set_mBVH34Desc_1'] = createExportWrapper('emscripten_bind_PxMidphaseDesc_set_mBVH34Desc_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxMidphaseDesc___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxMidphaseDesc___destroy___0');
  _emscripten_bind_PxMidphaseDesc___destroy___0 = Module['_emscripten_bind_PxMidphaseDesc___destroy___0'] = createExportWrapper('emscripten_bind_PxMidphaseDesc___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxObstacleContext_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacleContext_release_0');
  _emscripten_bind_PxObstacleContext_release_0 = Module['_emscripten_bind_PxObstacleContext_release_0'] = createExportWrapper('emscripten_bind_PxObstacleContext_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxObstacleContext_getControllerManager_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacleContext_getControllerManager_0');
  _emscripten_bind_PxObstacleContext_getControllerManager_0 = Module['_emscripten_bind_PxObstacleContext_getControllerManager_0'] = createExportWrapper('emscripten_bind_PxObstacleContext_getControllerManager_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxObstacleContext_addObstacle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacleContext_addObstacle_1');
  _emscripten_bind_PxObstacleContext_addObstacle_1 = Module['_emscripten_bind_PxObstacleContext_addObstacle_1'] = createExportWrapper('emscripten_bind_PxObstacleContext_addObstacle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxObstacleContext_removeObstacle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacleContext_removeObstacle_1');
  _emscripten_bind_PxObstacleContext_removeObstacle_1 = Module['_emscripten_bind_PxObstacleContext_removeObstacle_1'] = createExportWrapper('emscripten_bind_PxObstacleContext_removeObstacle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxObstacleContext_updateObstacle_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacleContext_updateObstacle_2');
  _emscripten_bind_PxObstacleContext_updateObstacle_2 = Module['_emscripten_bind_PxObstacleContext_updateObstacle_2'] = createExportWrapper('emscripten_bind_PxObstacleContext_updateObstacle_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxObstacleContext_getNbObstacles_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacleContext_getNbObstacles_0');
  _emscripten_bind_PxObstacleContext_getNbObstacles_0 = Module['_emscripten_bind_PxObstacleContext_getNbObstacles_0'] = createExportWrapper('emscripten_bind_PxObstacleContext_getNbObstacles_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxObstacleContext_getObstacle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacleContext_getObstacle_1');
  _emscripten_bind_PxObstacleContext_getObstacle_1 = Module['_emscripten_bind_PxObstacleContext_getObstacle_1'] = createExportWrapper('emscripten_bind_PxObstacleContext_getObstacle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxObstacleContext_getObstacleByHandle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacleContext_getObstacleByHandle_1');
  _emscripten_bind_PxObstacleContext_getObstacleByHandle_1 = Module['_emscripten_bind_PxObstacleContext_getObstacleByHandle_1'] = createExportWrapper('emscripten_bind_PxObstacleContext_getObstacleByHandle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxObstacleContext___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxObstacleContext___destroy___0');
  _emscripten_bind_PxObstacleContext___destroy___0 = Module['_emscripten_bind_PxObstacleContext___destroy___0'] = createExportWrapper('emscripten_bind_PxObstacleContext___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOmniPvd_startSampling_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOmniPvd_startSampling_0');
  _emscripten_bind_PxOmniPvd_startSampling_0 = Module['_emscripten_bind_PxOmniPvd_startSampling_0'] = createExportWrapper('emscripten_bind_PxOmniPvd_startSampling_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOmniPvd_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOmniPvd_release_0');
  _emscripten_bind_PxOmniPvd_release_0 = Module['_emscripten_bind_PxOmniPvd_release_0'] = createExportWrapper('emscripten_bind_PxOmniPvd_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOmniPvd___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOmniPvd___destroy___0');
  _emscripten_bind_PxOmniPvd___destroy___0 = Module['_emscripten_bind_PxOmniPvd___destroy___0'] = createExportWrapper('emscripten_bind_PxOmniPvd___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapBuffer10_PxOverlapBuffer10_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapBuffer10_PxOverlapBuffer10_0');
  _emscripten_bind_PxOverlapBuffer10_PxOverlapBuffer10_0 = Module['_emscripten_bind_PxOverlapBuffer10_PxOverlapBuffer10_0'] = createExportWrapper('emscripten_bind_PxOverlapBuffer10_PxOverlapBuffer10_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxOverlapBuffer10_getNbAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapBuffer10_getNbAnyHits_0');
  _emscripten_bind_PxOverlapBuffer10_getNbAnyHits_0 = Module['_emscripten_bind_PxOverlapBuffer10_getNbAnyHits_0'] = createExportWrapper('emscripten_bind_PxOverlapBuffer10_getNbAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapBuffer10_getAnyHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapBuffer10_getAnyHit_1');
  _emscripten_bind_PxOverlapBuffer10_getAnyHit_1 = Module['_emscripten_bind_PxOverlapBuffer10_getAnyHit_1'] = createExportWrapper('emscripten_bind_PxOverlapBuffer10_getAnyHit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxOverlapBuffer10_getNbTouches_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapBuffer10_getNbTouches_0');
  _emscripten_bind_PxOverlapBuffer10_getNbTouches_0 = Module['_emscripten_bind_PxOverlapBuffer10_getNbTouches_0'] = createExportWrapper('emscripten_bind_PxOverlapBuffer10_getNbTouches_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapBuffer10_getTouches_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapBuffer10_getTouches_0');
  _emscripten_bind_PxOverlapBuffer10_getTouches_0 = Module['_emscripten_bind_PxOverlapBuffer10_getTouches_0'] = createExportWrapper('emscripten_bind_PxOverlapBuffer10_getTouches_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapBuffer10_getTouch_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapBuffer10_getTouch_1');
  _emscripten_bind_PxOverlapBuffer10_getTouch_1 = Module['_emscripten_bind_PxOverlapBuffer10_getTouch_1'] = createExportWrapper('emscripten_bind_PxOverlapBuffer10_getTouch_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxOverlapBuffer10_getMaxNbTouches_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapBuffer10_getMaxNbTouches_0');
  _emscripten_bind_PxOverlapBuffer10_getMaxNbTouches_0 = Module['_emscripten_bind_PxOverlapBuffer10_getMaxNbTouches_0'] = createExportWrapper('emscripten_bind_PxOverlapBuffer10_getMaxNbTouches_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapBuffer10_hasAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapBuffer10_hasAnyHits_0');
  _emscripten_bind_PxOverlapBuffer10_hasAnyHits_0 = Module['_emscripten_bind_PxOverlapBuffer10_hasAnyHits_0'] = createExportWrapper('emscripten_bind_PxOverlapBuffer10_hasAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapBuffer10_get_block_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapBuffer10_get_block_0');
  _emscripten_bind_PxOverlapBuffer10_get_block_0 = Module['_emscripten_bind_PxOverlapBuffer10_get_block_0'] = createExportWrapper('emscripten_bind_PxOverlapBuffer10_get_block_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapBuffer10_set_block_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapBuffer10_set_block_1');
  _emscripten_bind_PxOverlapBuffer10_set_block_1 = Module['_emscripten_bind_PxOverlapBuffer10_set_block_1'] = createExportWrapper('emscripten_bind_PxOverlapBuffer10_set_block_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxOverlapBuffer10_get_hasBlock_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapBuffer10_get_hasBlock_0');
  _emscripten_bind_PxOverlapBuffer10_get_hasBlock_0 = Module['_emscripten_bind_PxOverlapBuffer10_get_hasBlock_0'] = createExportWrapper('emscripten_bind_PxOverlapBuffer10_get_hasBlock_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapBuffer10_set_hasBlock_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapBuffer10_set_hasBlock_1');
  _emscripten_bind_PxOverlapBuffer10_set_hasBlock_1 = Module['_emscripten_bind_PxOverlapBuffer10_set_hasBlock_1'] = createExportWrapper('emscripten_bind_PxOverlapBuffer10_set_hasBlock_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxOverlapBuffer10___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapBuffer10___destroy___0');
  _emscripten_bind_PxOverlapBuffer10___destroy___0 = Module['_emscripten_bind_PxOverlapBuffer10___destroy___0'] = createExportWrapper('emscripten_bind_PxOverlapBuffer10___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapHit_get_actor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapHit_get_actor_0');
  _emscripten_bind_PxOverlapHit_get_actor_0 = Module['_emscripten_bind_PxOverlapHit_get_actor_0'] = createExportWrapper('emscripten_bind_PxOverlapHit_get_actor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapHit_set_actor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapHit_set_actor_1');
  _emscripten_bind_PxOverlapHit_set_actor_1 = Module['_emscripten_bind_PxOverlapHit_set_actor_1'] = createExportWrapper('emscripten_bind_PxOverlapHit_set_actor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxOverlapHit_get_shape_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapHit_get_shape_0');
  _emscripten_bind_PxOverlapHit_get_shape_0 = Module['_emscripten_bind_PxOverlapHit_get_shape_0'] = createExportWrapper('emscripten_bind_PxOverlapHit_get_shape_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapHit_set_shape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapHit_set_shape_1');
  _emscripten_bind_PxOverlapHit_set_shape_1 = Module['_emscripten_bind_PxOverlapHit_set_shape_1'] = createExportWrapper('emscripten_bind_PxOverlapHit_set_shape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxOverlapHit_get_faceIndex_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapHit_get_faceIndex_0');
  _emscripten_bind_PxOverlapHit_get_faceIndex_0 = Module['_emscripten_bind_PxOverlapHit_get_faceIndex_0'] = createExportWrapper('emscripten_bind_PxOverlapHit_get_faceIndex_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapHit_set_faceIndex_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapHit_set_faceIndex_1');
  _emscripten_bind_PxOverlapHit_set_faceIndex_1 = Module['_emscripten_bind_PxOverlapHit_set_faceIndex_1'] = createExportWrapper('emscripten_bind_PxOverlapHit_set_faceIndex_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxOverlapHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapHit___destroy___0');
  _emscripten_bind_PxOverlapHit___destroy___0 = Module['_emscripten_bind_PxOverlapHit___destroy___0'] = createExportWrapper('emscripten_bind_PxOverlapHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapResult_PxOverlapResult_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapResult_PxOverlapResult_0');
  _emscripten_bind_PxOverlapResult_PxOverlapResult_0 = Module['_emscripten_bind_PxOverlapResult_PxOverlapResult_0'] = createExportWrapper('emscripten_bind_PxOverlapResult_PxOverlapResult_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxOverlapResult_getNbAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapResult_getNbAnyHits_0');
  _emscripten_bind_PxOverlapResult_getNbAnyHits_0 = Module['_emscripten_bind_PxOverlapResult_getNbAnyHits_0'] = createExportWrapper('emscripten_bind_PxOverlapResult_getNbAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapResult_getAnyHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapResult_getAnyHit_1');
  _emscripten_bind_PxOverlapResult_getAnyHit_1 = Module['_emscripten_bind_PxOverlapResult_getAnyHit_1'] = createExportWrapper('emscripten_bind_PxOverlapResult_getAnyHit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxOverlapResult_getNbTouches_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapResult_getNbTouches_0');
  _emscripten_bind_PxOverlapResult_getNbTouches_0 = Module['_emscripten_bind_PxOverlapResult_getNbTouches_0'] = createExportWrapper('emscripten_bind_PxOverlapResult_getNbTouches_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapResult_getTouch_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapResult_getTouch_1');
  _emscripten_bind_PxOverlapResult_getTouch_1 = Module['_emscripten_bind_PxOverlapResult_getTouch_1'] = createExportWrapper('emscripten_bind_PxOverlapResult_getTouch_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxOverlapResult_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapResult_clear_0');
  _emscripten_bind_PxOverlapResult_clear_0 = Module['_emscripten_bind_PxOverlapResult_clear_0'] = createExportWrapper('emscripten_bind_PxOverlapResult_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapResult_hasAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapResult_hasAnyHits_0');
  _emscripten_bind_PxOverlapResult_hasAnyHits_0 = Module['_emscripten_bind_PxOverlapResult_hasAnyHits_0'] = createExportWrapper('emscripten_bind_PxOverlapResult_hasAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapResult_get_block_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapResult_get_block_0');
  _emscripten_bind_PxOverlapResult_get_block_0 = Module['_emscripten_bind_PxOverlapResult_get_block_0'] = createExportWrapper('emscripten_bind_PxOverlapResult_get_block_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapResult_set_block_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapResult_set_block_1');
  _emscripten_bind_PxOverlapResult_set_block_1 = Module['_emscripten_bind_PxOverlapResult_set_block_1'] = createExportWrapper('emscripten_bind_PxOverlapResult_set_block_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxOverlapResult_get_hasBlock_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapResult_get_hasBlock_0');
  _emscripten_bind_PxOverlapResult_get_hasBlock_0 = Module['_emscripten_bind_PxOverlapResult_get_hasBlock_0'] = createExportWrapper('emscripten_bind_PxOverlapResult_get_hasBlock_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxOverlapResult_set_hasBlock_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapResult_set_hasBlock_1');
  _emscripten_bind_PxOverlapResult_set_hasBlock_1 = Module['_emscripten_bind_PxOverlapResult_set_hasBlock_1'] = createExportWrapper('emscripten_bind_PxOverlapResult_set_hasBlock_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxOverlapResult___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxOverlapResult___destroy___0');
  _emscripten_bind_PxOverlapResult___destroy___0 = Module['_emscripten_bind_PxOverlapResult___destroy___0'] = createExportWrapper('emscripten_bind_PxOverlapResult___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPairFlags_PxPairFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPairFlags_PxPairFlags_1');
  _emscripten_bind_PxPairFlags_PxPairFlags_1 = Module['_emscripten_bind_PxPairFlags_PxPairFlags_1'] = createExportWrapper('emscripten_bind_PxPairFlags_PxPairFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxPairFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPairFlags_isSet_1');
  _emscripten_bind_PxPairFlags_isSet_1 = Module['_emscripten_bind_PxPairFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxPairFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPairFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPairFlags_raise_1');
  _emscripten_bind_PxPairFlags_raise_1 = Module['_emscripten_bind_PxPairFlags_raise_1'] = createExportWrapper('emscripten_bind_PxPairFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPairFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPairFlags_clear_1');
  _emscripten_bind_PxPairFlags_clear_1 = Module['_emscripten_bind_PxPairFlags_clear_1'] = createExportWrapper('emscripten_bind_PxPairFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPairFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPairFlags___destroy___0');
  _emscripten_bind_PxPairFlags___destroy___0 = Module['_emscripten_bind_PxPairFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxPairFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_release_0');
  _emscripten_bind_PxPhysics_release_0 = Module['_emscripten_bind_PxPhysics_release_0'] = createExportWrapper('emscripten_bind_PxPhysics_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_getFoundation_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_getFoundation_0');
  _emscripten_bind_PxPhysics_getFoundation_0 = Module['_emscripten_bind_PxPhysics_getFoundation_0'] = createExportWrapper('emscripten_bind_PxPhysics_getFoundation_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_createAggregate_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_createAggregate_3');
  _emscripten_bind_PxPhysics_createAggregate_3 = Module['_emscripten_bind_PxPhysics_createAggregate_3'] = createExportWrapper('emscripten_bind_PxPhysics_createAggregate_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_getTolerancesScale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_getTolerancesScale_0');
  _emscripten_bind_PxPhysics_getTolerancesScale_0 = Module['_emscripten_bind_PxPhysics_getTolerancesScale_0'] = createExportWrapper('emscripten_bind_PxPhysics_getTolerancesScale_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_createScene_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_createScene_1');
  _emscripten_bind_PxPhysics_createScene_1 = Module['_emscripten_bind_PxPhysics_createScene_1'] = createExportWrapper('emscripten_bind_PxPhysics_createScene_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_createRigidStatic_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_createRigidStatic_1');
  _emscripten_bind_PxPhysics_createRigidStatic_1 = Module['_emscripten_bind_PxPhysics_createRigidStatic_1'] = createExportWrapper('emscripten_bind_PxPhysics_createRigidStatic_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_createRigidDynamic_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_createRigidDynamic_1');
  _emscripten_bind_PxPhysics_createRigidDynamic_1 = Module['_emscripten_bind_PxPhysics_createRigidDynamic_1'] = createExportWrapper('emscripten_bind_PxPhysics_createRigidDynamic_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_createShape_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_createShape_2');
  _emscripten_bind_PxPhysics_createShape_2 = Module['_emscripten_bind_PxPhysics_createShape_2'] = createExportWrapper('emscripten_bind_PxPhysics_createShape_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_createShape_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_createShape_3');
  _emscripten_bind_PxPhysics_createShape_3 = Module['_emscripten_bind_PxPhysics_createShape_3'] = createExportWrapper('emscripten_bind_PxPhysics_createShape_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_createShape_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_createShape_4');
  _emscripten_bind_PxPhysics_createShape_4 = Module['_emscripten_bind_PxPhysics_createShape_4'] = createExportWrapper('emscripten_bind_PxPhysics_createShape_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_createTriangleMesh_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_createTriangleMesh_1');
  _emscripten_bind_PxPhysics_createTriangleMesh_1 = Module['_emscripten_bind_PxPhysics_createTriangleMesh_1'] = createExportWrapper('emscripten_bind_PxPhysics_createTriangleMesh_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_createConvexMesh_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_createConvexMesh_1');
  _emscripten_bind_PxPhysics_createConvexMesh_1 = Module['_emscripten_bind_PxPhysics_createConvexMesh_1'] = createExportWrapper('emscripten_bind_PxPhysics_createConvexMesh_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_getNbShapes_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_getNbShapes_0');
  _emscripten_bind_PxPhysics_getNbShapes_0 = Module['_emscripten_bind_PxPhysics_getNbShapes_0'] = createExportWrapper('emscripten_bind_PxPhysics_getNbShapes_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_createArticulationReducedCoordinate_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_createArticulationReducedCoordinate_0');
  _emscripten_bind_PxPhysics_createArticulationReducedCoordinate_0 = Module['_emscripten_bind_PxPhysics_createArticulationReducedCoordinate_0'] = createExportWrapper('emscripten_bind_PxPhysics_createArticulationReducedCoordinate_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_createMaterial_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_createMaterial_3');
  _emscripten_bind_PxPhysics_createMaterial_3 = Module['_emscripten_bind_PxPhysics_createMaterial_3'] = createExportWrapper('emscripten_bind_PxPhysics_createMaterial_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxPhysics_getPhysicsInsertionCallback_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics_getPhysicsInsertionCallback_0');
  _emscripten_bind_PxPhysics_getPhysicsInsertionCallback_0 = Module['_emscripten_bind_PxPhysics_getPhysicsInsertionCallback_0'] = createExportWrapper('emscripten_bind_PxPhysics_getPhysicsInsertionCallback_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPhysics___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPhysics___destroy___0');
  _emscripten_bind_PxPhysics___destroy___0 = Module['_emscripten_bind_PxPhysics___destroy___0'] = createExportWrapper('emscripten_bind_PxPhysics___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPlane_PxPlane_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_PxPlane_0');
  _emscripten_bind_PxPlane_PxPlane_0 = Module['_emscripten_bind_PxPlane_PxPlane_0'] = createExportWrapper('emscripten_bind_PxPlane_PxPlane_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxPlane_PxPlane_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_PxPlane_2');
  _emscripten_bind_PxPlane_PxPlane_2 = Module['_emscripten_bind_PxPlane_PxPlane_2'] = createExportWrapper('emscripten_bind_PxPlane_PxPlane_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxPlane_PxPlane_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_PxPlane_3');
  _emscripten_bind_PxPlane_PxPlane_3 = Module['_emscripten_bind_PxPlane_PxPlane_3'] = createExportWrapper('emscripten_bind_PxPlane_PxPlane_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxPlane_PxPlane_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_PxPlane_4');
  _emscripten_bind_PxPlane_PxPlane_4 = Module['_emscripten_bind_PxPlane_PxPlane_4'] = createExportWrapper('emscripten_bind_PxPlane_PxPlane_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxPlane_distance_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_distance_1');
  _emscripten_bind_PxPlane_distance_1 = Module['_emscripten_bind_PxPlane_distance_1'] = createExportWrapper('emscripten_bind_PxPlane_distance_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPlane_contains_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_contains_1');
  _emscripten_bind_PxPlane_contains_1 = Module['_emscripten_bind_PxPlane_contains_1'] = createExportWrapper('emscripten_bind_PxPlane_contains_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPlane_project_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_project_1');
  _emscripten_bind_PxPlane_project_1 = Module['_emscripten_bind_PxPlane_project_1'] = createExportWrapper('emscripten_bind_PxPlane_project_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPlane_pointInPlane_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_pointInPlane_0');
  _emscripten_bind_PxPlane_pointInPlane_0 = Module['_emscripten_bind_PxPlane_pointInPlane_0'] = createExportWrapper('emscripten_bind_PxPlane_pointInPlane_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPlane_normalize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_normalize_0');
  _emscripten_bind_PxPlane_normalize_0 = Module['_emscripten_bind_PxPlane_normalize_0'] = createExportWrapper('emscripten_bind_PxPlane_normalize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPlane_transform_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_transform_1');
  _emscripten_bind_PxPlane_transform_1 = Module['_emscripten_bind_PxPlane_transform_1'] = createExportWrapper('emscripten_bind_PxPlane_transform_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPlane_inverseTransform_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_inverseTransform_1');
  _emscripten_bind_PxPlane_inverseTransform_1 = Module['_emscripten_bind_PxPlane_inverseTransform_1'] = createExportWrapper('emscripten_bind_PxPlane_inverseTransform_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPlane_get_n_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_get_n_0');
  _emscripten_bind_PxPlane_get_n_0 = Module['_emscripten_bind_PxPlane_get_n_0'] = createExportWrapper('emscripten_bind_PxPlane_get_n_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPlane_set_n_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_set_n_1');
  _emscripten_bind_PxPlane_set_n_1 = Module['_emscripten_bind_PxPlane_set_n_1'] = createExportWrapper('emscripten_bind_PxPlane_set_n_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPlane_get_d_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_get_d_0');
  _emscripten_bind_PxPlane_get_d_0 = Module['_emscripten_bind_PxPlane_get_d_0'] = createExportWrapper('emscripten_bind_PxPlane_get_d_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPlane_set_d_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane_set_d_1');
  _emscripten_bind_PxPlane_set_d_1 = Module['_emscripten_bind_PxPlane_set_d_1'] = createExportWrapper('emscripten_bind_PxPlane_set_d_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPlane___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlane___destroy___0');
  _emscripten_bind_PxPlane___destroy___0 = Module['_emscripten_bind_PxPlane___destroy___0'] = createExportWrapper('emscripten_bind_PxPlane___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPlaneGeometry_PxPlaneGeometry_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlaneGeometry_PxPlaneGeometry_0');
  _emscripten_bind_PxPlaneGeometry_PxPlaneGeometry_0 = Module['_emscripten_bind_PxPlaneGeometry_PxPlaneGeometry_0'] = createExportWrapper('emscripten_bind_PxPlaneGeometry_PxPlaneGeometry_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxPlaneGeometry_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlaneGeometry_getType_0');
  _emscripten_bind_PxPlaneGeometry_getType_0 = Module['_emscripten_bind_PxPlaneGeometry_getType_0'] = createExportWrapper('emscripten_bind_PxPlaneGeometry_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPlaneGeometry___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPlaneGeometry___destroy___0');
  _emscripten_bind_PxPlaneGeometry___destroy___0 = Module['_emscripten_bind_PxPlaneGeometry___destroy___0'] = createExportWrapper('emscripten_bind_PxPlaneGeometry___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getPosition_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getPosition_0');
  _emscripten_bind_PxPrismaticJoint_getPosition_0 = Module['_emscripten_bind_PxPrismaticJoint_getPosition_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getPosition_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getVelocity_0');
  _emscripten_bind_PxPrismaticJoint_getVelocity_0 = Module['_emscripten_bind_PxPrismaticJoint_getVelocity_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setLimit_1');
  _emscripten_bind_PxPrismaticJoint_setLimit_1 = Module['_emscripten_bind_PxPrismaticJoint_setLimit_1'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setPrismaticJointFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setPrismaticJointFlags_1');
  _emscripten_bind_PxPrismaticJoint_setPrismaticJointFlags_1 = Module['_emscripten_bind_PxPrismaticJoint_setPrismaticJointFlags_1'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setPrismaticJointFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setPrismaticJointFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setPrismaticJointFlag_2');
  _emscripten_bind_PxPrismaticJoint_setPrismaticJointFlag_2 = Module['_emscripten_bind_PxPrismaticJoint_setPrismaticJointFlag_2'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setPrismaticJointFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getPrismaticJointFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getPrismaticJointFlags_0');
  _emscripten_bind_PxPrismaticJoint_getPrismaticJointFlags_0 = Module['_emscripten_bind_PxPrismaticJoint_getPrismaticJointFlags_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getPrismaticJointFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_release_0');
  _emscripten_bind_PxPrismaticJoint_release_0 = Module['_emscripten_bind_PxPrismaticJoint_release_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getConcreteTypeName_0');
  _emscripten_bind_PxPrismaticJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxPrismaticJoint_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getConcreteType_0');
  _emscripten_bind_PxPrismaticJoint_getConcreteType_0 = Module['_emscripten_bind_PxPrismaticJoint_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setBaseFlag_2');
  _emscripten_bind_PxPrismaticJoint_setBaseFlag_2 = Module['_emscripten_bind_PxPrismaticJoint_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setBaseFlags_1');
  _emscripten_bind_PxPrismaticJoint_setBaseFlags_1 = Module['_emscripten_bind_PxPrismaticJoint_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getBaseFlags_0');
  _emscripten_bind_PxPrismaticJoint_getBaseFlags_0 = Module['_emscripten_bind_PxPrismaticJoint_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_isReleasable_0');
  _emscripten_bind_PxPrismaticJoint_isReleasable_0 = Module['_emscripten_bind_PxPrismaticJoint_isReleasable_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setActors_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setActors_2');
  _emscripten_bind_PxPrismaticJoint_setActors_2 = Module['_emscripten_bind_PxPrismaticJoint_setActors_2'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setActors_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setLocalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setLocalPose_2');
  _emscripten_bind_PxPrismaticJoint_setLocalPose_2 = Module['_emscripten_bind_PxPrismaticJoint_setLocalPose_2'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setLocalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getLocalPose_1');
  _emscripten_bind_PxPrismaticJoint_getLocalPose_1 = Module['_emscripten_bind_PxPrismaticJoint_getLocalPose_1'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getRelativeTransform_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getRelativeTransform_0');
  _emscripten_bind_PxPrismaticJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxPrismaticJoint_getRelativeTransform_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getRelativeTransform_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getRelativeLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getRelativeLinearVelocity_0');
  _emscripten_bind_PxPrismaticJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxPrismaticJoint_getRelativeLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getRelativeLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getRelativeAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getRelativeAngularVelocity_0');
  _emscripten_bind_PxPrismaticJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxPrismaticJoint_getRelativeAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getRelativeAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setBreakForce_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setBreakForce_2');
  _emscripten_bind_PxPrismaticJoint_setBreakForce_2 = Module['_emscripten_bind_PxPrismaticJoint_setBreakForce_2'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setBreakForce_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setConstraintFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setConstraintFlags_1');
  _emscripten_bind_PxPrismaticJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxPrismaticJoint_setConstraintFlags_1'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setConstraintFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setConstraintFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setConstraintFlag_2');
  _emscripten_bind_PxPrismaticJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxPrismaticJoint_setConstraintFlag_2'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setConstraintFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getConstraintFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getConstraintFlags_0');
  _emscripten_bind_PxPrismaticJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxPrismaticJoint_getConstraintFlags_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getConstraintFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setInvMassScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setInvMassScale0_1');
  _emscripten_bind_PxPrismaticJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxPrismaticJoint_setInvMassScale0_1'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setInvMassScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getInvMassScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getInvMassScale0_0');
  _emscripten_bind_PxPrismaticJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxPrismaticJoint_getInvMassScale0_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getInvMassScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setInvMassScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setInvMassScale1_1');
  _emscripten_bind_PxPrismaticJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxPrismaticJoint_setInvMassScale1_1'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setInvMassScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getInvMassScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getInvMassScale1_0');
  _emscripten_bind_PxPrismaticJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxPrismaticJoint_getInvMassScale1_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getInvMassScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setInvInertiaScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setInvInertiaScale0_1');
  _emscripten_bind_PxPrismaticJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxPrismaticJoint_setInvInertiaScale0_1'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setInvInertiaScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getInvInertiaScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getInvInertiaScale0_0');
  _emscripten_bind_PxPrismaticJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxPrismaticJoint_getInvInertiaScale0_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getInvInertiaScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setInvInertiaScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setInvInertiaScale1_1');
  _emscripten_bind_PxPrismaticJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxPrismaticJoint_setInvInertiaScale1_1'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setInvInertiaScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getInvInertiaScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getInvInertiaScale1_0');
  _emscripten_bind_PxPrismaticJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxPrismaticJoint_getInvInertiaScale1_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getInvInertiaScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getConstraint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getConstraint_0');
  _emscripten_bind_PxPrismaticJoint_getConstraint_0 = Module['_emscripten_bind_PxPrismaticJoint_getConstraint_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getConstraint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_setName_1');
  _emscripten_bind_PxPrismaticJoint_setName_1 = Module['_emscripten_bind_PxPrismaticJoint_setName_1'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getName_0');
  _emscripten_bind_PxPrismaticJoint_getName_0 = Module['_emscripten_bind_PxPrismaticJoint_getName_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_getScene_0');
  _emscripten_bind_PxPrismaticJoint_getScene_0 = Module['_emscripten_bind_PxPrismaticJoint_getScene_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_get_userData_0');
  _emscripten_bind_PxPrismaticJoint_get_userData_0 = Module['_emscripten_bind_PxPrismaticJoint_get_userData_0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint_set_userData_1');
  _emscripten_bind_PxPrismaticJoint_set_userData_1 = Module['_emscripten_bind_PxPrismaticJoint_set_userData_1'] = createExportWrapper('emscripten_bind_PxPrismaticJoint_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJoint___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJoint___destroy___0');
  _emscripten_bind_PxPrismaticJoint___destroy___0 = Module['_emscripten_bind_PxPrismaticJoint___destroy___0'] = createExportWrapper('emscripten_bind_PxPrismaticJoint___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJointFlags_PxPrismaticJointFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJointFlags_PxPrismaticJointFlags_1');
  _emscripten_bind_PxPrismaticJointFlags_PxPrismaticJointFlags_1 = Module['_emscripten_bind_PxPrismaticJointFlags_PxPrismaticJointFlags_1'] = createExportWrapper('emscripten_bind_PxPrismaticJointFlags_PxPrismaticJointFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJointFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJointFlags_isSet_1');
  _emscripten_bind_PxPrismaticJointFlags_isSet_1 = Module['_emscripten_bind_PxPrismaticJointFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxPrismaticJointFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJointFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJointFlags_raise_1');
  _emscripten_bind_PxPrismaticJointFlags_raise_1 = Module['_emscripten_bind_PxPrismaticJointFlags_raise_1'] = createExportWrapper('emscripten_bind_PxPrismaticJointFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJointFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJointFlags_clear_1');
  _emscripten_bind_PxPrismaticJointFlags_clear_1 = Module['_emscripten_bind_PxPrismaticJointFlags_clear_1'] = createExportWrapper('emscripten_bind_PxPrismaticJointFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPrismaticJointFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPrismaticJointFlags___destroy___0');
  _emscripten_bind_PxPrismaticJointFlags___destroy___0 = Module['_emscripten_bind_PxPrismaticJointFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxPrismaticJointFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPvd_connect_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvd_connect_2');
  _emscripten_bind_PxPvd_connect_2 = Module['_emscripten_bind_PxPvd_connect_2'] = createExportWrapper('emscripten_bind_PxPvd_connect_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxPvd_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvd_release_0');
  _emscripten_bind_PxPvd_release_0 = Module['_emscripten_bind_PxPvd_release_0'] = createExportWrapper('emscripten_bind_PxPvd_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPvdInstrumentationFlags_PxPvdInstrumentationFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdInstrumentationFlags_PxPvdInstrumentationFlags_1');
  _emscripten_bind_PxPvdInstrumentationFlags_PxPvdInstrumentationFlags_1 = Module['_emscripten_bind_PxPvdInstrumentationFlags_PxPvdInstrumentationFlags_1'] = createExportWrapper('emscripten_bind_PxPvdInstrumentationFlags_PxPvdInstrumentationFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxPvdInstrumentationFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdInstrumentationFlags_isSet_1');
  _emscripten_bind_PxPvdInstrumentationFlags_isSet_1 = Module['_emscripten_bind_PxPvdInstrumentationFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxPvdInstrumentationFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPvdInstrumentationFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdInstrumentationFlags_raise_1');
  _emscripten_bind_PxPvdInstrumentationFlags_raise_1 = Module['_emscripten_bind_PxPvdInstrumentationFlags_raise_1'] = createExportWrapper('emscripten_bind_PxPvdInstrumentationFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPvdInstrumentationFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdInstrumentationFlags_clear_1');
  _emscripten_bind_PxPvdInstrumentationFlags_clear_1 = Module['_emscripten_bind_PxPvdInstrumentationFlags_clear_1'] = createExportWrapper('emscripten_bind_PxPvdInstrumentationFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPvdInstrumentationFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdInstrumentationFlags___destroy___0');
  _emscripten_bind_PxPvdInstrumentationFlags___destroy___0 = Module['_emscripten_bind_PxPvdInstrumentationFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxPvdInstrumentationFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPvdSceneClient_setScenePvdFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdSceneClient_setScenePvdFlag_2');
  _emscripten_bind_PxPvdSceneClient_setScenePvdFlag_2 = Module['_emscripten_bind_PxPvdSceneClient_setScenePvdFlag_2'] = createExportWrapper('emscripten_bind_PxPvdSceneClient_setScenePvdFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxPvdSceneClient_setScenePvdFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdSceneClient_setScenePvdFlags_1');
  _emscripten_bind_PxPvdSceneClient_setScenePvdFlags_1 = Module['_emscripten_bind_PxPvdSceneClient_setScenePvdFlags_1'] = createExportWrapper('emscripten_bind_PxPvdSceneClient_setScenePvdFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPvdSceneClient_getScenePvdFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdSceneClient_getScenePvdFlags_0');
  _emscripten_bind_PxPvdSceneClient_getScenePvdFlags_0 = Module['_emscripten_bind_PxPvdSceneClient_getScenePvdFlags_0'] = createExportWrapper('emscripten_bind_PxPvdSceneClient_getScenePvdFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxPvdSceneClient_updateCamera_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdSceneClient_updateCamera_4');
  _emscripten_bind_PxPvdSceneClient_updateCamera_4 = Module['_emscripten_bind_PxPvdSceneClient_updateCamera_4'] = createExportWrapper('emscripten_bind_PxPvdSceneClient_updateCamera_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxPvdSceneFlags_PxPvdSceneFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdSceneFlags_PxPvdSceneFlags_1');
  _emscripten_bind_PxPvdSceneFlags_PxPvdSceneFlags_1 = Module['_emscripten_bind_PxPvdSceneFlags_PxPvdSceneFlags_1'] = createExportWrapper('emscripten_bind_PxPvdSceneFlags_PxPvdSceneFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxPvdSceneFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdSceneFlags_isSet_1');
  _emscripten_bind_PxPvdSceneFlags_isSet_1 = Module['_emscripten_bind_PxPvdSceneFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxPvdSceneFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPvdSceneFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdSceneFlags_raise_1');
  _emscripten_bind_PxPvdSceneFlags_raise_1 = Module['_emscripten_bind_PxPvdSceneFlags_raise_1'] = createExportWrapper('emscripten_bind_PxPvdSceneFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPvdSceneFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdSceneFlags_clear_1');
  _emscripten_bind_PxPvdSceneFlags_clear_1 = Module['_emscripten_bind_PxPvdSceneFlags_clear_1'] = createExportWrapper('emscripten_bind_PxPvdSceneFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxPvdSceneFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxPvdSceneFlags___destroy___0');
  _emscripten_bind_PxPvdSceneFlags___destroy___0 = Module['_emscripten_bind_PxPvdSceneFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxPvdSceneFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_PxQuat_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_PxQuat_0');
  _emscripten_bind_PxQuat_PxQuat_0 = Module['_emscripten_bind_PxQuat_PxQuat_0'] = createExportWrapper('emscripten_bind_PxQuat_PxQuat_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxQuat_PxQuat_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_PxQuat_1');
  _emscripten_bind_PxQuat_PxQuat_1 = Module['_emscripten_bind_PxQuat_PxQuat_1'] = createExportWrapper('emscripten_bind_PxQuat_PxQuat_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_PxQuat_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_PxQuat_2');
  _emscripten_bind_PxQuat_PxQuat_2 = Module['_emscripten_bind_PxQuat_PxQuat_2'] = createExportWrapper('emscripten_bind_PxQuat_PxQuat_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxQuat_PxQuat_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_PxQuat_4');
  _emscripten_bind_PxQuat_PxQuat_4 = Module['_emscripten_bind_PxQuat_PxQuat_4'] = createExportWrapper('emscripten_bind_PxQuat_PxQuat_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxQuat_isIdentity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_isIdentity_0');
  _emscripten_bind_PxQuat_isIdentity_0 = Module['_emscripten_bind_PxQuat_isIdentity_0'] = createExportWrapper('emscripten_bind_PxQuat_isIdentity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_isFinite_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_isFinite_0');
  _emscripten_bind_PxQuat_isFinite_0 = Module['_emscripten_bind_PxQuat_isFinite_0'] = createExportWrapper('emscripten_bind_PxQuat_isFinite_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_isUnit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_isUnit_0');
  _emscripten_bind_PxQuat_isUnit_0 = Module['_emscripten_bind_PxQuat_isUnit_0'] = createExportWrapper('emscripten_bind_PxQuat_isUnit_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_isSane_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_isSane_0');
  _emscripten_bind_PxQuat_isSane_0 = Module['_emscripten_bind_PxQuat_isSane_0'] = createExportWrapper('emscripten_bind_PxQuat_isSane_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_getAngle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_getAngle_0');
  _emscripten_bind_PxQuat_getAngle_0 = Module['_emscripten_bind_PxQuat_getAngle_0'] = createExportWrapper('emscripten_bind_PxQuat_getAngle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_getAngle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_getAngle_1');
  _emscripten_bind_PxQuat_getAngle_1 = Module['_emscripten_bind_PxQuat_getAngle_1'] = createExportWrapper('emscripten_bind_PxQuat_getAngle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQuat_magnitudeSquared_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_magnitudeSquared_0');
  _emscripten_bind_PxQuat_magnitudeSquared_0 = Module['_emscripten_bind_PxQuat_magnitudeSquared_0'] = createExportWrapper('emscripten_bind_PxQuat_magnitudeSquared_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_dot_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_dot_1');
  _emscripten_bind_PxQuat_dot_1 = Module['_emscripten_bind_PxQuat_dot_1'] = createExportWrapper('emscripten_bind_PxQuat_dot_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQuat_getNormalized_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_getNormalized_0');
  _emscripten_bind_PxQuat_getNormalized_0 = Module['_emscripten_bind_PxQuat_getNormalized_0'] = createExportWrapper('emscripten_bind_PxQuat_getNormalized_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_magnitude_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_magnitude_0');
  _emscripten_bind_PxQuat_magnitude_0 = Module['_emscripten_bind_PxQuat_magnitude_0'] = createExportWrapper('emscripten_bind_PxQuat_magnitude_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_normalize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_normalize_0');
  _emscripten_bind_PxQuat_normalize_0 = Module['_emscripten_bind_PxQuat_normalize_0'] = createExportWrapper('emscripten_bind_PxQuat_normalize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_getConjugate_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_getConjugate_0');
  _emscripten_bind_PxQuat_getConjugate_0 = Module['_emscripten_bind_PxQuat_getConjugate_0'] = createExportWrapper('emscripten_bind_PxQuat_getConjugate_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_getImaginaryPart_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_getImaginaryPart_0');
  _emscripten_bind_PxQuat_getImaginaryPart_0 = Module['_emscripten_bind_PxQuat_getImaginaryPart_0'] = createExportWrapper('emscripten_bind_PxQuat_getImaginaryPart_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_getBasisVector0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_getBasisVector0_0');
  _emscripten_bind_PxQuat_getBasisVector0_0 = Module['_emscripten_bind_PxQuat_getBasisVector0_0'] = createExportWrapper('emscripten_bind_PxQuat_getBasisVector0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_getBasisVector1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_getBasisVector1_0');
  _emscripten_bind_PxQuat_getBasisVector1_0 = Module['_emscripten_bind_PxQuat_getBasisVector1_0'] = createExportWrapper('emscripten_bind_PxQuat_getBasisVector1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_getBasisVector2_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_getBasisVector2_0');
  _emscripten_bind_PxQuat_getBasisVector2_0 = Module['_emscripten_bind_PxQuat_getBasisVector2_0'] = createExportWrapper('emscripten_bind_PxQuat_getBasisVector2_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_rotate_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_rotate_1');
  _emscripten_bind_PxQuat_rotate_1 = Module['_emscripten_bind_PxQuat_rotate_1'] = createExportWrapper('emscripten_bind_PxQuat_rotate_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQuat_rotateInv_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_rotateInv_1');
  _emscripten_bind_PxQuat_rotateInv_1 = Module['_emscripten_bind_PxQuat_rotateInv_1'] = createExportWrapper('emscripten_bind_PxQuat_rotateInv_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQuat_get_x_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_get_x_0');
  _emscripten_bind_PxQuat_get_x_0 = Module['_emscripten_bind_PxQuat_get_x_0'] = createExportWrapper('emscripten_bind_PxQuat_get_x_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_set_x_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_set_x_1');
  _emscripten_bind_PxQuat_set_x_1 = Module['_emscripten_bind_PxQuat_set_x_1'] = createExportWrapper('emscripten_bind_PxQuat_set_x_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQuat_get_y_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_get_y_0');
  _emscripten_bind_PxQuat_get_y_0 = Module['_emscripten_bind_PxQuat_get_y_0'] = createExportWrapper('emscripten_bind_PxQuat_get_y_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_set_y_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_set_y_1');
  _emscripten_bind_PxQuat_set_y_1 = Module['_emscripten_bind_PxQuat_set_y_1'] = createExportWrapper('emscripten_bind_PxQuat_set_y_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQuat_get_z_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_get_z_0');
  _emscripten_bind_PxQuat_get_z_0 = Module['_emscripten_bind_PxQuat_get_z_0'] = createExportWrapper('emscripten_bind_PxQuat_get_z_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_set_z_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_set_z_1');
  _emscripten_bind_PxQuat_set_z_1 = Module['_emscripten_bind_PxQuat_set_z_1'] = createExportWrapper('emscripten_bind_PxQuat_set_z_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQuat_get_w_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_get_w_0');
  _emscripten_bind_PxQuat_get_w_0 = Module['_emscripten_bind_PxQuat_get_w_0'] = createExportWrapper('emscripten_bind_PxQuat_get_w_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQuat_set_w_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat_set_w_1');
  _emscripten_bind_PxQuat_set_w_1 = Module['_emscripten_bind_PxQuat_set_w_1'] = createExportWrapper('emscripten_bind_PxQuat_set_w_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQuat___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQuat___destroy___0');
  _emscripten_bind_PxQuat___destroy___0 = Module['_emscripten_bind_PxQuat___destroy___0'] = createExportWrapper('emscripten_bind_PxQuat___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQueryFilterCallbackImpl_PxQueryFilterCallbackImpl_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFilterCallbackImpl_PxQueryFilterCallbackImpl_0');
  _emscripten_bind_PxQueryFilterCallbackImpl_PxQueryFilterCallbackImpl_0 = Module['_emscripten_bind_PxQueryFilterCallbackImpl_PxQueryFilterCallbackImpl_0'] = createExportWrapper('emscripten_bind_PxQueryFilterCallbackImpl_PxQueryFilterCallbackImpl_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxQueryFilterCallbackImpl_simplePreFilter_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFilterCallbackImpl_simplePreFilter_4');
  _emscripten_bind_PxQueryFilterCallbackImpl_simplePreFilter_4 = Module['_emscripten_bind_PxQueryFilterCallbackImpl_simplePreFilter_4'] = createExportWrapper('emscripten_bind_PxQueryFilterCallbackImpl_simplePreFilter_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxQueryFilterCallbackImpl_simplePostFilter_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFilterCallbackImpl_simplePostFilter_4');
  _emscripten_bind_PxQueryFilterCallbackImpl_simplePostFilter_4 = Module['_emscripten_bind_PxQueryFilterCallbackImpl_simplePostFilter_4'] = createExportWrapper('emscripten_bind_PxQueryFilterCallbackImpl_simplePostFilter_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxQueryFilterCallbackImpl___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFilterCallbackImpl___destroy___0');
  _emscripten_bind_PxQueryFilterCallbackImpl___destroy___0 = Module['_emscripten_bind_PxQueryFilterCallbackImpl___destroy___0'] = createExportWrapper('emscripten_bind_PxQueryFilterCallbackImpl___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQueryFilterData_PxQueryFilterData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFilterData_PxQueryFilterData_0');
  _emscripten_bind_PxQueryFilterData_PxQueryFilterData_0 = Module['_emscripten_bind_PxQueryFilterData_PxQueryFilterData_0'] = createExportWrapper('emscripten_bind_PxQueryFilterData_PxQueryFilterData_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxQueryFilterData_PxQueryFilterData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFilterData_PxQueryFilterData_1');
  _emscripten_bind_PxQueryFilterData_PxQueryFilterData_1 = Module['_emscripten_bind_PxQueryFilterData_PxQueryFilterData_1'] = createExportWrapper('emscripten_bind_PxQueryFilterData_PxQueryFilterData_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxQueryFilterData_PxQueryFilterData_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFilterData_PxQueryFilterData_2');
  _emscripten_bind_PxQueryFilterData_PxQueryFilterData_2 = Module['_emscripten_bind_PxQueryFilterData_PxQueryFilterData_2'] = createExportWrapper('emscripten_bind_PxQueryFilterData_PxQueryFilterData_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxQueryFilterData_get_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFilterData_get_data_0');
  _emscripten_bind_PxQueryFilterData_get_data_0 = Module['_emscripten_bind_PxQueryFilterData_get_data_0'] = createExportWrapper('emscripten_bind_PxQueryFilterData_get_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQueryFilterData_set_data_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFilterData_set_data_1');
  _emscripten_bind_PxQueryFilterData_set_data_1 = Module['_emscripten_bind_PxQueryFilterData_set_data_1'] = createExportWrapper('emscripten_bind_PxQueryFilterData_set_data_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQueryFilterData_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFilterData_get_flags_0');
  _emscripten_bind_PxQueryFilterData_get_flags_0 = Module['_emscripten_bind_PxQueryFilterData_get_flags_0'] = createExportWrapper('emscripten_bind_PxQueryFilterData_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQueryFilterData_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFilterData_set_flags_1');
  _emscripten_bind_PxQueryFilterData_set_flags_1 = Module['_emscripten_bind_PxQueryFilterData_set_flags_1'] = createExportWrapper('emscripten_bind_PxQueryFilterData_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQueryFilterData___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFilterData___destroy___0');
  _emscripten_bind_PxQueryFilterData___destroy___0 = Module['_emscripten_bind_PxQueryFilterData___destroy___0'] = createExportWrapper('emscripten_bind_PxQueryFilterData___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxQueryFlags_PxQueryFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFlags_PxQueryFlags_1');
  _emscripten_bind_PxQueryFlags_PxQueryFlags_1 = Module['_emscripten_bind_PxQueryFlags_PxQueryFlags_1'] = createExportWrapper('emscripten_bind_PxQueryFlags_PxQueryFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxQueryFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFlags_isSet_1');
  _emscripten_bind_PxQueryFlags_isSet_1 = Module['_emscripten_bind_PxQueryFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxQueryFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQueryFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFlags_raise_1');
  _emscripten_bind_PxQueryFlags_raise_1 = Module['_emscripten_bind_PxQueryFlags_raise_1'] = createExportWrapper('emscripten_bind_PxQueryFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQueryFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFlags_clear_1');
  _emscripten_bind_PxQueryFlags_clear_1 = Module['_emscripten_bind_PxQueryFlags_clear_1'] = createExportWrapper('emscripten_bind_PxQueryFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxQueryFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxQueryFlags___destroy___0');
  _emscripten_bind_PxQueryFlags___destroy___0 = Module['_emscripten_bind_PxQueryFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxQueryFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setJoints_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setJoints_2');
  _emscripten_bind_PxRackAndPinionJoint_setJoints_2 = Module['_emscripten_bind_PxRackAndPinionJoint_setJoints_2'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setJoints_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setRatio_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setRatio_1');
  _emscripten_bind_PxRackAndPinionJoint_setRatio_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setRatio_1'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setRatio_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getRatio_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getRatio_0');
  _emscripten_bind_PxRackAndPinionJoint_getRatio_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getRatio_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getRatio_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setData_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setData_3');
  _emscripten_bind_PxRackAndPinionJoint_setData_3 = Module['_emscripten_bind_PxRackAndPinionJoint_setData_3'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setData_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_release_0');
  _emscripten_bind_PxRackAndPinionJoint_release_0 = Module['_emscripten_bind_PxRackAndPinionJoint_release_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getConcreteTypeName_0');
  _emscripten_bind_PxRackAndPinionJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getConcreteType_0');
  _emscripten_bind_PxRackAndPinionJoint_getConcreteType_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setBaseFlag_2');
  _emscripten_bind_PxRackAndPinionJoint_setBaseFlag_2 = Module['_emscripten_bind_PxRackAndPinionJoint_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setBaseFlags_1');
  _emscripten_bind_PxRackAndPinionJoint_setBaseFlags_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getBaseFlags_0');
  _emscripten_bind_PxRackAndPinionJoint_getBaseFlags_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_isReleasable_0');
  _emscripten_bind_PxRackAndPinionJoint_isReleasable_0 = Module['_emscripten_bind_PxRackAndPinionJoint_isReleasable_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setActors_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setActors_2');
  _emscripten_bind_PxRackAndPinionJoint_setActors_2 = Module['_emscripten_bind_PxRackAndPinionJoint_setActors_2'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setActors_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setLocalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setLocalPose_2');
  _emscripten_bind_PxRackAndPinionJoint_setLocalPose_2 = Module['_emscripten_bind_PxRackAndPinionJoint_setLocalPose_2'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setLocalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getLocalPose_1');
  _emscripten_bind_PxRackAndPinionJoint_getLocalPose_1 = Module['_emscripten_bind_PxRackAndPinionJoint_getLocalPose_1'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getRelativeTransform_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getRelativeTransform_0');
  _emscripten_bind_PxRackAndPinionJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getRelativeTransform_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getRelativeTransform_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getRelativeLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getRelativeLinearVelocity_0');
  _emscripten_bind_PxRackAndPinionJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getRelativeLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getRelativeLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getRelativeAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getRelativeAngularVelocity_0');
  _emscripten_bind_PxRackAndPinionJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getRelativeAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getRelativeAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setBreakForce_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setBreakForce_2');
  _emscripten_bind_PxRackAndPinionJoint_setBreakForce_2 = Module['_emscripten_bind_PxRackAndPinionJoint_setBreakForce_2'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setBreakForce_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setConstraintFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setConstraintFlags_1');
  _emscripten_bind_PxRackAndPinionJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setConstraintFlags_1'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setConstraintFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setConstraintFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setConstraintFlag_2');
  _emscripten_bind_PxRackAndPinionJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxRackAndPinionJoint_setConstraintFlag_2'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setConstraintFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getConstraintFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getConstraintFlags_0');
  _emscripten_bind_PxRackAndPinionJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getConstraintFlags_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getConstraintFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setInvMassScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setInvMassScale0_1');
  _emscripten_bind_PxRackAndPinionJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setInvMassScale0_1'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setInvMassScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getInvMassScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getInvMassScale0_0');
  _emscripten_bind_PxRackAndPinionJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getInvMassScale0_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getInvMassScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setInvMassScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setInvMassScale1_1');
  _emscripten_bind_PxRackAndPinionJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setInvMassScale1_1'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setInvMassScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getInvMassScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getInvMassScale1_0');
  _emscripten_bind_PxRackAndPinionJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getInvMassScale1_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getInvMassScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale0_1');
  _emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale0_1'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale0_0');
  _emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale0_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale1_1');
  _emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale1_1'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale1_0');
  _emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale1_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getConstraint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getConstraint_0');
  _emscripten_bind_PxRackAndPinionJoint_getConstraint_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getConstraint_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getConstraint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_setName_1');
  _emscripten_bind_PxRackAndPinionJoint_setName_1 = Module['_emscripten_bind_PxRackAndPinionJoint_setName_1'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getName_0');
  _emscripten_bind_PxRackAndPinionJoint_getName_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getName_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_getScene_0');
  _emscripten_bind_PxRackAndPinionJoint_getScene_0 = Module['_emscripten_bind_PxRackAndPinionJoint_getScene_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_get_userData_0');
  _emscripten_bind_PxRackAndPinionJoint_get_userData_0 = Module['_emscripten_bind_PxRackAndPinionJoint_get_userData_0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint_set_userData_1');
  _emscripten_bind_PxRackAndPinionJoint_set_userData_1 = Module['_emscripten_bind_PxRackAndPinionJoint_set_userData_1'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRackAndPinionJoint___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRackAndPinionJoint___destroy___0');
  _emscripten_bind_PxRackAndPinionJoint___destroy___0 = Module['_emscripten_bind_PxRackAndPinionJoint___destroy___0'] = createExportWrapper('emscripten_bind_PxRackAndPinionJoint___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastBuffer10_PxRaycastBuffer10_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastBuffer10_PxRaycastBuffer10_0');
  _emscripten_bind_PxRaycastBuffer10_PxRaycastBuffer10_0 = Module['_emscripten_bind_PxRaycastBuffer10_PxRaycastBuffer10_0'] = createExportWrapper('emscripten_bind_PxRaycastBuffer10_PxRaycastBuffer10_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxRaycastBuffer10_getNbAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastBuffer10_getNbAnyHits_0');
  _emscripten_bind_PxRaycastBuffer10_getNbAnyHits_0 = Module['_emscripten_bind_PxRaycastBuffer10_getNbAnyHits_0'] = createExportWrapper('emscripten_bind_PxRaycastBuffer10_getNbAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastBuffer10_getAnyHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastBuffer10_getAnyHit_1');
  _emscripten_bind_PxRaycastBuffer10_getAnyHit_1 = Module['_emscripten_bind_PxRaycastBuffer10_getAnyHit_1'] = createExportWrapper('emscripten_bind_PxRaycastBuffer10_getAnyHit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastBuffer10_getNbTouches_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastBuffer10_getNbTouches_0');
  _emscripten_bind_PxRaycastBuffer10_getNbTouches_0 = Module['_emscripten_bind_PxRaycastBuffer10_getNbTouches_0'] = createExportWrapper('emscripten_bind_PxRaycastBuffer10_getNbTouches_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastBuffer10_getTouches_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastBuffer10_getTouches_0');
  _emscripten_bind_PxRaycastBuffer10_getTouches_0 = Module['_emscripten_bind_PxRaycastBuffer10_getTouches_0'] = createExportWrapper('emscripten_bind_PxRaycastBuffer10_getTouches_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastBuffer10_getTouch_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastBuffer10_getTouch_1');
  _emscripten_bind_PxRaycastBuffer10_getTouch_1 = Module['_emscripten_bind_PxRaycastBuffer10_getTouch_1'] = createExportWrapper('emscripten_bind_PxRaycastBuffer10_getTouch_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastBuffer10_getMaxNbTouches_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastBuffer10_getMaxNbTouches_0');
  _emscripten_bind_PxRaycastBuffer10_getMaxNbTouches_0 = Module['_emscripten_bind_PxRaycastBuffer10_getMaxNbTouches_0'] = createExportWrapper('emscripten_bind_PxRaycastBuffer10_getMaxNbTouches_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastBuffer10_hasAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastBuffer10_hasAnyHits_0');
  _emscripten_bind_PxRaycastBuffer10_hasAnyHits_0 = Module['_emscripten_bind_PxRaycastBuffer10_hasAnyHits_0'] = createExportWrapper('emscripten_bind_PxRaycastBuffer10_hasAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastBuffer10_get_block_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastBuffer10_get_block_0');
  _emscripten_bind_PxRaycastBuffer10_get_block_0 = Module['_emscripten_bind_PxRaycastBuffer10_get_block_0'] = createExportWrapper('emscripten_bind_PxRaycastBuffer10_get_block_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastBuffer10_set_block_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastBuffer10_set_block_1');
  _emscripten_bind_PxRaycastBuffer10_set_block_1 = Module['_emscripten_bind_PxRaycastBuffer10_set_block_1'] = createExportWrapper('emscripten_bind_PxRaycastBuffer10_set_block_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastBuffer10_get_hasBlock_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastBuffer10_get_hasBlock_0');
  _emscripten_bind_PxRaycastBuffer10_get_hasBlock_0 = Module['_emscripten_bind_PxRaycastBuffer10_get_hasBlock_0'] = createExportWrapper('emscripten_bind_PxRaycastBuffer10_get_hasBlock_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastBuffer10_set_hasBlock_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastBuffer10_set_hasBlock_1');
  _emscripten_bind_PxRaycastBuffer10_set_hasBlock_1 = Module['_emscripten_bind_PxRaycastBuffer10_set_hasBlock_1'] = createExportWrapper('emscripten_bind_PxRaycastBuffer10_set_hasBlock_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastBuffer10___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastBuffer10___destroy___0');
  _emscripten_bind_PxRaycastBuffer10___destroy___0 = Module['_emscripten_bind_PxRaycastBuffer10___destroy___0'] = createExportWrapper('emscripten_bind_PxRaycastBuffer10___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_PxRaycastHit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_PxRaycastHit_0');
  _emscripten_bind_PxRaycastHit_PxRaycastHit_0 = Module['_emscripten_bind_PxRaycastHit_PxRaycastHit_0'] = createExportWrapper('emscripten_bind_PxRaycastHit_PxRaycastHit_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_hadInitialOverlap_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_hadInitialOverlap_0');
  _emscripten_bind_PxRaycastHit_hadInitialOverlap_0 = Module['_emscripten_bind_PxRaycastHit_hadInitialOverlap_0'] = createExportWrapper('emscripten_bind_PxRaycastHit_hadInitialOverlap_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_get_actor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_get_actor_0');
  _emscripten_bind_PxRaycastHit_get_actor_0 = Module['_emscripten_bind_PxRaycastHit_get_actor_0'] = createExportWrapper('emscripten_bind_PxRaycastHit_get_actor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_set_actor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_set_actor_1');
  _emscripten_bind_PxRaycastHit_set_actor_1 = Module['_emscripten_bind_PxRaycastHit_set_actor_1'] = createExportWrapper('emscripten_bind_PxRaycastHit_set_actor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_get_shape_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_get_shape_0');
  _emscripten_bind_PxRaycastHit_get_shape_0 = Module['_emscripten_bind_PxRaycastHit_get_shape_0'] = createExportWrapper('emscripten_bind_PxRaycastHit_get_shape_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_set_shape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_set_shape_1');
  _emscripten_bind_PxRaycastHit_set_shape_1 = Module['_emscripten_bind_PxRaycastHit_set_shape_1'] = createExportWrapper('emscripten_bind_PxRaycastHit_set_shape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_get_u_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_get_u_0');
  _emscripten_bind_PxRaycastHit_get_u_0 = Module['_emscripten_bind_PxRaycastHit_get_u_0'] = createExportWrapper('emscripten_bind_PxRaycastHit_get_u_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_set_u_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_set_u_1');
  _emscripten_bind_PxRaycastHit_set_u_1 = Module['_emscripten_bind_PxRaycastHit_set_u_1'] = createExportWrapper('emscripten_bind_PxRaycastHit_set_u_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_get_v_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_get_v_0');
  _emscripten_bind_PxRaycastHit_get_v_0 = Module['_emscripten_bind_PxRaycastHit_get_v_0'] = createExportWrapper('emscripten_bind_PxRaycastHit_get_v_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_set_v_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_set_v_1');
  _emscripten_bind_PxRaycastHit_set_v_1 = Module['_emscripten_bind_PxRaycastHit_set_v_1'] = createExportWrapper('emscripten_bind_PxRaycastHit_set_v_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_get_flags_0');
  _emscripten_bind_PxRaycastHit_get_flags_0 = Module['_emscripten_bind_PxRaycastHit_get_flags_0'] = createExportWrapper('emscripten_bind_PxRaycastHit_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_set_flags_1');
  _emscripten_bind_PxRaycastHit_set_flags_1 = Module['_emscripten_bind_PxRaycastHit_set_flags_1'] = createExportWrapper('emscripten_bind_PxRaycastHit_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_get_position_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_get_position_0');
  _emscripten_bind_PxRaycastHit_get_position_0 = Module['_emscripten_bind_PxRaycastHit_get_position_0'] = createExportWrapper('emscripten_bind_PxRaycastHit_get_position_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_set_position_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_set_position_1');
  _emscripten_bind_PxRaycastHit_set_position_1 = Module['_emscripten_bind_PxRaycastHit_set_position_1'] = createExportWrapper('emscripten_bind_PxRaycastHit_set_position_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_get_normal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_get_normal_0');
  _emscripten_bind_PxRaycastHit_get_normal_0 = Module['_emscripten_bind_PxRaycastHit_get_normal_0'] = createExportWrapper('emscripten_bind_PxRaycastHit_get_normal_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_set_normal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_set_normal_1');
  _emscripten_bind_PxRaycastHit_set_normal_1 = Module['_emscripten_bind_PxRaycastHit_set_normal_1'] = createExportWrapper('emscripten_bind_PxRaycastHit_set_normal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_get_distance_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_get_distance_0');
  _emscripten_bind_PxRaycastHit_get_distance_0 = Module['_emscripten_bind_PxRaycastHit_get_distance_0'] = createExportWrapper('emscripten_bind_PxRaycastHit_get_distance_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_set_distance_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_set_distance_1');
  _emscripten_bind_PxRaycastHit_set_distance_1 = Module['_emscripten_bind_PxRaycastHit_set_distance_1'] = createExportWrapper('emscripten_bind_PxRaycastHit_set_distance_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_get_faceIndex_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_get_faceIndex_0');
  _emscripten_bind_PxRaycastHit_get_faceIndex_0 = Module['_emscripten_bind_PxRaycastHit_get_faceIndex_0'] = createExportWrapper('emscripten_bind_PxRaycastHit_get_faceIndex_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit_set_faceIndex_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit_set_faceIndex_1');
  _emscripten_bind_PxRaycastHit_set_faceIndex_1 = Module['_emscripten_bind_PxRaycastHit_set_faceIndex_1'] = createExportWrapper('emscripten_bind_PxRaycastHit_set_faceIndex_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastHit___destroy___0');
  _emscripten_bind_PxRaycastHit___destroy___0 = Module['_emscripten_bind_PxRaycastHit___destroy___0'] = createExportWrapper('emscripten_bind_PxRaycastHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastResult_PxRaycastResult_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastResult_PxRaycastResult_0');
  _emscripten_bind_PxRaycastResult_PxRaycastResult_0 = Module['_emscripten_bind_PxRaycastResult_PxRaycastResult_0'] = createExportWrapper('emscripten_bind_PxRaycastResult_PxRaycastResult_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxRaycastResult_getNbAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastResult_getNbAnyHits_0');
  _emscripten_bind_PxRaycastResult_getNbAnyHits_0 = Module['_emscripten_bind_PxRaycastResult_getNbAnyHits_0'] = createExportWrapper('emscripten_bind_PxRaycastResult_getNbAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastResult_getAnyHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastResult_getAnyHit_1');
  _emscripten_bind_PxRaycastResult_getAnyHit_1 = Module['_emscripten_bind_PxRaycastResult_getAnyHit_1'] = createExportWrapper('emscripten_bind_PxRaycastResult_getAnyHit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastResult_getNbTouches_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastResult_getNbTouches_0');
  _emscripten_bind_PxRaycastResult_getNbTouches_0 = Module['_emscripten_bind_PxRaycastResult_getNbTouches_0'] = createExportWrapper('emscripten_bind_PxRaycastResult_getNbTouches_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastResult_getTouch_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastResult_getTouch_1');
  _emscripten_bind_PxRaycastResult_getTouch_1 = Module['_emscripten_bind_PxRaycastResult_getTouch_1'] = createExportWrapper('emscripten_bind_PxRaycastResult_getTouch_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastResult_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastResult_clear_0');
  _emscripten_bind_PxRaycastResult_clear_0 = Module['_emscripten_bind_PxRaycastResult_clear_0'] = createExportWrapper('emscripten_bind_PxRaycastResult_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastResult_hasAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastResult_hasAnyHits_0');
  _emscripten_bind_PxRaycastResult_hasAnyHits_0 = Module['_emscripten_bind_PxRaycastResult_hasAnyHits_0'] = createExportWrapper('emscripten_bind_PxRaycastResult_hasAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastResult_get_block_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastResult_get_block_0');
  _emscripten_bind_PxRaycastResult_get_block_0 = Module['_emscripten_bind_PxRaycastResult_get_block_0'] = createExportWrapper('emscripten_bind_PxRaycastResult_get_block_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastResult_set_block_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastResult_set_block_1');
  _emscripten_bind_PxRaycastResult_set_block_1 = Module['_emscripten_bind_PxRaycastResult_set_block_1'] = createExportWrapper('emscripten_bind_PxRaycastResult_set_block_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastResult_get_hasBlock_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastResult_get_hasBlock_0');
  _emscripten_bind_PxRaycastResult_get_hasBlock_0 = Module['_emscripten_bind_PxRaycastResult_get_hasBlock_0'] = createExportWrapper('emscripten_bind_PxRaycastResult_get_hasBlock_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRaycastResult_set_hasBlock_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastResult_set_hasBlock_1');
  _emscripten_bind_PxRaycastResult_set_hasBlock_1 = Module['_emscripten_bind_PxRaycastResult_set_hasBlock_1'] = createExportWrapper('emscripten_bind_PxRaycastResult_set_hasBlock_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRaycastResult___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRaycastResult___destroy___0');
  _emscripten_bind_PxRaycastResult___destroy___0 = Module['_emscripten_bind_PxRaycastResult___destroy___0'] = createExportWrapper('emscripten_bind_PxRaycastResult___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRealPtr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRealPtr___destroy___0');
  _emscripten_bind_PxRealPtr___destroy___0 = Module['_emscripten_bind_PxRealPtr___destroy___0'] = createExportWrapper('emscripten_bind_PxRealPtr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_getNbPoints_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_getNbPoints_0');
  _emscripten_bind_PxRenderBuffer_getNbPoints_0 = Module['_emscripten_bind_PxRenderBuffer_getNbPoints_0'] = createExportWrapper('emscripten_bind_PxRenderBuffer_getNbPoints_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_getPoints_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_getPoints_0');
  _emscripten_bind_PxRenderBuffer_getPoints_0 = Module['_emscripten_bind_PxRenderBuffer_getPoints_0'] = createExportWrapper('emscripten_bind_PxRenderBuffer_getPoints_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_addPoint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_addPoint_1');
  _emscripten_bind_PxRenderBuffer_addPoint_1 = Module['_emscripten_bind_PxRenderBuffer_addPoint_1'] = createExportWrapper('emscripten_bind_PxRenderBuffer_addPoint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_getNbLines_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_getNbLines_0');
  _emscripten_bind_PxRenderBuffer_getNbLines_0 = Module['_emscripten_bind_PxRenderBuffer_getNbLines_0'] = createExportWrapper('emscripten_bind_PxRenderBuffer_getNbLines_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_getLines_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_getLines_0');
  _emscripten_bind_PxRenderBuffer_getLines_0 = Module['_emscripten_bind_PxRenderBuffer_getLines_0'] = createExportWrapper('emscripten_bind_PxRenderBuffer_getLines_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_addLine_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_addLine_1');
  _emscripten_bind_PxRenderBuffer_addLine_1 = Module['_emscripten_bind_PxRenderBuffer_addLine_1'] = createExportWrapper('emscripten_bind_PxRenderBuffer_addLine_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_reserveLines_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_reserveLines_1');
  _emscripten_bind_PxRenderBuffer_reserveLines_1 = Module['_emscripten_bind_PxRenderBuffer_reserveLines_1'] = createExportWrapper('emscripten_bind_PxRenderBuffer_reserveLines_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_reservePoints_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_reservePoints_1');
  _emscripten_bind_PxRenderBuffer_reservePoints_1 = Module['_emscripten_bind_PxRenderBuffer_reservePoints_1'] = createExportWrapper('emscripten_bind_PxRenderBuffer_reservePoints_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_getNbTriangles_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_getNbTriangles_0');
  _emscripten_bind_PxRenderBuffer_getNbTriangles_0 = Module['_emscripten_bind_PxRenderBuffer_getNbTriangles_0'] = createExportWrapper('emscripten_bind_PxRenderBuffer_getNbTriangles_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_getTriangles_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_getTriangles_0');
  _emscripten_bind_PxRenderBuffer_getTriangles_0 = Module['_emscripten_bind_PxRenderBuffer_getTriangles_0'] = createExportWrapper('emscripten_bind_PxRenderBuffer_getTriangles_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_addTriangle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_addTriangle_1');
  _emscripten_bind_PxRenderBuffer_addTriangle_1 = Module['_emscripten_bind_PxRenderBuffer_addTriangle_1'] = createExportWrapper('emscripten_bind_PxRenderBuffer_addTriangle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_append_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_append_1');
  _emscripten_bind_PxRenderBuffer_append_1 = Module['_emscripten_bind_PxRenderBuffer_append_1'] = createExportWrapper('emscripten_bind_PxRenderBuffer_append_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_clear_0');
  _emscripten_bind_PxRenderBuffer_clear_0 = Module['_emscripten_bind_PxRenderBuffer_clear_0'] = createExportWrapper('emscripten_bind_PxRenderBuffer_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_shift_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_shift_1');
  _emscripten_bind_PxRenderBuffer_shift_1 = Module['_emscripten_bind_PxRenderBuffer_shift_1'] = createExportWrapper('emscripten_bind_PxRenderBuffer_shift_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRenderBuffer_empty_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRenderBuffer_empty_0');
  _emscripten_bind_PxRenderBuffer_empty_0 = Module['_emscripten_bind_PxRenderBuffer_empty_0'] = createExportWrapper('emscripten_bind_PxRenderBuffer_empty_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getAngle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getAngle_0');
  _emscripten_bind_PxRevoluteJoint_getAngle_0 = Module['_emscripten_bind_PxRevoluteJoint_getAngle_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getAngle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getVelocity_0');
  _emscripten_bind_PxRevoluteJoint_getVelocity_0 = Module['_emscripten_bind_PxRevoluteJoint_getVelocity_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setLimit_1');
  _emscripten_bind_PxRevoluteJoint_setLimit_1 = Module['_emscripten_bind_PxRevoluteJoint_setLimit_1'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setDriveVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setDriveVelocity_1');
  _emscripten_bind_PxRevoluteJoint_setDriveVelocity_1 = Module['_emscripten_bind_PxRevoluteJoint_setDriveVelocity_1'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setDriveVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setDriveVelocity_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setDriveVelocity_2');
  _emscripten_bind_PxRevoluteJoint_setDriveVelocity_2 = Module['_emscripten_bind_PxRevoluteJoint_setDriveVelocity_2'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setDriveVelocity_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getDriveVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getDriveVelocity_0');
  _emscripten_bind_PxRevoluteJoint_getDriveVelocity_0 = Module['_emscripten_bind_PxRevoluteJoint_getDriveVelocity_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getDriveVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setDriveForceLimit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setDriveForceLimit_1');
  _emscripten_bind_PxRevoluteJoint_setDriveForceLimit_1 = Module['_emscripten_bind_PxRevoluteJoint_setDriveForceLimit_1'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setDriveForceLimit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getDriveForceLimit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getDriveForceLimit_0');
  _emscripten_bind_PxRevoluteJoint_getDriveForceLimit_0 = Module['_emscripten_bind_PxRevoluteJoint_getDriveForceLimit_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getDriveForceLimit_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setDriveGearRatio_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setDriveGearRatio_1');
  _emscripten_bind_PxRevoluteJoint_setDriveGearRatio_1 = Module['_emscripten_bind_PxRevoluteJoint_setDriveGearRatio_1'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setDriveGearRatio_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getDriveGearRatio_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getDriveGearRatio_0');
  _emscripten_bind_PxRevoluteJoint_getDriveGearRatio_0 = Module['_emscripten_bind_PxRevoluteJoint_getDriveGearRatio_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getDriveGearRatio_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setRevoluteJointFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setRevoluteJointFlags_1');
  _emscripten_bind_PxRevoluteJoint_setRevoluteJointFlags_1 = Module['_emscripten_bind_PxRevoluteJoint_setRevoluteJointFlags_1'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setRevoluteJointFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setRevoluteJointFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setRevoluteJointFlag_2');
  _emscripten_bind_PxRevoluteJoint_setRevoluteJointFlag_2 = Module['_emscripten_bind_PxRevoluteJoint_setRevoluteJointFlag_2'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setRevoluteJointFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getRevoluteJointFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getRevoluteJointFlags_0');
  _emscripten_bind_PxRevoluteJoint_getRevoluteJointFlags_0 = Module['_emscripten_bind_PxRevoluteJoint_getRevoluteJointFlags_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getRevoluteJointFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_release_0');
  _emscripten_bind_PxRevoluteJoint_release_0 = Module['_emscripten_bind_PxRevoluteJoint_release_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getConcreteTypeName_0');
  _emscripten_bind_PxRevoluteJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxRevoluteJoint_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getConcreteType_0');
  _emscripten_bind_PxRevoluteJoint_getConcreteType_0 = Module['_emscripten_bind_PxRevoluteJoint_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setBaseFlag_2');
  _emscripten_bind_PxRevoluteJoint_setBaseFlag_2 = Module['_emscripten_bind_PxRevoluteJoint_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setBaseFlags_1');
  _emscripten_bind_PxRevoluteJoint_setBaseFlags_1 = Module['_emscripten_bind_PxRevoluteJoint_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getBaseFlags_0');
  _emscripten_bind_PxRevoluteJoint_getBaseFlags_0 = Module['_emscripten_bind_PxRevoluteJoint_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_isReleasable_0');
  _emscripten_bind_PxRevoluteJoint_isReleasable_0 = Module['_emscripten_bind_PxRevoluteJoint_isReleasable_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setActors_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setActors_2');
  _emscripten_bind_PxRevoluteJoint_setActors_2 = Module['_emscripten_bind_PxRevoluteJoint_setActors_2'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setActors_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setLocalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setLocalPose_2');
  _emscripten_bind_PxRevoluteJoint_setLocalPose_2 = Module['_emscripten_bind_PxRevoluteJoint_setLocalPose_2'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setLocalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getLocalPose_1');
  _emscripten_bind_PxRevoluteJoint_getLocalPose_1 = Module['_emscripten_bind_PxRevoluteJoint_getLocalPose_1'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getRelativeTransform_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getRelativeTransform_0');
  _emscripten_bind_PxRevoluteJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxRevoluteJoint_getRelativeTransform_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getRelativeTransform_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getRelativeLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getRelativeLinearVelocity_0');
  _emscripten_bind_PxRevoluteJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxRevoluteJoint_getRelativeLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getRelativeLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getRelativeAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getRelativeAngularVelocity_0');
  _emscripten_bind_PxRevoluteJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxRevoluteJoint_getRelativeAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getRelativeAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setBreakForce_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setBreakForce_2');
  _emscripten_bind_PxRevoluteJoint_setBreakForce_2 = Module['_emscripten_bind_PxRevoluteJoint_setBreakForce_2'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setBreakForce_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setConstraintFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setConstraintFlags_1');
  _emscripten_bind_PxRevoluteJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxRevoluteJoint_setConstraintFlags_1'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setConstraintFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setConstraintFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setConstraintFlag_2');
  _emscripten_bind_PxRevoluteJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxRevoluteJoint_setConstraintFlag_2'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setConstraintFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getConstraintFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getConstraintFlags_0');
  _emscripten_bind_PxRevoluteJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxRevoluteJoint_getConstraintFlags_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getConstraintFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setInvMassScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setInvMassScale0_1');
  _emscripten_bind_PxRevoluteJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxRevoluteJoint_setInvMassScale0_1'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setInvMassScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getInvMassScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getInvMassScale0_0');
  _emscripten_bind_PxRevoluteJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxRevoluteJoint_getInvMassScale0_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getInvMassScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setInvMassScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setInvMassScale1_1');
  _emscripten_bind_PxRevoluteJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxRevoluteJoint_setInvMassScale1_1'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setInvMassScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getInvMassScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getInvMassScale1_0');
  _emscripten_bind_PxRevoluteJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxRevoluteJoint_getInvMassScale1_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getInvMassScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setInvInertiaScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setInvInertiaScale0_1');
  _emscripten_bind_PxRevoluteJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxRevoluteJoint_setInvInertiaScale0_1'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setInvInertiaScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getInvInertiaScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getInvInertiaScale0_0');
  _emscripten_bind_PxRevoluteJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxRevoluteJoint_getInvInertiaScale0_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getInvInertiaScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setInvInertiaScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setInvInertiaScale1_1');
  _emscripten_bind_PxRevoluteJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxRevoluteJoint_setInvInertiaScale1_1'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setInvInertiaScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getInvInertiaScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getInvInertiaScale1_0');
  _emscripten_bind_PxRevoluteJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxRevoluteJoint_getInvInertiaScale1_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getInvInertiaScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getConstraint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getConstraint_0');
  _emscripten_bind_PxRevoluteJoint_getConstraint_0 = Module['_emscripten_bind_PxRevoluteJoint_getConstraint_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getConstraint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_setName_1');
  _emscripten_bind_PxRevoluteJoint_setName_1 = Module['_emscripten_bind_PxRevoluteJoint_setName_1'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getName_0');
  _emscripten_bind_PxRevoluteJoint_getName_0 = Module['_emscripten_bind_PxRevoluteJoint_getName_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_getScene_0');
  _emscripten_bind_PxRevoluteJoint_getScene_0 = Module['_emscripten_bind_PxRevoluteJoint_getScene_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_get_userData_0');
  _emscripten_bind_PxRevoluteJoint_get_userData_0 = Module['_emscripten_bind_PxRevoluteJoint_get_userData_0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint_set_userData_1');
  _emscripten_bind_PxRevoluteJoint_set_userData_1 = Module['_emscripten_bind_PxRevoluteJoint_set_userData_1'] = createExportWrapper('emscripten_bind_PxRevoluteJoint_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJoint___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJoint___destroy___0');
  _emscripten_bind_PxRevoluteJoint___destroy___0 = Module['_emscripten_bind_PxRevoluteJoint___destroy___0'] = createExportWrapper('emscripten_bind_PxRevoluteJoint___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJointFlags_PxRevoluteJointFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJointFlags_PxRevoluteJointFlags_1');
  _emscripten_bind_PxRevoluteJointFlags_PxRevoluteJointFlags_1 = Module['_emscripten_bind_PxRevoluteJointFlags_PxRevoluteJointFlags_1'] = createExportWrapper('emscripten_bind_PxRevoluteJointFlags_PxRevoluteJointFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJointFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJointFlags_isSet_1');
  _emscripten_bind_PxRevoluteJointFlags_isSet_1 = Module['_emscripten_bind_PxRevoluteJointFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxRevoluteJointFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJointFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJointFlags_raise_1');
  _emscripten_bind_PxRevoluteJointFlags_raise_1 = Module['_emscripten_bind_PxRevoluteJointFlags_raise_1'] = createExportWrapper('emscripten_bind_PxRevoluteJointFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJointFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJointFlags_clear_1');
  _emscripten_bind_PxRevoluteJointFlags_clear_1 = Module['_emscripten_bind_PxRevoluteJointFlags_clear_1'] = createExportWrapper('emscripten_bind_PxRevoluteJointFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRevoluteJointFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRevoluteJointFlags___destroy___0');
  _emscripten_bind_PxRevoluteJointFlags___destroy___0 = Module['_emscripten_bind_PxRevoluteJointFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxRevoluteJointFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidActorExt_createExclusiveShape_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActorExt_createExclusiveShape_3');
  _emscripten_bind_PxRigidActorExt_createExclusiveShape_3 = Module['_emscripten_bind_PxRigidActorExt_createExclusiveShape_3'] = createExportWrapper('emscripten_bind_PxRigidActorExt_createExclusiveShape_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidActorExt_createExclusiveShape_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActorExt_createExclusiveShape_4');
  _emscripten_bind_PxRigidActorExt_createExclusiveShape_4 = Module['_emscripten_bind_PxRigidActorExt_createExclusiveShape_4'] = createExportWrapper('emscripten_bind_PxRigidActorExt_createExclusiveShape_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidActorExt___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidActorExt___destroy___0');
  _emscripten_bind_PxRigidActorExt___destroy___0 = Module['_emscripten_bind_PxRigidActorExt___destroy___0'] = createExportWrapper('emscripten_bind_PxRigidActorExt___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_updateMassAndInertia_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_updateMassAndInertia_2');
  _emscripten_bind_PxRigidBodyExt_updateMassAndInertia_2 = Module['_emscripten_bind_PxRigidBodyExt_updateMassAndInertia_2'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_updateMassAndInertia_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_updateMassAndInertia_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_updateMassAndInertia_3');
  _emscripten_bind_PxRigidBodyExt_updateMassAndInertia_3 = Module['_emscripten_bind_PxRigidBodyExt_updateMassAndInertia_3'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_updateMassAndInertia_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_updateMassAndInertia_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_updateMassAndInertia_4');
  _emscripten_bind_PxRigidBodyExt_updateMassAndInertia_4 = Module['_emscripten_bind_PxRigidBodyExt_updateMassAndInertia_4'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_updateMassAndInertia_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_2');
  _emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_2 = Module['_emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_2'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_3');
  _emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_3 = Module['_emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_3'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_4');
  _emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_4 = Module['_emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_4'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_addForceAtPos_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_addForceAtPos_3');
  _emscripten_bind_PxRigidBodyExt_addForceAtPos_3 = Module['_emscripten_bind_PxRigidBodyExt_addForceAtPos_3'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_addForceAtPos_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_addForceAtPos_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_addForceAtPos_4');
  _emscripten_bind_PxRigidBodyExt_addForceAtPos_4 = Module['_emscripten_bind_PxRigidBodyExt_addForceAtPos_4'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_addForceAtPos_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_addForceAtPos_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_addForceAtPos_5');
  _emscripten_bind_PxRigidBodyExt_addForceAtPos_5 = Module['_emscripten_bind_PxRigidBodyExt_addForceAtPos_5'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_addForceAtPos_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_3');
  _emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_3 = Module['_emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_3'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_4');
  _emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_4 = Module['_emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_4'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_5');
  _emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_5 = Module['_emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_5'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_3');
  _emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_3 = Module['_emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_3'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_4');
  _emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_4 = Module['_emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_4'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_5');
  _emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_5 = Module['_emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_5'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_3');
  _emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_3 = Module['_emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_3'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_4');
  _emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_4 = Module['_emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_4'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_5');
  _emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_5 = Module['_emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_5'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_getVelocityAtPos_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_getVelocityAtPos_2');
  _emscripten_bind_PxRigidBodyExt_getVelocityAtPos_2 = Module['_emscripten_bind_PxRigidBodyExt_getVelocityAtPos_2'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_getVelocityAtPos_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_getLocalVelocityAtLocalPos_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_getLocalVelocityAtLocalPos_2');
  _emscripten_bind_PxRigidBodyExt_getLocalVelocityAtLocalPos_2 = Module['_emscripten_bind_PxRigidBodyExt_getLocalVelocityAtLocalPos_2'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_getLocalVelocityAtLocalPos_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_getVelocityAtOffset_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_getVelocityAtOffset_2');
  _emscripten_bind_PxRigidBodyExt_getVelocityAtOffset_2 = Module['_emscripten_bind_PxRigidBodyExt_getVelocityAtOffset_2'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_getVelocityAtOffset_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_5');
  _emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_5 = Module['_emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_5'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_8'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_8');
  _emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_8 = Module['_emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_8'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_8', 8);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt_computeLinearAngularImpulse_8'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt_computeLinearAngularImpulse_8');
  _emscripten_bind_PxRigidBodyExt_computeLinearAngularImpulse_8 = Module['_emscripten_bind_PxRigidBodyExt_computeLinearAngularImpulse_8'] = createExportWrapper('emscripten_bind_PxRigidBodyExt_computeLinearAngularImpulse_8', 8);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyExt___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyExt___destroy___0');
  _emscripten_bind_PxRigidBodyExt___destroy___0 = Module['_emscripten_bind_PxRigidBodyExt___destroy___0'] = createExportWrapper('emscripten_bind_PxRigidBodyExt___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyFlags_PxRigidBodyFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyFlags_PxRigidBodyFlags_1');
  _emscripten_bind_PxRigidBodyFlags_PxRigidBodyFlags_1 = Module['_emscripten_bind_PxRigidBodyFlags_PxRigidBodyFlags_1'] = createExportWrapper('emscripten_bind_PxRigidBodyFlags_PxRigidBodyFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyFlags_isSet_1');
  _emscripten_bind_PxRigidBodyFlags_isSet_1 = Module['_emscripten_bind_PxRigidBodyFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxRigidBodyFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyFlags_raise_1');
  _emscripten_bind_PxRigidBodyFlags_raise_1 = Module['_emscripten_bind_PxRigidBodyFlags_raise_1'] = createExportWrapper('emscripten_bind_PxRigidBodyFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyFlags_clear_1');
  _emscripten_bind_PxRigidBodyFlags_clear_1 = Module['_emscripten_bind_PxRigidBodyFlags_clear_1'] = createExportWrapper('emscripten_bind_PxRigidBodyFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidBodyFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidBodyFlags___destroy___0');
  _emscripten_bind_PxRigidBodyFlags___destroy___0 = Module['_emscripten_bind_PxRigidBodyFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxRigidBodyFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setKinematicTarget_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setKinematicTarget_1');
  _emscripten_bind_PxRigidDynamic_setKinematicTarget_1 = Module['_emscripten_bind_PxRigidDynamic_setKinematicTarget_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setKinematicTarget_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getKinematicTarget_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getKinematicTarget_1');
  _emscripten_bind_PxRigidDynamic_getKinematicTarget_1 = Module['_emscripten_bind_PxRigidDynamic_getKinematicTarget_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getKinematicTarget_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_isSleeping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_isSleeping_0');
  _emscripten_bind_PxRigidDynamic_isSleeping_0 = Module['_emscripten_bind_PxRigidDynamic_isSleeping_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_isSleeping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setSleepThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setSleepThreshold_1');
  _emscripten_bind_PxRigidDynamic_setSleepThreshold_1 = Module['_emscripten_bind_PxRigidDynamic_setSleepThreshold_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setSleepThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getSleepThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getSleepThreshold_0');
  _emscripten_bind_PxRigidDynamic_getSleepThreshold_0 = Module['_emscripten_bind_PxRigidDynamic_getSleepThreshold_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getSleepThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setStabilizationThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setStabilizationThreshold_1');
  _emscripten_bind_PxRigidDynamic_setStabilizationThreshold_1 = Module['_emscripten_bind_PxRigidDynamic_setStabilizationThreshold_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setStabilizationThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getStabilizationThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getStabilizationThreshold_0');
  _emscripten_bind_PxRigidDynamic_getStabilizationThreshold_0 = Module['_emscripten_bind_PxRigidDynamic_getStabilizationThreshold_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getStabilizationThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getRigidDynamicLockFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getRigidDynamicLockFlags_0');
  _emscripten_bind_PxRigidDynamic_getRigidDynamicLockFlags_0 = Module['_emscripten_bind_PxRigidDynamic_getRigidDynamicLockFlags_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getRigidDynamicLockFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlag_2');
  _emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlag_2 = Module['_emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlag_2'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlags_1');
  _emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlags_1 = Module['_emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlags_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setLinearVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setLinearVelocity_1');
  _emscripten_bind_PxRigidDynamic_setLinearVelocity_1 = Module['_emscripten_bind_PxRigidDynamic_setLinearVelocity_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setLinearVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setLinearVelocity_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setLinearVelocity_2');
  _emscripten_bind_PxRigidDynamic_setLinearVelocity_2 = Module['_emscripten_bind_PxRigidDynamic_setLinearVelocity_2'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setLinearVelocity_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setAngularVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setAngularVelocity_1');
  _emscripten_bind_PxRigidDynamic_setAngularVelocity_1 = Module['_emscripten_bind_PxRigidDynamic_setAngularVelocity_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setAngularVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setAngularVelocity_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setAngularVelocity_2');
  _emscripten_bind_PxRigidDynamic_setAngularVelocity_2 = Module['_emscripten_bind_PxRigidDynamic_setAngularVelocity_2'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setAngularVelocity_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setWakeCounter_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setWakeCounter_1');
  _emscripten_bind_PxRigidDynamic_setWakeCounter_1 = Module['_emscripten_bind_PxRigidDynamic_setWakeCounter_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setWakeCounter_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getWakeCounter_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getWakeCounter_0');
  _emscripten_bind_PxRigidDynamic_getWakeCounter_0 = Module['_emscripten_bind_PxRigidDynamic_getWakeCounter_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getWakeCounter_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_wakeUp_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_wakeUp_0');
  _emscripten_bind_PxRigidDynamic_wakeUp_0 = Module['_emscripten_bind_PxRigidDynamic_wakeUp_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_wakeUp_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_putToSleep_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_putToSleep_0');
  _emscripten_bind_PxRigidDynamic_putToSleep_0 = Module['_emscripten_bind_PxRigidDynamic_putToSleep_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_putToSleep_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setSolverIterationCounts_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setSolverIterationCounts_1');
  _emscripten_bind_PxRigidDynamic_setSolverIterationCounts_1 = Module['_emscripten_bind_PxRigidDynamic_setSolverIterationCounts_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setSolverIterationCounts_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setSolverIterationCounts_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setSolverIterationCounts_2');
  _emscripten_bind_PxRigidDynamic_setSolverIterationCounts_2 = Module['_emscripten_bind_PxRigidDynamic_setSolverIterationCounts_2'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setSolverIterationCounts_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getContactReportThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getContactReportThreshold_0');
  _emscripten_bind_PxRigidDynamic_getContactReportThreshold_0 = Module['_emscripten_bind_PxRigidDynamic_getContactReportThreshold_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getContactReportThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setContactReportThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setContactReportThreshold_1');
  _emscripten_bind_PxRigidDynamic_setContactReportThreshold_1 = Module['_emscripten_bind_PxRigidDynamic_setContactReportThreshold_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setContactReportThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getType_0');
  _emscripten_bind_PxRigidDynamic_getType_0 = Module['_emscripten_bind_PxRigidDynamic_getType_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getScene_0');
  _emscripten_bind_PxRigidDynamic_getScene_0 = Module['_emscripten_bind_PxRigidDynamic_getScene_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setName_1');
  _emscripten_bind_PxRigidDynamic_setName_1 = Module['_emscripten_bind_PxRigidDynamic_setName_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getName_0');
  _emscripten_bind_PxRigidDynamic_getName_0 = Module['_emscripten_bind_PxRigidDynamic_getName_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getWorldBounds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getWorldBounds_0');
  _emscripten_bind_PxRigidDynamic_getWorldBounds_0 = Module['_emscripten_bind_PxRigidDynamic_getWorldBounds_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getWorldBounds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getWorldBounds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getWorldBounds_1');
  _emscripten_bind_PxRigidDynamic_getWorldBounds_1 = Module['_emscripten_bind_PxRigidDynamic_getWorldBounds_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getWorldBounds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setActorFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setActorFlag_2');
  _emscripten_bind_PxRigidDynamic_setActorFlag_2 = Module['_emscripten_bind_PxRigidDynamic_setActorFlag_2'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setActorFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setActorFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setActorFlags_1');
  _emscripten_bind_PxRigidDynamic_setActorFlags_1 = Module['_emscripten_bind_PxRigidDynamic_setActorFlags_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setActorFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getActorFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getActorFlags_0');
  _emscripten_bind_PxRigidDynamic_getActorFlags_0 = Module['_emscripten_bind_PxRigidDynamic_getActorFlags_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getActorFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setDominanceGroup_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setDominanceGroup_1');
  _emscripten_bind_PxRigidDynamic_setDominanceGroup_1 = Module['_emscripten_bind_PxRigidDynamic_setDominanceGroup_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setDominanceGroup_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getDominanceGroup_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getDominanceGroup_0');
  _emscripten_bind_PxRigidDynamic_getDominanceGroup_0 = Module['_emscripten_bind_PxRigidDynamic_getDominanceGroup_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getDominanceGroup_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setOwnerClient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setOwnerClient_1');
  _emscripten_bind_PxRigidDynamic_setOwnerClient_1 = Module['_emscripten_bind_PxRigidDynamic_setOwnerClient_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setOwnerClient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getOwnerClient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getOwnerClient_0');
  _emscripten_bind_PxRigidDynamic_getOwnerClient_0 = Module['_emscripten_bind_PxRigidDynamic_getOwnerClient_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getOwnerClient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_release_0');
  _emscripten_bind_PxRigidDynamic_release_0 = Module['_emscripten_bind_PxRigidDynamic_release_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getConcreteTypeName_0');
  _emscripten_bind_PxRigidDynamic_getConcreteTypeName_0 = Module['_emscripten_bind_PxRigidDynamic_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getConcreteType_0');
  _emscripten_bind_PxRigidDynamic_getConcreteType_0 = Module['_emscripten_bind_PxRigidDynamic_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setBaseFlag_2');
  _emscripten_bind_PxRigidDynamic_setBaseFlag_2 = Module['_emscripten_bind_PxRigidDynamic_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setBaseFlags_1');
  _emscripten_bind_PxRigidDynamic_setBaseFlags_1 = Module['_emscripten_bind_PxRigidDynamic_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getBaseFlags_0');
  _emscripten_bind_PxRigidDynamic_getBaseFlags_0 = Module['_emscripten_bind_PxRigidDynamic_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_isReleasable_0');
  _emscripten_bind_PxRigidDynamic_isReleasable_0 = Module['_emscripten_bind_PxRigidDynamic_isReleasable_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getGlobalPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getGlobalPose_0');
  _emscripten_bind_PxRigidDynamic_getGlobalPose_0 = Module['_emscripten_bind_PxRigidDynamic_getGlobalPose_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getGlobalPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setGlobalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setGlobalPose_1');
  _emscripten_bind_PxRigidDynamic_setGlobalPose_1 = Module['_emscripten_bind_PxRigidDynamic_setGlobalPose_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setGlobalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setGlobalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setGlobalPose_2');
  _emscripten_bind_PxRigidDynamic_setGlobalPose_2 = Module['_emscripten_bind_PxRigidDynamic_setGlobalPose_2'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setGlobalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_attachShape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_attachShape_1');
  _emscripten_bind_PxRigidDynamic_attachShape_1 = Module['_emscripten_bind_PxRigidDynamic_attachShape_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_attachShape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_detachShape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_detachShape_1');
  _emscripten_bind_PxRigidDynamic_detachShape_1 = Module['_emscripten_bind_PxRigidDynamic_detachShape_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_detachShape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_detachShape_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_detachShape_2');
  _emscripten_bind_PxRigidDynamic_detachShape_2 = Module['_emscripten_bind_PxRigidDynamic_detachShape_2'] = createExportWrapper('emscripten_bind_PxRigidDynamic_detachShape_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getNbShapes_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getNbShapes_0');
  _emscripten_bind_PxRigidDynamic_getNbShapes_0 = Module['_emscripten_bind_PxRigidDynamic_getNbShapes_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getNbShapes_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getShapes_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getShapes_3');
  _emscripten_bind_PxRigidDynamic_getShapes_3 = Module['_emscripten_bind_PxRigidDynamic_getShapes_3'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getShapes_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getNbConstraints_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getNbConstraints_0');
  _emscripten_bind_PxRigidDynamic_getNbConstraints_0 = Module['_emscripten_bind_PxRigidDynamic_getNbConstraints_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getNbConstraints_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setCMassLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setCMassLocalPose_1');
  _emscripten_bind_PxRigidDynamic_setCMassLocalPose_1 = Module['_emscripten_bind_PxRigidDynamic_setCMassLocalPose_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setCMassLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getCMassLocalPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getCMassLocalPose_0');
  _emscripten_bind_PxRigidDynamic_getCMassLocalPose_0 = Module['_emscripten_bind_PxRigidDynamic_getCMassLocalPose_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getCMassLocalPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setMass_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setMass_1');
  _emscripten_bind_PxRigidDynamic_setMass_1 = Module['_emscripten_bind_PxRigidDynamic_setMass_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setMass_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getMass_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getMass_0');
  _emscripten_bind_PxRigidDynamic_getMass_0 = Module['_emscripten_bind_PxRigidDynamic_getMass_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getMass_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getInvMass_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getInvMass_0');
  _emscripten_bind_PxRigidDynamic_getInvMass_0 = Module['_emscripten_bind_PxRigidDynamic_getInvMass_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getInvMass_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setMassSpaceInertiaTensor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setMassSpaceInertiaTensor_1');
  _emscripten_bind_PxRigidDynamic_setMassSpaceInertiaTensor_1 = Module['_emscripten_bind_PxRigidDynamic_setMassSpaceInertiaTensor_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setMassSpaceInertiaTensor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getMassSpaceInertiaTensor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getMassSpaceInertiaTensor_0');
  _emscripten_bind_PxRigidDynamic_getMassSpaceInertiaTensor_0 = Module['_emscripten_bind_PxRigidDynamic_getMassSpaceInertiaTensor_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getMassSpaceInertiaTensor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getMassSpaceInvInertiaTensor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getMassSpaceInvInertiaTensor_0');
  _emscripten_bind_PxRigidDynamic_getMassSpaceInvInertiaTensor_0 = Module['_emscripten_bind_PxRigidDynamic_getMassSpaceInvInertiaTensor_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getMassSpaceInvInertiaTensor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setLinearDamping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setLinearDamping_1');
  _emscripten_bind_PxRigidDynamic_setLinearDamping_1 = Module['_emscripten_bind_PxRigidDynamic_setLinearDamping_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setLinearDamping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getLinearDamping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getLinearDamping_0');
  _emscripten_bind_PxRigidDynamic_getLinearDamping_0 = Module['_emscripten_bind_PxRigidDynamic_getLinearDamping_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getLinearDamping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setAngularDamping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setAngularDamping_1');
  _emscripten_bind_PxRigidDynamic_setAngularDamping_1 = Module['_emscripten_bind_PxRigidDynamic_setAngularDamping_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setAngularDamping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getAngularDamping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getAngularDamping_0');
  _emscripten_bind_PxRigidDynamic_getAngularDamping_0 = Module['_emscripten_bind_PxRigidDynamic_getAngularDamping_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getAngularDamping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getLinearVelocity_0');
  _emscripten_bind_PxRigidDynamic_getLinearVelocity_0 = Module['_emscripten_bind_PxRigidDynamic_getLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getAngularVelocity_0');
  _emscripten_bind_PxRigidDynamic_getAngularVelocity_0 = Module['_emscripten_bind_PxRigidDynamic_getAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setMaxLinearVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setMaxLinearVelocity_1');
  _emscripten_bind_PxRigidDynamic_setMaxLinearVelocity_1 = Module['_emscripten_bind_PxRigidDynamic_setMaxLinearVelocity_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setMaxLinearVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getMaxLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getMaxLinearVelocity_0');
  _emscripten_bind_PxRigidDynamic_getMaxLinearVelocity_0 = Module['_emscripten_bind_PxRigidDynamic_getMaxLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getMaxLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setMaxAngularVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setMaxAngularVelocity_1');
  _emscripten_bind_PxRigidDynamic_setMaxAngularVelocity_1 = Module['_emscripten_bind_PxRigidDynamic_setMaxAngularVelocity_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setMaxAngularVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getMaxAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getMaxAngularVelocity_0');
  _emscripten_bind_PxRigidDynamic_getMaxAngularVelocity_0 = Module['_emscripten_bind_PxRigidDynamic_getMaxAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getMaxAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_addForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_addForce_1');
  _emscripten_bind_PxRigidDynamic_addForce_1 = Module['_emscripten_bind_PxRigidDynamic_addForce_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_addForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_addForce_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_addForce_2');
  _emscripten_bind_PxRigidDynamic_addForce_2 = Module['_emscripten_bind_PxRigidDynamic_addForce_2'] = createExportWrapper('emscripten_bind_PxRigidDynamic_addForce_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_addForce_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_addForce_3');
  _emscripten_bind_PxRigidDynamic_addForce_3 = Module['_emscripten_bind_PxRigidDynamic_addForce_3'] = createExportWrapper('emscripten_bind_PxRigidDynamic_addForce_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_addTorque_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_addTorque_1');
  _emscripten_bind_PxRigidDynamic_addTorque_1 = Module['_emscripten_bind_PxRigidDynamic_addTorque_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_addTorque_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_addTorque_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_addTorque_2');
  _emscripten_bind_PxRigidDynamic_addTorque_2 = Module['_emscripten_bind_PxRigidDynamic_addTorque_2'] = createExportWrapper('emscripten_bind_PxRigidDynamic_addTorque_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_addTorque_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_addTorque_3');
  _emscripten_bind_PxRigidDynamic_addTorque_3 = Module['_emscripten_bind_PxRigidDynamic_addTorque_3'] = createExportWrapper('emscripten_bind_PxRigidDynamic_addTorque_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_clearForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_clearForce_1');
  _emscripten_bind_PxRigidDynamic_clearForce_1 = Module['_emscripten_bind_PxRigidDynamic_clearForce_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_clearForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_clearTorque_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_clearTorque_1');
  _emscripten_bind_PxRigidDynamic_clearTorque_1 = Module['_emscripten_bind_PxRigidDynamic_clearTorque_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_clearTorque_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setForceAndTorque_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setForceAndTorque_2');
  _emscripten_bind_PxRigidDynamic_setForceAndTorque_2 = Module['_emscripten_bind_PxRigidDynamic_setForceAndTorque_2'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setForceAndTorque_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setForceAndTorque_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setForceAndTorque_3');
  _emscripten_bind_PxRigidDynamic_setForceAndTorque_3 = Module['_emscripten_bind_PxRigidDynamic_setForceAndTorque_3'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setForceAndTorque_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setRigidBodyFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setRigidBodyFlag_2');
  _emscripten_bind_PxRigidDynamic_setRigidBodyFlag_2 = Module['_emscripten_bind_PxRigidDynamic_setRigidBodyFlag_2'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setRigidBodyFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setRigidBodyFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setRigidBodyFlags_1');
  _emscripten_bind_PxRigidDynamic_setRigidBodyFlags_1 = Module['_emscripten_bind_PxRigidDynamic_setRigidBodyFlags_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setRigidBodyFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getRigidBodyFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getRigidBodyFlags_0');
  _emscripten_bind_PxRigidDynamic_getRigidBodyFlags_0 = Module['_emscripten_bind_PxRigidDynamic_getRigidBodyFlags_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getRigidBodyFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setMinCCDAdvanceCoefficient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setMinCCDAdvanceCoefficient_1');
  _emscripten_bind_PxRigidDynamic_setMinCCDAdvanceCoefficient_1 = Module['_emscripten_bind_PxRigidDynamic_setMinCCDAdvanceCoefficient_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setMinCCDAdvanceCoefficient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getMinCCDAdvanceCoefficient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getMinCCDAdvanceCoefficient_0');
  _emscripten_bind_PxRigidDynamic_getMinCCDAdvanceCoefficient_0 = Module['_emscripten_bind_PxRigidDynamic_getMinCCDAdvanceCoefficient_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getMinCCDAdvanceCoefficient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setMaxDepenetrationVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setMaxDepenetrationVelocity_1');
  _emscripten_bind_PxRigidDynamic_setMaxDepenetrationVelocity_1 = Module['_emscripten_bind_PxRigidDynamic_setMaxDepenetrationVelocity_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setMaxDepenetrationVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getMaxDepenetrationVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getMaxDepenetrationVelocity_0');
  _emscripten_bind_PxRigidDynamic_getMaxDepenetrationVelocity_0 = Module['_emscripten_bind_PxRigidDynamic_getMaxDepenetrationVelocity_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getMaxDepenetrationVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setMaxContactImpulse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setMaxContactImpulse_1');
  _emscripten_bind_PxRigidDynamic_setMaxContactImpulse_1 = Module['_emscripten_bind_PxRigidDynamic_setMaxContactImpulse_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setMaxContactImpulse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getMaxContactImpulse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getMaxContactImpulse_0');
  _emscripten_bind_PxRigidDynamic_getMaxContactImpulse_0 = Module['_emscripten_bind_PxRigidDynamic_getMaxContactImpulse_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getMaxContactImpulse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_setContactSlopCoefficient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_setContactSlopCoefficient_1');
  _emscripten_bind_PxRigidDynamic_setContactSlopCoefficient_1 = Module['_emscripten_bind_PxRigidDynamic_setContactSlopCoefficient_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_setContactSlopCoefficient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_getContactSlopCoefficient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_getContactSlopCoefficient_0');
  _emscripten_bind_PxRigidDynamic_getContactSlopCoefficient_0 = Module['_emscripten_bind_PxRigidDynamic_getContactSlopCoefficient_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_getContactSlopCoefficient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_get_userData_0');
  _emscripten_bind_PxRigidDynamic_get_userData_0 = Module['_emscripten_bind_PxRigidDynamic_get_userData_0'] = createExportWrapper('emscripten_bind_PxRigidDynamic_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamic_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamic_set_userData_1');
  _emscripten_bind_PxRigidDynamic_set_userData_1 = Module['_emscripten_bind_PxRigidDynamic_set_userData_1'] = createExportWrapper('emscripten_bind_PxRigidDynamic_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamicLockFlags_PxRigidDynamicLockFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamicLockFlags_PxRigidDynamicLockFlags_1');
  _emscripten_bind_PxRigidDynamicLockFlags_PxRigidDynamicLockFlags_1 = Module['_emscripten_bind_PxRigidDynamicLockFlags_PxRigidDynamicLockFlags_1'] = createExportWrapper('emscripten_bind_PxRigidDynamicLockFlags_PxRigidDynamicLockFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamicLockFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamicLockFlags_isSet_1');
  _emscripten_bind_PxRigidDynamicLockFlags_isSet_1 = Module['_emscripten_bind_PxRigidDynamicLockFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxRigidDynamicLockFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamicLockFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamicLockFlags_raise_1');
  _emscripten_bind_PxRigidDynamicLockFlags_raise_1 = Module['_emscripten_bind_PxRigidDynamicLockFlags_raise_1'] = createExportWrapper('emscripten_bind_PxRigidDynamicLockFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamicLockFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamicLockFlags_clear_1');
  _emscripten_bind_PxRigidDynamicLockFlags_clear_1 = Module['_emscripten_bind_PxRigidDynamicLockFlags_clear_1'] = createExportWrapper('emscripten_bind_PxRigidDynamicLockFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidDynamicLockFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidDynamicLockFlags___destroy___0');
  _emscripten_bind_PxRigidDynamicLockFlags___destroy___0 = Module['_emscripten_bind_PxRigidDynamicLockFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxRigidDynamicLockFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getType_0');
  _emscripten_bind_PxRigidStatic_getType_0 = Module['_emscripten_bind_PxRigidStatic_getType_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getScene_0');
  _emscripten_bind_PxRigidStatic_getScene_0 = Module['_emscripten_bind_PxRigidStatic_getScene_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_setName_1');
  _emscripten_bind_PxRigidStatic_setName_1 = Module['_emscripten_bind_PxRigidStatic_setName_1'] = createExportWrapper('emscripten_bind_PxRigidStatic_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getName_0');
  _emscripten_bind_PxRigidStatic_getName_0 = Module['_emscripten_bind_PxRigidStatic_getName_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getWorldBounds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getWorldBounds_0');
  _emscripten_bind_PxRigidStatic_getWorldBounds_0 = Module['_emscripten_bind_PxRigidStatic_getWorldBounds_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_getWorldBounds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getWorldBounds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getWorldBounds_1');
  _emscripten_bind_PxRigidStatic_getWorldBounds_1 = Module['_emscripten_bind_PxRigidStatic_getWorldBounds_1'] = createExportWrapper('emscripten_bind_PxRigidStatic_getWorldBounds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_setActorFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_setActorFlag_2');
  _emscripten_bind_PxRigidStatic_setActorFlag_2 = Module['_emscripten_bind_PxRigidStatic_setActorFlag_2'] = createExportWrapper('emscripten_bind_PxRigidStatic_setActorFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_setActorFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_setActorFlags_1');
  _emscripten_bind_PxRigidStatic_setActorFlags_1 = Module['_emscripten_bind_PxRigidStatic_setActorFlags_1'] = createExportWrapper('emscripten_bind_PxRigidStatic_setActorFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getActorFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getActorFlags_0');
  _emscripten_bind_PxRigidStatic_getActorFlags_0 = Module['_emscripten_bind_PxRigidStatic_getActorFlags_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_getActorFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_setDominanceGroup_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_setDominanceGroup_1');
  _emscripten_bind_PxRigidStatic_setDominanceGroup_1 = Module['_emscripten_bind_PxRigidStatic_setDominanceGroup_1'] = createExportWrapper('emscripten_bind_PxRigidStatic_setDominanceGroup_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getDominanceGroup_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getDominanceGroup_0');
  _emscripten_bind_PxRigidStatic_getDominanceGroup_0 = Module['_emscripten_bind_PxRigidStatic_getDominanceGroup_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_getDominanceGroup_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_setOwnerClient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_setOwnerClient_1');
  _emscripten_bind_PxRigidStatic_setOwnerClient_1 = Module['_emscripten_bind_PxRigidStatic_setOwnerClient_1'] = createExportWrapper('emscripten_bind_PxRigidStatic_setOwnerClient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getOwnerClient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getOwnerClient_0');
  _emscripten_bind_PxRigidStatic_getOwnerClient_0 = Module['_emscripten_bind_PxRigidStatic_getOwnerClient_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_getOwnerClient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_release_0');
  _emscripten_bind_PxRigidStatic_release_0 = Module['_emscripten_bind_PxRigidStatic_release_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getConcreteTypeName_0');
  _emscripten_bind_PxRigidStatic_getConcreteTypeName_0 = Module['_emscripten_bind_PxRigidStatic_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getConcreteType_0');
  _emscripten_bind_PxRigidStatic_getConcreteType_0 = Module['_emscripten_bind_PxRigidStatic_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_setBaseFlag_2');
  _emscripten_bind_PxRigidStatic_setBaseFlag_2 = Module['_emscripten_bind_PxRigidStatic_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxRigidStatic_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_setBaseFlags_1');
  _emscripten_bind_PxRigidStatic_setBaseFlags_1 = Module['_emscripten_bind_PxRigidStatic_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxRigidStatic_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getBaseFlags_0');
  _emscripten_bind_PxRigidStatic_getBaseFlags_0 = Module['_emscripten_bind_PxRigidStatic_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_isReleasable_0');
  _emscripten_bind_PxRigidStatic_isReleasable_0 = Module['_emscripten_bind_PxRigidStatic_isReleasable_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getGlobalPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getGlobalPose_0');
  _emscripten_bind_PxRigidStatic_getGlobalPose_0 = Module['_emscripten_bind_PxRigidStatic_getGlobalPose_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_getGlobalPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_setGlobalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_setGlobalPose_1');
  _emscripten_bind_PxRigidStatic_setGlobalPose_1 = Module['_emscripten_bind_PxRigidStatic_setGlobalPose_1'] = createExportWrapper('emscripten_bind_PxRigidStatic_setGlobalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_setGlobalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_setGlobalPose_2');
  _emscripten_bind_PxRigidStatic_setGlobalPose_2 = Module['_emscripten_bind_PxRigidStatic_setGlobalPose_2'] = createExportWrapper('emscripten_bind_PxRigidStatic_setGlobalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_attachShape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_attachShape_1');
  _emscripten_bind_PxRigidStatic_attachShape_1 = Module['_emscripten_bind_PxRigidStatic_attachShape_1'] = createExportWrapper('emscripten_bind_PxRigidStatic_attachShape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_detachShape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_detachShape_1');
  _emscripten_bind_PxRigidStatic_detachShape_1 = Module['_emscripten_bind_PxRigidStatic_detachShape_1'] = createExportWrapper('emscripten_bind_PxRigidStatic_detachShape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_detachShape_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_detachShape_2');
  _emscripten_bind_PxRigidStatic_detachShape_2 = Module['_emscripten_bind_PxRigidStatic_detachShape_2'] = createExportWrapper('emscripten_bind_PxRigidStatic_detachShape_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getNbShapes_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getNbShapes_0');
  _emscripten_bind_PxRigidStatic_getNbShapes_0 = Module['_emscripten_bind_PxRigidStatic_getNbShapes_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_getNbShapes_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getShapes_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getShapes_3');
  _emscripten_bind_PxRigidStatic_getShapes_3 = Module['_emscripten_bind_PxRigidStatic_getShapes_3'] = createExportWrapper('emscripten_bind_PxRigidStatic_getShapes_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_getNbConstraints_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_getNbConstraints_0');
  _emscripten_bind_PxRigidStatic_getNbConstraints_0 = Module['_emscripten_bind_PxRigidStatic_getNbConstraints_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_getNbConstraints_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_get_userData_0');
  _emscripten_bind_PxRigidStatic_get_userData_0 = Module['_emscripten_bind_PxRigidStatic_get_userData_0'] = createExportWrapper('emscripten_bind_PxRigidStatic_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxRigidStatic_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxRigidStatic_set_userData_1');
  _emscripten_bind_PxRigidStatic_set_userData_1 = Module['_emscripten_bind_PxRigidStatic_set_userData_1'] = createExportWrapper('emscripten_bind_PxRigidStatic_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_PxSDFDesc_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_PxSDFDesc_0');
  _emscripten_bind_PxSDFDesc_PxSDFDesc_0 = Module['_emscripten_bind_PxSDFDesc_PxSDFDesc_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_PxSDFDesc_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_isValid_0');
  _emscripten_bind_PxSDFDesc_isValid_0 = Module['_emscripten_bind_PxSDFDesc_isValid_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_get_sdf_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_get_sdf_0');
  _emscripten_bind_PxSDFDesc_get_sdf_0 = Module['_emscripten_bind_PxSDFDesc_get_sdf_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_get_sdf_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_set_sdf_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_set_sdf_1');
  _emscripten_bind_PxSDFDesc_set_sdf_1 = Module['_emscripten_bind_PxSDFDesc_set_sdf_1'] = createExportWrapper('emscripten_bind_PxSDFDesc_set_sdf_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_get_dims_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_get_dims_0');
  _emscripten_bind_PxSDFDesc_get_dims_0 = Module['_emscripten_bind_PxSDFDesc_get_dims_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_get_dims_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_set_dims_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_set_dims_1');
  _emscripten_bind_PxSDFDesc_set_dims_1 = Module['_emscripten_bind_PxSDFDesc_set_dims_1'] = createExportWrapper('emscripten_bind_PxSDFDesc_set_dims_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_get_meshLower_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_get_meshLower_0');
  _emscripten_bind_PxSDFDesc_get_meshLower_0 = Module['_emscripten_bind_PxSDFDesc_get_meshLower_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_get_meshLower_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_set_meshLower_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_set_meshLower_1');
  _emscripten_bind_PxSDFDesc_set_meshLower_1 = Module['_emscripten_bind_PxSDFDesc_set_meshLower_1'] = createExportWrapper('emscripten_bind_PxSDFDesc_set_meshLower_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_get_spacing_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_get_spacing_0');
  _emscripten_bind_PxSDFDesc_get_spacing_0 = Module['_emscripten_bind_PxSDFDesc_get_spacing_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_get_spacing_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_set_spacing_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_set_spacing_1');
  _emscripten_bind_PxSDFDesc_set_spacing_1 = Module['_emscripten_bind_PxSDFDesc_set_spacing_1'] = createExportWrapper('emscripten_bind_PxSDFDesc_set_spacing_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_get_subgridSize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_get_subgridSize_0');
  _emscripten_bind_PxSDFDesc_get_subgridSize_0 = Module['_emscripten_bind_PxSDFDesc_get_subgridSize_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_get_subgridSize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_set_subgridSize_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_set_subgridSize_1');
  _emscripten_bind_PxSDFDesc_set_subgridSize_1 = Module['_emscripten_bind_PxSDFDesc_set_subgridSize_1'] = createExportWrapper('emscripten_bind_PxSDFDesc_set_subgridSize_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_get_bitsPerSubgridPixel_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_get_bitsPerSubgridPixel_0');
  _emscripten_bind_PxSDFDesc_get_bitsPerSubgridPixel_0 = Module['_emscripten_bind_PxSDFDesc_get_bitsPerSubgridPixel_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_get_bitsPerSubgridPixel_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_set_bitsPerSubgridPixel_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_set_bitsPerSubgridPixel_1');
  _emscripten_bind_PxSDFDesc_set_bitsPerSubgridPixel_1 = Module['_emscripten_bind_PxSDFDesc_set_bitsPerSubgridPixel_1'] = createExportWrapper('emscripten_bind_PxSDFDesc_set_bitsPerSubgridPixel_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_get_sdfSubgrids3DTexBlockDim_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_get_sdfSubgrids3DTexBlockDim_0');
  _emscripten_bind_PxSDFDesc_get_sdfSubgrids3DTexBlockDim_0 = Module['_emscripten_bind_PxSDFDesc_get_sdfSubgrids3DTexBlockDim_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_get_sdfSubgrids3DTexBlockDim_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_set_sdfSubgrids3DTexBlockDim_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_set_sdfSubgrids3DTexBlockDim_1');
  _emscripten_bind_PxSDFDesc_set_sdfSubgrids3DTexBlockDim_1 = Module['_emscripten_bind_PxSDFDesc_set_sdfSubgrids3DTexBlockDim_1'] = createExportWrapper('emscripten_bind_PxSDFDesc_set_sdfSubgrids3DTexBlockDim_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_get_sdfSubgrids_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_get_sdfSubgrids_0');
  _emscripten_bind_PxSDFDesc_get_sdfSubgrids_0 = Module['_emscripten_bind_PxSDFDesc_get_sdfSubgrids_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_get_sdfSubgrids_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_set_sdfSubgrids_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_set_sdfSubgrids_1');
  _emscripten_bind_PxSDFDesc_set_sdfSubgrids_1 = Module['_emscripten_bind_PxSDFDesc_set_sdfSubgrids_1'] = createExportWrapper('emscripten_bind_PxSDFDesc_set_sdfSubgrids_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_get_sdfStartSlots_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_get_sdfStartSlots_0');
  _emscripten_bind_PxSDFDesc_get_sdfStartSlots_0 = Module['_emscripten_bind_PxSDFDesc_get_sdfStartSlots_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_get_sdfStartSlots_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_set_sdfStartSlots_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_set_sdfStartSlots_1');
  _emscripten_bind_PxSDFDesc_set_sdfStartSlots_1 = Module['_emscripten_bind_PxSDFDesc_set_sdfStartSlots_1'] = createExportWrapper('emscripten_bind_PxSDFDesc_set_sdfStartSlots_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_get_subgridsMinSdfValue_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_get_subgridsMinSdfValue_0');
  _emscripten_bind_PxSDFDesc_get_subgridsMinSdfValue_0 = Module['_emscripten_bind_PxSDFDesc_get_subgridsMinSdfValue_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_get_subgridsMinSdfValue_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_set_subgridsMinSdfValue_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_set_subgridsMinSdfValue_1');
  _emscripten_bind_PxSDFDesc_set_subgridsMinSdfValue_1 = Module['_emscripten_bind_PxSDFDesc_set_subgridsMinSdfValue_1'] = createExportWrapper('emscripten_bind_PxSDFDesc_set_subgridsMinSdfValue_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_get_subgridsMaxSdfValue_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_get_subgridsMaxSdfValue_0');
  _emscripten_bind_PxSDFDesc_get_subgridsMaxSdfValue_0 = Module['_emscripten_bind_PxSDFDesc_get_subgridsMaxSdfValue_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_get_subgridsMaxSdfValue_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_set_subgridsMaxSdfValue_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_set_subgridsMaxSdfValue_1');
  _emscripten_bind_PxSDFDesc_set_subgridsMaxSdfValue_1 = Module['_emscripten_bind_PxSDFDesc_set_subgridsMaxSdfValue_1'] = createExportWrapper('emscripten_bind_PxSDFDesc_set_subgridsMaxSdfValue_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_get_sdfBounds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_get_sdfBounds_0');
  _emscripten_bind_PxSDFDesc_get_sdfBounds_0 = Module['_emscripten_bind_PxSDFDesc_get_sdfBounds_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_get_sdfBounds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_set_sdfBounds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_set_sdfBounds_1');
  _emscripten_bind_PxSDFDesc_set_sdfBounds_1 = Module['_emscripten_bind_PxSDFDesc_set_sdfBounds_1'] = createExportWrapper('emscripten_bind_PxSDFDesc_set_sdfBounds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_get_narrowBandThicknessRelativeToSdfBoundsDiagonal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_get_narrowBandThicknessRelativeToSdfBoundsDiagonal_0');
  _emscripten_bind_PxSDFDesc_get_narrowBandThicknessRelativeToSdfBoundsDiagonal_0 = Module['_emscripten_bind_PxSDFDesc_get_narrowBandThicknessRelativeToSdfBoundsDiagonal_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_get_narrowBandThicknessRelativeToSdfBoundsDiagonal_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_set_narrowBandThicknessRelativeToSdfBoundsDiagonal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_set_narrowBandThicknessRelativeToSdfBoundsDiagonal_1');
  _emscripten_bind_PxSDFDesc_set_narrowBandThicknessRelativeToSdfBoundsDiagonal_1 = Module['_emscripten_bind_PxSDFDesc_set_narrowBandThicknessRelativeToSdfBoundsDiagonal_1'] = createExportWrapper('emscripten_bind_PxSDFDesc_set_narrowBandThicknessRelativeToSdfBoundsDiagonal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_get_numThreadsForSdfConstruction_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_get_numThreadsForSdfConstruction_0');
  _emscripten_bind_PxSDFDesc_get_numThreadsForSdfConstruction_0 = Module['_emscripten_bind_PxSDFDesc_get_numThreadsForSdfConstruction_0'] = createExportWrapper('emscripten_bind_PxSDFDesc_get_numThreadsForSdfConstruction_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc_set_numThreadsForSdfConstruction_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc_set_numThreadsForSdfConstruction_1');
  _emscripten_bind_PxSDFDesc_set_numThreadsForSdfConstruction_1 = Module['_emscripten_bind_PxSDFDesc_set_numThreadsForSdfConstruction_1'] = createExportWrapper('emscripten_bind_PxSDFDesc_set_numThreadsForSdfConstruction_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSDFDesc___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSDFDesc___destroy___0');
  _emscripten_bind_PxSDFDesc___destroy___0 = Module['_emscripten_bind_PxSDFDesc___destroy___0'] = createExportWrapper('emscripten_bind_PxSDFDesc___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_addActor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_addActor_1');
  _emscripten_bind_PxScene_addActor_1 = Module['_emscripten_bind_PxScene_addActor_1'] = createExportWrapper('emscripten_bind_PxScene_addActor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_addActor_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_addActor_2');
  _emscripten_bind_PxScene_addActor_2 = Module['_emscripten_bind_PxScene_addActor_2'] = createExportWrapper('emscripten_bind_PxScene_addActor_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_removeActor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_removeActor_1');
  _emscripten_bind_PxScene_removeActor_1 = Module['_emscripten_bind_PxScene_removeActor_1'] = createExportWrapper('emscripten_bind_PxScene_removeActor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_removeActor_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_removeActor_2');
  _emscripten_bind_PxScene_removeActor_2 = Module['_emscripten_bind_PxScene_removeActor_2'] = createExportWrapper('emscripten_bind_PxScene_removeActor_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_addAggregate_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_addAggregate_1');
  _emscripten_bind_PxScene_addAggregate_1 = Module['_emscripten_bind_PxScene_addAggregate_1'] = createExportWrapper('emscripten_bind_PxScene_addAggregate_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_removeAggregate_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_removeAggregate_1');
  _emscripten_bind_PxScene_removeAggregate_1 = Module['_emscripten_bind_PxScene_removeAggregate_1'] = createExportWrapper('emscripten_bind_PxScene_removeAggregate_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_removeAggregate_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_removeAggregate_2');
  _emscripten_bind_PxScene_removeAggregate_2 = Module['_emscripten_bind_PxScene_removeAggregate_2'] = createExportWrapper('emscripten_bind_PxScene_removeAggregate_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_addCollection_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_addCollection_1');
  _emscripten_bind_PxScene_addCollection_1 = Module['_emscripten_bind_PxScene_addCollection_1'] = createExportWrapper('emscripten_bind_PxScene_addCollection_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getWakeCounterResetValue_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getWakeCounterResetValue_0');
  _emscripten_bind_PxScene_getWakeCounterResetValue_0 = Module['_emscripten_bind_PxScene_getWakeCounterResetValue_0'] = createExportWrapper('emscripten_bind_PxScene_getWakeCounterResetValue_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_shiftOrigin_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_shiftOrigin_1');
  _emscripten_bind_PxScene_shiftOrigin_1 = Module['_emscripten_bind_PxScene_shiftOrigin_1'] = createExportWrapper('emscripten_bind_PxScene_shiftOrigin_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_addArticulation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_addArticulation_1');
  _emscripten_bind_PxScene_addArticulation_1 = Module['_emscripten_bind_PxScene_addArticulation_1'] = createExportWrapper('emscripten_bind_PxScene_addArticulation_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_removeArticulation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_removeArticulation_1');
  _emscripten_bind_PxScene_removeArticulation_1 = Module['_emscripten_bind_PxScene_removeArticulation_1'] = createExportWrapper('emscripten_bind_PxScene_removeArticulation_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_removeArticulation_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_removeArticulation_2');
  _emscripten_bind_PxScene_removeArticulation_2 = Module['_emscripten_bind_PxScene_removeArticulation_2'] = createExportWrapper('emscripten_bind_PxScene_removeArticulation_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_getNbActors_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getNbActors_1');
  _emscripten_bind_PxScene_getNbActors_1 = Module['_emscripten_bind_PxScene_getNbActors_1'] = createExportWrapper('emscripten_bind_PxScene_getNbActors_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getNbArticulations_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getNbArticulations_0');
  _emscripten_bind_PxScene_getNbArticulations_0 = Module['_emscripten_bind_PxScene_getNbArticulations_0'] = createExportWrapper('emscripten_bind_PxScene_getNbArticulations_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getNbConstraints_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getNbConstraints_0');
  _emscripten_bind_PxScene_getNbConstraints_0 = Module['_emscripten_bind_PxScene_getNbConstraints_0'] = createExportWrapper('emscripten_bind_PxScene_getNbConstraints_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getNbAggregates_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getNbAggregates_0');
  _emscripten_bind_PxScene_getNbAggregates_0 = Module['_emscripten_bind_PxScene_getNbAggregates_0'] = createExportWrapper('emscripten_bind_PxScene_getNbAggregates_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setDominanceGroupPair_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setDominanceGroupPair_3');
  _emscripten_bind_PxScene_setDominanceGroupPair_3 = Module['_emscripten_bind_PxScene_setDominanceGroupPair_3'] = createExportWrapper('emscripten_bind_PxScene_setDominanceGroupPair_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxScene_getCpuDispatcher_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getCpuDispatcher_0');
  _emscripten_bind_PxScene_getCpuDispatcher_0 = Module['_emscripten_bind_PxScene_getCpuDispatcher_0'] = createExportWrapper('emscripten_bind_PxScene_getCpuDispatcher_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_createClient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_createClient_0');
  _emscripten_bind_PxScene_createClient_0 = Module['_emscripten_bind_PxScene_createClient_0'] = createExportWrapper('emscripten_bind_PxScene_createClient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setSimulationEventCallback_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setSimulationEventCallback_1');
  _emscripten_bind_PxScene_setSimulationEventCallback_1 = Module['_emscripten_bind_PxScene_setSimulationEventCallback_1'] = createExportWrapper('emscripten_bind_PxScene_setSimulationEventCallback_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getSimulationEventCallback_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getSimulationEventCallback_0');
  _emscripten_bind_PxScene_getSimulationEventCallback_0 = Module['_emscripten_bind_PxScene_getSimulationEventCallback_0'] = createExportWrapper('emscripten_bind_PxScene_getSimulationEventCallback_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setFilterShaderData_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setFilterShaderData_2');
  _emscripten_bind_PxScene_setFilterShaderData_2 = Module['_emscripten_bind_PxScene_setFilterShaderData_2'] = createExportWrapper('emscripten_bind_PxScene_setFilterShaderData_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_getFilterShaderData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getFilterShaderData_0');
  _emscripten_bind_PxScene_getFilterShaderData_0 = Module['_emscripten_bind_PxScene_getFilterShaderData_0'] = createExportWrapper('emscripten_bind_PxScene_getFilterShaderData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getFilterShaderDataSize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getFilterShaderDataSize_0');
  _emscripten_bind_PxScene_getFilterShaderDataSize_0 = Module['_emscripten_bind_PxScene_getFilterShaderDataSize_0'] = createExportWrapper('emscripten_bind_PxScene_getFilterShaderDataSize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getFilterShader_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getFilterShader_0');
  _emscripten_bind_PxScene_getFilterShader_0 = Module['_emscripten_bind_PxScene_getFilterShader_0'] = createExportWrapper('emscripten_bind_PxScene_getFilterShader_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_resetFiltering_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_resetFiltering_1');
  _emscripten_bind_PxScene_resetFiltering_1 = Module['_emscripten_bind_PxScene_resetFiltering_1'] = createExportWrapper('emscripten_bind_PxScene_resetFiltering_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getKinematicKinematicFilteringMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getKinematicKinematicFilteringMode_0');
  _emscripten_bind_PxScene_getKinematicKinematicFilteringMode_0 = Module['_emscripten_bind_PxScene_getKinematicKinematicFilteringMode_0'] = createExportWrapper('emscripten_bind_PxScene_getKinematicKinematicFilteringMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getStaticKinematicFilteringMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getStaticKinematicFilteringMode_0');
  _emscripten_bind_PxScene_getStaticKinematicFilteringMode_0 = Module['_emscripten_bind_PxScene_getStaticKinematicFilteringMode_0'] = createExportWrapper('emscripten_bind_PxScene_getStaticKinematicFilteringMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_simulate_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_simulate_1');
  _emscripten_bind_PxScene_simulate_1 = Module['_emscripten_bind_PxScene_simulate_1'] = createExportWrapper('emscripten_bind_PxScene_simulate_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_simulate_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_simulate_2');
  _emscripten_bind_PxScene_simulate_2 = Module['_emscripten_bind_PxScene_simulate_2'] = createExportWrapper('emscripten_bind_PxScene_simulate_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_simulate_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_simulate_3');
  _emscripten_bind_PxScene_simulate_3 = Module['_emscripten_bind_PxScene_simulate_3'] = createExportWrapper('emscripten_bind_PxScene_simulate_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxScene_simulate_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_simulate_4');
  _emscripten_bind_PxScene_simulate_4 = Module['_emscripten_bind_PxScene_simulate_4'] = createExportWrapper('emscripten_bind_PxScene_simulate_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxScene_simulate_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_simulate_5');
  _emscripten_bind_PxScene_simulate_5 = Module['_emscripten_bind_PxScene_simulate_5'] = createExportWrapper('emscripten_bind_PxScene_simulate_5', 6);
  assert(typeof wasmExports['emscripten_bind_PxScene_advance_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_advance_0');
  _emscripten_bind_PxScene_advance_0 = Module['_emscripten_bind_PxScene_advance_0'] = createExportWrapper('emscripten_bind_PxScene_advance_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_advance_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_advance_1');
  _emscripten_bind_PxScene_advance_1 = Module['_emscripten_bind_PxScene_advance_1'] = createExportWrapper('emscripten_bind_PxScene_advance_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_collide_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_collide_1');
  _emscripten_bind_PxScene_collide_1 = Module['_emscripten_bind_PxScene_collide_1'] = createExportWrapper('emscripten_bind_PxScene_collide_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_collide_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_collide_2');
  _emscripten_bind_PxScene_collide_2 = Module['_emscripten_bind_PxScene_collide_2'] = createExportWrapper('emscripten_bind_PxScene_collide_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_collide_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_collide_3');
  _emscripten_bind_PxScene_collide_3 = Module['_emscripten_bind_PxScene_collide_3'] = createExportWrapper('emscripten_bind_PxScene_collide_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxScene_collide_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_collide_4');
  _emscripten_bind_PxScene_collide_4 = Module['_emscripten_bind_PxScene_collide_4'] = createExportWrapper('emscripten_bind_PxScene_collide_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxScene_collide_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_collide_5');
  _emscripten_bind_PxScene_collide_5 = Module['_emscripten_bind_PxScene_collide_5'] = createExportWrapper('emscripten_bind_PxScene_collide_5', 6);
  assert(typeof wasmExports['emscripten_bind_PxScene_checkResults_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_checkResults_0');
  _emscripten_bind_PxScene_checkResults_0 = Module['_emscripten_bind_PxScene_checkResults_0'] = createExportWrapper('emscripten_bind_PxScene_checkResults_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_checkResults_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_checkResults_1');
  _emscripten_bind_PxScene_checkResults_1 = Module['_emscripten_bind_PxScene_checkResults_1'] = createExportWrapper('emscripten_bind_PxScene_checkResults_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_fetchCollision_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_fetchCollision_0');
  _emscripten_bind_PxScene_fetchCollision_0 = Module['_emscripten_bind_PxScene_fetchCollision_0'] = createExportWrapper('emscripten_bind_PxScene_fetchCollision_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_fetchCollision_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_fetchCollision_1');
  _emscripten_bind_PxScene_fetchCollision_1 = Module['_emscripten_bind_PxScene_fetchCollision_1'] = createExportWrapper('emscripten_bind_PxScene_fetchCollision_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_fetchResults_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_fetchResults_0');
  _emscripten_bind_PxScene_fetchResults_0 = Module['_emscripten_bind_PxScene_fetchResults_0'] = createExportWrapper('emscripten_bind_PxScene_fetchResults_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_fetchResults_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_fetchResults_1');
  _emscripten_bind_PxScene_fetchResults_1 = Module['_emscripten_bind_PxScene_fetchResults_1'] = createExportWrapper('emscripten_bind_PxScene_fetchResults_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_processCallbacks_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_processCallbacks_1');
  _emscripten_bind_PxScene_processCallbacks_1 = Module['_emscripten_bind_PxScene_processCallbacks_1'] = createExportWrapper('emscripten_bind_PxScene_processCallbacks_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_fetchResultsParticleSystem_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_fetchResultsParticleSystem_0');
  _emscripten_bind_PxScene_fetchResultsParticleSystem_0 = Module['_emscripten_bind_PxScene_fetchResultsParticleSystem_0'] = createExportWrapper('emscripten_bind_PxScene_fetchResultsParticleSystem_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_flushSimulation_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_flushSimulation_0');
  _emscripten_bind_PxScene_flushSimulation_0 = Module['_emscripten_bind_PxScene_flushSimulation_0'] = createExportWrapper('emscripten_bind_PxScene_flushSimulation_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_flushSimulation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_flushSimulation_1');
  _emscripten_bind_PxScene_flushSimulation_1 = Module['_emscripten_bind_PxScene_flushSimulation_1'] = createExportWrapper('emscripten_bind_PxScene_flushSimulation_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_setGravity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setGravity_1');
  _emscripten_bind_PxScene_setGravity_1 = Module['_emscripten_bind_PxScene_setGravity_1'] = createExportWrapper('emscripten_bind_PxScene_setGravity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getGravity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getGravity_0');
  _emscripten_bind_PxScene_getGravity_0 = Module['_emscripten_bind_PxScene_getGravity_0'] = createExportWrapper('emscripten_bind_PxScene_getGravity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setBounceThresholdVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setBounceThresholdVelocity_1');
  _emscripten_bind_PxScene_setBounceThresholdVelocity_1 = Module['_emscripten_bind_PxScene_setBounceThresholdVelocity_1'] = createExportWrapper('emscripten_bind_PxScene_setBounceThresholdVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getBounceThresholdVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getBounceThresholdVelocity_0');
  _emscripten_bind_PxScene_getBounceThresholdVelocity_0 = Module['_emscripten_bind_PxScene_getBounceThresholdVelocity_0'] = createExportWrapper('emscripten_bind_PxScene_getBounceThresholdVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setCCDMaxPasses_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setCCDMaxPasses_1');
  _emscripten_bind_PxScene_setCCDMaxPasses_1 = Module['_emscripten_bind_PxScene_setCCDMaxPasses_1'] = createExportWrapper('emscripten_bind_PxScene_setCCDMaxPasses_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getCCDMaxPasses_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getCCDMaxPasses_0');
  _emscripten_bind_PxScene_getCCDMaxPasses_0 = Module['_emscripten_bind_PxScene_getCCDMaxPasses_0'] = createExportWrapper('emscripten_bind_PxScene_getCCDMaxPasses_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setCCDMaxSeparation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setCCDMaxSeparation_1');
  _emscripten_bind_PxScene_setCCDMaxSeparation_1 = Module['_emscripten_bind_PxScene_setCCDMaxSeparation_1'] = createExportWrapper('emscripten_bind_PxScene_setCCDMaxSeparation_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getCCDMaxSeparation_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getCCDMaxSeparation_0');
  _emscripten_bind_PxScene_getCCDMaxSeparation_0 = Module['_emscripten_bind_PxScene_getCCDMaxSeparation_0'] = createExportWrapper('emscripten_bind_PxScene_getCCDMaxSeparation_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setCCDThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setCCDThreshold_1');
  _emscripten_bind_PxScene_setCCDThreshold_1 = Module['_emscripten_bind_PxScene_setCCDThreshold_1'] = createExportWrapper('emscripten_bind_PxScene_setCCDThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getCCDThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getCCDThreshold_0');
  _emscripten_bind_PxScene_getCCDThreshold_0 = Module['_emscripten_bind_PxScene_getCCDThreshold_0'] = createExportWrapper('emscripten_bind_PxScene_getCCDThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setMaxBiasCoefficient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setMaxBiasCoefficient_1');
  _emscripten_bind_PxScene_setMaxBiasCoefficient_1 = Module['_emscripten_bind_PxScene_setMaxBiasCoefficient_1'] = createExportWrapper('emscripten_bind_PxScene_setMaxBiasCoefficient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getMaxBiasCoefficient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getMaxBiasCoefficient_0');
  _emscripten_bind_PxScene_getMaxBiasCoefficient_0 = Module['_emscripten_bind_PxScene_getMaxBiasCoefficient_0'] = createExportWrapper('emscripten_bind_PxScene_getMaxBiasCoefficient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setFrictionOffsetThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setFrictionOffsetThreshold_1');
  _emscripten_bind_PxScene_setFrictionOffsetThreshold_1 = Module['_emscripten_bind_PxScene_setFrictionOffsetThreshold_1'] = createExportWrapper('emscripten_bind_PxScene_setFrictionOffsetThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getFrictionOffsetThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getFrictionOffsetThreshold_0');
  _emscripten_bind_PxScene_getFrictionOffsetThreshold_0 = Module['_emscripten_bind_PxScene_getFrictionOffsetThreshold_0'] = createExportWrapper('emscripten_bind_PxScene_getFrictionOffsetThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setFrictionCorrelationDistance_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setFrictionCorrelationDistance_1');
  _emscripten_bind_PxScene_setFrictionCorrelationDistance_1 = Module['_emscripten_bind_PxScene_setFrictionCorrelationDistance_1'] = createExportWrapper('emscripten_bind_PxScene_setFrictionCorrelationDistance_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getFrictionCorrelationDistance_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getFrictionCorrelationDistance_0');
  _emscripten_bind_PxScene_getFrictionCorrelationDistance_0 = Module['_emscripten_bind_PxScene_getFrictionCorrelationDistance_0'] = createExportWrapper('emscripten_bind_PxScene_getFrictionCorrelationDistance_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getFrictionType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getFrictionType_0');
  _emscripten_bind_PxScene_getFrictionType_0 = Module['_emscripten_bind_PxScene_getFrictionType_0'] = createExportWrapper('emscripten_bind_PxScene_getFrictionType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getSolverType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getSolverType_0');
  _emscripten_bind_PxScene_getSolverType_0 = Module['_emscripten_bind_PxScene_getSolverType_0'] = createExportWrapper('emscripten_bind_PxScene_getSolverType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getRenderBuffer_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getRenderBuffer_0');
  _emscripten_bind_PxScene_getRenderBuffer_0 = Module['_emscripten_bind_PxScene_getRenderBuffer_0'] = createExportWrapper('emscripten_bind_PxScene_getRenderBuffer_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setVisualizationParameter_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setVisualizationParameter_2');
  _emscripten_bind_PxScene_setVisualizationParameter_2 = Module['_emscripten_bind_PxScene_setVisualizationParameter_2'] = createExportWrapper('emscripten_bind_PxScene_setVisualizationParameter_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_getVisualizationParameter_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getVisualizationParameter_1');
  _emscripten_bind_PxScene_getVisualizationParameter_1 = Module['_emscripten_bind_PxScene_getVisualizationParameter_1'] = createExportWrapper('emscripten_bind_PxScene_getVisualizationParameter_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_setVisualizationCullingBox_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setVisualizationCullingBox_1');
  _emscripten_bind_PxScene_setVisualizationCullingBox_1 = Module['_emscripten_bind_PxScene_setVisualizationCullingBox_1'] = createExportWrapper('emscripten_bind_PxScene_setVisualizationCullingBox_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getVisualizationCullingBox_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getVisualizationCullingBox_0');
  _emscripten_bind_PxScene_getVisualizationCullingBox_0 = Module['_emscripten_bind_PxScene_getVisualizationCullingBox_0'] = createExportWrapper('emscripten_bind_PxScene_getVisualizationCullingBox_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getSimulationStatistics_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getSimulationStatistics_1');
  _emscripten_bind_PxScene_getSimulationStatistics_1 = Module['_emscripten_bind_PxScene_getSimulationStatistics_1'] = createExportWrapper('emscripten_bind_PxScene_getSimulationStatistics_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getBroadPhaseType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getBroadPhaseType_0');
  _emscripten_bind_PxScene_getBroadPhaseType_0 = Module['_emscripten_bind_PxScene_getBroadPhaseType_0'] = createExportWrapper('emscripten_bind_PxScene_getBroadPhaseType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getBroadPhaseCaps_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getBroadPhaseCaps_1');
  _emscripten_bind_PxScene_getBroadPhaseCaps_1 = Module['_emscripten_bind_PxScene_getBroadPhaseCaps_1'] = createExportWrapper('emscripten_bind_PxScene_getBroadPhaseCaps_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getNbBroadPhaseRegions_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getNbBroadPhaseRegions_0');
  _emscripten_bind_PxScene_getNbBroadPhaseRegions_0 = Module['_emscripten_bind_PxScene_getNbBroadPhaseRegions_0'] = createExportWrapper('emscripten_bind_PxScene_getNbBroadPhaseRegions_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getBroadPhaseRegions_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getBroadPhaseRegions_2');
  _emscripten_bind_PxScene_getBroadPhaseRegions_2 = Module['_emscripten_bind_PxScene_getBroadPhaseRegions_2'] = createExportWrapper('emscripten_bind_PxScene_getBroadPhaseRegions_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_getBroadPhaseRegions_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getBroadPhaseRegions_3');
  _emscripten_bind_PxScene_getBroadPhaseRegions_3 = Module['_emscripten_bind_PxScene_getBroadPhaseRegions_3'] = createExportWrapper('emscripten_bind_PxScene_getBroadPhaseRegions_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxScene_addBroadPhaseRegion_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_addBroadPhaseRegion_1');
  _emscripten_bind_PxScene_addBroadPhaseRegion_1 = Module['_emscripten_bind_PxScene_addBroadPhaseRegion_1'] = createExportWrapper('emscripten_bind_PxScene_addBroadPhaseRegion_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_addBroadPhaseRegion_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_addBroadPhaseRegion_2');
  _emscripten_bind_PxScene_addBroadPhaseRegion_2 = Module['_emscripten_bind_PxScene_addBroadPhaseRegion_2'] = createExportWrapper('emscripten_bind_PxScene_addBroadPhaseRegion_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_removeBroadPhaseRegion_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_removeBroadPhaseRegion_1');
  _emscripten_bind_PxScene_removeBroadPhaseRegion_1 = Module['_emscripten_bind_PxScene_removeBroadPhaseRegion_1'] = createExportWrapper('emscripten_bind_PxScene_removeBroadPhaseRegion_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_lockRead_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_lockRead_0');
  _emscripten_bind_PxScene_lockRead_0 = Module['_emscripten_bind_PxScene_lockRead_0'] = createExportWrapper('emscripten_bind_PxScene_lockRead_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_lockRead_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_lockRead_1');
  _emscripten_bind_PxScene_lockRead_1 = Module['_emscripten_bind_PxScene_lockRead_1'] = createExportWrapper('emscripten_bind_PxScene_lockRead_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_lockRead_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_lockRead_2');
  _emscripten_bind_PxScene_lockRead_2 = Module['_emscripten_bind_PxScene_lockRead_2'] = createExportWrapper('emscripten_bind_PxScene_lockRead_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_unlockRead_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_unlockRead_0');
  _emscripten_bind_PxScene_unlockRead_0 = Module['_emscripten_bind_PxScene_unlockRead_0'] = createExportWrapper('emscripten_bind_PxScene_unlockRead_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_lockWrite_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_lockWrite_0');
  _emscripten_bind_PxScene_lockWrite_0 = Module['_emscripten_bind_PxScene_lockWrite_0'] = createExportWrapper('emscripten_bind_PxScene_lockWrite_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_lockWrite_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_lockWrite_1');
  _emscripten_bind_PxScene_lockWrite_1 = Module['_emscripten_bind_PxScene_lockWrite_1'] = createExportWrapper('emscripten_bind_PxScene_lockWrite_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_lockWrite_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_lockWrite_2');
  _emscripten_bind_PxScene_lockWrite_2 = Module['_emscripten_bind_PxScene_lockWrite_2'] = createExportWrapper('emscripten_bind_PxScene_lockWrite_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_unlockWrite_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_unlockWrite_0');
  _emscripten_bind_PxScene_unlockWrite_0 = Module['_emscripten_bind_PxScene_unlockWrite_0'] = createExportWrapper('emscripten_bind_PxScene_unlockWrite_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setNbContactDataBlocks_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setNbContactDataBlocks_1');
  _emscripten_bind_PxScene_setNbContactDataBlocks_1 = Module['_emscripten_bind_PxScene_setNbContactDataBlocks_1'] = createExportWrapper('emscripten_bind_PxScene_setNbContactDataBlocks_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getNbContactDataBlocksUsed_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getNbContactDataBlocksUsed_0');
  _emscripten_bind_PxScene_getNbContactDataBlocksUsed_0 = Module['_emscripten_bind_PxScene_getNbContactDataBlocksUsed_0'] = createExportWrapper('emscripten_bind_PxScene_getNbContactDataBlocksUsed_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getMaxNbContactDataBlocksUsed_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getMaxNbContactDataBlocksUsed_0');
  _emscripten_bind_PxScene_getMaxNbContactDataBlocksUsed_0 = Module['_emscripten_bind_PxScene_getMaxNbContactDataBlocksUsed_0'] = createExportWrapper('emscripten_bind_PxScene_getMaxNbContactDataBlocksUsed_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getContactReportStreamBufferSize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getContactReportStreamBufferSize_0');
  _emscripten_bind_PxScene_getContactReportStreamBufferSize_0 = Module['_emscripten_bind_PxScene_getContactReportStreamBufferSize_0'] = createExportWrapper('emscripten_bind_PxScene_getContactReportStreamBufferSize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setSolverBatchSize_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setSolverBatchSize_1');
  _emscripten_bind_PxScene_setSolverBatchSize_1 = Module['_emscripten_bind_PxScene_setSolverBatchSize_1'] = createExportWrapper('emscripten_bind_PxScene_setSolverBatchSize_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getSolverBatchSize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getSolverBatchSize_0');
  _emscripten_bind_PxScene_getSolverBatchSize_0 = Module['_emscripten_bind_PxScene_getSolverBatchSize_0'] = createExportWrapper('emscripten_bind_PxScene_getSolverBatchSize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setSolverArticulationBatchSize_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setSolverArticulationBatchSize_1');
  _emscripten_bind_PxScene_setSolverArticulationBatchSize_1 = Module['_emscripten_bind_PxScene_setSolverArticulationBatchSize_1'] = createExportWrapper('emscripten_bind_PxScene_setSolverArticulationBatchSize_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getSolverArticulationBatchSize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getSolverArticulationBatchSize_0');
  _emscripten_bind_PxScene_getSolverArticulationBatchSize_0 = Module['_emscripten_bind_PxScene_getSolverArticulationBatchSize_0'] = createExportWrapper('emscripten_bind_PxScene_getSolverArticulationBatchSize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_release_0');
  _emscripten_bind_PxScene_release_0 = Module['_emscripten_bind_PxScene_release_0'] = createExportWrapper('emscripten_bind_PxScene_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setFlag_2');
  _emscripten_bind_PxScene_setFlag_2 = Module['_emscripten_bind_PxScene_setFlag_2'] = createExportWrapper('emscripten_bind_PxScene_setFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_getFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getFlags_0');
  _emscripten_bind_PxScene_getFlags_0 = Module['_emscripten_bind_PxScene_getFlags_0'] = createExportWrapper('emscripten_bind_PxScene_getFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setLimits_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setLimits_1');
  _emscripten_bind_PxScene_setLimits_1 = Module['_emscripten_bind_PxScene_setLimits_1'] = createExportWrapper('emscripten_bind_PxScene_setLimits_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getLimits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getLimits_0');
  _emscripten_bind_PxScene_getLimits_0 = Module['_emscripten_bind_PxScene_getLimits_0'] = createExportWrapper('emscripten_bind_PxScene_getLimits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getPhysics_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getPhysics_0');
  _emscripten_bind_PxScene_getPhysics_0 = Module['_emscripten_bind_PxScene_getPhysics_0'] = createExportWrapper('emscripten_bind_PxScene_getPhysics_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getTimestamp_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getTimestamp_0');
  _emscripten_bind_PxScene_getTimestamp_0 = Module['_emscripten_bind_PxScene_getTimestamp_0'] = createExportWrapper('emscripten_bind_PxScene_getTimestamp_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getScenePvdClient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getScenePvdClient_0');
  _emscripten_bind_PxScene_getScenePvdClient_0 = Module['_emscripten_bind_PxScene_getScenePvdClient_0'] = createExportWrapper('emscripten_bind_PxScene_getScenePvdClient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_setDynamicTreeRebuildRateHint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setDynamicTreeRebuildRateHint_1');
  _emscripten_bind_PxScene_setDynamicTreeRebuildRateHint_1 = Module['_emscripten_bind_PxScene_setDynamicTreeRebuildRateHint_1'] = createExportWrapper('emscripten_bind_PxScene_setDynamicTreeRebuildRateHint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getDynamicTreeRebuildRateHint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getDynamicTreeRebuildRateHint_0');
  _emscripten_bind_PxScene_getDynamicTreeRebuildRateHint_0 = Module['_emscripten_bind_PxScene_getDynamicTreeRebuildRateHint_0'] = createExportWrapper('emscripten_bind_PxScene_getDynamicTreeRebuildRateHint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_forceRebuildDynamicTree_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_forceRebuildDynamicTree_1');
  _emscripten_bind_PxScene_forceRebuildDynamicTree_1 = Module['_emscripten_bind_PxScene_forceRebuildDynamicTree_1'] = createExportWrapper('emscripten_bind_PxScene_forceRebuildDynamicTree_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_setUpdateMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setUpdateMode_1');
  _emscripten_bind_PxScene_setUpdateMode_1 = Module['_emscripten_bind_PxScene_setUpdateMode_1'] = createExportWrapper('emscripten_bind_PxScene_setUpdateMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getUpdateMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getUpdateMode_0');
  _emscripten_bind_PxScene_getUpdateMode_0 = Module['_emscripten_bind_PxScene_getUpdateMode_0'] = createExportWrapper('emscripten_bind_PxScene_getUpdateMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getStaticTimestamp_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getStaticTimestamp_0');
  _emscripten_bind_PxScene_getStaticTimestamp_0 = Module['_emscripten_bind_PxScene_getStaticTimestamp_0'] = createExportWrapper('emscripten_bind_PxScene_getStaticTimestamp_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_flushUpdates_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_flushUpdates_0');
  _emscripten_bind_PxScene_flushUpdates_0 = Module['_emscripten_bind_PxScene_flushUpdates_0'] = createExportWrapper('emscripten_bind_PxScene_flushUpdates_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_raycast_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_raycast_4');
  _emscripten_bind_PxScene_raycast_4 = Module['_emscripten_bind_PxScene_raycast_4'] = createExportWrapper('emscripten_bind_PxScene_raycast_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxScene_raycast_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_raycast_5');
  _emscripten_bind_PxScene_raycast_5 = Module['_emscripten_bind_PxScene_raycast_5'] = createExportWrapper('emscripten_bind_PxScene_raycast_5', 6);
  assert(typeof wasmExports['emscripten_bind_PxScene_raycast_6'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_raycast_6');
  _emscripten_bind_PxScene_raycast_6 = Module['_emscripten_bind_PxScene_raycast_6'] = createExportWrapper('emscripten_bind_PxScene_raycast_6', 7);
  assert(typeof wasmExports['emscripten_bind_PxScene_sweep_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_sweep_5');
  _emscripten_bind_PxScene_sweep_5 = Module['_emscripten_bind_PxScene_sweep_5'] = createExportWrapper('emscripten_bind_PxScene_sweep_5', 6);
  assert(typeof wasmExports['emscripten_bind_PxScene_sweep_6'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_sweep_6');
  _emscripten_bind_PxScene_sweep_6 = Module['_emscripten_bind_PxScene_sweep_6'] = createExportWrapper('emscripten_bind_PxScene_sweep_6', 7);
  assert(typeof wasmExports['emscripten_bind_PxScene_sweep_7'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_sweep_7');
  _emscripten_bind_PxScene_sweep_7 = Module['_emscripten_bind_PxScene_sweep_7'] = createExportWrapper('emscripten_bind_PxScene_sweep_7', 8);
  assert(typeof wasmExports['emscripten_bind_PxScene_overlap_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_overlap_3');
  _emscripten_bind_PxScene_overlap_3 = Module['_emscripten_bind_PxScene_overlap_3'] = createExportWrapper('emscripten_bind_PxScene_overlap_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxScene_overlap_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_overlap_4');
  _emscripten_bind_PxScene_overlap_4 = Module['_emscripten_bind_PxScene_overlap_4'] = createExportWrapper('emscripten_bind_PxScene_overlap_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxScene_setSceneQueryUpdateMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_setSceneQueryUpdateMode_1');
  _emscripten_bind_PxScene_setSceneQueryUpdateMode_1 = Module['_emscripten_bind_PxScene_setSceneQueryUpdateMode_1'] = createExportWrapper('emscripten_bind_PxScene_setSceneQueryUpdateMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_getSceneQueryUpdateMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getSceneQueryUpdateMode_0');
  _emscripten_bind_PxScene_getSceneQueryUpdateMode_0 = Module['_emscripten_bind_PxScene_getSceneQueryUpdateMode_0'] = createExportWrapper('emscripten_bind_PxScene_getSceneQueryUpdateMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getSceneQueryStaticTimestamp_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getSceneQueryStaticTimestamp_0');
  _emscripten_bind_PxScene_getSceneQueryStaticTimestamp_0 = Module['_emscripten_bind_PxScene_getSceneQueryStaticTimestamp_0'] = createExportWrapper('emscripten_bind_PxScene_getSceneQueryStaticTimestamp_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_flushQueryUpdates_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_flushQueryUpdates_0');
  _emscripten_bind_PxScene_flushQueryUpdates_0 = Module['_emscripten_bind_PxScene_flushQueryUpdates_0'] = createExportWrapper('emscripten_bind_PxScene_flushQueryUpdates_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_forceDynamicTreeRebuild_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_forceDynamicTreeRebuild_2');
  _emscripten_bind_PxScene_forceDynamicTreeRebuild_2 = Module['_emscripten_bind_PxScene_forceDynamicTreeRebuild_2'] = createExportWrapper('emscripten_bind_PxScene_forceDynamicTreeRebuild_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_getStaticStructure_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getStaticStructure_0');
  _emscripten_bind_PxScene_getStaticStructure_0 = Module['_emscripten_bind_PxScene_getStaticStructure_0'] = createExportWrapper('emscripten_bind_PxScene_getStaticStructure_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_getDynamicStructure_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_getDynamicStructure_0');
  _emscripten_bind_PxScene_getDynamicStructure_0 = Module['_emscripten_bind_PxScene_getDynamicStructure_0'] = createExportWrapper('emscripten_bind_PxScene_getDynamicStructure_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_sceneQueriesUpdate_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_sceneQueriesUpdate_0');
  _emscripten_bind_PxScene_sceneQueriesUpdate_0 = Module['_emscripten_bind_PxScene_sceneQueriesUpdate_0'] = createExportWrapper('emscripten_bind_PxScene_sceneQueriesUpdate_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_sceneQueriesUpdate_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_sceneQueriesUpdate_1');
  _emscripten_bind_PxScene_sceneQueriesUpdate_1 = Module['_emscripten_bind_PxScene_sceneQueriesUpdate_1'] = createExportWrapper('emscripten_bind_PxScene_sceneQueriesUpdate_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_sceneQueriesUpdate_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_sceneQueriesUpdate_2');
  _emscripten_bind_PxScene_sceneQueriesUpdate_2 = Module['_emscripten_bind_PxScene_sceneQueriesUpdate_2'] = createExportWrapper('emscripten_bind_PxScene_sceneQueriesUpdate_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxScene_checkQueries_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_checkQueries_0');
  _emscripten_bind_PxScene_checkQueries_0 = Module['_emscripten_bind_PxScene_checkQueries_0'] = createExportWrapper('emscripten_bind_PxScene_checkQueries_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_checkQueries_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_checkQueries_1');
  _emscripten_bind_PxScene_checkQueries_1 = Module['_emscripten_bind_PxScene_checkQueries_1'] = createExportWrapper('emscripten_bind_PxScene_checkQueries_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_fetchQueries_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_fetchQueries_0');
  _emscripten_bind_PxScene_fetchQueries_0 = Module['_emscripten_bind_PxScene_fetchQueries_0'] = createExportWrapper('emscripten_bind_PxScene_fetchQueries_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_fetchQueries_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_fetchQueries_1');
  _emscripten_bind_PxScene_fetchQueries_1 = Module['_emscripten_bind_PxScene_fetchQueries_1'] = createExportWrapper('emscripten_bind_PxScene_fetchQueries_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxScene_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_get_userData_0');
  _emscripten_bind_PxScene_get_userData_0 = Module['_emscripten_bind_PxScene_get_userData_0'] = createExportWrapper('emscripten_bind_PxScene_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxScene_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxScene_set_userData_1');
  _emscripten_bind_PxScene_set_userData_1 = Module['_emscripten_bind_PxScene_set_userData_1'] = createExportWrapper('emscripten_bind_PxScene_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_PxSceneDesc_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_PxSceneDesc_1');
  _emscripten_bind_PxSceneDesc_PxSceneDesc_1 = Module['_emscripten_bind_PxSceneDesc_PxSceneDesc_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_PxSceneDesc_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_setToDefault_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_setToDefault_1');
  _emscripten_bind_PxSceneDesc_setToDefault_1 = Module['_emscripten_bind_PxSceneDesc_setToDefault_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_setToDefault_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_isValid_0');
  _emscripten_bind_PxSceneDesc_isValid_0 = Module['_emscripten_bind_PxSceneDesc_isValid_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_gravity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_gravity_0');
  _emscripten_bind_PxSceneDesc_get_gravity_0 = Module['_emscripten_bind_PxSceneDesc_get_gravity_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_gravity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_gravity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_gravity_1');
  _emscripten_bind_PxSceneDesc_set_gravity_1 = Module['_emscripten_bind_PxSceneDesc_set_gravity_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_gravity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_simulationEventCallback_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_simulationEventCallback_0');
  _emscripten_bind_PxSceneDesc_get_simulationEventCallback_0 = Module['_emscripten_bind_PxSceneDesc_get_simulationEventCallback_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_simulationEventCallback_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_simulationEventCallback_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_simulationEventCallback_1');
  _emscripten_bind_PxSceneDesc_set_simulationEventCallback_1 = Module['_emscripten_bind_PxSceneDesc_set_simulationEventCallback_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_simulationEventCallback_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_filterShaderData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_filterShaderData_0');
  _emscripten_bind_PxSceneDesc_get_filterShaderData_0 = Module['_emscripten_bind_PxSceneDesc_get_filterShaderData_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_filterShaderData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_filterShaderData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_filterShaderData_1');
  _emscripten_bind_PxSceneDesc_set_filterShaderData_1 = Module['_emscripten_bind_PxSceneDesc_set_filterShaderData_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_filterShaderData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_filterShaderDataSize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_filterShaderDataSize_0');
  _emscripten_bind_PxSceneDesc_get_filterShaderDataSize_0 = Module['_emscripten_bind_PxSceneDesc_get_filterShaderDataSize_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_filterShaderDataSize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_filterShaderDataSize_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_filterShaderDataSize_1');
  _emscripten_bind_PxSceneDesc_set_filterShaderDataSize_1 = Module['_emscripten_bind_PxSceneDesc_set_filterShaderDataSize_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_filterShaderDataSize_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_filterShader_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_filterShader_0');
  _emscripten_bind_PxSceneDesc_get_filterShader_0 = Module['_emscripten_bind_PxSceneDesc_get_filterShader_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_filterShader_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_filterShader_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_filterShader_1');
  _emscripten_bind_PxSceneDesc_set_filterShader_1 = Module['_emscripten_bind_PxSceneDesc_set_filterShader_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_filterShader_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_kineKineFilteringMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_kineKineFilteringMode_0');
  _emscripten_bind_PxSceneDesc_get_kineKineFilteringMode_0 = Module['_emscripten_bind_PxSceneDesc_get_kineKineFilteringMode_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_kineKineFilteringMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_kineKineFilteringMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_kineKineFilteringMode_1');
  _emscripten_bind_PxSceneDesc_set_kineKineFilteringMode_1 = Module['_emscripten_bind_PxSceneDesc_set_kineKineFilteringMode_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_kineKineFilteringMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_staticKineFilteringMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_staticKineFilteringMode_0');
  _emscripten_bind_PxSceneDesc_get_staticKineFilteringMode_0 = Module['_emscripten_bind_PxSceneDesc_get_staticKineFilteringMode_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_staticKineFilteringMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_staticKineFilteringMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_staticKineFilteringMode_1');
  _emscripten_bind_PxSceneDesc_set_staticKineFilteringMode_1 = Module['_emscripten_bind_PxSceneDesc_set_staticKineFilteringMode_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_staticKineFilteringMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_broadPhaseType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_broadPhaseType_0');
  _emscripten_bind_PxSceneDesc_get_broadPhaseType_0 = Module['_emscripten_bind_PxSceneDesc_get_broadPhaseType_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_broadPhaseType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_broadPhaseType_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_broadPhaseType_1');
  _emscripten_bind_PxSceneDesc_set_broadPhaseType_1 = Module['_emscripten_bind_PxSceneDesc_set_broadPhaseType_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_broadPhaseType_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_limits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_limits_0');
  _emscripten_bind_PxSceneDesc_get_limits_0 = Module['_emscripten_bind_PxSceneDesc_get_limits_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_limits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_limits_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_limits_1');
  _emscripten_bind_PxSceneDesc_set_limits_1 = Module['_emscripten_bind_PxSceneDesc_set_limits_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_limits_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_frictionType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_frictionType_0');
  _emscripten_bind_PxSceneDesc_get_frictionType_0 = Module['_emscripten_bind_PxSceneDesc_get_frictionType_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_frictionType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_frictionType_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_frictionType_1');
  _emscripten_bind_PxSceneDesc_set_frictionType_1 = Module['_emscripten_bind_PxSceneDesc_set_frictionType_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_frictionType_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_solverType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_solverType_0');
  _emscripten_bind_PxSceneDesc_get_solverType_0 = Module['_emscripten_bind_PxSceneDesc_get_solverType_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_solverType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_solverType_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_solverType_1');
  _emscripten_bind_PxSceneDesc_set_solverType_1 = Module['_emscripten_bind_PxSceneDesc_set_solverType_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_solverType_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_bounceThresholdVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_bounceThresholdVelocity_0');
  _emscripten_bind_PxSceneDesc_get_bounceThresholdVelocity_0 = Module['_emscripten_bind_PxSceneDesc_get_bounceThresholdVelocity_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_bounceThresholdVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_bounceThresholdVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_bounceThresholdVelocity_1');
  _emscripten_bind_PxSceneDesc_set_bounceThresholdVelocity_1 = Module['_emscripten_bind_PxSceneDesc_set_bounceThresholdVelocity_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_bounceThresholdVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_frictionOffsetThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_frictionOffsetThreshold_0');
  _emscripten_bind_PxSceneDesc_get_frictionOffsetThreshold_0 = Module['_emscripten_bind_PxSceneDesc_get_frictionOffsetThreshold_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_frictionOffsetThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_frictionOffsetThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_frictionOffsetThreshold_1');
  _emscripten_bind_PxSceneDesc_set_frictionOffsetThreshold_1 = Module['_emscripten_bind_PxSceneDesc_set_frictionOffsetThreshold_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_frictionOffsetThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_frictionCorrelationDistance_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_frictionCorrelationDistance_0');
  _emscripten_bind_PxSceneDesc_get_frictionCorrelationDistance_0 = Module['_emscripten_bind_PxSceneDesc_get_frictionCorrelationDistance_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_frictionCorrelationDistance_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_frictionCorrelationDistance_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_frictionCorrelationDistance_1');
  _emscripten_bind_PxSceneDesc_set_frictionCorrelationDistance_1 = Module['_emscripten_bind_PxSceneDesc_set_frictionCorrelationDistance_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_frictionCorrelationDistance_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_flags_0');
  _emscripten_bind_PxSceneDesc_get_flags_0 = Module['_emscripten_bind_PxSceneDesc_get_flags_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_flags_1');
  _emscripten_bind_PxSceneDesc_set_flags_1 = Module['_emscripten_bind_PxSceneDesc_set_flags_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_cpuDispatcher_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_cpuDispatcher_0');
  _emscripten_bind_PxSceneDesc_get_cpuDispatcher_0 = Module['_emscripten_bind_PxSceneDesc_get_cpuDispatcher_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_cpuDispatcher_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_cpuDispatcher_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_cpuDispatcher_1');
  _emscripten_bind_PxSceneDesc_set_cpuDispatcher_1 = Module['_emscripten_bind_PxSceneDesc_set_cpuDispatcher_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_cpuDispatcher_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_userData_0');
  _emscripten_bind_PxSceneDesc_get_userData_0 = Module['_emscripten_bind_PxSceneDesc_get_userData_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_userData_1');
  _emscripten_bind_PxSceneDesc_set_userData_1 = Module['_emscripten_bind_PxSceneDesc_set_userData_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_solverBatchSize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_solverBatchSize_0');
  _emscripten_bind_PxSceneDesc_get_solverBatchSize_0 = Module['_emscripten_bind_PxSceneDesc_get_solverBatchSize_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_solverBatchSize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_solverBatchSize_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_solverBatchSize_1');
  _emscripten_bind_PxSceneDesc_set_solverBatchSize_1 = Module['_emscripten_bind_PxSceneDesc_set_solverBatchSize_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_solverBatchSize_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_solverArticulationBatchSize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_solverArticulationBatchSize_0');
  _emscripten_bind_PxSceneDesc_get_solverArticulationBatchSize_0 = Module['_emscripten_bind_PxSceneDesc_get_solverArticulationBatchSize_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_solverArticulationBatchSize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_solverArticulationBatchSize_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_solverArticulationBatchSize_1');
  _emscripten_bind_PxSceneDesc_set_solverArticulationBatchSize_1 = Module['_emscripten_bind_PxSceneDesc_set_solverArticulationBatchSize_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_solverArticulationBatchSize_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_nbContactDataBlocks_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_nbContactDataBlocks_0');
  _emscripten_bind_PxSceneDesc_get_nbContactDataBlocks_0 = Module['_emscripten_bind_PxSceneDesc_get_nbContactDataBlocks_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_nbContactDataBlocks_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_nbContactDataBlocks_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_nbContactDataBlocks_1');
  _emscripten_bind_PxSceneDesc_set_nbContactDataBlocks_1 = Module['_emscripten_bind_PxSceneDesc_set_nbContactDataBlocks_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_nbContactDataBlocks_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_maxNbContactDataBlocks_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_maxNbContactDataBlocks_0');
  _emscripten_bind_PxSceneDesc_get_maxNbContactDataBlocks_0 = Module['_emscripten_bind_PxSceneDesc_get_maxNbContactDataBlocks_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_maxNbContactDataBlocks_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_maxNbContactDataBlocks_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_maxNbContactDataBlocks_1');
  _emscripten_bind_PxSceneDesc_set_maxNbContactDataBlocks_1 = Module['_emscripten_bind_PxSceneDesc_set_maxNbContactDataBlocks_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_maxNbContactDataBlocks_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_maxBiasCoefficient_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_maxBiasCoefficient_0');
  _emscripten_bind_PxSceneDesc_get_maxBiasCoefficient_0 = Module['_emscripten_bind_PxSceneDesc_get_maxBiasCoefficient_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_maxBiasCoefficient_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_maxBiasCoefficient_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_maxBiasCoefficient_1');
  _emscripten_bind_PxSceneDesc_set_maxBiasCoefficient_1 = Module['_emscripten_bind_PxSceneDesc_set_maxBiasCoefficient_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_maxBiasCoefficient_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_contactReportStreamBufferSize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_contactReportStreamBufferSize_0');
  _emscripten_bind_PxSceneDesc_get_contactReportStreamBufferSize_0 = Module['_emscripten_bind_PxSceneDesc_get_contactReportStreamBufferSize_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_contactReportStreamBufferSize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_contactReportStreamBufferSize_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_contactReportStreamBufferSize_1');
  _emscripten_bind_PxSceneDesc_set_contactReportStreamBufferSize_1 = Module['_emscripten_bind_PxSceneDesc_set_contactReportStreamBufferSize_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_contactReportStreamBufferSize_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_ccdMaxPasses_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_ccdMaxPasses_0');
  _emscripten_bind_PxSceneDesc_get_ccdMaxPasses_0 = Module['_emscripten_bind_PxSceneDesc_get_ccdMaxPasses_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_ccdMaxPasses_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_ccdMaxPasses_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_ccdMaxPasses_1');
  _emscripten_bind_PxSceneDesc_set_ccdMaxPasses_1 = Module['_emscripten_bind_PxSceneDesc_set_ccdMaxPasses_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_ccdMaxPasses_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_ccdThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_ccdThreshold_0');
  _emscripten_bind_PxSceneDesc_get_ccdThreshold_0 = Module['_emscripten_bind_PxSceneDesc_get_ccdThreshold_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_ccdThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_ccdThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_ccdThreshold_1');
  _emscripten_bind_PxSceneDesc_set_ccdThreshold_1 = Module['_emscripten_bind_PxSceneDesc_set_ccdThreshold_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_ccdThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_ccdMaxSeparation_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_ccdMaxSeparation_0');
  _emscripten_bind_PxSceneDesc_get_ccdMaxSeparation_0 = Module['_emscripten_bind_PxSceneDesc_get_ccdMaxSeparation_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_ccdMaxSeparation_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_ccdMaxSeparation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_ccdMaxSeparation_1');
  _emscripten_bind_PxSceneDesc_set_ccdMaxSeparation_1 = Module['_emscripten_bind_PxSceneDesc_set_ccdMaxSeparation_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_ccdMaxSeparation_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_wakeCounterResetValue_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_wakeCounterResetValue_0');
  _emscripten_bind_PxSceneDesc_get_wakeCounterResetValue_0 = Module['_emscripten_bind_PxSceneDesc_get_wakeCounterResetValue_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_wakeCounterResetValue_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_wakeCounterResetValue_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_wakeCounterResetValue_1');
  _emscripten_bind_PxSceneDesc_set_wakeCounterResetValue_1 = Module['_emscripten_bind_PxSceneDesc_set_wakeCounterResetValue_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_wakeCounterResetValue_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_sanityBounds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_sanityBounds_0');
  _emscripten_bind_PxSceneDesc_get_sanityBounds_0 = Module['_emscripten_bind_PxSceneDesc_get_sanityBounds_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_sanityBounds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_sanityBounds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_sanityBounds_1');
  _emscripten_bind_PxSceneDesc_set_sanityBounds_1 = Module['_emscripten_bind_PxSceneDesc_set_sanityBounds_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_sanityBounds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_gpuMaxNumPartitions_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_gpuMaxNumPartitions_0');
  _emscripten_bind_PxSceneDesc_get_gpuMaxNumPartitions_0 = Module['_emscripten_bind_PxSceneDesc_get_gpuMaxNumPartitions_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_gpuMaxNumPartitions_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_gpuMaxNumPartitions_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_gpuMaxNumPartitions_1');
  _emscripten_bind_PxSceneDesc_set_gpuMaxNumPartitions_1 = Module['_emscripten_bind_PxSceneDesc_set_gpuMaxNumPartitions_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_gpuMaxNumPartitions_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_gpuMaxNumStaticPartitions_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_gpuMaxNumStaticPartitions_0');
  _emscripten_bind_PxSceneDesc_get_gpuMaxNumStaticPartitions_0 = Module['_emscripten_bind_PxSceneDesc_get_gpuMaxNumStaticPartitions_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_gpuMaxNumStaticPartitions_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_gpuMaxNumStaticPartitions_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_gpuMaxNumStaticPartitions_1');
  _emscripten_bind_PxSceneDesc_set_gpuMaxNumStaticPartitions_1 = Module['_emscripten_bind_PxSceneDesc_set_gpuMaxNumStaticPartitions_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_gpuMaxNumStaticPartitions_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_gpuComputeVersion_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_gpuComputeVersion_0');
  _emscripten_bind_PxSceneDesc_get_gpuComputeVersion_0 = Module['_emscripten_bind_PxSceneDesc_get_gpuComputeVersion_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_gpuComputeVersion_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_gpuComputeVersion_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_gpuComputeVersion_1');
  _emscripten_bind_PxSceneDesc_set_gpuComputeVersion_1 = Module['_emscripten_bind_PxSceneDesc_set_gpuComputeVersion_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_gpuComputeVersion_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_contactPairSlabSize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_contactPairSlabSize_0');
  _emscripten_bind_PxSceneDesc_get_contactPairSlabSize_0 = Module['_emscripten_bind_PxSceneDesc_get_contactPairSlabSize_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_contactPairSlabSize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_contactPairSlabSize_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_contactPairSlabSize_1');
  _emscripten_bind_PxSceneDesc_set_contactPairSlabSize_1 = Module['_emscripten_bind_PxSceneDesc_set_contactPairSlabSize_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_contactPairSlabSize_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_staticStructure_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_staticStructure_0');
  _emscripten_bind_PxSceneDesc_get_staticStructure_0 = Module['_emscripten_bind_PxSceneDesc_get_staticStructure_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_staticStructure_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_staticStructure_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_staticStructure_1');
  _emscripten_bind_PxSceneDesc_set_staticStructure_1 = Module['_emscripten_bind_PxSceneDesc_set_staticStructure_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_staticStructure_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_dynamicStructure_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_dynamicStructure_0');
  _emscripten_bind_PxSceneDesc_get_dynamicStructure_0 = Module['_emscripten_bind_PxSceneDesc_get_dynamicStructure_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_dynamicStructure_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_dynamicStructure_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_dynamicStructure_1');
  _emscripten_bind_PxSceneDesc_set_dynamicStructure_1 = Module['_emscripten_bind_PxSceneDesc_set_dynamicStructure_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_dynamicStructure_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_dynamicTreeRebuildRateHint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_dynamicTreeRebuildRateHint_0');
  _emscripten_bind_PxSceneDesc_get_dynamicTreeRebuildRateHint_0 = Module['_emscripten_bind_PxSceneDesc_get_dynamicTreeRebuildRateHint_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_dynamicTreeRebuildRateHint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_dynamicTreeRebuildRateHint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_dynamicTreeRebuildRateHint_1');
  _emscripten_bind_PxSceneDesc_set_dynamicTreeRebuildRateHint_1 = Module['_emscripten_bind_PxSceneDesc_set_dynamicTreeRebuildRateHint_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_dynamicTreeRebuildRateHint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_dynamicTreeSecondaryPruner_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_dynamicTreeSecondaryPruner_0');
  _emscripten_bind_PxSceneDesc_get_dynamicTreeSecondaryPruner_0 = Module['_emscripten_bind_PxSceneDesc_get_dynamicTreeSecondaryPruner_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_dynamicTreeSecondaryPruner_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_dynamicTreeSecondaryPruner_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_dynamicTreeSecondaryPruner_1');
  _emscripten_bind_PxSceneDesc_set_dynamicTreeSecondaryPruner_1 = Module['_emscripten_bind_PxSceneDesc_set_dynamicTreeSecondaryPruner_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_dynamicTreeSecondaryPruner_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_staticBVHBuildStrategy_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_staticBVHBuildStrategy_0');
  _emscripten_bind_PxSceneDesc_get_staticBVHBuildStrategy_0 = Module['_emscripten_bind_PxSceneDesc_get_staticBVHBuildStrategy_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_staticBVHBuildStrategy_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_staticBVHBuildStrategy_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_staticBVHBuildStrategy_1');
  _emscripten_bind_PxSceneDesc_set_staticBVHBuildStrategy_1 = Module['_emscripten_bind_PxSceneDesc_set_staticBVHBuildStrategy_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_staticBVHBuildStrategy_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_dynamicBVHBuildStrategy_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_dynamicBVHBuildStrategy_0');
  _emscripten_bind_PxSceneDesc_get_dynamicBVHBuildStrategy_0 = Module['_emscripten_bind_PxSceneDesc_get_dynamicBVHBuildStrategy_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_dynamicBVHBuildStrategy_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_dynamicBVHBuildStrategy_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_dynamicBVHBuildStrategy_1');
  _emscripten_bind_PxSceneDesc_set_dynamicBVHBuildStrategy_1 = Module['_emscripten_bind_PxSceneDesc_set_dynamicBVHBuildStrategy_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_dynamicBVHBuildStrategy_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_staticNbObjectsPerNode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_staticNbObjectsPerNode_0');
  _emscripten_bind_PxSceneDesc_get_staticNbObjectsPerNode_0 = Module['_emscripten_bind_PxSceneDesc_get_staticNbObjectsPerNode_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_staticNbObjectsPerNode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_staticNbObjectsPerNode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_staticNbObjectsPerNode_1');
  _emscripten_bind_PxSceneDesc_set_staticNbObjectsPerNode_1 = Module['_emscripten_bind_PxSceneDesc_set_staticNbObjectsPerNode_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_staticNbObjectsPerNode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_dynamicNbObjectsPerNode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_dynamicNbObjectsPerNode_0');
  _emscripten_bind_PxSceneDesc_get_dynamicNbObjectsPerNode_0 = Module['_emscripten_bind_PxSceneDesc_get_dynamicNbObjectsPerNode_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_dynamicNbObjectsPerNode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_dynamicNbObjectsPerNode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_dynamicNbObjectsPerNode_1');
  _emscripten_bind_PxSceneDesc_set_dynamicNbObjectsPerNode_1 = Module['_emscripten_bind_PxSceneDesc_set_dynamicNbObjectsPerNode_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_dynamicNbObjectsPerNode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_get_sceneQueryUpdateMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_get_sceneQueryUpdateMode_0');
  _emscripten_bind_PxSceneDesc_get_sceneQueryUpdateMode_0 = Module['_emscripten_bind_PxSceneDesc_get_sceneQueryUpdateMode_0'] = createExportWrapper('emscripten_bind_PxSceneDesc_get_sceneQueryUpdateMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc_set_sceneQueryUpdateMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc_set_sceneQueryUpdateMode_1');
  _emscripten_bind_PxSceneDesc_set_sceneQueryUpdateMode_1 = Module['_emscripten_bind_PxSceneDesc_set_sceneQueryUpdateMode_1'] = createExportWrapper('emscripten_bind_PxSceneDesc_set_sceneQueryUpdateMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneDesc___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneDesc___destroy___0');
  _emscripten_bind_PxSceneDesc___destroy___0 = Module['_emscripten_bind_PxSceneDesc___destroy___0'] = createExportWrapper('emscripten_bind_PxSceneDesc___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneFlags_PxSceneFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneFlags_PxSceneFlags_1');
  _emscripten_bind_PxSceneFlags_PxSceneFlags_1 = Module['_emscripten_bind_PxSceneFlags_PxSceneFlags_1'] = createExportWrapper('emscripten_bind_PxSceneFlags_PxSceneFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneFlags_isSet_1');
  _emscripten_bind_PxSceneFlags_isSet_1 = Module['_emscripten_bind_PxSceneFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxSceneFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneFlags_raise_1');
  _emscripten_bind_PxSceneFlags_raise_1 = Module['_emscripten_bind_PxSceneFlags_raise_1'] = createExportWrapper('emscripten_bind_PxSceneFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneFlags_clear_1');
  _emscripten_bind_PxSceneFlags_clear_1 = Module['_emscripten_bind_PxSceneFlags_clear_1'] = createExportWrapper('emscripten_bind_PxSceneFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneFlags___destroy___0');
  _emscripten_bind_PxSceneFlags___destroy___0 = Module['_emscripten_bind_PxSceneFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxSceneFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_PxSceneLimits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_PxSceneLimits_0');
  _emscripten_bind_PxSceneLimits_PxSceneLimits_0 = Module['_emscripten_bind_PxSceneLimits_PxSceneLimits_0'] = createExportWrapper('emscripten_bind_PxSceneLimits_PxSceneLimits_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_setToDefault_0');
  _emscripten_bind_PxSceneLimits_setToDefault_0 = Module['_emscripten_bind_PxSceneLimits_setToDefault_0'] = createExportWrapper('emscripten_bind_PxSceneLimits_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_isValid_0');
  _emscripten_bind_PxSceneLimits_isValid_0 = Module['_emscripten_bind_PxSceneLimits_isValid_0'] = createExportWrapper('emscripten_bind_PxSceneLimits_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_get_maxNbActors_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_get_maxNbActors_0');
  _emscripten_bind_PxSceneLimits_get_maxNbActors_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbActors_0'] = createExportWrapper('emscripten_bind_PxSceneLimits_get_maxNbActors_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_set_maxNbActors_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_set_maxNbActors_1');
  _emscripten_bind_PxSceneLimits_set_maxNbActors_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbActors_1'] = createExportWrapper('emscripten_bind_PxSceneLimits_set_maxNbActors_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_get_maxNbBodies_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_get_maxNbBodies_0');
  _emscripten_bind_PxSceneLimits_get_maxNbBodies_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbBodies_0'] = createExportWrapper('emscripten_bind_PxSceneLimits_get_maxNbBodies_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_set_maxNbBodies_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_set_maxNbBodies_1');
  _emscripten_bind_PxSceneLimits_set_maxNbBodies_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbBodies_1'] = createExportWrapper('emscripten_bind_PxSceneLimits_set_maxNbBodies_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_get_maxNbStaticShapes_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_get_maxNbStaticShapes_0');
  _emscripten_bind_PxSceneLimits_get_maxNbStaticShapes_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbStaticShapes_0'] = createExportWrapper('emscripten_bind_PxSceneLimits_get_maxNbStaticShapes_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_set_maxNbStaticShapes_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_set_maxNbStaticShapes_1');
  _emscripten_bind_PxSceneLimits_set_maxNbStaticShapes_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbStaticShapes_1'] = createExportWrapper('emscripten_bind_PxSceneLimits_set_maxNbStaticShapes_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_get_maxNbDynamicShapes_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_get_maxNbDynamicShapes_0');
  _emscripten_bind_PxSceneLimits_get_maxNbDynamicShapes_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbDynamicShapes_0'] = createExportWrapper('emscripten_bind_PxSceneLimits_get_maxNbDynamicShapes_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_set_maxNbDynamicShapes_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_set_maxNbDynamicShapes_1');
  _emscripten_bind_PxSceneLimits_set_maxNbDynamicShapes_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbDynamicShapes_1'] = createExportWrapper('emscripten_bind_PxSceneLimits_set_maxNbDynamicShapes_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_get_maxNbAggregates_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_get_maxNbAggregates_0');
  _emscripten_bind_PxSceneLimits_get_maxNbAggregates_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbAggregates_0'] = createExportWrapper('emscripten_bind_PxSceneLimits_get_maxNbAggregates_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_set_maxNbAggregates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_set_maxNbAggregates_1');
  _emscripten_bind_PxSceneLimits_set_maxNbAggregates_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbAggregates_1'] = createExportWrapper('emscripten_bind_PxSceneLimits_set_maxNbAggregates_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_get_maxNbConstraints_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_get_maxNbConstraints_0');
  _emscripten_bind_PxSceneLimits_get_maxNbConstraints_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbConstraints_0'] = createExportWrapper('emscripten_bind_PxSceneLimits_get_maxNbConstraints_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_set_maxNbConstraints_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_set_maxNbConstraints_1');
  _emscripten_bind_PxSceneLimits_set_maxNbConstraints_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbConstraints_1'] = createExportWrapper('emscripten_bind_PxSceneLimits_set_maxNbConstraints_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_get_maxNbRegions_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_get_maxNbRegions_0');
  _emscripten_bind_PxSceneLimits_get_maxNbRegions_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbRegions_0'] = createExportWrapper('emscripten_bind_PxSceneLimits_get_maxNbRegions_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_set_maxNbRegions_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_set_maxNbRegions_1');
  _emscripten_bind_PxSceneLimits_set_maxNbRegions_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbRegions_1'] = createExportWrapper('emscripten_bind_PxSceneLimits_set_maxNbRegions_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_get_maxNbBroadPhaseOverlaps_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_get_maxNbBroadPhaseOverlaps_0');
  _emscripten_bind_PxSceneLimits_get_maxNbBroadPhaseOverlaps_0 = Module['_emscripten_bind_PxSceneLimits_get_maxNbBroadPhaseOverlaps_0'] = createExportWrapper('emscripten_bind_PxSceneLimits_get_maxNbBroadPhaseOverlaps_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits_set_maxNbBroadPhaseOverlaps_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits_set_maxNbBroadPhaseOverlaps_1');
  _emscripten_bind_PxSceneLimits_set_maxNbBroadPhaseOverlaps_1 = Module['_emscripten_bind_PxSceneLimits_set_maxNbBroadPhaseOverlaps_1'] = createExportWrapper('emscripten_bind_PxSceneLimits_set_maxNbBroadPhaseOverlaps_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSceneLimits___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSceneLimits___destroy___0');
  _emscripten_bind_PxSceneLimits___destroy___0 = Module['_emscripten_bind_PxSceneLimits___destroy___0'] = createExportWrapper('emscripten_bind_PxSceneLimits___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_isSerializable_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_isSerializable_2');
  _emscripten_bind_PxSerialization_isSerializable_2 = Module['_emscripten_bind_PxSerialization_isSerializable_2'] = createExportWrapper('emscripten_bind_PxSerialization_isSerializable_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_isSerializable_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_isSerializable_3');
  _emscripten_bind_PxSerialization_isSerializable_3 = Module['_emscripten_bind_PxSerialization_isSerializable_3'] = createExportWrapper('emscripten_bind_PxSerialization_isSerializable_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_complete_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_complete_2');
  _emscripten_bind_PxSerialization_complete_2 = Module['_emscripten_bind_PxSerialization_complete_2'] = createExportWrapper('emscripten_bind_PxSerialization_complete_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_complete_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_complete_3');
  _emscripten_bind_PxSerialization_complete_3 = Module['_emscripten_bind_PxSerialization_complete_3'] = createExportWrapper('emscripten_bind_PxSerialization_complete_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_complete_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_complete_4');
  _emscripten_bind_PxSerialization_complete_4 = Module['_emscripten_bind_PxSerialization_complete_4'] = createExportWrapper('emscripten_bind_PxSerialization_complete_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_createSerialObjectIds_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_createSerialObjectIds_2');
  _emscripten_bind_PxSerialization_createSerialObjectIds_2 = Module['_emscripten_bind_PxSerialization_createSerialObjectIds_2'] = createExportWrapper('emscripten_bind_PxSerialization_createSerialObjectIds_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_createCollectionFromXml_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_createCollectionFromXml_3');
  _emscripten_bind_PxSerialization_createCollectionFromXml_3 = Module['_emscripten_bind_PxSerialization_createCollectionFromXml_3'] = createExportWrapper('emscripten_bind_PxSerialization_createCollectionFromXml_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_createCollectionFromXml_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_createCollectionFromXml_4');
  _emscripten_bind_PxSerialization_createCollectionFromXml_4 = Module['_emscripten_bind_PxSerialization_createCollectionFromXml_4'] = createExportWrapper('emscripten_bind_PxSerialization_createCollectionFromXml_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_createCollectionFromBinary_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_createCollectionFromBinary_2');
  _emscripten_bind_PxSerialization_createCollectionFromBinary_2 = Module['_emscripten_bind_PxSerialization_createCollectionFromBinary_2'] = createExportWrapper('emscripten_bind_PxSerialization_createCollectionFromBinary_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_createCollectionFromBinary_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_createCollectionFromBinary_3');
  _emscripten_bind_PxSerialization_createCollectionFromBinary_3 = Module['_emscripten_bind_PxSerialization_createCollectionFromBinary_3'] = createExportWrapper('emscripten_bind_PxSerialization_createCollectionFromBinary_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_serializeCollectionToXml_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_serializeCollectionToXml_3');
  _emscripten_bind_PxSerialization_serializeCollectionToXml_3 = Module['_emscripten_bind_PxSerialization_serializeCollectionToXml_3'] = createExportWrapper('emscripten_bind_PxSerialization_serializeCollectionToXml_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_serializeCollectionToXml_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_serializeCollectionToXml_4');
  _emscripten_bind_PxSerialization_serializeCollectionToXml_4 = Module['_emscripten_bind_PxSerialization_serializeCollectionToXml_4'] = createExportWrapper('emscripten_bind_PxSerialization_serializeCollectionToXml_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_serializeCollectionToXml_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_serializeCollectionToXml_5');
  _emscripten_bind_PxSerialization_serializeCollectionToXml_5 = Module['_emscripten_bind_PxSerialization_serializeCollectionToXml_5'] = createExportWrapper('emscripten_bind_PxSerialization_serializeCollectionToXml_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_serializeCollectionToBinary_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_serializeCollectionToBinary_3');
  _emscripten_bind_PxSerialization_serializeCollectionToBinary_3 = Module['_emscripten_bind_PxSerialization_serializeCollectionToBinary_3'] = createExportWrapper('emscripten_bind_PxSerialization_serializeCollectionToBinary_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_serializeCollectionToBinary_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_serializeCollectionToBinary_4');
  _emscripten_bind_PxSerialization_serializeCollectionToBinary_4 = Module['_emscripten_bind_PxSerialization_serializeCollectionToBinary_4'] = createExportWrapper('emscripten_bind_PxSerialization_serializeCollectionToBinary_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_serializeCollectionToBinary_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_serializeCollectionToBinary_5');
  _emscripten_bind_PxSerialization_serializeCollectionToBinary_5 = Module['_emscripten_bind_PxSerialization_serializeCollectionToBinary_5'] = createExportWrapper('emscripten_bind_PxSerialization_serializeCollectionToBinary_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxSerialization_createSerializationRegistry_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization_createSerializationRegistry_1');
  _emscripten_bind_PxSerialization_createSerializationRegistry_1 = Module['_emscripten_bind_PxSerialization_createSerializationRegistry_1'] = createExportWrapper('emscripten_bind_PxSerialization_createSerializationRegistry_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxSerialization___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerialization___destroy___0');
  _emscripten_bind_PxSerialization___destroy___0 = Module['_emscripten_bind_PxSerialization___destroy___0'] = createExportWrapper('emscripten_bind_PxSerialization___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSerializationRegistry_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSerializationRegistry_release_0');
  _emscripten_bind_PxSerializationRegistry_release_0 = Module['_emscripten_bind_PxSerializationRegistry_release_0'] = createExportWrapper('emscripten_bind_PxSerializationRegistry_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_setGeometry_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_setGeometry_1');
  _emscripten_bind_PxShape_setGeometry_1 = Module['_emscripten_bind_PxShape_setGeometry_1'] = createExportWrapper('emscripten_bind_PxShape_setGeometry_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShape_getGeometry_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getGeometry_0');
  _emscripten_bind_PxShape_getGeometry_0 = Module['_emscripten_bind_PxShape_getGeometry_0'] = createExportWrapper('emscripten_bind_PxShape_getGeometry_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_getActor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getActor_0');
  _emscripten_bind_PxShape_getActor_0 = Module['_emscripten_bind_PxShape_getActor_0'] = createExportWrapper('emscripten_bind_PxShape_getActor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_setMaterials_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_setMaterials_2');
  _emscripten_bind_PxShape_setMaterials_2 = Module['_emscripten_bind_PxShape_setMaterials_2'] = createExportWrapper('emscripten_bind_PxShape_setMaterials_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxShape_getNbMaterials_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getNbMaterials_0');
  _emscripten_bind_PxShape_getNbMaterials_0 = Module['_emscripten_bind_PxShape_getNbMaterials_0'] = createExportWrapper('emscripten_bind_PxShape_getNbMaterials_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_getMaterials_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getMaterials_3');
  _emscripten_bind_PxShape_getMaterials_3 = Module['_emscripten_bind_PxShape_getMaterials_3'] = createExportWrapper('emscripten_bind_PxShape_getMaterials_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxShape_getMaterialFromInternalFaceIndex_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getMaterialFromInternalFaceIndex_1');
  _emscripten_bind_PxShape_getMaterialFromInternalFaceIndex_1 = Module['_emscripten_bind_PxShape_getMaterialFromInternalFaceIndex_1'] = createExportWrapper('emscripten_bind_PxShape_getMaterialFromInternalFaceIndex_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShape_setContactOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_setContactOffset_1');
  _emscripten_bind_PxShape_setContactOffset_1 = Module['_emscripten_bind_PxShape_setContactOffset_1'] = createExportWrapper('emscripten_bind_PxShape_setContactOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShape_getContactOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getContactOffset_0');
  _emscripten_bind_PxShape_getContactOffset_0 = Module['_emscripten_bind_PxShape_getContactOffset_0'] = createExportWrapper('emscripten_bind_PxShape_getContactOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_setRestOffset_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_setRestOffset_1');
  _emscripten_bind_PxShape_setRestOffset_1 = Module['_emscripten_bind_PxShape_setRestOffset_1'] = createExportWrapper('emscripten_bind_PxShape_setRestOffset_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShape_getRestOffset_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getRestOffset_0');
  _emscripten_bind_PxShape_getRestOffset_0 = Module['_emscripten_bind_PxShape_getRestOffset_0'] = createExportWrapper('emscripten_bind_PxShape_getRestOffset_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_setTorsionalPatchRadius_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_setTorsionalPatchRadius_1');
  _emscripten_bind_PxShape_setTorsionalPatchRadius_1 = Module['_emscripten_bind_PxShape_setTorsionalPatchRadius_1'] = createExportWrapper('emscripten_bind_PxShape_setTorsionalPatchRadius_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShape_getTorsionalPatchRadius_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getTorsionalPatchRadius_0');
  _emscripten_bind_PxShape_getTorsionalPatchRadius_0 = Module['_emscripten_bind_PxShape_getTorsionalPatchRadius_0'] = createExportWrapper('emscripten_bind_PxShape_getTorsionalPatchRadius_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_setMinTorsionalPatchRadius_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_setMinTorsionalPatchRadius_1');
  _emscripten_bind_PxShape_setMinTorsionalPatchRadius_1 = Module['_emscripten_bind_PxShape_setMinTorsionalPatchRadius_1'] = createExportWrapper('emscripten_bind_PxShape_setMinTorsionalPatchRadius_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShape_getMinTorsionalPatchRadius_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getMinTorsionalPatchRadius_0');
  _emscripten_bind_PxShape_getMinTorsionalPatchRadius_0 = Module['_emscripten_bind_PxShape_getMinTorsionalPatchRadius_0'] = createExportWrapper('emscripten_bind_PxShape_getMinTorsionalPatchRadius_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_setFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_setFlag_2');
  _emscripten_bind_PxShape_setFlag_2 = Module['_emscripten_bind_PxShape_setFlag_2'] = createExportWrapper('emscripten_bind_PxShape_setFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxShape_setFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_setFlags_1');
  _emscripten_bind_PxShape_setFlags_1 = Module['_emscripten_bind_PxShape_setFlags_1'] = createExportWrapper('emscripten_bind_PxShape_setFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShape_getFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getFlags_0');
  _emscripten_bind_PxShape_getFlags_0 = Module['_emscripten_bind_PxShape_getFlags_0'] = createExportWrapper('emscripten_bind_PxShape_getFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_isExclusive_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_isExclusive_0');
  _emscripten_bind_PxShape_isExclusive_0 = Module['_emscripten_bind_PxShape_isExclusive_0'] = createExportWrapper('emscripten_bind_PxShape_isExclusive_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_setName_1');
  _emscripten_bind_PxShape_setName_1 = Module['_emscripten_bind_PxShape_setName_1'] = createExportWrapper('emscripten_bind_PxShape_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShape_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getName_0');
  _emscripten_bind_PxShape_getName_0 = Module['_emscripten_bind_PxShape_getName_0'] = createExportWrapper('emscripten_bind_PxShape_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_setLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_setLocalPose_1');
  _emscripten_bind_PxShape_setLocalPose_1 = Module['_emscripten_bind_PxShape_setLocalPose_1'] = createExportWrapper('emscripten_bind_PxShape_setLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShape_getLocalPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getLocalPose_0');
  _emscripten_bind_PxShape_getLocalPose_0 = Module['_emscripten_bind_PxShape_getLocalPose_0'] = createExportWrapper('emscripten_bind_PxShape_getLocalPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_setSimulationFilterData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_setSimulationFilterData_1');
  _emscripten_bind_PxShape_setSimulationFilterData_1 = Module['_emscripten_bind_PxShape_setSimulationFilterData_1'] = createExportWrapper('emscripten_bind_PxShape_setSimulationFilterData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShape_getSimulationFilterData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getSimulationFilterData_0');
  _emscripten_bind_PxShape_getSimulationFilterData_0 = Module['_emscripten_bind_PxShape_getSimulationFilterData_0'] = createExportWrapper('emscripten_bind_PxShape_getSimulationFilterData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_setQueryFilterData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_setQueryFilterData_1');
  _emscripten_bind_PxShape_setQueryFilterData_1 = Module['_emscripten_bind_PxShape_setQueryFilterData_1'] = createExportWrapper('emscripten_bind_PxShape_setQueryFilterData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShape_getQueryFilterData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getQueryFilterData_0');
  _emscripten_bind_PxShape_getQueryFilterData_0 = Module['_emscripten_bind_PxShape_getQueryFilterData_0'] = createExportWrapper('emscripten_bind_PxShape_getQueryFilterData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_release_0');
  _emscripten_bind_PxShape_release_0 = Module['_emscripten_bind_PxShape_release_0'] = createExportWrapper('emscripten_bind_PxShape_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getConcreteTypeName_0');
  _emscripten_bind_PxShape_getConcreteTypeName_0 = Module['_emscripten_bind_PxShape_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxShape_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getConcreteType_0');
  _emscripten_bind_PxShape_getConcreteType_0 = Module['_emscripten_bind_PxShape_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxShape_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_setBaseFlag_2');
  _emscripten_bind_PxShape_setBaseFlag_2 = Module['_emscripten_bind_PxShape_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxShape_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxShape_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_setBaseFlags_1');
  _emscripten_bind_PxShape_setBaseFlags_1 = Module['_emscripten_bind_PxShape_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxShape_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShape_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getBaseFlags_0');
  _emscripten_bind_PxShape_getBaseFlags_0 = Module['_emscripten_bind_PxShape_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxShape_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_isReleasable_0');
  _emscripten_bind_PxShape_isReleasable_0 = Module['_emscripten_bind_PxShape_isReleasable_0'] = createExportWrapper('emscripten_bind_PxShape_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_getReferenceCount_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_getReferenceCount_0');
  _emscripten_bind_PxShape_getReferenceCount_0 = Module['_emscripten_bind_PxShape_getReferenceCount_0'] = createExportWrapper('emscripten_bind_PxShape_getReferenceCount_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_acquireReference_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_acquireReference_0');
  _emscripten_bind_PxShape_acquireReference_0 = Module['_emscripten_bind_PxShape_acquireReference_0'] = createExportWrapper('emscripten_bind_PxShape_acquireReference_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_get_userData_0');
  _emscripten_bind_PxShape_get_userData_0 = Module['_emscripten_bind_PxShape_get_userData_0'] = createExportWrapper('emscripten_bind_PxShape_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShape_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShape_set_userData_1');
  _emscripten_bind_PxShape_set_userData_1 = Module['_emscripten_bind_PxShape_set_userData_1'] = createExportWrapper('emscripten_bind_PxShape_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShapeExt_getGlobalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShapeExt_getGlobalPose_2');
  _emscripten_bind_PxShapeExt_getGlobalPose_2 = Module['_emscripten_bind_PxShapeExt_getGlobalPose_2'] = createExportWrapper('emscripten_bind_PxShapeExt_getGlobalPose_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxShapeExt_raycast_8'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShapeExt_raycast_8');
  _emscripten_bind_PxShapeExt_raycast_8 = Module['_emscripten_bind_PxShapeExt_raycast_8'] = createExportWrapper('emscripten_bind_PxShapeExt_raycast_8', 8);
  assert(typeof wasmExports['emscripten_bind_PxShapeExt_overlap_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShapeExt_overlap_4');
  _emscripten_bind_PxShapeExt_overlap_4 = Module['_emscripten_bind_PxShapeExt_overlap_4'] = createExportWrapper('emscripten_bind_PxShapeExt_overlap_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxShapeExt_sweep_8'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShapeExt_sweep_8');
  _emscripten_bind_PxShapeExt_sweep_8 = Module['_emscripten_bind_PxShapeExt_sweep_8'] = createExportWrapper('emscripten_bind_PxShapeExt_sweep_8', 8);
  assert(typeof wasmExports['emscripten_bind_PxShapeExt_getWorldBounds_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShapeExt_getWorldBounds_2');
  _emscripten_bind_PxShapeExt_getWorldBounds_2 = Module['_emscripten_bind_PxShapeExt_getWorldBounds_2'] = createExportWrapper('emscripten_bind_PxShapeExt_getWorldBounds_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxShapeExt_getWorldBounds_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShapeExt_getWorldBounds_3');
  _emscripten_bind_PxShapeExt_getWorldBounds_3 = Module['_emscripten_bind_PxShapeExt_getWorldBounds_3'] = createExportWrapper('emscripten_bind_PxShapeExt_getWorldBounds_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxShapeExt___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShapeExt___destroy___0');
  _emscripten_bind_PxShapeExt___destroy___0 = Module['_emscripten_bind_PxShapeExt___destroy___0'] = createExportWrapper('emscripten_bind_PxShapeExt___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShapeFlags_PxShapeFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShapeFlags_PxShapeFlags_1');
  _emscripten_bind_PxShapeFlags_PxShapeFlags_1 = Module['_emscripten_bind_PxShapeFlags_PxShapeFlags_1'] = createExportWrapper('emscripten_bind_PxShapeFlags_PxShapeFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxShapeFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShapeFlags_isSet_1');
  _emscripten_bind_PxShapeFlags_isSet_1 = Module['_emscripten_bind_PxShapeFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxShapeFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShapeFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShapeFlags_raise_1');
  _emscripten_bind_PxShapeFlags_raise_1 = Module['_emscripten_bind_PxShapeFlags_raise_1'] = createExportWrapper('emscripten_bind_PxShapeFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShapeFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShapeFlags_clear_1');
  _emscripten_bind_PxShapeFlags_clear_1 = Module['_emscripten_bind_PxShapeFlags_clear_1'] = createExportWrapper('emscripten_bind_PxShapeFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxShapeFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShapeFlags___destroy___0');
  _emscripten_bind_PxShapeFlags___destroy___0 = Module['_emscripten_bind_PxShapeFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxShapeFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxShapePtr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxShapePtr___destroy___0');
  _emscripten_bind_PxShapePtr___destroy___0 = Module['_emscripten_bind_PxShapePtr___destroy___0'] = createExportWrapper('emscripten_bind_PxShapePtr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationEventCallbackImpl_PxSimulationEventCallbackImpl_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationEventCallbackImpl_PxSimulationEventCallbackImpl_0');
  _emscripten_bind_PxSimulationEventCallbackImpl_PxSimulationEventCallbackImpl_0 = Module['_emscripten_bind_PxSimulationEventCallbackImpl_PxSimulationEventCallbackImpl_0'] = createExportWrapper('emscripten_bind_PxSimulationEventCallbackImpl_PxSimulationEventCallbackImpl_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxSimulationEventCallbackImpl_onConstraintBreak_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationEventCallbackImpl_onConstraintBreak_2');
  _emscripten_bind_PxSimulationEventCallbackImpl_onConstraintBreak_2 = Module['_emscripten_bind_PxSimulationEventCallbackImpl_onConstraintBreak_2'] = createExportWrapper('emscripten_bind_PxSimulationEventCallbackImpl_onConstraintBreak_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxSimulationEventCallbackImpl_onWake_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationEventCallbackImpl_onWake_2');
  _emscripten_bind_PxSimulationEventCallbackImpl_onWake_2 = Module['_emscripten_bind_PxSimulationEventCallbackImpl_onWake_2'] = createExportWrapper('emscripten_bind_PxSimulationEventCallbackImpl_onWake_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxSimulationEventCallbackImpl_onSleep_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationEventCallbackImpl_onSleep_2');
  _emscripten_bind_PxSimulationEventCallbackImpl_onSleep_2 = Module['_emscripten_bind_PxSimulationEventCallbackImpl_onSleep_2'] = createExportWrapper('emscripten_bind_PxSimulationEventCallbackImpl_onSleep_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxSimulationEventCallbackImpl_onContact_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationEventCallbackImpl_onContact_3');
  _emscripten_bind_PxSimulationEventCallbackImpl_onContact_3 = Module['_emscripten_bind_PxSimulationEventCallbackImpl_onContact_3'] = createExportWrapper('emscripten_bind_PxSimulationEventCallbackImpl_onContact_3', 4);
  assert(typeof wasmExports['emscripten_bind_PxSimulationEventCallbackImpl_onTrigger_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationEventCallbackImpl_onTrigger_2');
  _emscripten_bind_PxSimulationEventCallbackImpl_onTrigger_2 = Module['_emscripten_bind_PxSimulationEventCallbackImpl_onTrigger_2'] = createExportWrapper('emscripten_bind_PxSimulationEventCallbackImpl_onTrigger_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxSimulationEventCallbackImpl___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationEventCallbackImpl___destroy___0');
  _emscripten_bind_PxSimulationEventCallbackImpl___destroy___0 = Module['_emscripten_bind_PxSimulationEventCallbackImpl___destroy___0'] = createExportWrapper('emscripten_bind_PxSimulationEventCallbackImpl___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbActiveConstraints_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbActiveConstraints_0');
  _emscripten_bind_PxSimulationStatistics_get_nbActiveConstraints_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbActiveConstraints_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbActiveConstraints_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbActiveConstraints_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbActiveConstraints_1');
  _emscripten_bind_PxSimulationStatistics_set_nbActiveConstraints_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbActiveConstraints_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbActiveConstraints_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbActiveDynamicBodies_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbActiveDynamicBodies_0');
  _emscripten_bind_PxSimulationStatistics_get_nbActiveDynamicBodies_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbActiveDynamicBodies_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbActiveDynamicBodies_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbActiveDynamicBodies_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbActiveDynamicBodies_1');
  _emscripten_bind_PxSimulationStatistics_set_nbActiveDynamicBodies_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbActiveDynamicBodies_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbActiveDynamicBodies_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbActiveKinematicBodies_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbActiveKinematicBodies_0');
  _emscripten_bind_PxSimulationStatistics_get_nbActiveKinematicBodies_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbActiveKinematicBodies_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbActiveKinematicBodies_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbActiveKinematicBodies_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbActiveKinematicBodies_1');
  _emscripten_bind_PxSimulationStatistics_set_nbActiveKinematicBodies_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbActiveKinematicBodies_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbActiveKinematicBodies_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbStaticBodies_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbStaticBodies_0');
  _emscripten_bind_PxSimulationStatistics_get_nbStaticBodies_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbStaticBodies_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbStaticBodies_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbStaticBodies_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbStaticBodies_1');
  _emscripten_bind_PxSimulationStatistics_set_nbStaticBodies_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbStaticBodies_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbStaticBodies_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbDynamicBodies_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbDynamicBodies_0');
  _emscripten_bind_PxSimulationStatistics_get_nbDynamicBodies_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbDynamicBodies_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbDynamicBodies_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbDynamicBodies_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbDynamicBodies_1');
  _emscripten_bind_PxSimulationStatistics_set_nbDynamicBodies_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbDynamicBodies_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbDynamicBodies_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbKinematicBodies_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbKinematicBodies_0');
  _emscripten_bind_PxSimulationStatistics_get_nbKinematicBodies_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbKinematicBodies_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbKinematicBodies_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbKinematicBodies_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbKinematicBodies_1');
  _emscripten_bind_PxSimulationStatistics_set_nbKinematicBodies_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbKinematicBodies_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbKinematicBodies_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbShapes_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbShapes_1');
  _emscripten_bind_PxSimulationStatistics_get_nbShapes_1 = Module['_emscripten_bind_PxSimulationStatistics_get_nbShapes_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbShapes_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbShapes_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbShapes_2');
  _emscripten_bind_PxSimulationStatistics_set_nbShapes_2 = Module['_emscripten_bind_PxSimulationStatistics_set_nbShapes_2'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbShapes_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbAggregates_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbAggregates_0');
  _emscripten_bind_PxSimulationStatistics_get_nbAggregates_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbAggregates_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbAggregates_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbAggregates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbAggregates_1');
  _emscripten_bind_PxSimulationStatistics_set_nbAggregates_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbAggregates_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbAggregates_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbArticulations_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbArticulations_0');
  _emscripten_bind_PxSimulationStatistics_get_nbArticulations_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbArticulations_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbArticulations_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbArticulations_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbArticulations_1');
  _emscripten_bind_PxSimulationStatistics_set_nbArticulations_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbArticulations_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbArticulations_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbAxisSolverConstraints_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbAxisSolverConstraints_0');
  _emscripten_bind_PxSimulationStatistics_get_nbAxisSolverConstraints_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbAxisSolverConstraints_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbAxisSolverConstraints_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbAxisSolverConstraints_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbAxisSolverConstraints_1');
  _emscripten_bind_PxSimulationStatistics_set_nbAxisSolverConstraints_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbAxisSolverConstraints_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbAxisSolverConstraints_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_compressedContactSize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_compressedContactSize_0');
  _emscripten_bind_PxSimulationStatistics_get_compressedContactSize_0 = Module['_emscripten_bind_PxSimulationStatistics_get_compressedContactSize_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_compressedContactSize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_compressedContactSize_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_compressedContactSize_1');
  _emscripten_bind_PxSimulationStatistics_set_compressedContactSize_1 = Module['_emscripten_bind_PxSimulationStatistics_set_compressedContactSize_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_compressedContactSize_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_requiredContactConstraintMemory_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_requiredContactConstraintMemory_0');
  _emscripten_bind_PxSimulationStatistics_get_requiredContactConstraintMemory_0 = Module['_emscripten_bind_PxSimulationStatistics_get_requiredContactConstraintMemory_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_requiredContactConstraintMemory_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_requiredContactConstraintMemory_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_requiredContactConstraintMemory_1');
  _emscripten_bind_PxSimulationStatistics_set_requiredContactConstraintMemory_1 = Module['_emscripten_bind_PxSimulationStatistics_set_requiredContactConstraintMemory_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_requiredContactConstraintMemory_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_peakConstraintMemory_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_peakConstraintMemory_0');
  _emscripten_bind_PxSimulationStatistics_get_peakConstraintMemory_0 = Module['_emscripten_bind_PxSimulationStatistics_get_peakConstraintMemory_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_peakConstraintMemory_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_peakConstraintMemory_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_peakConstraintMemory_1');
  _emscripten_bind_PxSimulationStatistics_set_peakConstraintMemory_1 = Module['_emscripten_bind_PxSimulationStatistics_set_peakConstraintMemory_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_peakConstraintMemory_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsTotal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsTotal_0');
  _emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsTotal_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsTotal_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsTotal_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsTotal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsTotal_1');
  _emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsTotal_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsTotal_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsTotal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithCacheHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithCacheHits_0');
  _emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithCacheHits_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithCacheHits_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithCacheHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithCacheHits_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithCacheHits_1');
  _emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithCacheHits_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithCacheHits_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithCacheHits_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithContacts_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithContacts_0');
  _emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithContacts_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithContacts_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithContacts_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithContacts_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithContacts_1');
  _emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithContacts_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithContacts_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithContacts_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbNewPairs_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbNewPairs_0');
  _emscripten_bind_PxSimulationStatistics_get_nbNewPairs_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbNewPairs_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbNewPairs_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbNewPairs_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbNewPairs_1');
  _emscripten_bind_PxSimulationStatistics_set_nbNewPairs_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbNewPairs_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbNewPairs_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbLostPairs_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbLostPairs_0');
  _emscripten_bind_PxSimulationStatistics_get_nbLostPairs_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbLostPairs_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbLostPairs_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbLostPairs_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbLostPairs_1');
  _emscripten_bind_PxSimulationStatistics_set_nbLostPairs_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbLostPairs_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbLostPairs_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbNewTouches_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbNewTouches_0');
  _emscripten_bind_PxSimulationStatistics_get_nbNewTouches_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbNewTouches_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbNewTouches_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbNewTouches_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbNewTouches_1');
  _emscripten_bind_PxSimulationStatistics_set_nbNewTouches_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbNewTouches_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbNewTouches_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbLostTouches_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbLostTouches_0');
  _emscripten_bind_PxSimulationStatistics_get_nbLostTouches_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbLostTouches_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbLostTouches_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbLostTouches_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbLostTouches_1');
  _emscripten_bind_PxSimulationStatistics_set_nbLostTouches_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbLostTouches_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbLostTouches_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbPartitions_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbPartitions_0');
  _emscripten_bind_PxSimulationStatistics_get_nbPartitions_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbPartitions_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbPartitions_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbPartitions_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbPartitions_1');
  _emscripten_bind_PxSimulationStatistics_set_nbPartitions_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbPartitions_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbPartitions_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseAdds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseAdds_0');
  _emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseAdds_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseAdds_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseAdds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseAdds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseAdds_1');
  _emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseAdds_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseAdds_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseAdds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseRemoves_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseRemoves_0');
  _emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseRemoves_0 = Module['_emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseRemoves_0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseRemoves_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseRemoves_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseRemoves_1');
  _emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseRemoves_1 = Module['_emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseRemoves_1'] = createExportWrapper('emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseRemoves_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSimulationStatistics___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSimulationStatistics___destroy___0');
  _emscripten_bind_PxSimulationStatistics___destroy___0 = Module['_emscripten_bind_PxSimulationStatistics___destroy___0'] = createExportWrapper('emscripten_bind_PxSimulationStatistics___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSpatialForce_get_force_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpatialForce_get_force_0');
  _emscripten_bind_PxSpatialForce_get_force_0 = Module['_emscripten_bind_PxSpatialForce_get_force_0'] = createExportWrapper('emscripten_bind_PxSpatialForce_get_force_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSpatialForce_set_force_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpatialForce_set_force_1');
  _emscripten_bind_PxSpatialForce_set_force_1 = Module['_emscripten_bind_PxSpatialForce_set_force_1'] = createExportWrapper('emscripten_bind_PxSpatialForce_set_force_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSpatialForce_get_torque_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpatialForce_get_torque_0');
  _emscripten_bind_PxSpatialForce_get_torque_0 = Module['_emscripten_bind_PxSpatialForce_get_torque_0'] = createExportWrapper('emscripten_bind_PxSpatialForce_get_torque_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSpatialForce_set_torque_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpatialForce_set_torque_1');
  _emscripten_bind_PxSpatialForce_set_torque_1 = Module['_emscripten_bind_PxSpatialForce_set_torque_1'] = createExportWrapper('emscripten_bind_PxSpatialForce_set_torque_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSpatialForce___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpatialForce___destroy___0');
  _emscripten_bind_PxSpatialForce___destroy___0 = Module['_emscripten_bind_PxSpatialForce___destroy___0'] = createExportWrapper('emscripten_bind_PxSpatialForce___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSpatialVelocity_get_linear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpatialVelocity_get_linear_0');
  _emscripten_bind_PxSpatialVelocity_get_linear_0 = Module['_emscripten_bind_PxSpatialVelocity_get_linear_0'] = createExportWrapper('emscripten_bind_PxSpatialVelocity_get_linear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSpatialVelocity_set_linear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpatialVelocity_set_linear_1');
  _emscripten_bind_PxSpatialVelocity_set_linear_1 = Module['_emscripten_bind_PxSpatialVelocity_set_linear_1'] = createExportWrapper('emscripten_bind_PxSpatialVelocity_set_linear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSpatialVelocity_get_angular_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpatialVelocity_get_angular_0');
  _emscripten_bind_PxSpatialVelocity_get_angular_0 = Module['_emscripten_bind_PxSpatialVelocity_get_angular_0'] = createExportWrapper('emscripten_bind_PxSpatialVelocity_get_angular_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSpatialVelocity_set_angular_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpatialVelocity_set_angular_1');
  _emscripten_bind_PxSpatialVelocity_set_angular_1 = Module['_emscripten_bind_PxSpatialVelocity_set_angular_1'] = createExportWrapper('emscripten_bind_PxSpatialVelocity_set_angular_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSpatialVelocity___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSpatialVelocity___destroy___0');
  _emscripten_bind_PxSpatialVelocity___destroy___0 = Module['_emscripten_bind_PxSpatialVelocity___destroy___0'] = createExportWrapper('emscripten_bind_PxSpatialVelocity___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphereGeometry_PxSphereGeometry_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphereGeometry_PxSphereGeometry_1');
  _emscripten_bind_PxSphereGeometry_PxSphereGeometry_1 = Module['_emscripten_bind_PxSphereGeometry_PxSphereGeometry_1'] = createExportWrapper('emscripten_bind_PxSphereGeometry_PxSphereGeometry_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphereGeometry_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphereGeometry_getType_0');
  _emscripten_bind_PxSphereGeometry_getType_0 = Module['_emscripten_bind_PxSphereGeometry_getType_0'] = createExportWrapper('emscripten_bind_PxSphereGeometry_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphereGeometry_get_radius_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphereGeometry_get_radius_0');
  _emscripten_bind_PxSphereGeometry_get_radius_0 = Module['_emscripten_bind_PxSphereGeometry_get_radius_0'] = createExportWrapper('emscripten_bind_PxSphereGeometry_get_radius_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphereGeometry_set_radius_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphereGeometry_set_radius_1');
  _emscripten_bind_PxSphereGeometry_set_radius_1 = Module['_emscripten_bind_PxSphereGeometry_set_radius_1'] = createExportWrapper('emscripten_bind_PxSphereGeometry_set_radius_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphereGeometry___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphereGeometry___destroy___0');
  _emscripten_bind_PxSphereGeometry___destroy___0 = Module['_emscripten_bind_PxSphereGeometry___destroy___0'] = createExportWrapper('emscripten_bind_PxSphereGeometry___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setLimitCone_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setLimitCone_1');
  _emscripten_bind_PxSphericalJoint_setLimitCone_1 = Module['_emscripten_bind_PxSphericalJoint_setLimitCone_1'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setLimitCone_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getSwingYAngle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getSwingYAngle_0');
  _emscripten_bind_PxSphericalJoint_getSwingYAngle_0 = Module['_emscripten_bind_PxSphericalJoint_getSwingYAngle_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getSwingYAngle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getSwingZAngle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getSwingZAngle_0');
  _emscripten_bind_PxSphericalJoint_getSwingZAngle_0 = Module['_emscripten_bind_PxSphericalJoint_getSwingZAngle_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getSwingZAngle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setSphericalJointFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setSphericalJointFlags_1');
  _emscripten_bind_PxSphericalJoint_setSphericalJointFlags_1 = Module['_emscripten_bind_PxSphericalJoint_setSphericalJointFlags_1'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setSphericalJointFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setSphericalJointFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setSphericalJointFlag_2');
  _emscripten_bind_PxSphericalJoint_setSphericalJointFlag_2 = Module['_emscripten_bind_PxSphericalJoint_setSphericalJointFlag_2'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setSphericalJointFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getSphericalJointFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getSphericalJointFlags_0');
  _emscripten_bind_PxSphericalJoint_getSphericalJointFlags_0 = Module['_emscripten_bind_PxSphericalJoint_getSphericalJointFlags_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getSphericalJointFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_release_0');
  _emscripten_bind_PxSphericalJoint_release_0 = Module['_emscripten_bind_PxSphericalJoint_release_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getConcreteTypeName_0');
  _emscripten_bind_PxSphericalJoint_getConcreteTypeName_0 = Module['_emscripten_bind_PxSphericalJoint_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getConcreteType_0');
  _emscripten_bind_PxSphericalJoint_getConcreteType_0 = Module['_emscripten_bind_PxSphericalJoint_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setBaseFlag_2');
  _emscripten_bind_PxSphericalJoint_setBaseFlag_2 = Module['_emscripten_bind_PxSphericalJoint_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setBaseFlags_1');
  _emscripten_bind_PxSphericalJoint_setBaseFlags_1 = Module['_emscripten_bind_PxSphericalJoint_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getBaseFlags_0');
  _emscripten_bind_PxSphericalJoint_getBaseFlags_0 = Module['_emscripten_bind_PxSphericalJoint_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_isReleasable_0');
  _emscripten_bind_PxSphericalJoint_isReleasable_0 = Module['_emscripten_bind_PxSphericalJoint_isReleasable_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setActors_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setActors_2');
  _emscripten_bind_PxSphericalJoint_setActors_2 = Module['_emscripten_bind_PxSphericalJoint_setActors_2'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setActors_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setLocalPose_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setLocalPose_2');
  _emscripten_bind_PxSphericalJoint_setLocalPose_2 = Module['_emscripten_bind_PxSphericalJoint_setLocalPose_2'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setLocalPose_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getLocalPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getLocalPose_1');
  _emscripten_bind_PxSphericalJoint_getLocalPose_1 = Module['_emscripten_bind_PxSphericalJoint_getLocalPose_1'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getLocalPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getRelativeTransform_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getRelativeTransform_0');
  _emscripten_bind_PxSphericalJoint_getRelativeTransform_0 = Module['_emscripten_bind_PxSphericalJoint_getRelativeTransform_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getRelativeTransform_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getRelativeLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getRelativeLinearVelocity_0');
  _emscripten_bind_PxSphericalJoint_getRelativeLinearVelocity_0 = Module['_emscripten_bind_PxSphericalJoint_getRelativeLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getRelativeLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getRelativeAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getRelativeAngularVelocity_0');
  _emscripten_bind_PxSphericalJoint_getRelativeAngularVelocity_0 = Module['_emscripten_bind_PxSphericalJoint_getRelativeAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getRelativeAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setBreakForce_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setBreakForce_2');
  _emscripten_bind_PxSphericalJoint_setBreakForce_2 = Module['_emscripten_bind_PxSphericalJoint_setBreakForce_2'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setBreakForce_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setConstraintFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setConstraintFlags_1');
  _emscripten_bind_PxSphericalJoint_setConstraintFlags_1 = Module['_emscripten_bind_PxSphericalJoint_setConstraintFlags_1'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setConstraintFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setConstraintFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setConstraintFlag_2');
  _emscripten_bind_PxSphericalJoint_setConstraintFlag_2 = Module['_emscripten_bind_PxSphericalJoint_setConstraintFlag_2'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setConstraintFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getConstraintFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getConstraintFlags_0');
  _emscripten_bind_PxSphericalJoint_getConstraintFlags_0 = Module['_emscripten_bind_PxSphericalJoint_getConstraintFlags_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getConstraintFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setInvMassScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setInvMassScale0_1');
  _emscripten_bind_PxSphericalJoint_setInvMassScale0_1 = Module['_emscripten_bind_PxSphericalJoint_setInvMassScale0_1'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setInvMassScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getInvMassScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getInvMassScale0_0');
  _emscripten_bind_PxSphericalJoint_getInvMassScale0_0 = Module['_emscripten_bind_PxSphericalJoint_getInvMassScale0_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getInvMassScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setInvMassScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setInvMassScale1_1');
  _emscripten_bind_PxSphericalJoint_setInvMassScale1_1 = Module['_emscripten_bind_PxSphericalJoint_setInvMassScale1_1'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setInvMassScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getInvMassScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getInvMassScale1_0');
  _emscripten_bind_PxSphericalJoint_getInvMassScale1_0 = Module['_emscripten_bind_PxSphericalJoint_getInvMassScale1_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getInvMassScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setInvInertiaScale0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setInvInertiaScale0_1');
  _emscripten_bind_PxSphericalJoint_setInvInertiaScale0_1 = Module['_emscripten_bind_PxSphericalJoint_setInvInertiaScale0_1'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setInvInertiaScale0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getInvInertiaScale0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getInvInertiaScale0_0');
  _emscripten_bind_PxSphericalJoint_getInvInertiaScale0_0 = Module['_emscripten_bind_PxSphericalJoint_getInvInertiaScale0_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getInvInertiaScale0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setInvInertiaScale1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setInvInertiaScale1_1');
  _emscripten_bind_PxSphericalJoint_setInvInertiaScale1_1 = Module['_emscripten_bind_PxSphericalJoint_setInvInertiaScale1_1'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setInvInertiaScale1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getInvInertiaScale1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getInvInertiaScale1_0');
  _emscripten_bind_PxSphericalJoint_getInvInertiaScale1_0 = Module['_emscripten_bind_PxSphericalJoint_getInvInertiaScale1_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getInvInertiaScale1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getConstraint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getConstraint_0');
  _emscripten_bind_PxSphericalJoint_getConstraint_0 = Module['_emscripten_bind_PxSphericalJoint_getConstraint_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getConstraint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_setName_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_setName_1');
  _emscripten_bind_PxSphericalJoint_setName_1 = Module['_emscripten_bind_PxSphericalJoint_setName_1'] = createExportWrapper('emscripten_bind_PxSphericalJoint_setName_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getName_0');
  _emscripten_bind_PxSphericalJoint_getName_0 = Module['_emscripten_bind_PxSphericalJoint_getName_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_getScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_getScene_0');
  _emscripten_bind_PxSphericalJoint_getScene_0 = Module['_emscripten_bind_PxSphericalJoint_getScene_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_getScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_get_userData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_get_userData_0');
  _emscripten_bind_PxSphericalJoint_get_userData_0 = Module['_emscripten_bind_PxSphericalJoint_get_userData_0'] = createExportWrapper('emscripten_bind_PxSphericalJoint_get_userData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint_set_userData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint_set_userData_1');
  _emscripten_bind_PxSphericalJoint_set_userData_1 = Module['_emscripten_bind_PxSphericalJoint_set_userData_1'] = createExportWrapper('emscripten_bind_PxSphericalJoint_set_userData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJoint___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJoint___destroy___0');
  _emscripten_bind_PxSphericalJoint___destroy___0 = Module['_emscripten_bind_PxSphericalJoint___destroy___0'] = createExportWrapper('emscripten_bind_PxSphericalJoint___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJointFlags_PxSphericalJointFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJointFlags_PxSphericalJointFlags_1');
  _emscripten_bind_PxSphericalJointFlags_PxSphericalJointFlags_1 = Module['_emscripten_bind_PxSphericalJointFlags_PxSphericalJointFlags_1'] = createExportWrapper('emscripten_bind_PxSphericalJointFlags_PxSphericalJointFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJointFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJointFlags_isSet_1');
  _emscripten_bind_PxSphericalJointFlags_isSet_1 = Module['_emscripten_bind_PxSphericalJointFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxSphericalJointFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJointFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJointFlags_raise_1');
  _emscripten_bind_PxSphericalJointFlags_raise_1 = Module['_emscripten_bind_PxSphericalJointFlags_raise_1'] = createExportWrapper('emscripten_bind_PxSphericalJointFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJointFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJointFlags_clear_1');
  _emscripten_bind_PxSphericalJointFlags_clear_1 = Module['_emscripten_bind_PxSphericalJointFlags_clear_1'] = createExportWrapper('emscripten_bind_PxSphericalJointFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSphericalJointFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSphericalJointFlags___destroy___0');
  _emscripten_bind_PxSphericalJointFlags___destroy___0 = Module['_emscripten_bind_PxSphericalJointFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxSphericalJointFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepBuffer10_PxSweepBuffer10_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepBuffer10_PxSweepBuffer10_0');
  _emscripten_bind_PxSweepBuffer10_PxSweepBuffer10_0 = Module['_emscripten_bind_PxSweepBuffer10_PxSweepBuffer10_0'] = createExportWrapper('emscripten_bind_PxSweepBuffer10_PxSweepBuffer10_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxSweepBuffer10_getNbAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepBuffer10_getNbAnyHits_0');
  _emscripten_bind_PxSweepBuffer10_getNbAnyHits_0 = Module['_emscripten_bind_PxSweepBuffer10_getNbAnyHits_0'] = createExportWrapper('emscripten_bind_PxSweepBuffer10_getNbAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepBuffer10_getAnyHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepBuffer10_getAnyHit_1');
  _emscripten_bind_PxSweepBuffer10_getAnyHit_1 = Module['_emscripten_bind_PxSweepBuffer10_getAnyHit_1'] = createExportWrapper('emscripten_bind_PxSweepBuffer10_getAnyHit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepBuffer10_getNbTouches_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepBuffer10_getNbTouches_0');
  _emscripten_bind_PxSweepBuffer10_getNbTouches_0 = Module['_emscripten_bind_PxSweepBuffer10_getNbTouches_0'] = createExportWrapper('emscripten_bind_PxSweepBuffer10_getNbTouches_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepBuffer10_getTouches_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepBuffer10_getTouches_0');
  _emscripten_bind_PxSweepBuffer10_getTouches_0 = Module['_emscripten_bind_PxSweepBuffer10_getTouches_0'] = createExportWrapper('emscripten_bind_PxSweepBuffer10_getTouches_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepBuffer10_getTouch_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepBuffer10_getTouch_1');
  _emscripten_bind_PxSweepBuffer10_getTouch_1 = Module['_emscripten_bind_PxSweepBuffer10_getTouch_1'] = createExportWrapper('emscripten_bind_PxSweepBuffer10_getTouch_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepBuffer10_getMaxNbTouches_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepBuffer10_getMaxNbTouches_0');
  _emscripten_bind_PxSweepBuffer10_getMaxNbTouches_0 = Module['_emscripten_bind_PxSweepBuffer10_getMaxNbTouches_0'] = createExportWrapper('emscripten_bind_PxSweepBuffer10_getMaxNbTouches_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepBuffer10_hasAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepBuffer10_hasAnyHits_0');
  _emscripten_bind_PxSweepBuffer10_hasAnyHits_0 = Module['_emscripten_bind_PxSweepBuffer10_hasAnyHits_0'] = createExportWrapper('emscripten_bind_PxSweepBuffer10_hasAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepBuffer10_get_block_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepBuffer10_get_block_0');
  _emscripten_bind_PxSweepBuffer10_get_block_0 = Module['_emscripten_bind_PxSweepBuffer10_get_block_0'] = createExportWrapper('emscripten_bind_PxSweepBuffer10_get_block_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepBuffer10_set_block_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepBuffer10_set_block_1');
  _emscripten_bind_PxSweepBuffer10_set_block_1 = Module['_emscripten_bind_PxSweepBuffer10_set_block_1'] = createExportWrapper('emscripten_bind_PxSweepBuffer10_set_block_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepBuffer10_get_hasBlock_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepBuffer10_get_hasBlock_0');
  _emscripten_bind_PxSweepBuffer10_get_hasBlock_0 = Module['_emscripten_bind_PxSweepBuffer10_get_hasBlock_0'] = createExportWrapper('emscripten_bind_PxSweepBuffer10_get_hasBlock_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepBuffer10_set_hasBlock_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepBuffer10_set_hasBlock_1');
  _emscripten_bind_PxSweepBuffer10_set_hasBlock_1 = Module['_emscripten_bind_PxSweepBuffer10_set_hasBlock_1'] = createExportWrapper('emscripten_bind_PxSweepBuffer10_set_hasBlock_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepBuffer10___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepBuffer10___destroy___0');
  _emscripten_bind_PxSweepBuffer10___destroy___0 = Module['_emscripten_bind_PxSweepBuffer10___destroy___0'] = createExportWrapper('emscripten_bind_PxSweepBuffer10___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_PxSweepHit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_PxSweepHit_0');
  _emscripten_bind_PxSweepHit_PxSweepHit_0 = Module['_emscripten_bind_PxSweepHit_PxSweepHit_0'] = createExportWrapper('emscripten_bind_PxSweepHit_PxSweepHit_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_hadInitialOverlap_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_hadInitialOverlap_0');
  _emscripten_bind_PxSweepHit_hadInitialOverlap_0 = Module['_emscripten_bind_PxSweepHit_hadInitialOverlap_0'] = createExportWrapper('emscripten_bind_PxSweepHit_hadInitialOverlap_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_get_actor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_get_actor_0');
  _emscripten_bind_PxSweepHit_get_actor_0 = Module['_emscripten_bind_PxSweepHit_get_actor_0'] = createExportWrapper('emscripten_bind_PxSweepHit_get_actor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_set_actor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_set_actor_1');
  _emscripten_bind_PxSweepHit_set_actor_1 = Module['_emscripten_bind_PxSweepHit_set_actor_1'] = createExportWrapper('emscripten_bind_PxSweepHit_set_actor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_get_shape_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_get_shape_0');
  _emscripten_bind_PxSweepHit_get_shape_0 = Module['_emscripten_bind_PxSweepHit_get_shape_0'] = createExportWrapper('emscripten_bind_PxSweepHit_get_shape_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_set_shape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_set_shape_1');
  _emscripten_bind_PxSweepHit_set_shape_1 = Module['_emscripten_bind_PxSweepHit_set_shape_1'] = createExportWrapper('emscripten_bind_PxSweepHit_set_shape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_get_flags_0');
  _emscripten_bind_PxSweepHit_get_flags_0 = Module['_emscripten_bind_PxSweepHit_get_flags_0'] = createExportWrapper('emscripten_bind_PxSweepHit_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_set_flags_1');
  _emscripten_bind_PxSweepHit_set_flags_1 = Module['_emscripten_bind_PxSweepHit_set_flags_1'] = createExportWrapper('emscripten_bind_PxSweepHit_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_get_position_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_get_position_0');
  _emscripten_bind_PxSweepHit_get_position_0 = Module['_emscripten_bind_PxSweepHit_get_position_0'] = createExportWrapper('emscripten_bind_PxSweepHit_get_position_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_set_position_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_set_position_1');
  _emscripten_bind_PxSweepHit_set_position_1 = Module['_emscripten_bind_PxSweepHit_set_position_1'] = createExportWrapper('emscripten_bind_PxSweepHit_set_position_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_get_normal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_get_normal_0');
  _emscripten_bind_PxSweepHit_get_normal_0 = Module['_emscripten_bind_PxSweepHit_get_normal_0'] = createExportWrapper('emscripten_bind_PxSweepHit_get_normal_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_set_normal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_set_normal_1');
  _emscripten_bind_PxSweepHit_set_normal_1 = Module['_emscripten_bind_PxSweepHit_set_normal_1'] = createExportWrapper('emscripten_bind_PxSweepHit_set_normal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_get_distance_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_get_distance_0');
  _emscripten_bind_PxSweepHit_get_distance_0 = Module['_emscripten_bind_PxSweepHit_get_distance_0'] = createExportWrapper('emscripten_bind_PxSweepHit_get_distance_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_set_distance_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_set_distance_1');
  _emscripten_bind_PxSweepHit_set_distance_1 = Module['_emscripten_bind_PxSweepHit_set_distance_1'] = createExportWrapper('emscripten_bind_PxSweepHit_set_distance_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_get_faceIndex_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_get_faceIndex_0');
  _emscripten_bind_PxSweepHit_get_faceIndex_0 = Module['_emscripten_bind_PxSweepHit_get_faceIndex_0'] = createExportWrapper('emscripten_bind_PxSweepHit_get_faceIndex_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit_set_faceIndex_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit_set_faceIndex_1');
  _emscripten_bind_PxSweepHit_set_faceIndex_1 = Module['_emscripten_bind_PxSweepHit_set_faceIndex_1'] = createExportWrapper('emscripten_bind_PxSweepHit_set_faceIndex_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepHit___destroy___0');
  _emscripten_bind_PxSweepHit___destroy___0 = Module['_emscripten_bind_PxSweepHit___destroy___0'] = createExportWrapper('emscripten_bind_PxSweepHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepResult_PxSweepResult_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepResult_PxSweepResult_0');
  _emscripten_bind_PxSweepResult_PxSweepResult_0 = Module['_emscripten_bind_PxSweepResult_PxSweepResult_0'] = createExportWrapper('emscripten_bind_PxSweepResult_PxSweepResult_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxSweepResult_getNbAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepResult_getNbAnyHits_0');
  _emscripten_bind_PxSweepResult_getNbAnyHits_0 = Module['_emscripten_bind_PxSweepResult_getNbAnyHits_0'] = createExportWrapper('emscripten_bind_PxSweepResult_getNbAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepResult_getAnyHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepResult_getAnyHit_1');
  _emscripten_bind_PxSweepResult_getAnyHit_1 = Module['_emscripten_bind_PxSweepResult_getAnyHit_1'] = createExportWrapper('emscripten_bind_PxSweepResult_getAnyHit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepResult_getNbTouches_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepResult_getNbTouches_0');
  _emscripten_bind_PxSweepResult_getNbTouches_0 = Module['_emscripten_bind_PxSweepResult_getNbTouches_0'] = createExportWrapper('emscripten_bind_PxSweepResult_getNbTouches_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepResult_getTouch_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepResult_getTouch_1');
  _emscripten_bind_PxSweepResult_getTouch_1 = Module['_emscripten_bind_PxSweepResult_getTouch_1'] = createExportWrapper('emscripten_bind_PxSweepResult_getTouch_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepResult_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepResult_clear_0');
  _emscripten_bind_PxSweepResult_clear_0 = Module['_emscripten_bind_PxSweepResult_clear_0'] = createExportWrapper('emscripten_bind_PxSweepResult_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepResult_hasAnyHits_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepResult_hasAnyHits_0');
  _emscripten_bind_PxSweepResult_hasAnyHits_0 = Module['_emscripten_bind_PxSweepResult_hasAnyHits_0'] = createExportWrapper('emscripten_bind_PxSweepResult_hasAnyHits_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepResult_get_block_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepResult_get_block_0');
  _emscripten_bind_PxSweepResult_get_block_0 = Module['_emscripten_bind_PxSweepResult_get_block_0'] = createExportWrapper('emscripten_bind_PxSweepResult_get_block_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepResult_set_block_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepResult_set_block_1');
  _emscripten_bind_PxSweepResult_set_block_1 = Module['_emscripten_bind_PxSweepResult_set_block_1'] = createExportWrapper('emscripten_bind_PxSweepResult_set_block_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepResult_get_hasBlock_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepResult_get_hasBlock_0');
  _emscripten_bind_PxSweepResult_get_hasBlock_0 = Module['_emscripten_bind_PxSweepResult_get_hasBlock_0'] = createExportWrapper('emscripten_bind_PxSweepResult_get_hasBlock_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxSweepResult_set_hasBlock_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepResult_set_hasBlock_1');
  _emscripten_bind_PxSweepResult_set_hasBlock_1 = Module['_emscripten_bind_PxSweepResult_set_hasBlock_1'] = createExportWrapper('emscripten_bind_PxSweepResult_set_hasBlock_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxSweepResult___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxSweepResult___destroy___0');
  _emscripten_bind_PxSweepResult___destroy___0 = Module['_emscripten_bind_PxSweepResult___destroy___0'] = createExportWrapper('emscripten_bind_PxSweepResult___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_createConformingTetrahedronMesh_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_createConformingTetrahedronMesh_5');
  _emscripten_bind_PxTetMaker_createConformingTetrahedronMesh_5 = Module['_emscripten_bind_PxTetMaker_createConformingTetrahedronMesh_5'] = createExportWrapper('emscripten_bind_PxTetMaker_createConformingTetrahedronMesh_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_createVoxelTetrahedronMesh_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_createVoxelTetrahedronMesh_4');
  _emscripten_bind_PxTetMaker_createVoxelTetrahedronMesh_4 = Module['_emscripten_bind_PxTetMaker_createVoxelTetrahedronMesh_4'] = createExportWrapper('emscripten_bind_PxTetMaker_createVoxelTetrahedronMesh_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_createVoxelTetrahedronMeshFromEdgeLength_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_createVoxelTetrahedronMeshFromEdgeLength_4');
  _emscripten_bind_PxTetMaker_createVoxelTetrahedronMeshFromEdgeLength_4 = Module['_emscripten_bind_PxTetMaker_createVoxelTetrahedronMeshFromEdgeLength_4'] = createExportWrapper('emscripten_bind_PxTetMaker_createVoxelTetrahedronMeshFromEdgeLength_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_validateTriangleMesh_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_validateTriangleMesh_3');
  _emscripten_bind_PxTetMaker_validateTriangleMesh_3 = Module['_emscripten_bind_PxTetMaker_validateTriangleMesh_3'] = createExportWrapper('emscripten_bind_PxTetMaker_validateTriangleMesh_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_validateTetrahedronMesh_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_validateTetrahedronMesh_3');
  _emscripten_bind_PxTetMaker_validateTetrahedronMesh_3 = Module['_emscripten_bind_PxTetMaker_validateTetrahedronMesh_3'] = createExportWrapper('emscripten_bind_PxTetMaker_validateTetrahedronMesh_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_simplifyTriangleMesh_6'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_simplifyTriangleMesh_6');
  _emscripten_bind_PxTetMaker_simplifyTriangleMesh_6 = Module['_emscripten_bind_PxTetMaker_simplifyTriangleMesh_6'] = createExportWrapper('emscripten_bind_PxTetMaker_simplifyTriangleMesh_6', 6);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_simplifyTriangleMesh_7'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_simplifyTriangleMesh_7');
  _emscripten_bind_PxTetMaker_simplifyTriangleMesh_7 = Module['_emscripten_bind_PxTetMaker_simplifyTriangleMesh_7'] = createExportWrapper('emscripten_bind_PxTetMaker_simplifyTriangleMesh_7', 7);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_simplifyTriangleMesh_8'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_simplifyTriangleMesh_8');
  _emscripten_bind_PxTetMaker_simplifyTriangleMesh_8 = Module['_emscripten_bind_PxTetMaker_simplifyTriangleMesh_8'] = createExportWrapper('emscripten_bind_PxTetMaker_simplifyTriangleMesh_8', 8);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_simplifyTriangleMesh_9'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_simplifyTriangleMesh_9');
  _emscripten_bind_PxTetMaker_simplifyTriangleMesh_9 = Module['_emscripten_bind_PxTetMaker_simplifyTriangleMesh_9'] = createExportWrapper('emscripten_bind_PxTetMaker_simplifyTriangleMesh_9', 9);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_simplifyTriangleMesh_10'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_simplifyTriangleMesh_10');
  _emscripten_bind_PxTetMaker_simplifyTriangleMesh_10 = Module['_emscripten_bind_PxTetMaker_simplifyTriangleMesh_10'] = createExportWrapper('emscripten_bind_PxTetMaker_simplifyTriangleMesh_10', 10);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_simplifyTriangleMesh_11'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_simplifyTriangleMesh_11');
  _emscripten_bind_PxTetMaker_simplifyTriangleMesh_11 = Module['_emscripten_bind_PxTetMaker_simplifyTriangleMesh_11'] = createExportWrapper('emscripten_bind_PxTetMaker_simplifyTriangleMesh_11', 11);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_simplifyTriangleMesh_12'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_simplifyTriangleMesh_12');
  _emscripten_bind_PxTetMaker_simplifyTriangleMesh_12 = Module['_emscripten_bind_PxTetMaker_simplifyTriangleMesh_12'] = createExportWrapper('emscripten_bind_PxTetMaker_simplifyTriangleMesh_12', 12);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_remeshTriangleMesh_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_remeshTriangleMesh_5');
  _emscripten_bind_PxTetMaker_remeshTriangleMesh_5 = Module['_emscripten_bind_PxTetMaker_remeshTriangleMesh_5'] = createExportWrapper('emscripten_bind_PxTetMaker_remeshTriangleMesh_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_remeshTriangleMesh_6'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_remeshTriangleMesh_6');
  _emscripten_bind_PxTetMaker_remeshTriangleMesh_6 = Module['_emscripten_bind_PxTetMaker_remeshTriangleMesh_6'] = createExportWrapper('emscripten_bind_PxTetMaker_remeshTriangleMesh_6', 6);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_createTreeBasedTetrahedralMesh_6'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_createTreeBasedTetrahedralMesh_6');
  _emscripten_bind_PxTetMaker_createTreeBasedTetrahedralMesh_6 = Module['_emscripten_bind_PxTetMaker_createTreeBasedTetrahedralMesh_6'] = createExportWrapper('emscripten_bind_PxTetMaker_createTreeBasedTetrahedralMesh_6', 6);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_5');
  _emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_5 = Module['_emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_5'] = createExportWrapper('emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_6'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_6');
  _emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_6 = Module['_emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_6'] = createExportWrapper('emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_6', 6);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_7'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_7');
  _emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_7 = Module['_emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_7'] = createExportWrapper('emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_7', 7);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_detectTriangleIslands_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_detectTriangleIslands_3');
  _emscripten_bind_PxTetMaker_detectTriangleIslands_3 = Module['_emscripten_bind_PxTetMaker_detectTriangleIslands_3'] = createExportWrapper('emscripten_bind_PxTetMaker_detectTriangleIslands_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTetMaker_findLargestIslandId_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetMaker_findLargestIslandId_2');
  _emscripten_bind_PxTetMaker_findLargestIslandId_2 = Module['_emscripten_bind_PxTetMaker_findLargestIslandId_2'] = createExportWrapper('emscripten_bind_PxTetMaker_findLargestIslandId_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_getNbVertices_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_getNbVertices_0');
  _emscripten_bind_PxTetrahedronMesh_getNbVertices_0 = Module['_emscripten_bind_PxTetrahedronMesh_getNbVertices_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_getNbVertices_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_getVertices_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_getVertices_0');
  _emscripten_bind_PxTetrahedronMesh_getVertices_0 = Module['_emscripten_bind_PxTetrahedronMesh_getVertices_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_getVertices_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_getNbTetrahedrons_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_getNbTetrahedrons_0');
  _emscripten_bind_PxTetrahedronMesh_getNbTetrahedrons_0 = Module['_emscripten_bind_PxTetrahedronMesh_getNbTetrahedrons_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_getNbTetrahedrons_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_getTetrahedrons_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_getTetrahedrons_0');
  _emscripten_bind_PxTetrahedronMesh_getTetrahedrons_0 = Module['_emscripten_bind_PxTetrahedronMesh_getTetrahedrons_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_getTetrahedrons_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_getTetrahedronMeshFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_getTetrahedronMeshFlags_0');
  _emscripten_bind_PxTetrahedronMesh_getTetrahedronMeshFlags_0 = Module['_emscripten_bind_PxTetrahedronMesh_getTetrahedronMeshFlags_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_getTetrahedronMeshFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_getTetrahedraRemap_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_getTetrahedraRemap_0');
  _emscripten_bind_PxTetrahedronMesh_getTetrahedraRemap_0 = Module['_emscripten_bind_PxTetrahedronMesh_getTetrahedraRemap_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_getTetrahedraRemap_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_getLocalBounds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_getLocalBounds_0');
  _emscripten_bind_PxTetrahedronMesh_getLocalBounds_0 = Module['_emscripten_bind_PxTetrahedronMesh_getLocalBounds_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_getLocalBounds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_release_0');
  _emscripten_bind_PxTetrahedronMesh_release_0 = Module['_emscripten_bind_PxTetrahedronMesh_release_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_getConcreteTypeName_0');
  _emscripten_bind_PxTetrahedronMesh_getConcreteTypeName_0 = Module['_emscripten_bind_PxTetrahedronMesh_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_getConcreteType_0');
  _emscripten_bind_PxTetrahedronMesh_getConcreteType_0 = Module['_emscripten_bind_PxTetrahedronMesh_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_setBaseFlag_2');
  _emscripten_bind_PxTetrahedronMesh_setBaseFlag_2 = Module['_emscripten_bind_PxTetrahedronMesh_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_setBaseFlags_1');
  _emscripten_bind_PxTetrahedronMesh_setBaseFlags_1 = Module['_emscripten_bind_PxTetrahedronMesh_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_getBaseFlags_0');
  _emscripten_bind_PxTetrahedronMesh_getBaseFlags_0 = Module['_emscripten_bind_PxTetrahedronMesh_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_isReleasable_0');
  _emscripten_bind_PxTetrahedronMesh_isReleasable_0 = Module['_emscripten_bind_PxTetrahedronMesh_isReleasable_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_getReferenceCount_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_getReferenceCount_0');
  _emscripten_bind_PxTetrahedronMesh_getReferenceCount_0 = Module['_emscripten_bind_PxTetrahedronMesh_getReferenceCount_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_getReferenceCount_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMesh_acquireReference_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMesh_acquireReference_0');
  _emscripten_bind_PxTetrahedronMesh_acquireReference_0 = Module['_emscripten_bind_PxTetrahedronMesh_acquireReference_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMesh_acquireReference_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshAnalysisResults_PxTetrahedronMeshAnalysisResults_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshAnalysisResults_PxTetrahedronMeshAnalysisResults_1');
  _emscripten_bind_PxTetrahedronMeshAnalysisResults_PxTetrahedronMeshAnalysisResults_1 = Module['_emscripten_bind_PxTetrahedronMeshAnalysisResults_PxTetrahedronMeshAnalysisResults_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshAnalysisResults_PxTetrahedronMeshAnalysisResults_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshAnalysisResults_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshAnalysisResults_isSet_1');
  _emscripten_bind_PxTetrahedronMeshAnalysisResults_isSet_1 = Module['_emscripten_bind_PxTetrahedronMeshAnalysisResults_isSet_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshAnalysisResults_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshAnalysisResults_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshAnalysisResults_raise_1');
  _emscripten_bind_PxTetrahedronMeshAnalysisResults_raise_1 = Module['_emscripten_bind_PxTetrahedronMeshAnalysisResults_raise_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshAnalysisResults_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshAnalysisResults_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshAnalysisResults_clear_1');
  _emscripten_bind_PxTetrahedronMeshAnalysisResults_clear_1 = Module['_emscripten_bind_PxTetrahedronMeshAnalysisResults_clear_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshAnalysisResults_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshAnalysisResults___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshAnalysisResults___destroy___0');
  _emscripten_bind_PxTetrahedronMeshAnalysisResults___destroy___0 = Module['_emscripten_bind_PxTetrahedronMeshAnalysisResults___destroy___0'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshAnalysisResults___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_0');
  _emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_0 = Module['_emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_2');
  _emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_2 = Module['_emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_2'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_3');
  _emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_3 = Module['_emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_3'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_4');
  _emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_4 = Module['_emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_4'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_isValid_0');
  _emscripten_bind_PxTetrahedronMeshDesc_isValid_0 = Module['_emscripten_bind_PxTetrahedronMeshDesc_isValid_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_get_materialIndices_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_get_materialIndices_0');
  _emscripten_bind_PxTetrahedronMeshDesc_get_materialIndices_0 = Module['_emscripten_bind_PxTetrahedronMeshDesc_get_materialIndices_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_get_materialIndices_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_set_materialIndices_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_set_materialIndices_1');
  _emscripten_bind_PxTetrahedronMeshDesc_set_materialIndices_1 = Module['_emscripten_bind_PxTetrahedronMeshDesc_set_materialIndices_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_set_materialIndices_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_get_points_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_get_points_0');
  _emscripten_bind_PxTetrahedronMeshDesc_get_points_0 = Module['_emscripten_bind_PxTetrahedronMeshDesc_get_points_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_get_points_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_set_points_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_set_points_1');
  _emscripten_bind_PxTetrahedronMeshDesc_set_points_1 = Module['_emscripten_bind_PxTetrahedronMeshDesc_set_points_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_set_points_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_get_tetrahedrons_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_get_tetrahedrons_0');
  _emscripten_bind_PxTetrahedronMeshDesc_get_tetrahedrons_0 = Module['_emscripten_bind_PxTetrahedronMeshDesc_get_tetrahedrons_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_get_tetrahedrons_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_set_tetrahedrons_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_set_tetrahedrons_1');
  _emscripten_bind_PxTetrahedronMeshDesc_set_tetrahedrons_1 = Module['_emscripten_bind_PxTetrahedronMeshDesc_set_tetrahedrons_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_set_tetrahedrons_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_get_flags_0');
  _emscripten_bind_PxTetrahedronMeshDesc_get_flags_0 = Module['_emscripten_bind_PxTetrahedronMeshDesc_get_flags_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_set_flags_1');
  _emscripten_bind_PxTetrahedronMeshDesc_set_flags_1 = Module['_emscripten_bind_PxTetrahedronMeshDesc_set_flags_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_get_tetsPerElement_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_get_tetsPerElement_0');
  _emscripten_bind_PxTetrahedronMeshDesc_get_tetsPerElement_0 = Module['_emscripten_bind_PxTetrahedronMeshDesc_get_tetsPerElement_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_get_tetsPerElement_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc_set_tetsPerElement_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc_set_tetsPerElement_1');
  _emscripten_bind_PxTetrahedronMeshDesc_set_tetsPerElement_1 = Module['_emscripten_bind_PxTetrahedronMeshDesc_set_tetsPerElement_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc_set_tetsPerElement_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshDesc___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshDesc___destroy___0');
  _emscripten_bind_PxTetrahedronMeshDesc___destroy___0 = Module['_emscripten_bind_PxTetrahedronMeshDesc___destroy___0'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshDesc___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshExt_findTetrahedronContainingPoint_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshExt_findTetrahedronContainingPoint_4');
  _emscripten_bind_PxTetrahedronMeshExt_findTetrahedronContainingPoint_4 = Module['_emscripten_bind_PxTetrahedronMeshExt_findTetrahedronContainingPoint_4'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshExt_findTetrahedronContainingPoint_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshExt_findTetrahedronClosestToPoint_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshExt_findTetrahedronClosestToPoint_3');
  _emscripten_bind_PxTetrahedronMeshExt_findTetrahedronClosestToPoint_3 = Module['_emscripten_bind_PxTetrahedronMeshExt_findTetrahedronClosestToPoint_3'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshExt_findTetrahedronClosestToPoint_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshExt_createPointsToTetrahedronMap_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshExt_createPointsToTetrahedronMap_5');
  _emscripten_bind_PxTetrahedronMeshExt_createPointsToTetrahedronMap_5 = Module['_emscripten_bind_PxTetrahedronMeshExt_createPointsToTetrahedronMap_5'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshExt_createPointsToTetrahedronMap_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_2');
  _emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_2 = Module['_emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_2'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_3');
  _emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_3 = Module['_emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_3'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_4');
  _emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_4 = Module['_emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_4'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshFlags_PxTetrahedronMeshFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshFlags_PxTetrahedronMeshFlags_1');
  _emscripten_bind_PxTetrahedronMeshFlags_PxTetrahedronMeshFlags_1 = Module['_emscripten_bind_PxTetrahedronMeshFlags_PxTetrahedronMeshFlags_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshFlags_PxTetrahedronMeshFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshFlags_isSet_1');
  _emscripten_bind_PxTetrahedronMeshFlags_isSet_1 = Module['_emscripten_bind_PxTetrahedronMeshFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshFlags_raise_1');
  _emscripten_bind_PxTetrahedronMeshFlags_raise_1 = Module['_emscripten_bind_PxTetrahedronMeshFlags_raise_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshFlags_clear_1');
  _emscripten_bind_PxTetrahedronMeshFlags_clear_1 = Module['_emscripten_bind_PxTetrahedronMeshFlags_clear_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshFlags___destroy___0');
  _emscripten_bind_PxTetrahedronMeshFlags___destroy___0 = Module['_emscripten_bind_PxTetrahedronMeshFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshGeometry_PxTetrahedronMeshGeometry_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshGeometry_PxTetrahedronMeshGeometry_1');
  _emscripten_bind_PxTetrahedronMeshGeometry_PxTetrahedronMeshGeometry_1 = Module['_emscripten_bind_PxTetrahedronMeshGeometry_PxTetrahedronMeshGeometry_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshGeometry_PxTetrahedronMeshGeometry_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshGeometry_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshGeometry_isValid_0');
  _emscripten_bind_PxTetrahedronMeshGeometry_isValid_0 = Module['_emscripten_bind_PxTetrahedronMeshGeometry_isValid_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshGeometry_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshGeometry_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshGeometry_getType_0');
  _emscripten_bind_PxTetrahedronMeshGeometry_getType_0 = Module['_emscripten_bind_PxTetrahedronMeshGeometry_getType_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshGeometry_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshGeometry_get_tetrahedronMesh_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshGeometry_get_tetrahedronMesh_0');
  _emscripten_bind_PxTetrahedronMeshGeometry_get_tetrahedronMesh_0 = Module['_emscripten_bind_PxTetrahedronMeshGeometry_get_tetrahedronMesh_0'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshGeometry_get_tetrahedronMesh_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTetrahedronMeshGeometry_set_tetrahedronMesh_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTetrahedronMeshGeometry_set_tetrahedronMesh_1');
  _emscripten_bind_PxTetrahedronMeshGeometry_set_tetrahedronMesh_1 = Module['_emscripten_bind_PxTetrahedronMeshGeometry_set_tetrahedronMesh_1'] = createExportWrapper('emscripten_bind_PxTetrahedronMeshGeometry_set_tetrahedronMesh_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTolerancesScale_PxTolerancesScale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTolerancesScale_PxTolerancesScale_0');
  _emscripten_bind_PxTolerancesScale_PxTolerancesScale_0 = Module['_emscripten_bind_PxTolerancesScale_PxTolerancesScale_0'] = createExportWrapper('emscripten_bind_PxTolerancesScale_PxTolerancesScale_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxTolerancesScale_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTolerancesScale_isValid_0');
  _emscripten_bind_PxTolerancesScale_isValid_0 = Module['_emscripten_bind_PxTolerancesScale_isValid_0'] = createExportWrapper('emscripten_bind_PxTolerancesScale_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTolerancesScale_get_length_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTolerancesScale_get_length_0');
  _emscripten_bind_PxTolerancesScale_get_length_0 = Module['_emscripten_bind_PxTolerancesScale_get_length_0'] = createExportWrapper('emscripten_bind_PxTolerancesScale_get_length_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTolerancesScale_set_length_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTolerancesScale_set_length_1');
  _emscripten_bind_PxTolerancesScale_set_length_1 = Module['_emscripten_bind_PxTolerancesScale_set_length_1'] = createExportWrapper('emscripten_bind_PxTolerancesScale_set_length_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTolerancesScale_get_speed_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTolerancesScale_get_speed_0');
  _emscripten_bind_PxTolerancesScale_get_speed_0 = Module['_emscripten_bind_PxTolerancesScale_get_speed_0'] = createExportWrapper('emscripten_bind_PxTolerancesScale_get_speed_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTolerancesScale_set_speed_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTolerancesScale_set_speed_1');
  _emscripten_bind_PxTolerancesScale_set_speed_1 = Module['_emscripten_bind_PxTolerancesScale_set_speed_1'] = createExportWrapper('emscripten_bind_PxTolerancesScale_set_speed_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTolerancesScale___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTolerancesScale___destroy___0');
  _emscripten_bind_PxTolerancesScale___destroy___0 = Module['_emscripten_bind_PxTolerancesScale___destroy___0'] = createExportWrapper('emscripten_bind_PxTolerancesScale___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_DefaultFilterShader_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_DefaultFilterShader_0');
  _emscripten_bind_PxTopLevelFunctions_DefaultFilterShader_0 = Module['_emscripten_bind_PxTopLevelFunctions_DefaultFilterShader_0'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_DefaultFilterShader_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_setupPassThroughFilterShader_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_setupPassThroughFilterShader_2');
  _emscripten_bind_PxTopLevelFunctions_setupPassThroughFilterShader_2 = Module['_emscripten_bind_PxTopLevelFunctions_setupPassThroughFilterShader_2'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_setupPassThroughFilterShader_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreateControllerManager_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreateControllerManager_1');
  _emscripten_bind_PxTopLevelFunctions_CreateControllerManager_1 = Module['_emscripten_bind_PxTopLevelFunctions_CreateControllerManager_1'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreateControllerManager_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreateControllerManager_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreateControllerManager_2');
  _emscripten_bind_PxTopLevelFunctions_CreateControllerManager_2 = Module['_emscripten_bind_PxTopLevelFunctions_CreateControllerManager_2'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreateControllerManager_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreateFoundation_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreateFoundation_3');
  _emscripten_bind_PxTopLevelFunctions_CreateFoundation_3 = Module['_emscripten_bind_PxTopLevelFunctions_CreateFoundation_3'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreateFoundation_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreatePhysics_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreatePhysics_3');
  _emscripten_bind_PxTopLevelFunctions_CreatePhysics_3 = Module['_emscripten_bind_PxTopLevelFunctions_CreatePhysics_3'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreatePhysics_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreatePhysics_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreatePhysics_4');
  _emscripten_bind_PxTopLevelFunctions_CreatePhysics_4 = Module['_emscripten_bind_PxTopLevelFunctions_CreatePhysics_4'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreatePhysics_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreatePhysics_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreatePhysics_5');
  _emscripten_bind_PxTopLevelFunctions_CreatePhysics_5 = Module['_emscripten_bind_PxTopLevelFunctions_CreatePhysics_5'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreatePhysics_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_DefaultCpuDispatcherCreate_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_DefaultCpuDispatcherCreate_1');
  _emscripten_bind_PxTopLevelFunctions_DefaultCpuDispatcherCreate_1 = Module['_emscripten_bind_PxTopLevelFunctions_DefaultCpuDispatcherCreate_1'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_DefaultCpuDispatcherCreate_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_InitExtensions_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_InitExtensions_1');
  _emscripten_bind_PxTopLevelFunctions_InitExtensions_1 = Module['_emscripten_bind_PxTopLevelFunctions_InitExtensions_1'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_InitExtensions_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CloseExtensions_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CloseExtensions_0');
  _emscripten_bind_PxTopLevelFunctions_CloseExtensions_0 = Module['_emscripten_bind_PxTopLevelFunctions_CloseExtensions_0'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CloseExtensions_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreatePvd_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreatePvd_1');
  _emscripten_bind_PxTopLevelFunctions_CreatePvd_1 = Module['_emscripten_bind_PxTopLevelFunctions_CreatePvd_1'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreatePvd_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_D6JointCreate_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_D6JointCreate_5');
  _emscripten_bind_PxTopLevelFunctions_D6JointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_D6JointCreate_5'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_D6JointCreate_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_DistanceJointCreate_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_DistanceJointCreate_5');
  _emscripten_bind_PxTopLevelFunctions_DistanceJointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_DistanceJointCreate_5'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_DistanceJointCreate_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_FixedJointCreate_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_FixedJointCreate_5');
  _emscripten_bind_PxTopLevelFunctions_FixedJointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_FixedJointCreate_5'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_FixedJointCreate_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_GearJointCreate_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_GearJointCreate_5');
  _emscripten_bind_PxTopLevelFunctions_GearJointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_GearJointCreate_5'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_GearJointCreate_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_PrismaticJointCreate_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_PrismaticJointCreate_5');
  _emscripten_bind_PxTopLevelFunctions_PrismaticJointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_PrismaticJointCreate_5'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_PrismaticJointCreate_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_RackAndPinionJointCreate_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_RackAndPinionJointCreate_5');
  _emscripten_bind_PxTopLevelFunctions_RackAndPinionJointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_RackAndPinionJointCreate_5'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_RackAndPinionJointCreate_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_RevoluteJointCreate_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_RevoluteJointCreate_5');
  _emscripten_bind_PxTopLevelFunctions_RevoluteJointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_RevoluteJointCreate_5'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_RevoluteJointCreate_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_SphericalJointCreate_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_SphericalJointCreate_5');
  _emscripten_bind_PxTopLevelFunctions_SphericalJointCreate_5 = Module['_emscripten_bind_PxTopLevelFunctions_SphericalJointCreate_5'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_SphericalJointCreate_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreateConvexMesh_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreateConvexMesh_2');
  _emscripten_bind_PxTopLevelFunctions_CreateConvexMesh_2 = Module['_emscripten_bind_PxTopLevelFunctions_CreateConvexMesh_2'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreateConvexMesh_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreateTriangleMesh_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreateTriangleMesh_2');
  _emscripten_bind_PxTopLevelFunctions_CreateTriangleMesh_2 = Module['_emscripten_bind_PxTopLevelFunctions_CreateTriangleMesh_2'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreateTriangleMesh_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreateHeightField_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreateHeightField_1');
  _emscripten_bind_PxTopLevelFunctions_CreateHeightField_1 = Module['_emscripten_bind_PxTopLevelFunctions_CreateHeightField_1'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreateHeightField_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CookTriangleMesh_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CookTriangleMesh_3');
  _emscripten_bind_PxTopLevelFunctions_CookTriangleMesh_3 = Module['_emscripten_bind_PxTopLevelFunctions_CookTriangleMesh_3'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CookTriangleMesh_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CookConvexMesh_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CookConvexMesh_3');
  _emscripten_bind_PxTopLevelFunctions_CookConvexMesh_3 = Module['_emscripten_bind_PxTopLevelFunctions_CookConvexMesh_3'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CookConvexMesh_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreateDynamicFromShape_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreateDynamicFromShape_4');
  _emscripten_bind_PxTopLevelFunctions_CreateDynamicFromShape_4 = Module['_emscripten_bind_PxTopLevelFunctions_CreateDynamicFromShape_4'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreateDynamicFromShape_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreateDynamic_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreateDynamic_5');
  _emscripten_bind_PxTopLevelFunctions_CreateDynamic_5 = Module['_emscripten_bind_PxTopLevelFunctions_CreateDynamic_5'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreateDynamic_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreateDynamic_6'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreateDynamic_6');
  _emscripten_bind_PxTopLevelFunctions_CreateDynamic_6 = Module['_emscripten_bind_PxTopLevelFunctions_CreateDynamic_6'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreateDynamic_6', 6);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreateKinematicFromShape_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreateKinematicFromShape_4');
  _emscripten_bind_PxTopLevelFunctions_CreateKinematicFromShape_4 = Module['_emscripten_bind_PxTopLevelFunctions_CreateKinematicFromShape_4'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreateKinematicFromShape_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreateKinematic_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreateKinematic_5');
  _emscripten_bind_PxTopLevelFunctions_CreateKinematic_5 = Module['_emscripten_bind_PxTopLevelFunctions_CreateKinematic_5'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreateKinematic_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreateKinematic_6'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreateKinematic_6');
  _emscripten_bind_PxTopLevelFunctions_CreateKinematic_6 = Module['_emscripten_bind_PxTopLevelFunctions_CreateKinematic_6'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreateKinematic_6', 6);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreateStaticFromShape_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreateStaticFromShape_3');
  _emscripten_bind_PxTopLevelFunctions_CreateStaticFromShape_3 = Module['_emscripten_bind_PxTopLevelFunctions_CreateStaticFromShape_3'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreateStaticFromShape_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreateStatic_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreateStatic_5');
  _emscripten_bind_PxTopLevelFunctions_CreateStatic_5 = Module['_emscripten_bind_PxTopLevelFunctions_CreateStatic_5'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreateStatic_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CreatePlane_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CreatePlane_3');
  _emscripten_bind_PxTopLevelFunctions_CreatePlane_3 = Module['_emscripten_bind_PxTopLevelFunctions_CreatePlane_3'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CreatePlane_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CloneShape_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CloneShape_3');
  _emscripten_bind_PxTopLevelFunctions_CloneShape_3 = Module['_emscripten_bind_PxTopLevelFunctions_CloneShape_3'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CloneShape_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CloneStatic_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CloneStatic_3');
  _emscripten_bind_PxTopLevelFunctions_CloneStatic_3 = Module['_emscripten_bind_PxTopLevelFunctions_CloneStatic_3'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CloneStatic_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_CloneDynamic_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_CloneDynamic_3');
  _emscripten_bind_PxTopLevelFunctions_CloneDynamic_3 = Module['_emscripten_bind_PxTopLevelFunctions_CloneDynamic_3'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_CloneDynamic_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_ScaleRigidActor_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_ScaleRigidActor_3');
  _emscripten_bind_PxTopLevelFunctions_ScaleRigidActor_3 = Module['_emscripten_bind_PxTopLevelFunctions_ScaleRigidActor_3'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_ScaleRigidActor_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_IntegrateTransform_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_IntegrateTransform_5');
  _emscripten_bind_PxTopLevelFunctions_IntegrateTransform_5 = Module['_emscripten_bind_PxTopLevelFunctions_IntegrateTransform_5'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_IntegrateTransform_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_GetTriangleMeshSDFDimensions_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_GetTriangleMeshSDFDimensions_1');
  _emscripten_bind_PxTopLevelFunctions_GetTriangleMeshSDFDimensions_1 = Module['_emscripten_bind_PxTopLevelFunctions_GetTriangleMeshSDFDimensions_1'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_GetTriangleMeshSDFDimensions_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxTopLevelFunctions_get_PHYSICS_VERSION_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTopLevelFunctions_get_PHYSICS_VERSION_0');
  _emscripten_bind_PxTopLevelFunctions_get_PHYSICS_VERSION_0 = Module['_emscripten_bind_PxTopLevelFunctions_get_PHYSICS_VERSION_0'] = createExportWrapper('emscripten_bind_PxTopLevelFunctions_get_PHYSICS_VERSION_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTransform_PxTransform_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform_PxTransform_0');
  _emscripten_bind_PxTransform_PxTransform_0 = Module['_emscripten_bind_PxTransform_PxTransform_0'] = createExportWrapper('emscripten_bind_PxTransform_PxTransform_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxTransform_PxTransform_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform_PxTransform_1');
  _emscripten_bind_PxTransform_PxTransform_1 = Module['_emscripten_bind_PxTransform_PxTransform_1'] = createExportWrapper('emscripten_bind_PxTransform_PxTransform_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxTransform_PxTransform_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform_PxTransform_2');
  _emscripten_bind_PxTransform_PxTransform_2 = Module['_emscripten_bind_PxTransform_PxTransform_2'] = createExportWrapper('emscripten_bind_PxTransform_PxTransform_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxTransform_getInverse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform_getInverse_0');
  _emscripten_bind_PxTransform_getInverse_0 = Module['_emscripten_bind_PxTransform_getInverse_0'] = createExportWrapper('emscripten_bind_PxTransform_getInverse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTransform_transform_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform_transform_1');
  _emscripten_bind_PxTransform_transform_1 = Module['_emscripten_bind_PxTransform_transform_1'] = createExportWrapper('emscripten_bind_PxTransform_transform_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTransform_transformInv_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform_transformInv_1');
  _emscripten_bind_PxTransform_transformInv_1 = Module['_emscripten_bind_PxTransform_transformInv_1'] = createExportWrapper('emscripten_bind_PxTransform_transformInv_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTransform_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform_isValid_0');
  _emscripten_bind_PxTransform_isValid_0 = Module['_emscripten_bind_PxTransform_isValid_0'] = createExportWrapper('emscripten_bind_PxTransform_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTransform_isSane_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform_isSane_0');
  _emscripten_bind_PxTransform_isSane_0 = Module['_emscripten_bind_PxTransform_isSane_0'] = createExportWrapper('emscripten_bind_PxTransform_isSane_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTransform_isFinite_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform_isFinite_0');
  _emscripten_bind_PxTransform_isFinite_0 = Module['_emscripten_bind_PxTransform_isFinite_0'] = createExportWrapper('emscripten_bind_PxTransform_isFinite_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTransform_getNormalized_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform_getNormalized_0');
  _emscripten_bind_PxTransform_getNormalized_0 = Module['_emscripten_bind_PxTransform_getNormalized_0'] = createExportWrapper('emscripten_bind_PxTransform_getNormalized_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTransform_get_q_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform_get_q_0');
  _emscripten_bind_PxTransform_get_q_0 = Module['_emscripten_bind_PxTransform_get_q_0'] = createExportWrapper('emscripten_bind_PxTransform_get_q_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTransform_set_q_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform_set_q_1');
  _emscripten_bind_PxTransform_set_q_1 = Module['_emscripten_bind_PxTransform_set_q_1'] = createExportWrapper('emscripten_bind_PxTransform_set_q_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTransform_get_p_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform_get_p_0');
  _emscripten_bind_PxTransform_get_p_0 = Module['_emscripten_bind_PxTransform_get_p_0'] = createExportWrapper('emscripten_bind_PxTransform_get_p_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTransform_set_p_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform_set_p_1');
  _emscripten_bind_PxTransform_set_p_1 = Module['_emscripten_bind_PxTransform_set_p_1'] = createExportWrapper('emscripten_bind_PxTransform_set_p_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTransform___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTransform___destroy___0');
  _emscripten_bind_PxTransform___destroy___0 = Module['_emscripten_bind_PxTransform___destroy___0'] = createExportWrapper('emscripten_bind_PxTransform___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangle_PxTriangle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangle_PxTriangle_0');
  _emscripten_bind_PxTriangle_PxTriangle_0 = Module['_emscripten_bind_PxTriangle_PxTriangle_0'] = createExportWrapper('emscripten_bind_PxTriangle_PxTriangle_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxTriangle_PxTriangle_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangle_PxTriangle_3');
  _emscripten_bind_PxTriangle_PxTriangle_3 = Module['_emscripten_bind_PxTriangle_PxTriangle_3'] = createExportWrapper('emscripten_bind_PxTriangle_PxTriangle_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTriangle_normal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangle_normal_1');
  _emscripten_bind_PxTriangle_normal_1 = Module['_emscripten_bind_PxTriangle_normal_1'] = createExportWrapper('emscripten_bind_PxTriangle_normal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangle_denormalizedNormal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangle_denormalizedNormal_1');
  _emscripten_bind_PxTriangle_denormalizedNormal_1 = Module['_emscripten_bind_PxTriangle_denormalizedNormal_1'] = createExportWrapper('emscripten_bind_PxTriangle_denormalizedNormal_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangle_area_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangle_area_0');
  _emscripten_bind_PxTriangle_area_0 = Module['_emscripten_bind_PxTriangle_area_0'] = createExportWrapper('emscripten_bind_PxTriangle_area_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangle_pointFromUV_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangle_pointFromUV_2');
  _emscripten_bind_PxTriangle_pointFromUV_2 = Module['_emscripten_bind_PxTriangle_pointFromUV_2'] = createExportWrapper('emscripten_bind_PxTriangle_pointFromUV_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxTriangle___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangle___destroy___0');
  _emscripten_bind_PxTriangle___destroy___0 = Module['_emscripten_bind_PxTriangle___destroy___0'] = createExportWrapper('emscripten_bind_PxTriangle___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_getNbVertices_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_getNbVertices_0');
  _emscripten_bind_PxTriangleMesh_getNbVertices_0 = Module['_emscripten_bind_PxTriangleMesh_getNbVertices_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_getNbVertices_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_getVertices_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_getVertices_0');
  _emscripten_bind_PxTriangleMesh_getVertices_0 = Module['_emscripten_bind_PxTriangleMesh_getVertices_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_getVertices_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_getVerticesForModification_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_getVerticesForModification_0');
  _emscripten_bind_PxTriangleMesh_getVerticesForModification_0 = Module['_emscripten_bind_PxTriangleMesh_getVerticesForModification_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_getVerticesForModification_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_refitBVH_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_refitBVH_0');
  _emscripten_bind_PxTriangleMesh_refitBVH_0 = Module['_emscripten_bind_PxTriangleMesh_refitBVH_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_refitBVH_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_getNbTriangles_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_getNbTriangles_0');
  _emscripten_bind_PxTriangleMesh_getNbTriangles_0 = Module['_emscripten_bind_PxTriangleMesh_getNbTriangles_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_getNbTriangles_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_getTriangles_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_getTriangles_0');
  _emscripten_bind_PxTriangleMesh_getTriangles_0 = Module['_emscripten_bind_PxTriangleMesh_getTriangles_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_getTriangles_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_getTriangleMeshFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_getTriangleMeshFlags_0');
  _emscripten_bind_PxTriangleMesh_getTriangleMeshFlags_0 = Module['_emscripten_bind_PxTriangleMesh_getTriangleMeshFlags_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_getTriangleMeshFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_getTrianglesRemap_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_getTrianglesRemap_0');
  _emscripten_bind_PxTriangleMesh_getTrianglesRemap_0 = Module['_emscripten_bind_PxTriangleMesh_getTrianglesRemap_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_getTrianglesRemap_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_getTriangleMaterialIndex_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_getTriangleMaterialIndex_1');
  _emscripten_bind_PxTriangleMesh_getTriangleMaterialIndex_1 = Module['_emscripten_bind_PxTriangleMesh_getTriangleMaterialIndex_1'] = createExportWrapper('emscripten_bind_PxTriangleMesh_getTriangleMaterialIndex_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_getLocalBounds_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_getLocalBounds_0');
  _emscripten_bind_PxTriangleMesh_getLocalBounds_0 = Module['_emscripten_bind_PxTriangleMesh_getLocalBounds_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_getLocalBounds_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_getSDF_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_getSDF_0');
  _emscripten_bind_PxTriangleMesh_getSDF_0 = Module['_emscripten_bind_PxTriangleMesh_getSDF_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_getSDF_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_setPreferSDFProjection_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_setPreferSDFProjection_1');
  _emscripten_bind_PxTriangleMesh_setPreferSDFProjection_1 = Module['_emscripten_bind_PxTriangleMesh_setPreferSDFProjection_1'] = createExportWrapper('emscripten_bind_PxTriangleMesh_setPreferSDFProjection_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_release_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_release_0');
  _emscripten_bind_PxTriangleMesh_release_0 = Module['_emscripten_bind_PxTriangleMesh_release_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_release_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_getConcreteTypeName_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_getConcreteTypeName_0');
  _emscripten_bind_PxTriangleMesh_getConcreteTypeName_0 = Module['_emscripten_bind_PxTriangleMesh_getConcreteTypeName_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_getConcreteTypeName_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_getConcreteType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_getConcreteType_0');
  _emscripten_bind_PxTriangleMesh_getConcreteType_0 = Module['_emscripten_bind_PxTriangleMesh_getConcreteType_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_getConcreteType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_setBaseFlag_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_setBaseFlag_2');
  _emscripten_bind_PxTriangleMesh_setBaseFlag_2 = Module['_emscripten_bind_PxTriangleMesh_setBaseFlag_2'] = createExportWrapper('emscripten_bind_PxTriangleMesh_setBaseFlag_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_setBaseFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_setBaseFlags_1');
  _emscripten_bind_PxTriangleMesh_setBaseFlags_1 = Module['_emscripten_bind_PxTriangleMesh_setBaseFlags_1'] = createExportWrapper('emscripten_bind_PxTriangleMesh_setBaseFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_getBaseFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_getBaseFlags_0');
  _emscripten_bind_PxTriangleMesh_getBaseFlags_0 = Module['_emscripten_bind_PxTriangleMesh_getBaseFlags_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_getBaseFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_isReleasable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_isReleasable_0');
  _emscripten_bind_PxTriangleMesh_isReleasable_0 = Module['_emscripten_bind_PxTriangleMesh_isReleasable_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_isReleasable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_getReferenceCount_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_getReferenceCount_0');
  _emscripten_bind_PxTriangleMesh_getReferenceCount_0 = Module['_emscripten_bind_PxTriangleMesh_getReferenceCount_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_getReferenceCount_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMesh_acquireReference_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMesh_acquireReference_0');
  _emscripten_bind_PxTriangleMesh_acquireReference_0 = Module['_emscripten_bind_PxTriangleMesh_acquireReference_0'] = createExportWrapper('emscripten_bind_PxTriangleMesh_acquireReference_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshAnalysisResults_PxTriangleMeshAnalysisResults_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshAnalysisResults_PxTriangleMeshAnalysisResults_1');
  _emscripten_bind_PxTriangleMeshAnalysisResults_PxTriangleMeshAnalysisResults_1 = Module['_emscripten_bind_PxTriangleMeshAnalysisResults_PxTriangleMeshAnalysisResults_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshAnalysisResults_PxTriangleMeshAnalysisResults_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshAnalysisResults_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshAnalysisResults_isSet_1');
  _emscripten_bind_PxTriangleMeshAnalysisResults_isSet_1 = Module['_emscripten_bind_PxTriangleMeshAnalysisResults_isSet_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshAnalysisResults_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshAnalysisResults_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshAnalysisResults_raise_1');
  _emscripten_bind_PxTriangleMeshAnalysisResults_raise_1 = Module['_emscripten_bind_PxTriangleMeshAnalysisResults_raise_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshAnalysisResults_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshAnalysisResults_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshAnalysisResults_clear_1');
  _emscripten_bind_PxTriangleMeshAnalysisResults_clear_1 = Module['_emscripten_bind_PxTriangleMeshAnalysisResults_clear_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshAnalysisResults_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshAnalysisResults___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshAnalysisResults___destroy___0');
  _emscripten_bind_PxTriangleMeshAnalysisResults___destroy___0 = Module['_emscripten_bind_PxTriangleMeshAnalysisResults___destroy___0'] = createExportWrapper('emscripten_bind_PxTriangleMeshAnalysisResults___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshDesc_PxTriangleMeshDesc_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshDesc_PxTriangleMeshDesc_0');
  _emscripten_bind_PxTriangleMeshDesc_PxTriangleMeshDesc_0 = Module['_emscripten_bind_PxTriangleMeshDesc_PxTriangleMeshDesc_0'] = createExportWrapper('emscripten_bind_PxTriangleMeshDesc_PxTriangleMeshDesc_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshDesc_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshDesc_setToDefault_0');
  _emscripten_bind_PxTriangleMeshDesc_setToDefault_0 = Module['_emscripten_bind_PxTriangleMeshDesc_setToDefault_0'] = createExportWrapper('emscripten_bind_PxTriangleMeshDesc_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshDesc_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshDesc_isValid_0');
  _emscripten_bind_PxTriangleMeshDesc_isValid_0 = Module['_emscripten_bind_PxTriangleMeshDesc_isValid_0'] = createExportWrapper('emscripten_bind_PxTriangleMeshDesc_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshDesc_get_materialIndices_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshDesc_get_materialIndices_0');
  _emscripten_bind_PxTriangleMeshDesc_get_materialIndices_0 = Module['_emscripten_bind_PxTriangleMeshDesc_get_materialIndices_0'] = createExportWrapper('emscripten_bind_PxTriangleMeshDesc_get_materialIndices_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshDesc_set_materialIndices_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshDesc_set_materialIndices_1');
  _emscripten_bind_PxTriangleMeshDesc_set_materialIndices_1 = Module['_emscripten_bind_PxTriangleMeshDesc_set_materialIndices_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshDesc_set_materialIndices_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshDesc_get_sdfDesc_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshDesc_get_sdfDesc_0');
  _emscripten_bind_PxTriangleMeshDesc_get_sdfDesc_0 = Module['_emscripten_bind_PxTriangleMeshDesc_get_sdfDesc_0'] = createExportWrapper('emscripten_bind_PxTriangleMeshDesc_get_sdfDesc_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshDesc_set_sdfDesc_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshDesc_set_sdfDesc_1');
  _emscripten_bind_PxTriangleMeshDesc_set_sdfDesc_1 = Module['_emscripten_bind_PxTriangleMeshDesc_set_sdfDesc_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshDesc_set_sdfDesc_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshDesc_get_points_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshDesc_get_points_0');
  _emscripten_bind_PxTriangleMeshDesc_get_points_0 = Module['_emscripten_bind_PxTriangleMeshDesc_get_points_0'] = createExportWrapper('emscripten_bind_PxTriangleMeshDesc_get_points_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshDesc_set_points_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshDesc_set_points_1');
  _emscripten_bind_PxTriangleMeshDesc_set_points_1 = Module['_emscripten_bind_PxTriangleMeshDesc_set_points_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshDesc_set_points_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshDesc_get_triangles_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshDesc_get_triangles_0');
  _emscripten_bind_PxTriangleMeshDesc_get_triangles_0 = Module['_emscripten_bind_PxTriangleMeshDesc_get_triangles_0'] = createExportWrapper('emscripten_bind_PxTriangleMeshDesc_get_triangles_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshDesc_set_triangles_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshDesc_set_triangles_1');
  _emscripten_bind_PxTriangleMeshDesc_set_triangles_1 = Module['_emscripten_bind_PxTriangleMeshDesc_set_triangles_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshDesc_set_triangles_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshDesc_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshDesc_get_flags_0');
  _emscripten_bind_PxTriangleMeshDesc_get_flags_0 = Module['_emscripten_bind_PxTriangleMeshDesc_get_flags_0'] = createExportWrapper('emscripten_bind_PxTriangleMeshDesc_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshDesc_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshDesc_set_flags_1');
  _emscripten_bind_PxTriangleMeshDesc_set_flags_1 = Module['_emscripten_bind_PxTriangleMeshDesc_set_flags_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshDesc_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshDesc___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshDesc___destroy___0');
  _emscripten_bind_PxTriangleMeshDesc___destroy___0 = Module['_emscripten_bind_PxTriangleMeshDesc___destroy___0'] = createExportWrapper('emscripten_bind_PxTriangleMeshDesc___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshFlags_PxTriangleMeshFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshFlags_PxTriangleMeshFlags_1');
  _emscripten_bind_PxTriangleMeshFlags_PxTriangleMeshFlags_1 = Module['_emscripten_bind_PxTriangleMeshFlags_PxTriangleMeshFlags_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshFlags_PxTriangleMeshFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshFlags_isSet_1');
  _emscripten_bind_PxTriangleMeshFlags_isSet_1 = Module['_emscripten_bind_PxTriangleMeshFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshFlags_raise_1');
  _emscripten_bind_PxTriangleMeshFlags_raise_1 = Module['_emscripten_bind_PxTriangleMeshFlags_raise_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshFlags_clear_1');
  _emscripten_bind_PxTriangleMeshFlags_clear_1 = Module['_emscripten_bind_PxTriangleMeshFlags_clear_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshFlags___destroy___0');
  _emscripten_bind_PxTriangleMeshFlags___destroy___0 = Module['_emscripten_bind_PxTriangleMeshFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxTriangleMeshFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_1');
  _emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_1 = Module['_emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_2');
  _emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_2 = Module['_emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_2'] = createExportWrapper('emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_2', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_3');
  _emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_3 = Module['_emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_3'] = createExportWrapper('emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshGeometry_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshGeometry_isValid_0');
  _emscripten_bind_PxTriangleMeshGeometry_isValid_0 = Module['_emscripten_bind_PxTriangleMeshGeometry_isValid_0'] = createExportWrapper('emscripten_bind_PxTriangleMeshGeometry_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshGeometry_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshGeometry_getType_0');
  _emscripten_bind_PxTriangleMeshGeometry_getType_0 = Module['_emscripten_bind_PxTriangleMeshGeometry_getType_0'] = createExportWrapper('emscripten_bind_PxTriangleMeshGeometry_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshGeometry_get_scale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshGeometry_get_scale_0');
  _emscripten_bind_PxTriangleMeshGeometry_get_scale_0 = Module['_emscripten_bind_PxTriangleMeshGeometry_get_scale_0'] = createExportWrapper('emscripten_bind_PxTriangleMeshGeometry_get_scale_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshGeometry_set_scale_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshGeometry_set_scale_1');
  _emscripten_bind_PxTriangleMeshGeometry_set_scale_1 = Module['_emscripten_bind_PxTriangleMeshGeometry_set_scale_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshGeometry_set_scale_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshGeometry_get_meshFlags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshGeometry_get_meshFlags_0');
  _emscripten_bind_PxTriangleMeshGeometry_get_meshFlags_0 = Module['_emscripten_bind_PxTriangleMeshGeometry_get_meshFlags_0'] = createExportWrapper('emscripten_bind_PxTriangleMeshGeometry_get_meshFlags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshGeometry_set_meshFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshGeometry_set_meshFlags_1');
  _emscripten_bind_PxTriangleMeshGeometry_set_meshFlags_1 = Module['_emscripten_bind_PxTriangleMeshGeometry_set_meshFlags_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshGeometry_set_meshFlags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshGeometry_get_triangleMesh_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshGeometry_get_triangleMesh_0');
  _emscripten_bind_PxTriangleMeshGeometry_get_triangleMesh_0 = Module['_emscripten_bind_PxTriangleMeshGeometry_get_triangleMesh_0'] = createExportWrapper('emscripten_bind_PxTriangleMeshGeometry_get_triangleMesh_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshGeometry_set_triangleMesh_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshGeometry_set_triangleMesh_1');
  _emscripten_bind_PxTriangleMeshGeometry_set_triangleMesh_1 = Module['_emscripten_bind_PxTriangleMeshGeometry_set_triangleMesh_1'] = createExportWrapper('emscripten_bind_PxTriangleMeshGeometry_set_triangleMesh_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriangleMeshGeometry___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriangleMeshGeometry___destroy___0');
  _emscripten_bind_PxTriangleMeshGeometry___destroy___0 = Module['_emscripten_bind_PxTriangleMeshGeometry___destroy___0'] = createExportWrapper('emscripten_bind_PxTriangleMeshGeometry___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPair_get_triggerShape_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPair_get_triggerShape_0');
  _emscripten_bind_PxTriggerPair_get_triggerShape_0 = Module['_emscripten_bind_PxTriggerPair_get_triggerShape_0'] = createExportWrapper('emscripten_bind_PxTriggerPair_get_triggerShape_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPair_set_triggerShape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPair_set_triggerShape_1');
  _emscripten_bind_PxTriggerPair_set_triggerShape_1 = Module['_emscripten_bind_PxTriggerPair_set_triggerShape_1'] = createExportWrapper('emscripten_bind_PxTriggerPair_set_triggerShape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPair_get_triggerActor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPair_get_triggerActor_0');
  _emscripten_bind_PxTriggerPair_get_triggerActor_0 = Module['_emscripten_bind_PxTriggerPair_get_triggerActor_0'] = createExportWrapper('emscripten_bind_PxTriggerPair_get_triggerActor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPair_set_triggerActor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPair_set_triggerActor_1');
  _emscripten_bind_PxTriggerPair_set_triggerActor_1 = Module['_emscripten_bind_PxTriggerPair_set_triggerActor_1'] = createExportWrapper('emscripten_bind_PxTriggerPair_set_triggerActor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPair_get_otherShape_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPair_get_otherShape_0');
  _emscripten_bind_PxTriggerPair_get_otherShape_0 = Module['_emscripten_bind_PxTriggerPair_get_otherShape_0'] = createExportWrapper('emscripten_bind_PxTriggerPair_get_otherShape_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPair_set_otherShape_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPair_set_otherShape_1');
  _emscripten_bind_PxTriggerPair_set_otherShape_1 = Module['_emscripten_bind_PxTriggerPair_set_otherShape_1'] = createExportWrapper('emscripten_bind_PxTriggerPair_set_otherShape_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPair_get_otherActor_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPair_get_otherActor_0');
  _emscripten_bind_PxTriggerPair_get_otherActor_0 = Module['_emscripten_bind_PxTriggerPair_get_otherActor_0'] = createExportWrapper('emscripten_bind_PxTriggerPair_get_otherActor_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPair_set_otherActor_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPair_set_otherActor_1');
  _emscripten_bind_PxTriggerPair_set_otherActor_1 = Module['_emscripten_bind_PxTriggerPair_set_otherActor_1'] = createExportWrapper('emscripten_bind_PxTriggerPair_set_otherActor_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPair_get_status_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPair_get_status_0');
  _emscripten_bind_PxTriggerPair_get_status_0 = Module['_emscripten_bind_PxTriggerPair_get_status_0'] = createExportWrapper('emscripten_bind_PxTriggerPair_get_status_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPair_set_status_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPair_set_status_1');
  _emscripten_bind_PxTriggerPair_set_status_1 = Module['_emscripten_bind_PxTriggerPair_set_status_1'] = createExportWrapper('emscripten_bind_PxTriggerPair_set_status_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPair_get_flags_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPair_get_flags_0');
  _emscripten_bind_PxTriggerPair_get_flags_0 = Module['_emscripten_bind_PxTriggerPair_get_flags_0'] = createExportWrapper('emscripten_bind_PxTriggerPair_get_flags_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPair_set_flags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPair_set_flags_1');
  _emscripten_bind_PxTriggerPair_set_flags_1 = Module['_emscripten_bind_PxTriggerPair_set_flags_1'] = createExportWrapper('emscripten_bind_PxTriggerPair_set_flags_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPair___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPair___destroy___0');
  _emscripten_bind_PxTriggerPair___destroy___0 = Module['_emscripten_bind_PxTriggerPair___destroy___0'] = createExportWrapper('emscripten_bind_PxTriggerPair___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPairFlags_PxTriggerPairFlags_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPairFlags_PxTriggerPairFlags_1');
  _emscripten_bind_PxTriggerPairFlags_PxTriggerPairFlags_1 = Module['_emscripten_bind_PxTriggerPairFlags_PxTriggerPairFlags_1'] = createExportWrapper('emscripten_bind_PxTriggerPairFlags_PxTriggerPairFlags_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPairFlags_isSet_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPairFlags_isSet_1');
  _emscripten_bind_PxTriggerPairFlags_isSet_1 = Module['_emscripten_bind_PxTriggerPairFlags_isSet_1'] = createExportWrapper('emscripten_bind_PxTriggerPairFlags_isSet_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPairFlags_raise_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPairFlags_raise_1');
  _emscripten_bind_PxTriggerPairFlags_raise_1 = Module['_emscripten_bind_PxTriggerPairFlags_raise_1'] = createExportWrapper('emscripten_bind_PxTriggerPairFlags_raise_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPairFlags_clear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPairFlags_clear_1');
  _emscripten_bind_PxTriggerPairFlags_clear_1 = Module['_emscripten_bind_PxTriggerPairFlags_clear_1'] = createExportWrapper('emscripten_bind_PxTriggerPairFlags_clear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTriggerPairFlags___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTriggerPairFlags___destroy___0');
  _emscripten_bind_PxTriggerPairFlags___destroy___0 = Module['_emscripten_bind_PxTriggerPairFlags___destroy___0'] = createExportWrapper('emscripten_bind_PxTriggerPairFlags___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTypedBoundedData_PxU16_get_stride_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTypedBoundedData_PxU16_get_stride_0');
  _emscripten_bind_PxTypedBoundedData_PxU16_get_stride_0 = Module['_emscripten_bind_PxTypedBoundedData_PxU16_get_stride_0'] = createExportWrapper('emscripten_bind_PxTypedBoundedData_PxU16_get_stride_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTypedBoundedData_PxU16_set_stride_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTypedBoundedData_PxU16_set_stride_1');
  _emscripten_bind_PxTypedBoundedData_PxU16_set_stride_1 = Module['_emscripten_bind_PxTypedBoundedData_PxU16_set_stride_1'] = createExportWrapper('emscripten_bind_PxTypedBoundedData_PxU16_set_stride_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTypedBoundedData_PxU16_get_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTypedBoundedData_PxU16_get_data_0');
  _emscripten_bind_PxTypedBoundedData_PxU16_get_data_0 = Module['_emscripten_bind_PxTypedBoundedData_PxU16_get_data_0'] = createExportWrapper('emscripten_bind_PxTypedBoundedData_PxU16_get_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTypedBoundedData_PxU16_set_data_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTypedBoundedData_PxU16_set_data_1');
  _emscripten_bind_PxTypedBoundedData_PxU16_set_data_1 = Module['_emscripten_bind_PxTypedBoundedData_PxU16_set_data_1'] = createExportWrapper('emscripten_bind_PxTypedBoundedData_PxU16_set_data_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTypedBoundedData_PxU16___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTypedBoundedData_PxU16___destroy___0');
  _emscripten_bind_PxTypedBoundedData_PxU16___destroy___0 = Module['_emscripten_bind_PxTypedBoundedData_PxU16___destroy___0'] = createExportWrapper('emscripten_bind_PxTypedBoundedData_PxU16___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTypedBoundedData_PxU16Const_get_stride_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTypedBoundedData_PxU16Const_get_stride_0');
  _emscripten_bind_PxTypedBoundedData_PxU16Const_get_stride_0 = Module['_emscripten_bind_PxTypedBoundedData_PxU16Const_get_stride_0'] = createExportWrapper('emscripten_bind_PxTypedBoundedData_PxU16Const_get_stride_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTypedBoundedData_PxU16Const_set_stride_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTypedBoundedData_PxU16Const_set_stride_1');
  _emscripten_bind_PxTypedBoundedData_PxU16Const_set_stride_1 = Module['_emscripten_bind_PxTypedBoundedData_PxU16Const_set_stride_1'] = createExportWrapper('emscripten_bind_PxTypedBoundedData_PxU16Const_set_stride_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTypedBoundedData_PxU16Const_get_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTypedBoundedData_PxU16Const_get_data_0');
  _emscripten_bind_PxTypedBoundedData_PxU16Const_get_data_0 = Module['_emscripten_bind_PxTypedBoundedData_PxU16Const_get_data_0'] = createExportWrapper('emscripten_bind_PxTypedBoundedData_PxU16Const_get_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxTypedBoundedData_PxU16Const_set_data_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTypedBoundedData_PxU16Const_set_data_1');
  _emscripten_bind_PxTypedBoundedData_PxU16Const_set_data_1 = Module['_emscripten_bind_PxTypedBoundedData_PxU16Const_set_data_1'] = createExportWrapper('emscripten_bind_PxTypedBoundedData_PxU16Const_set_data_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxTypedBoundedData_PxU16Const___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxTypedBoundedData_PxU16Const___destroy___0');
  _emscripten_bind_PxTypedBoundedData_PxU16Const___destroy___0 = Module['_emscripten_bind_PxTypedBoundedData_PxU16Const___destroy___0'] = createExportWrapper('emscripten_bind_PxTypedBoundedData_PxU16Const___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxU16Ptr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxU16Ptr___destroy___0');
  _emscripten_bind_PxU16Ptr___destroy___0 = Module['_emscripten_bind_PxU16Ptr___destroy___0'] = createExportWrapper('emscripten_bind_PxU16Ptr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxU32Ptr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxU32Ptr___destroy___0');
  _emscripten_bind_PxU32Ptr___destroy___0 = Module['_emscripten_bind_PxU32Ptr___destroy___0'] = createExportWrapper('emscripten_bind_PxU32Ptr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxU8Ptr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxU8Ptr___destroy___0');
  _emscripten_bind_PxU8Ptr___destroy___0 = Module['_emscripten_bind_PxU8Ptr___destroy___0'] = createExportWrapper('emscripten_bind_PxU8Ptr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxUserControllerHitReportImpl_PxUserControllerHitReportImpl_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxUserControllerHitReportImpl_PxUserControllerHitReportImpl_0');
  _emscripten_bind_PxUserControllerHitReportImpl_PxUserControllerHitReportImpl_0 = Module['_emscripten_bind_PxUserControllerHitReportImpl_PxUserControllerHitReportImpl_0'] = createExportWrapper('emscripten_bind_PxUserControllerHitReportImpl_PxUserControllerHitReportImpl_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxUserControllerHitReportImpl_onShapeHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxUserControllerHitReportImpl_onShapeHit_1');
  _emscripten_bind_PxUserControllerHitReportImpl_onShapeHit_1 = Module['_emscripten_bind_PxUserControllerHitReportImpl_onShapeHit_1'] = createExportWrapper('emscripten_bind_PxUserControllerHitReportImpl_onShapeHit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxUserControllerHitReportImpl_onControllerHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxUserControllerHitReportImpl_onControllerHit_1');
  _emscripten_bind_PxUserControllerHitReportImpl_onControllerHit_1 = Module['_emscripten_bind_PxUserControllerHitReportImpl_onControllerHit_1'] = createExportWrapper('emscripten_bind_PxUserControllerHitReportImpl_onControllerHit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxUserControllerHitReportImpl_onObstacleHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxUserControllerHitReportImpl_onObstacleHit_1');
  _emscripten_bind_PxUserControllerHitReportImpl_onObstacleHit_1 = Module['_emscripten_bind_PxUserControllerHitReportImpl_onObstacleHit_1'] = createExportWrapper('emscripten_bind_PxUserControllerHitReportImpl_onObstacleHit_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxUserControllerHitReportImpl___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxUserControllerHitReportImpl___destroy___0');
  _emscripten_bind_PxUserControllerHitReportImpl___destroy___0 = Module['_emscripten_bind_PxUserControllerHitReportImpl___destroy___0'] = createExportWrapper('emscripten_bind_PxUserControllerHitReportImpl___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_PxVec3_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_PxVec3_0');
  _emscripten_bind_PxVec3_PxVec3_0 = Module['_emscripten_bind_PxVec3_PxVec3_0'] = createExportWrapper('emscripten_bind_PxVec3_PxVec3_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVec3_PxVec3_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_PxVec3_3');
  _emscripten_bind_PxVec3_PxVec3_3 = Module['_emscripten_bind_PxVec3_PxVec3_3'] = createExportWrapper('emscripten_bind_PxVec3_PxVec3_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxVec3_isZero_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_isZero_0');
  _emscripten_bind_PxVec3_isZero_0 = Module['_emscripten_bind_PxVec3_isZero_0'] = createExportWrapper('emscripten_bind_PxVec3_isZero_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_isFinite_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_isFinite_0');
  _emscripten_bind_PxVec3_isFinite_0 = Module['_emscripten_bind_PxVec3_isFinite_0'] = createExportWrapper('emscripten_bind_PxVec3_isFinite_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_isNormalized_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_isNormalized_0');
  _emscripten_bind_PxVec3_isNormalized_0 = Module['_emscripten_bind_PxVec3_isNormalized_0'] = createExportWrapper('emscripten_bind_PxVec3_isNormalized_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_magnitudeSquared_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_magnitudeSquared_0');
  _emscripten_bind_PxVec3_magnitudeSquared_0 = Module['_emscripten_bind_PxVec3_magnitudeSquared_0'] = createExportWrapper('emscripten_bind_PxVec3_magnitudeSquared_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_magnitude_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_magnitude_0');
  _emscripten_bind_PxVec3_magnitude_0 = Module['_emscripten_bind_PxVec3_magnitude_0'] = createExportWrapper('emscripten_bind_PxVec3_magnitude_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_dot_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_dot_1');
  _emscripten_bind_PxVec3_dot_1 = Module['_emscripten_bind_PxVec3_dot_1'] = createExportWrapper('emscripten_bind_PxVec3_dot_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec3_cross_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_cross_1');
  _emscripten_bind_PxVec3_cross_1 = Module['_emscripten_bind_PxVec3_cross_1'] = createExportWrapper('emscripten_bind_PxVec3_cross_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec3_getNormalized_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_getNormalized_0');
  _emscripten_bind_PxVec3_getNormalized_0 = Module['_emscripten_bind_PxVec3_getNormalized_0'] = createExportWrapper('emscripten_bind_PxVec3_getNormalized_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_normalize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_normalize_0');
  _emscripten_bind_PxVec3_normalize_0 = Module['_emscripten_bind_PxVec3_normalize_0'] = createExportWrapper('emscripten_bind_PxVec3_normalize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_normalizeSafe_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_normalizeSafe_0');
  _emscripten_bind_PxVec3_normalizeSafe_0 = Module['_emscripten_bind_PxVec3_normalizeSafe_0'] = createExportWrapper('emscripten_bind_PxVec3_normalizeSafe_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_normalizeFast_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_normalizeFast_0');
  _emscripten_bind_PxVec3_normalizeFast_0 = Module['_emscripten_bind_PxVec3_normalizeFast_0'] = createExportWrapper('emscripten_bind_PxVec3_normalizeFast_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_multiply_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_multiply_1');
  _emscripten_bind_PxVec3_multiply_1 = Module['_emscripten_bind_PxVec3_multiply_1'] = createExportWrapper('emscripten_bind_PxVec3_multiply_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec3_minimum_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_minimum_1');
  _emscripten_bind_PxVec3_minimum_1 = Module['_emscripten_bind_PxVec3_minimum_1'] = createExportWrapper('emscripten_bind_PxVec3_minimum_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec3_minElement_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_minElement_0');
  _emscripten_bind_PxVec3_minElement_0 = Module['_emscripten_bind_PxVec3_minElement_0'] = createExportWrapper('emscripten_bind_PxVec3_minElement_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_maximum_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_maximum_1');
  _emscripten_bind_PxVec3_maximum_1 = Module['_emscripten_bind_PxVec3_maximum_1'] = createExportWrapper('emscripten_bind_PxVec3_maximum_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec3_maxElement_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_maxElement_0');
  _emscripten_bind_PxVec3_maxElement_0 = Module['_emscripten_bind_PxVec3_maxElement_0'] = createExportWrapper('emscripten_bind_PxVec3_maxElement_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_abs_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_abs_0');
  _emscripten_bind_PxVec3_abs_0 = Module['_emscripten_bind_PxVec3_abs_0'] = createExportWrapper('emscripten_bind_PxVec3_abs_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_get_x_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_get_x_0');
  _emscripten_bind_PxVec3_get_x_0 = Module['_emscripten_bind_PxVec3_get_x_0'] = createExportWrapper('emscripten_bind_PxVec3_get_x_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_set_x_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_set_x_1');
  _emscripten_bind_PxVec3_set_x_1 = Module['_emscripten_bind_PxVec3_set_x_1'] = createExportWrapper('emscripten_bind_PxVec3_set_x_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec3_get_y_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_get_y_0');
  _emscripten_bind_PxVec3_get_y_0 = Module['_emscripten_bind_PxVec3_get_y_0'] = createExportWrapper('emscripten_bind_PxVec3_get_y_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_set_y_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_set_y_1');
  _emscripten_bind_PxVec3_set_y_1 = Module['_emscripten_bind_PxVec3_set_y_1'] = createExportWrapper('emscripten_bind_PxVec3_set_y_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec3_get_z_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_get_z_0');
  _emscripten_bind_PxVec3_get_z_0 = Module['_emscripten_bind_PxVec3_get_z_0'] = createExportWrapper('emscripten_bind_PxVec3_get_z_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec3_set_z_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3_set_z_1');
  _emscripten_bind_PxVec3_set_z_1 = Module['_emscripten_bind_PxVec3_set_z_1'] = createExportWrapper('emscripten_bind_PxVec3_set_z_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec3___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec3___destroy___0');
  _emscripten_bind_PxVec3___destroy___0 = Module['_emscripten_bind_PxVec3___destroy___0'] = createExportWrapper('emscripten_bind_PxVec3___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec4_PxVec4_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_PxVec4_0');
  _emscripten_bind_PxVec4_PxVec4_0 = Module['_emscripten_bind_PxVec4_PxVec4_0'] = createExportWrapper('emscripten_bind_PxVec4_PxVec4_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVec4_PxVec4_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_PxVec4_4');
  _emscripten_bind_PxVec4_PxVec4_4 = Module['_emscripten_bind_PxVec4_PxVec4_4'] = createExportWrapper('emscripten_bind_PxVec4_PxVec4_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxVec4_isZero_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_isZero_0');
  _emscripten_bind_PxVec4_isZero_0 = Module['_emscripten_bind_PxVec4_isZero_0'] = createExportWrapper('emscripten_bind_PxVec4_isZero_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec4_isFinite_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_isFinite_0');
  _emscripten_bind_PxVec4_isFinite_0 = Module['_emscripten_bind_PxVec4_isFinite_0'] = createExportWrapper('emscripten_bind_PxVec4_isFinite_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec4_isNormalized_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_isNormalized_0');
  _emscripten_bind_PxVec4_isNormalized_0 = Module['_emscripten_bind_PxVec4_isNormalized_0'] = createExportWrapper('emscripten_bind_PxVec4_isNormalized_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec4_magnitudeSquared_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_magnitudeSquared_0');
  _emscripten_bind_PxVec4_magnitudeSquared_0 = Module['_emscripten_bind_PxVec4_magnitudeSquared_0'] = createExportWrapper('emscripten_bind_PxVec4_magnitudeSquared_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec4_magnitude_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_magnitude_0');
  _emscripten_bind_PxVec4_magnitude_0 = Module['_emscripten_bind_PxVec4_magnitude_0'] = createExportWrapper('emscripten_bind_PxVec4_magnitude_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec4_dot_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_dot_1');
  _emscripten_bind_PxVec4_dot_1 = Module['_emscripten_bind_PxVec4_dot_1'] = createExportWrapper('emscripten_bind_PxVec4_dot_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec4_getNormalized_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_getNormalized_0');
  _emscripten_bind_PxVec4_getNormalized_0 = Module['_emscripten_bind_PxVec4_getNormalized_0'] = createExportWrapper('emscripten_bind_PxVec4_getNormalized_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec4_normalize_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_normalize_0');
  _emscripten_bind_PxVec4_normalize_0 = Module['_emscripten_bind_PxVec4_normalize_0'] = createExportWrapper('emscripten_bind_PxVec4_normalize_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec4_multiply_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_multiply_1');
  _emscripten_bind_PxVec4_multiply_1 = Module['_emscripten_bind_PxVec4_multiply_1'] = createExportWrapper('emscripten_bind_PxVec4_multiply_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec4_minimum_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_minimum_1');
  _emscripten_bind_PxVec4_minimum_1 = Module['_emscripten_bind_PxVec4_minimum_1'] = createExportWrapper('emscripten_bind_PxVec4_minimum_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec4_maximum_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_maximum_1');
  _emscripten_bind_PxVec4_maximum_1 = Module['_emscripten_bind_PxVec4_maximum_1'] = createExportWrapper('emscripten_bind_PxVec4_maximum_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec4_getXYZ_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_getXYZ_0');
  _emscripten_bind_PxVec4_getXYZ_0 = Module['_emscripten_bind_PxVec4_getXYZ_0'] = createExportWrapper('emscripten_bind_PxVec4_getXYZ_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec4_get_x_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_get_x_0');
  _emscripten_bind_PxVec4_get_x_0 = Module['_emscripten_bind_PxVec4_get_x_0'] = createExportWrapper('emscripten_bind_PxVec4_get_x_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec4_set_x_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_set_x_1');
  _emscripten_bind_PxVec4_set_x_1 = Module['_emscripten_bind_PxVec4_set_x_1'] = createExportWrapper('emscripten_bind_PxVec4_set_x_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec4_get_y_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_get_y_0');
  _emscripten_bind_PxVec4_get_y_0 = Module['_emscripten_bind_PxVec4_get_y_0'] = createExportWrapper('emscripten_bind_PxVec4_get_y_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec4_set_y_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_set_y_1');
  _emscripten_bind_PxVec4_set_y_1 = Module['_emscripten_bind_PxVec4_set_y_1'] = createExportWrapper('emscripten_bind_PxVec4_set_y_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec4_get_z_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_get_z_0');
  _emscripten_bind_PxVec4_get_z_0 = Module['_emscripten_bind_PxVec4_get_z_0'] = createExportWrapper('emscripten_bind_PxVec4_get_z_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec4_set_z_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_set_z_1');
  _emscripten_bind_PxVec4_set_z_1 = Module['_emscripten_bind_PxVec4_set_z_1'] = createExportWrapper('emscripten_bind_PxVec4_set_z_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec4_get_w_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_get_w_0');
  _emscripten_bind_PxVec4_get_w_0 = Module['_emscripten_bind_PxVec4_get_w_0'] = createExportWrapper('emscripten_bind_PxVec4_get_w_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVec4_set_w_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4_set_w_1');
  _emscripten_bind_PxVec4_set_w_1 = Module['_emscripten_bind_PxVec4_set_w_1'] = createExportWrapper('emscripten_bind_PxVec4_set_w_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVec4___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVec4___destroy___0');
  _emscripten_bind_PxVec4___destroy___0 = Module['_emscripten_bind_PxVec4___destroy___0'] = createExportWrapper('emscripten_bind_PxVec4___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAckermannParams_PxVehicleAckermannParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAckermannParams_PxVehicleAckermannParams_0');
  _emscripten_bind_PxVehicleAckermannParams_PxVehicleAckermannParams_0 = Module['_emscripten_bind_PxVehicleAckermannParams_PxVehicleAckermannParams_0'] = createExportWrapper('emscripten_bind_PxVehicleAckermannParams_PxVehicleAckermannParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAckermannParams_isValid_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAckermannParams_isValid_1');
  _emscripten_bind_PxVehicleAckermannParams_isValid_1 = Module['_emscripten_bind_PxVehicleAckermannParams_isValid_1'] = createExportWrapper('emscripten_bind_PxVehicleAckermannParams_isValid_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAckermannParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAckermannParams_transformAndScale_4');
  _emscripten_bind_PxVehicleAckermannParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleAckermannParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleAckermannParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAckermannParams_get_wheelIds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAckermannParams_get_wheelIds_1');
  _emscripten_bind_PxVehicleAckermannParams_get_wheelIds_1 = Module['_emscripten_bind_PxVehicleAckermannParams_get_wheelIds_1'] = createExportWrapper('emscripten_bind_PxVehicleAckermannParams_get_wheelIds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAckermannParams_set_wheelIds_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAckermannParams_set_wheelIds_2');
  _emscripten_bind_PxVehicleAckermannParams_set_wheelIds_2 = Module['_emscripten_bind_PxVehicleAckermannParams_set_wheelIds_2'] = createExportWrapper('emscripten_bind_PxVehicleAckermannParams_set_wheelIds_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAckermannParams_get_wheelBase_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAckermannParams_get_wheelBase_0');
  _emscripten_bind_PxVehicleAckermannParams_get_wheelBase_0 = Module['_emscripten_bind_PxVehicleAckermannParams_get_wheelBase_0'] = createExportWrapper('emscripten_bind_PxVehicleAckermannParams_get_wheelBase_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAckermannParams_set_wheelBase_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAckermannParams_set_wheelBase_1');
  _emscripten_bind_PxVehicleAckermannParams_set_wheelBase_1 = Module['_emscripten_bind_PxVehicleAckermannParams_set_wheelBase_1'] = createExportWrapper('emscripten_bind_PxVehicleAckermannParams_set_wheelBase_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAckermannParams_get_trackWidth_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAckermannParams_get_trackWidth_0');
  _emscripten_bind_PxVehicleAckermannParams_get_trackWidth_0 = Module['_emscripten_bind_PxVehicleAckermannParams_get_trackWidth_0'] = createExportWrapper('emscripten_bind_PxVehicleAckermannParams_get_trackWidth_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAckermannParams_set_trackWidth_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAckermannParams_set_trackWidth_1');
  _emscripten_bind_PxVehicleAckermannParams_set_trackWidth_1 = Module['_emscripten_bind_PxVehicleAckermannParams_set_trackWidth_1'] = createExportWrapper('emscripten_bind_PxVehicleAckermannParams_set_trackWidth_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAckermannParams_get_strength_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAckermannParams_get_strength_0');
  _emscripten_bind_PxVehicleAckermannParams_get_strength_0 = Module['_emscripten_bind_PxVehicleAckermannParams_get_strength_0'] = createExportWrapper('emscripten_bind_PxVehicleAckermannParams_get_strength_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAckermannParams_set_strength_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAckermannParams_set_strength_1');
  _emscripten_bind_PxVehicleAckermannParams_set_strength_1 = Module['_emscripten_bind_PxVehicleAckermannParams_set_strength_1'] = createExportWrapper('emscripten_bind_PxVehicleAckermannParams_set_strength_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAckermannParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAckermannParams___destroy___0');
  _emscripten_bind_PxVehicleAckermannParams___destroy___0 = Module['_emscripten_bind_PxVehicleAckermannParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleAckermannParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollForceParams_PxVehicleAntiRollForceParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollForceParams_PxVehicleAntiRollForceParams_0');
  _emscripten_bind_PxVehicleAntiRollForceParams_PxVehicleAntiRollForceParams_0 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_PxVehicleAntiRollForceParams_0'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollForceParams_PxVehicleAntiRollForceParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollForceParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollForceParams_transformAndScale_4');
  _emscripten_bind_PxVehicleAntiRollForceParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollForceParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollForceParams_isValid_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollForceParams_isValid_1');
  _emscripten_bind_PxVehicleAntiRollForceParams_isValid_1 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_isValid_1'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollForceParams_isValid_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollForceParams_get_wheel0_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollForceParams_get_wheel0_0');
  _emscripten_bind_PxVehicleAntiRollForceParams_get_wheel0_0 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_get_wheel0_0'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollForceParams_get_wheel0_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollForceParams_set_wheel0_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollForceParams_set_wheel0_1');
  _emscripten_bind_PxVehicleAntiRollForceParams_set_wheel0_1 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_set_wheel0_1'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollForceParams_set_wheel0_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollForceParams_get_wheel1_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollForceParams_get_wheel1_0');
  _emscripten_bind_PxVehicleAntiRollForceParams_get_wheel1_0 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_get_wheel1_0'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollForceParams_get_wheel1_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollForceParams_set_wheel1_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollForceParams_set_wheel1_1');
  _emscripten_bind_PxVehicleAntiRollForceParams_set_wheel1_1 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_set_wheel1_1'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollForceParams_set_wheel1_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollForceParams_get_stiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollForceParams_get_stiffness_0');
  _emscripten_bind_PxVehicleAntiRollForceParams_get_stiffness_0 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_get_stiffness_0'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollForceParams_get_stiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollForceParams_set_stiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollForceParams_set_stiffness_1');
  _emscripten_bind_PxVehicleAntiRollForceParams_set_stiffness_1 = Module['_emscripten_bind_PxVehicleAntiRollForceParams_set_stiffness_1'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollForceParams_set_stiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollForceParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollForceParams___destroy___0');
  _emscripten_bind_PxVehicleAntiRollForceParams___destroy___0 = Module['_emscripten_bind_PxVehicleAntiRollForceParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollForceParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollTorque_PxVehicleAntiRollTorque_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollTorque_PxVehicleAntiRollTorque_0');
  _emscripten_bind_PxVehicleAntiRollTorque_PxVehicleAntiRollTorque_0 = Module['_emscripten_bind_PxVehicleAntiRollTorque_PxVehicleAntiRollTorque_0'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollTorque_PxVehicleAntiRollTorque_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollTorque_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollTorque_setToDefault_0');
  _emscripten_bind_PxVehicleAntiRollTorque_setToDefault_0 = Module['_emscripten_bind_PxVehicleAntiRollTorque_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollTorque_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollTorque_get_antiRollTorque_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollTorque_get_antiRollTorque_0');
  _emscripten_bind_PxVehicleAntiRollTorque_get_antiRollTorque_0 = Module['_emscripten_bind_PxVehicleAntiRollTorque_get_antiRollTorque_0'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollTorque_get_antiRollTorque_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollTorque_set_antiRollTorque_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollTorque_set_antiRollTorque_1');
  _emscripten_bind_PxVehicleAntiRollTorque_set_antiRollTorque_1 = Module['_emscripten_bind_PxVehicleAntiRollTorque_set_antiRollTorque_1'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollTorque_set_antiRollTorque_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAntiRollTorque___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAntiRollTorque___destroy___0');
  _emscripten_bind_PxVehicleAntiRollTorque___destroy___0 = Module['_emscripten_bind_PxVehicleAntiRollTorque___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleAntiRollTorque___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxParams_PxVehicleAutoboxParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxParams_PxVehicleAutoboxParams_0');
  _emscripten_bind_PxVehicleAutoboxParams_PxVehicleAutoboxParams_0 = Module['_emscripten_bind_PxVehicleAutoboxParams_PxVehicleAutoboxParams_0'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxParams_PxVehicleAutoboxParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxParams_transformAndScale_4');
  _emscripten_bind_PxVehicleAutoboxParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleAutoboxParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxParams_isValid_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxParams_isValid_1');
  _emscripten_bind_PxVehicleAutoboxParams_isValid_1 = Module['_emscripten_bind_PxVehicleAutoboxParams_isValid_1'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxParams_isValid_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxParams_get_upRatios_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxParams_get_upRatios_1');
  _emscripten_bind_PxVehicleAutoboxParams_get_upRatios_1 = Module['_emscripten_bind_PxVehicleAutoboxParams_get_upRatios_1'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxParams_get_upRatios_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxParams_set_upRatios_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxParams_set_upRatios_2');
  _emscripten_bind_PxVehicleAutoboxParams_set_upRatios_2 = Module['_emscripten_bind_PxVehicleAutoboxParams_set_upRatios_2'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxParams_set_upRatios_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxParams_get_downRatios_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxParams_get_downRatios_1');
  _emscripten_bind_PxVehicleAutoboxParams_get_downRatios_1 = Module['_emscripten_bind_PxVehicleAutoboxParams_get_downRatios_1'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxParams_get_downRatios_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxParams_set_downRatios_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxParams_set_downRatios_2');
  _emscripten_bind_PxVehicleAutoboxParams_set_downRatios_2 = Module['_emscripten_bind_PxVehicleAutoboxParams_set_downRatios_2'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxParams_set_downRatios_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxParams_get_latency_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxParams_get_latency_0');
  _emscripten_bind_PxVehicleAutoboxParams_get_latency_0 = Module['_emscripten_bind_PxVehicleAutoboxParams_get_latency_0'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxParams_get_latency_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxParams_set_latency_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxParams_set_latency_1');
  _emscripten_bind_PxVehicleAutoboxParams_set_latency_1 = Module['_emscripten_bind_PxVehicleAutoboxParams_set_latency_1'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxParams_set_latency_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxParams___destroy___0');
  _emscripten_bind_PxVehicleAutoboxParams___destroy___0 = Module['_emscripten_bind_PxVehicleAutoboxParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxState_PxVehicleAutoboxState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxState_PxVehicleAutoboxState_0');
  _emscripten_bind_PxVehicleAutoboxState_PxVehicleAutoboxState_0 = Module['_emscripten_bind_PxVehicleAutoboxState_PxVehicleAutoboxState_0'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxState_PxVehicleAutoboxState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxState_setToDefault_0');
  _emscripten_bind_PxVehicleAutoboxState_setToDefault_0 = Module['_emscripten_bind_PxVehicleAutoboxState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxState_get_timeSinceLastShift_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxState_get_timeSinceLastShift_0');
  _emscripten_bind_PxVehicleAutoboxState_get_timeSinceLastShift_0 = Module['_emscripten_bind_PxVehicleAutoboxState_get_timeSinceLastShift_0'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxState_get_timeSinceLastShift_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxState_set_timeSinceLastShift_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxState_set_timeSinceLastShift_1');
  _emscripten_bind_PxVehicleAutoboxState_set_timeSinceLastShift_1 = Module['_emscripten_bind_PxVehicleAutoboxState_set_timeSinceLastShift_1'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxState_set_timeSinceLastShift_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxState_get_activeAutoboxGearShift_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxState_get_activeAutoboxGearShift_0');
  _emscripten_bind_PxVehicleAutoboxState_get_activeAutoboxGearShift_0 = Module['_emscripten_bind_PxVehicleAutoboxState_get_activeAutoboxGearShift_0'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxState_get_activeAutoboxGearShift_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxState_set_activeAutoboxGearShift_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxState_set_activeAutoboxGearShift_1');
  _emscripten_bind_PxVehicleAutoboxState_set_activeAutoboxGearShift_1 = Module['_emscripten_bind_PxVehicleAutoboxState_set_activeAutoboxGearShift_1'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxState_set_activeAutoboxGearShift_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAutoboxState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAutoboxState___destroy___0');
  _emscripten_bind_PxVehicleAutoboxState___destroy___0 = Module['_emscripten_bind_PxVehicleAutoboxState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleAutoboxState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_PxVehicleAxleDescription_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_PxVehicleAxleDescription_0');
  _emscripten_bind_PxVehicleAxleDescription_PxVehicleAxleDescription_0 = Module['_emscripten_bind_PxVehicleAxleDescription_PxVehicleAxleDescription_0'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_PxVehicleAxleDescription_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_setToDefault_0');
  _emscripten_bind_PxVehicleAxleDescription_setToDefault_0 = Module['_emscripten_bind_PxVehicleAxleDescription_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_getNbWheelsOnAxle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_getNbWheelsOnAxle_1');
  _emscripten_bind_PxVehicleAxleDescription_getNbWheelsOnAxle_1 = Module['_emscripten_bind_PxVehicleAxleDescription_getNbWheelsOnAxle_1'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_getNbWheelsOnAxle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_getWheelOnAxle_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_getWheelOnAxle_2');
  _emscripten_bind_PxVehicleAxleDescription_getWheelOnAxle_2 = Module['_emscripten_bind_PxVehicleAxleDescription_getWheelOnAxle_2'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_getWheelOnAxle_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_getAxle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_getAxle_1');
  _emscripten_bind_PxVehicleAxleDescription_getAxle_1 = Module['_emscripten_bind_PxVehicleAxleDescription_getAxle_1'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_getAxle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_isValid_0');
  _emscripten_bind_PxVehicleAxleDescription_isValid_0 = Module['_emscripten_bind_PxVehicleAxleDescription_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_get_nbAxles_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_get_nbAxles_0');
  _emscripten_bind_PxVehicleAxleDescription_get_nbAxles_0 = Module['_emscripten_bind_PxVehicleAxleDescription_get_nbAxles_0'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_get_nbAxles_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_set_nbAxles_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_set_nbAxles_1');
  _emscripten_bind_PxVehicleAxleDescription_set_nbAxles_1 = Module['_emscripten_bind_PxVehicleAxleDescription_set_nbAxles_1'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_set_nbAxles_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_get_nbWheelsPerAxle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_get_nbWheelsPerAxle_1');
  _emscripten_bind_PxVehicleAxleDescription_get_nbWheelsPerAxle_1 = Module['_emscripten_bind_PxVehicleAxleDescription_get_nbWheelsPerAxle_1'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_get_nbWheelsPerAxle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_set_nbWheelsPerAxle_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_set_nbWheelsPerAxle_2');
  _emscripten_bind_PxVehicleAxleDescription_set_nbWheelsPerAxle_2 = Module['_emscripten_bind_PxVehicleAxleDescription_set_nbWheelsPerAxle_2'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_set_nbWheelsPerAxle_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_get_axleToWheelIds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_get_axleToWheelIds_1');
  _emscripten_bind_PxVehicleAxleDescription_get_axleToWheelIds_1 = Module['_emscripten_bind_PxVehicleAxleDescription_get_axleToWheelIds_1'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_get_axleToWheelIds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_set_axleToWheelIds_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_set_axleToWheelIds_2');
  _emscripten_bind_PxVehicleAxleDescription_set_axleToWheelIds_2 = Module['_emscripten_bind_PxVehicleAxleDescription_set_axleToWheelIds_2'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_set_axleToWheelIds_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_get_wheelIdsInAxleOrder_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_get_wheelIdsInAxleOrder_1');
  _emscripten_bind_PxVehicleAxleDescription_get_wheelIdsInAxleOrder_1 = Module['_emscripten_bind_PxVehicleAxleDescription_get_wheelIdsInAxleOrder_1'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_get_wheelIdsInAxleOrder_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_set_wheelIdsInAxleOrder_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_set_wheelIdsInAxleOrder_2');
  _emscripten_bind_PxVehicleAxleDescription_set_wheelIdsInAxleOrder_2 = Module['_emscripten_bind_PxVehicleAxleDescription_set_wheelIdsInAxleOrder_2'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_set_wheelIdsInAxleOrder_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_get_nbWheels_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_get_nbWheels_0');
  _emscripten_bind_PxVehicleAxleDescription_get_nbWheels_0 = Module['_emscripten_bind_PxVehicleAxleDescription_get_nbWheels_0'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_get_nbWheels_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription_set_nbWheels_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription_set_nbWheels_1');
  _emscripten_bind_PxVehicleAxleDescription_set_nbWheels_1 = Module['_emscripten_bind_PxVehicleAxleDescription_set_nbWheels_1'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription_set_nbWheels_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleAxleDescription___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleAxleDescription___destroy___0');
  _emscripten_bind_PxVehicleAxleDescription___destroy___0 = Module['_emscripten_bind_PxVehicleAxleDescription___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleAxleDescription___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleBrakeCommandResponseParams_PxVehicleBrakeCommandResponseParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleBrakeCommandResponseParams_PxVehicleBrakeCommandResponseParams_0');
  _emscripten_bind_PxVehicleBrakeCommandResponseParams_PxVehicleBrakeCommandResponseParams_0 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_PxVehicleBrakeCommandResponseParams_0'] = createExportWrapper('emscripten_bind_PxVehicleBrakeCommandResponseParams_PxVehicleBrakeCommandResponseParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleBrakeCommandResponseParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleBrakeCommandResponseParams_transformAndScale_4');
  _emscripten_bind_PxVehicleBrakeCommandResponseParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleBrakeCommandResponseParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleBrakeCommandResponseParams_isValid_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleBrakeCommandResponseParams_isValid_1');
  _emscripten_bind_PxVehicleBrakeCommandResponseParams_isValid_1 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_isValid_1'] = createExportWrapper('emscripten_bind_PxVehicleBrakeCommandResponseParams_isValid_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleBrakeCommandResponseParams_get_nonlinearResponse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleBrakeCommandResponseParams_get_nonlinearResponse_0');
  _emscripten_bind_PxVehicleBrakeCommandResponseParams_get_nonlinearResponse_0 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_get_nonlinearResponse_0'] = createExportWrapper('emscripten_bind_PxVehicleBrakeCommandResponseParams_get_nonlinearResponse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleBrakeCommandResponseParams_set_nonlinearResponse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleBrakeCommandResponseParams_set_nonlinearResponse_1');
  _emscripten_bind_PxVehicleBrakeCommandResponseParams_set_nonlinearResponse_1 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_set_nonlinearResponse_1'] = createExportWrapper('emscripten_bind_PxVehicleBrakeCommandResponseParams_set_nonlinearResponse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleBrakeCommandResponseParams_get_wheelResponseMultipliers_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleBrakeCommandResponseParams_get_wheelResponseMultipliers_1');
  _emscripten_bind_PxVehicleBrakeCommandResponseParams_get_wheelResponseMultipliers_1 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_get_wheelResponseMultipliers_1'] = createExportWrapper('emscripten_bind_PxVehicleBrakeCommandResponseParams_get_wheelResponseMultipliers_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleBrakeCommandResponseParams_set_wheelResponseMultipliers_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleBrakeCommandResponseParams_set_wheelResponseMultipliers_2');
  _emscripten_bind_PxVehicleBrakeCommandResponseParams_set_wheelResponseMultipliers_2 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_set_wheelResponseMultipliers_2'] = createExportWrapper('emscripten_bind_PxVehicleBrakeCommandResponseParams_set_wheelResponseMultipliers_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleBrakeCommandResponseParams_get_maxResponse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleBrakeCommandResponseParams_get_maxResponse_0');
  _emscripten_bind_PxVehicleBrakeCommandResponseParams_get_maxResponse_0 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_get_maxResponse_0'] = createExportWrapper('emscripten_bind_PxVehicleBrakeCommandResponseParams_get_maxResponse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleBrakeCommandResponseParams_set_maxResponse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleBrakeCommandResponseParams_set_maxResponse_1');
  _emscripten_bind_PxVehicleBrakeCommandResponseParams_set_maxResponse_1 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams_set_maxResponse_1'] = createExportWrapper('emscripten_bind_PxVehicleBrakeCommandResponseParams_set_maxResponse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleBrakeCommandResponseParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleBrakeCommandResponseParams___destroy___0');
  _emscripten_bind_PxVehicleBrakeCommandResponseParams___destroy___0 = Module['_emscripten_bind_PxVehicleBrakeCommandResponseParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleBrakeCommandResponseParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchCommandResponseParams_PxVehicleClutchCommandResponseParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchCommandResponseParams_PxVehicleClutchCommandResponseParams_0');
  _emscripten_bind_PxVehicleClutchCommandResponseParams_PxVehicleClutchCommandResponseParams_0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseParams_PxVehicleClutchCommandResponseParams_0'] = createExportWrapper('emscripten_bind_PxVehicleClutchCommandResponseParams_PxVehicleClutchCommandResponseParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchCommandResponseParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchCommandResponseParams_transformAndScale_4');
  _emscripten_bind_PxVehicleClutchCommandResponseParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleClutchCommandResponseParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleClutchCommandResponseParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchCommandResponseParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchCommandResponseParams_isValid_0');
  _emscripten_bind_PxVehicleClutchCommandResponseParams_isValid_0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleClutchCommandResponseParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchCommandResponseParams_get_maxResponse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchCommandResponseParams_get_maxResponse_0');
  _emscripten_bind_PxVehicleClutchCommandResponseParams_get_maxResponse_0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseParams_get_maxResponse_0'] = createExportWrapper('emscripten_bind_PxVehicleClutchCommandResponseParams_get_maxResponse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchCommandResponseParams_set_maxResponse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchCommandResponseParams_set_maxResponse_1');
  _emscripten_bind_PxVehicleClutchCommandResponseParams_set_maxResponse_1 = Module['_emscripten_bind_PxVehicleClutchCommandResponseParams_set_maxResponse_1'] = createExportWrapper('emscripten_bind_PxVehicleClutchCommandResponseParams_set_maxResponse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchCommandResponseParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchCommandResponseParams___destroy___0');
  _emscripten_bind_PxVehicleClutchCommandResponseParams___destroy___0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleClutchCommandResponseParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchCommandResponseState_PxVehicleClutchCommandResponseState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchCommandResponseState_PxVehicleClutchCommandResponseState_0');
  _emscripten_bind_PxVehicleClutchCommandResponseState_PxVehicleClutchCommandResponseState_0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseState_PxVehicleClutchCommandResponseState_0'] = createExportWrapper('emscripten_bind_PxVehicleClutchCommandResponseState_PxVehicleClutchCommandResponseState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchCommandResponseState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchCommandResponseState_setToDefault_0');
  _emscripten_bind_PxVehicleClutchCommandResponseState_setToDefault_0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleClutchCommandResponseState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchCommandResponseState_get_normalisedCommandResponse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchCommandResponseState_get_normalisedCommandResponse_0');
  _emscripten_bind_PxVehicleClutchCommandResponseState_get_normalisedCommandResponse_0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseState_get_normalisedCommandResponse_0'] = createExportWrapper('emscripten_bind_PxVehicleClutchCommandResponseState_get_normalisedCommandResponse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchCommandResponseState_set_normalisedCommandResponse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchCommandResponseState_set_normalisedCommandResponse_1');
  _emscripten_bind_PxVehicleClutchCommandResponseState_set_normalisedCommandResponse_1 = Module['_emscripten_bind_PxVehicleClutchCommandResponseState_set_normalisedCommandResponse_1'] = createExportWrapper('emscripten_bind_PxVehicleClutchCommandResponseState_set_normalisedCommandResponse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchCommandResponseState_get_commandResponse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchCommandResponseState_get_commandResponse_0');
  _emscripten_bind_PxVehicleClutchCommandResponseState_get_commandResponse_0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseState_get_commandResponse_0'] = createExportWrapper('emscripten_bind_PxVehicleClutchCommandResponseState_get_commandResponse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchCommandResponseState_set_commandResponse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchCommandResponseState_set_commandResponse_1');
  _emscripten_bind_PxVehicleClutchCommandResponseState_set_commandResponse_1 = Module['_emscripten_bind_PxVehicleClutchCommandResponseState_set_commandResponse_1'] = createExportWrapper('emscripten_bind_PxVehicleClutchCommandResponseState_set_commandResponse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchCommandResponseState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchCommandResponseState___destroy___0');
  _emscripten_bind_PxVehicleClutchCommandResponseState___destroy___0 = Module['_emscripten_bind_PxVehicleClutchCommandResponseState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleClutchCommandResponseState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchParams_PxVehicleClutchParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchParams_PxVehicleClutchParams_0');
  _emscripten_bind_PxVehicleClutchParams_PxVehicleClutchParams_0 = Module['_emscripten_bind_PxVehicleClutchParams_PxVehicleClutchParams_0'] = createExportWrapper('emscripten_bind_PxVehicleClutchParams_PxVehicleClutchParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchParams_transformAndScale_4');
  _emscripten_bind_PxVehicleClutchParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleClutchParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleClutchParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchParams_isValid_0');
  _emscripten_bind_PxVehicleClutchParams_isValid_0 = Module['_emscripten_bind_PxVehicleClutchParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleClutchParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchParams_get_accuracyMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchParams_get_accuracyMode_0');
  _emscripten_bind_PxVehicleClutchParams_get_accuracyMode_0 = Module['_emscripten_bind_PxVehicleClutchParams_get_accuracyMode_0'] = createExportWrapper('emscripten_bind_PxVehicleClutchParams_get_accuracyMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchParams_set_accuracyMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchParams_set_accuracyMode_1');
  _emscripten_bind_PxVehicleClutchParams_set_accuracyMode_1 = Module['_emscripten_bind_PxVehicleClutchParams_set_accuracyMode_1'] = createExportWrapper('emscripten_bind_PxVehicleClutchParams_set_accuracyMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchParams_get_estimateIterations_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchParams_get_estimateIterations_0');
  _emscripten_bind_PxVehicleClutchParams_get_estimateIterations_0 = Module['_emscripten_bind_PxVehicleClutchParams_get_estimateIterations_0'] = createExportWrapper('emscripten_bind_PxVehicleClutchParams_get_estimateIterations_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchParams_set_estimateIterations_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchParams_set_estimateIterations_1');
  _emscripten_bind_PxVehicleClutchParams_set_estimateIterations_1 = Module['_emscripten_bind_PxVehicleClutchParams_set_estimateIterations_1'] = createExportWrapper('emscripten_bind_PxVehicleClutchParams_set_estimateIterations_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchParams___destroy___0');
  _emscripten_bind_PxVehicleClutchParams___destroy___0 = Module['_emscripten_bind_PxVehicleClutchParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleClutchParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchSlipState_PxVehicleClutchSlipState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchSlipState_PxVehicleClutchSlipState_0');
  _emscripten_bind_PxVehicleClutchSlipState_PxVehicleClutchSlipState_0 = Module['_emscripten_bind_PxVehicleClutchSlipState_PxVehicleClutchSlipState_0'] = createExportWrapper('emscripten_bind_PxVehicleClutchSlipState_PxVehicleClutchSlipState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchSlipState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchSlipState_setToDefault_0');
  _emscripten_bind_PxVehicleClutchSlipState_setToDefault_0 = Module['_emscripten_bind_PxVehicleClutchSlipState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleClutchSlipState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchSlipState_get_clutchSlip_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchSlipState_get_clutchSlip_0');
  _emscripten_bind_PxVehicleClutchSlipState_get_clutchSlip_0 = Module['_emscripten_bind_PxVehicleClutchSlipState_get_clutchSlip_0'] = createExportWrapper('emscripten_bind_PxVehicleClutchSlipState_get_clutchSlip_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchSlipState_set_clutchSlip_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchSlipState_set_clutchSlip_1');
  _emscripten_bind_PxVehicleClutchSlipState_set_clutchSlip_1 = Module['_emscripten_bind_PxVehicleClutchSlipState_set_clutchSlip_1'] = createExportWrapper('emscripten_bind_PxVehicleClutchSlipState_set_clutchSlip_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleClutchSlipState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleClutchSlipState___destroy___0');
  _emscripten_bind_PxVehicleClutchSlipState___destroy___0 = Module['_emscripten_bind_PxVehicleClutchSlipState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleClutchSlipState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_PxVehicleCommandNonLinearResponseParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_PxVehicleCommandNonLinearResponseParams_0');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_PxVehicleCommandNonLinearResponseParams_0 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_PxVehicleCommandNonLinearResponseParams_0'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_PxVehicleCommandNonLinearResponseParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_clear_0');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_clear_0 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_clear_0'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_addResponse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_addResponse_1');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_addResponse_1 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_addResponse_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_addResponse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponses_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponses_1');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponses_1 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponses_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponses_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponses_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponses_2');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponses_2 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponses_2'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponses_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponses_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponses_0');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponses_0 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponses_0'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponses_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponses_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponses_1');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponses_1 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponses_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponses_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponsesPerCommandValue_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponsesPerCommandValue_1');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponsesPerCommandValue_1 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponsesPerCommandValue_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponsesPerCommandValue_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponsesPerCommandValue_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponsesPerCommandValue_2');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponsesPerCommandValue_2 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponsesPerCommandValue_2'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponsesPerCommandValue_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponsesPerCommandValue_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponsesPerCommandValue_1');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponsesPerCommandValue_1 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponsesPerCommandValue_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponsesPerCommandValue_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponsesPerCommandValue_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponsesPerCommandValue_2');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponsesPerCommandValue_2 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponsesPerCommandValue_2'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponsesPerCommandValue_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_commandValues_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_commandValues_1');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_commandValues_1 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_commandValues_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_commandValues_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_commandValues_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_commandValues_2');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_commandValues_2 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_commandValues_2'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_commandValues_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbCommandValues_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbCommandValues_0');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbCommandValues_0 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbCommandValues_0'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbCommandValues_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbCommandValues_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbCommandValues_1');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbCommandValues_1 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbCommandValues_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbCommandValues_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandNonLinearResponseParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandNonLinearResponseParams___destroy___0');
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams___destroy___0 = Module['_emscripten_bind_PxVehicleCommandNonLinearResponseParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleCommandNonLinearResponseParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandState_PxVehicleCommandState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandState_PxVehicleCommandState_0');
  _emscripten_bind_PxVehicleCommandState_PxVehicleCommandState_0 = Module['_emscripten_bind_PxVehicleCommandState_PxVehicleCommandState_0'] = createExportWrapper('emscripten_bind_PxVehicleCommandState_PxVehicleCommandState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandState_setToDefault_0');
  _emscripten_bind_PxVehicleCommandState_setToDefault_0 = Module['_emscripten_bind_PxVehicleCommandState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleCommandState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandState_get_brakes_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandState_get_brakes_1');
  _emscripten_bind_PxVehicleCommandState_get_brakes_1 = Module['_emscripten_bind_PxVehicleCommandState_get_brakes_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandState_get_brakes_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandState_set_brakes_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandState_set_brakes_2');
  _emscripten_bind_PxVehicleCommandState_set_brakes_2 = Module['_emscripten_bind_PxVehicleCommandState_set_brakes_2'] = createExportWrapper('emscripten_bind_PxVehicleCommandState_set_brakes_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandState_get_nbBrakes_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandState_get_nbBrakes_0');
  _emscripten_bind_PxVehicleCommandState_get_nbBrakes_0 = Module['_emscripten_bind_PxVehicleCommandState_get_nbBrakes_0'] = createExportWrapper('emscripten_bind_PxVehicleCommandState_get_nbBrakes_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandState_set_nbBrakes_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandState_set_nbBrakes_1');
  _emscripten_bind_PxVehicleCommandState_set_nbBrakes_1 = Module['_emscripten_bind_PxVehicleCommandState_set_nbBrakes_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandState_set_nbBrakes_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandState_get_throttle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandState_get_throttle_0');
  _emscripten_bind_PxVehicleCommandState_get_throttle_0 = Module['_emscripten_bind_PxVehicleCommandState_get_throttle_0'] = createExportWrapper('emscripten_bind_PxVehicleCommandState_get_throttle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandState_set_throttle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandState_set_throttle_1');
  _emscripten_bind_PxVehicleCommandState_set_throttle_1 = Module['_emscripten_bind_PxVehicleCommandState_set_throttle_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandState_set_throttle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandState_get_steer_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandState_get_steer_0');
  _emscripten_bind_PxVehicleCommandState_get_steer_0 = Module['_emscripten_bind_PxVehicleCommandState_get_steer_0'] = createExportWrapper('emscripten_bind_PxVehicleCommandState_get_steer_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandState_set_steer_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandState_set_steer_1');
  _emscripten_bind_PxVehicleCommandState_set_steer_1 = Module['_emscripten_bind_PxVehicleCommandState_set_steer_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandState_set_steer_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandState___destroy___0');
  _emscripten_bind_PxVehicleCommandState___destroy___0 = Module['_emscripten_bind_PxVehicleCommandState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleCommandState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandValueResponseTable_PxVehicleCommandValueResponseTable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandValueResponseTable_PxVehicleCommandValueResponseTable_0');
  _emscripten_bind_PxVehicleCommandValueResponseTable_PxVehicleCommandValueResponseTable_0 = Module['_emscripten_bind_PxVehicleCommandValueResponseTable_PxVehicleCommandValueResponseTable_0'] = createExportWrapper('emscripten_bind_PxVehicleCommandValueResponseTable_PxVehicleCommandValueResponseTable_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandValueResponseTable_get_commandValue_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandValueResponseTable_get_commandValue_0');
  _emscripten_bind_PxVehicleCommandValueResponseTable_get_commandValue_0 = Module['_emscripten_bind_PxVehicleCommandValueResponseTable_get_commandValue_0'] = createExportWrapper('emscripten_bind_PxVehicleCommandValueResponseTable_get_commandValue_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandValueResponseTable_set_commandValue_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandValueResponseTable_set_commandValue_1');
  _emscripten_bind_PxVehicleCommandValueResponseTable_set_commandValue_1 = Module['_emscripten_bind_PxVehicleCommandValueResponseTable_set_commandValue_1'] = createExportWrapper('emscripten_bind_PxVehicleCommandValueResponseTable_set_commandValue_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleCommandValueResponseTable___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleCommandValueResponseTable___destroy___0');
  _emscripten_bind_PxVehicleCommandValueResponseTable___destroy___0 = Module['_emscripten_bind_PxVehicleCommandValueResponseTable___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleCommandValueResponseTable___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleComponent___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleComponent___destroy___0');
  _emscripten_bind_PxVehicleComponent___destroy___0 = Module['_emscripten_bind_PxVehicleComponent___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleComponent___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleComponentSequence_PxVehicleComponentSequence_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleComponentSequence_PxVehicleComponentSequence_0');
  _emscripten_bind_PxVehicleComponentSequence_PxVehicleComponentSequence_0 = Module['_emscripten_bind_PxVehicleComponentSequence_PxVehicleComponentSequence_0'] = createExportWrapper('emscripten_bind_PxVehicleComponentSequence_PxVehicleComponentSequence_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleComponentSequence_add_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleComponentSequence_add_1');
  _emscripten_bind_PxVehicleComponentSequence_add_1 = Module['_emscripten_bind_PxVehicleComponentSequence_add_1'] = createExportWrapper('emscripten_bind_PxVehicleComponentSequence_add_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_0');
  _emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_0 = Module['_emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_0'] = createExportWrapper('emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_1');
  _emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_1 = Module['_emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_1'] = createExportWrapper('emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleComponentSequence_endSubstepGroup_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleComponentSequence_endSubstepGroup_0');
  _emscripten_bind_PxVehicleComponentSequence_endSubstepGroup_0 = Module['_emscripten_bind_PxVehicleComponentSequence_endSubstepGroup_0'] = createExportWrapper('emscripten_bind_PxVehicleComponentSequence_endSubstepGroup_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleComponentSequence_setSubsteps_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleComponentSequence_setSubsteps_2');
  _emscripten_bind_PxVehicleComponentSequence_setSubsteps_2 = Module['_emscripten_bind_PxVehicleComponentSequence_setSubsteps_2'] = createExportWrapper('emscripten_bind_PxVehicleComponentSequence_setSubsteps_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleComponentSequence_update_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleComponentSequence_update_2');
  _emscripten_bind_PxVehicleComponentSequence_update_2 = Module['_emscripten_bind_PxVehicleComponentSequence_update_2'] = createExportWrapper('emscripten_bind_PxVehicleComponentSequence_update_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleComponentSequence___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleComponentSequence___destroy___0');
  _emscripten_bind_PxVehicleComponentSequence___destroy___0 = Module['_emscripten_bind_PxVehicleComponentSequence___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleComponentSequence___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_0');
  _emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_0 = Module['_emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_0'] = createExportWrapper('emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_1');
  _emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_1 = Module['_emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_1'] = createExportWrapper('emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleConstraintConnector_setConstraintState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleConstraintConnector_setConstraintState_1');
  _emscripten_bind_PxVehicleConstraintConnector_setConstraintState_1 = Module['_emscripten_bind_PxVehicleConstraintConnector_setConstraintState_1'] = createExportWrapper('emscripten_bind_PxVehicleConstraintConnector_setConstraintState_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleConstraintConnector_getConstantBlock_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleConstraintConnector_getConstantBlock_0');
  _emscripten_bind_PxVehicleConstraintConnector_getConstantBlock_0 = Module['_emscripten_bind_PxVehicleConstraintConnector_getConstantBlock_0'] = createExportWrapper('emscripten_bind_PxVehicleConstraintConnector_getConstantBlock_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleConstraintConnector_prepareData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleConstraintConnector_prepareData_0');
  _emscripten_bind_PxVehicleConstraintConnector_prepareData_0 = Module['_emscripten_bind_PxVehicleConstraintConnector_prepareData_0'] = createExportWrapper('emscripten_bind_PxVehicleConstraintConnector_prepareData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleConstraintConnector_updateOmniPvdProperties_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleConstraintConnector_updateOmniPvdProperties_0');
  _emscripten_bind_PxVehicleConstraintConnector_updateOmniPvdProperties_0 = Module['_emscripten_bind_PxVehicleConstraintConnector_updateOmniPvdProperties_0'] = createExportWrapper('emscripten_bind_PxVehicleConstraintConnector_updateOmniPvdProperties_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleConstraintConnector_onConstraintRelease_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleConstraintConnector_onConstraintRelease_0');
  _emscripten_bind_PxVehicleConstraintConnector_onConstraintRelease_0 = Module['_emscripten_bind_PxVehicleConstraintConnector_onConstraintRelease_0'] = createExportWrapper('emscripten_bind_PxVehicleConstraintConnector_onConstraintRelease_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleConstraintConnector_onComShift_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleConstraintConnector_onComShift_1');
  _emscripten_bind_PxVehicleConstraintConnector_onComShift_1 = Module['_emscripten_bind_PxVehicleConstraintConnector_onComShift_1'] = createExportWrapper('emscripten_bind_PxVehicleConstraintConnector_onComShift_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleConstraintConnector_onOriginShift_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleConstraintConnector_onOriginShift_1');
  _emscripten_bind_PxVehicleConstraintConnector_onOriginShift_1 = Module['_emscripten_bind_PxVehicleConstraintConnector_onOriginShift_1'] = createExportWrapper('emscripten_bind_PxVehicleConstraintConnector_onOriginShift_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleConstraintConnector_getSerializable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleConstraintConnector_getSerializable_0');
  _emscripten_bind_PxVehicleConstraintConnector_getSerializable_0 = Module['_emscripten_bind_PxVehicleConstraintConnector_getSerializable_0'] = createExportWrapper('emscripten_bind_PxVehicleConstraintConnector_getSerializable_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleConstraintConnector_getPrep_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleConstraintConnector_getPrep_0');
  _emscripten_bind_PxVehicleConstraintConnector_getPrep_0 = Module['_emscripten_bind_PxVehicleConstraintConnector_getPrep_0'] = createExportWrapper('emscripten_bind_PxVehicleConstraintConnector_getPrep_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleConstraintConnector_connectToConstraint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleConstraintConnector_connectToConstraint_1');
  _emscripten_bind_PxVehicleConstraintConnector_connectToConstraint_1 = Module['_emscripten_bind_PxVehicleConstraintConnector_connectToConstraint_1'] = createExportWrapper('emscripten_bind_PxVehicleConstraintConnector_connectToConstraint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleConstraintConnector___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleConstraintConnector___destroy___0');
  _emscripten_bind_PxVehicleConstraintConnector___destroy___0 = Module['_emscripten_bind_PxVehicleConstraintConnector___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleConstraintConnector___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDifferentialState_PxVehicleDifferentialState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDifferentialState_PxVehicleDifferentialState_0');
  _emscripten_bind_PxVehicleDifferentialState_PxVehicleDifferentialState_0 = Module['_emscripten_bind_PxVehicleDifferentialState_PxVehicleDifferentialState_0'] = createExportWrapper('emscripten_bind_PxVehicleDifferentialState_PxVehicleDifferentialState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDifferentialState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDifferentialState_setToDefault_0');
  _emscripten_bind_PxVehicleDifferentialState_setToDefault_0 = Module['_emscripten_bind_PxVehicleDifferentialState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleDifferentialState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDifferentialState_get_connectedWheels_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDifferentialState_get_connectedWheels_1');
  _emscripten_bind_PxVehicleDifferentialState_get_connectedWheels_1 = Module['_emscripten_bind_PxVehicleDifferentialState_get_connectedWheels_1'] = createExportWrapper('emscripten_bind_PxVehicleDifferentialState_get_connectedWheels_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDifferentialState_set_connectedWheels_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDifferentialState_set_connectedWheels_2');
  _emscripten_bind_PxVehicleDifferentialState_set_connectedWheels_2 = Module['_emscripten_bind_PxVehicleDifferentialState_set_connectedWheels_2'] = createExportWrapper('emscripten_bind_PxVehicleDifferentialState_set_connectedWheels_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDifferentialState_get_nbConnectedWheels_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDifferentialState_get_nbConnectedWheels_0');
  _emscripten_bind_PxVehicleDifferentialState_get_nbConnectedWheels_0 = Module['_emscripten_bind_PxVehicleDifferentialState_get_nbConnectedWheels_0'] = createExportWrapper('emscripten_bind_PxVehicleDifferentialState_get_nbConnectedWheels_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDifferentialState_set_nbConnectedWheels_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDifferentialState_set_nbConnectedWheels_1');
  _emscripten_bind_PxVehicleDifferentialState_set_nbConnectedWheels_1 = Module['_emscripten_bind_PxVehicleDifferentialState_set_nbConnectedWheels_1'] = createExportWrapper('emscripten_bind_PxVehicleDifferentialState_set_nbConnectedWheels_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDifferentialState_get_torqueRatiosAllWheels_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDifferentialState_get_torqueRatiosAllWheels_1');
  _emscripten_bind_PxVehicleDifferentialState_get_torqueRatiosAllWheels_1 = Module['_emscripten_bind_PxVehicleDifferentialState_get_torqueRatiosAllWheels_1'] = createExportWrapper('emscripten_bind_PxVehicleDifferentialState_get_torqueRatiosAllWheels_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDifferentialState_set_torqueRatiosAllWheels_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDifferentialState_set_torqueRatiosAllWheels_2');
  _emscripten_bind_PxVehicleDifferentialState_set_torqueRatiosAllWheels_2 = Module['_emscripten_bind_PxVehicleDifferentialState_set_torqueRatiosAllWheels_2'] = createExportWrapper('emscripten_bind_PxVehicleDifferentialState_set_torqueRatiosAllWheels_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDifferentialState_get_aveWheelSpeedContributionAllWheels_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDifferentialState_get_aveWheelSpeedContributionAllWheels_1');
  _emscripten_bind_PxVehicleDifferentialState_get_aveWheelSpeedContributionAllWheels_1 = Module['_emscripten_bind_PxVehicleDifferentialState_get_aveWheelSpeedContributionAllWheels_1'] = createExportWrapper('emscripten_bind_PxVehicleDifferentialState_get_aveWheelSpeedContributionAllWheels_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDifferentialState_set_aveWheelSpeedContributionAllWheels_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDifferentialState_set_aveWheelSpeedContributionAllWheels_2');
  _emscripten_bind_PxVehicleDifferentialState_set_aveWheelSpeedContributionAllWheels_2 = Module['_emscripten_bind_PxVehicleDifferentialState_set_aveWheelSpeedContributionAllWheels_2'] = createExportWrapper('emscripten_bind_PxVehicleDifferentialState_set_aveWheelSpeedContributionAllWheels_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDifferentialState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDifferentialState___destroy___0');
  _emscripten_bind_PxVehicleDifferentialState___destroy___0 = Module['_emscripten_bind_PxVehicleDifferentialState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleDifferentialState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_PxVehicleDirectDriveThrottleCommandResponseParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_PxVehicleDirectDriveThrottleCommandResponseParams_0');
  _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_PxVehicleDirectDriveThrottleCommandResponseParams_0 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_PxVehicleDirectDriveThrottleCommandResponseParams_0'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_PxVehicleDirectDriveThrottleCommandResponseParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_transformAndScale_4');
  _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_isValid_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_isValid_1');
  _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_isValid_1 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_isValid_1'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_isValid_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_nonlinearResponse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_nonlinearResponse_0');
  _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_nonlinearResponse_0 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_nonlinearResponse_0'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_nonlinearResponse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_nonlinearResponse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_nonlinearResponse_1');
  _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_nonlinearResponse_1 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_nonlinearResponse_1'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_nonlinearResponse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_wheelResponseMultipliers_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_wheelResponseMultipliers_1');
  _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_wheelResponseMultipliers_1 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_wheelResponseMultipliers_1'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_wheelResponseMultipliers_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_wheelResponseMultipliers_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_wheelResponseMultipliers_2');
  _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_wheelResponseMultipliers_2 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_wheelResponseMultipliers_2'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_wheelResponseMultipliers_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_maxResponse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_maxResponse_0');
  _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_maxResponse_0 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_maxResponse_0'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_maxResponse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_maxResponse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_maxResponse_1');
  _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_maxResponse_1 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_maxResponse_1'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_maxResponse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams___destroy___0');
  _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams___destroy___0 = Module['_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_PxVehicleDirectDriveTransmissionCommandState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_PxVehicleDirectDriveTransmissionCommandState_0');
  _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_PxVehicleDirectDriveTransmissionCommandState_0 = Module['_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_PxVehicleDirectDriveTransmissionCommandState_0'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_PxVehicleDirectDriveTransmissionCommandState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_setToDefault_0');
  _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_setToDefault_0 = Module['_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_get_gear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_get_gear_0');
  _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_get_gear_0 = Module['_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_get_gear_0'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_get_gear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_set_gear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_set_gear_1');
  _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_set_gear_1 = Module['_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_set_gear_1'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_set_gear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleDirectDriveTransmissionCommandState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleDirectDriveTransmissionCommandState___destroy___0');
  _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState___destroy___0 = Module['_emscripten_bind_PxVehicleDirectDriveTransmissionCommandState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleDirectDriveTransmissionCommandState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_PxVehicleEngineDriveThrottleCommandResponseState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_PxVehicleEngineDriveThrottleCommandResponseState_0');
  _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_PxVehicleEngineDriveThrottleCommandResponseState_0 = Module['_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_PxVehicleEngineDriveThrottleCommandResponseState_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_PxVehicleEngineDriveThrottleCommandResponseState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_setToDefault_0');
  _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_setToDefault_0 = Module['_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_get_commandResponse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_get_commandResponse_0');
  _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_get_commandResponse_0 = Module['_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_get_commandResponse_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_get_commandResponse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_set_commandResponse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_set_commandResponse_1');
  _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_set_commandResponse_1 = Module['_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_set_commandResponse_1'] = createExportWrapper('emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_set_commandResponse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState___destroy___0');
  _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState___destroy___0 = Module['_emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_PxVehicleEngineParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_PxVehicleEngineParams_0');
  _emscripten_bind_PxVehicleEngineParams_PxVehicleEngineParams_0 = Module['_emscripten_bind_PxVehicleEngineParams_PxVehicleEngineParams_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_PxVehicleEngineParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_transformAndScale_4');
  _emscripten_bind_PxVehicleEngineParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleEngineParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_isValid_0');
  _emscripten_bind_PxVehicleEngineParams_isValid_0 = Module['_emscripten_bind_PxVehicleEngineParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_get_torqueCurve_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_get_torqueCurve_0');
  _emscripten_bind_PxVehicleEngineParams_get_torqueCurve_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_torqueCurve_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_get_torqueCurve_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_set_torqueCurve_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_set_torqueCurve_1');
  _emscripten_bind_PxVehicleEngineParams_set_torqueCurve_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_torqueCurve_1'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_set_torqueCurve_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_get_moi_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_get_moi_0');
  _emscripten_bind_PxVehicleEngineParams_get_moi_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_moi_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_get_moi_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_set_moi_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_set_moi_1');
  _emscripten_bind_PxVehicleEngineParams_set_moi_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_moi_1'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_set_moi_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_get_peakTorque_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_get_peakTorque_0');
  _emscripten_bind_PxVehicleEngineParams_get_peakTorque_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_peakTorque_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_get_peakTorque_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_set_peakTorque_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_set_peakTorque_1');
  _emscripten_bind_PxVehicleEngineParams_set_peakTorque_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_peakTorque_1'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_set_peakTorque_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_get_idleOmega_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_get_idleOmega_0');
  _emscripten_bind_PxVehicleEngineParams_get_idleOmega_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_idleOmega_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_get_idleOmega_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_set_idleOmega_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_set_idleOmega_1');
  _emscripten_bind_PxVehicleEngineParams_set_idleOmega_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_idleOmega_1'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_set_idleOmega_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_get_maxOmega_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_get_maxOmega_0');
  _emscripten_bind_PxVehicleEngineParams_get_maxOmega_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_maxOmega_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_get_maxOmega_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_set_maxOmega_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_set_maxOmega_1');
  _emscripten_bind_PxVehicleEngineParams_set_maxOmega_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_maxOmega_1'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_set_maxOmega_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_get_dampingRateFullThrottle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_get_dampingRateFullThrottle_0');
  _emscripten_bind_PxVehicleEngineParams_get_dampingRateFullThrottle_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_dampingRateFullThrottle_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_get_dampingRateFullThrottle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_set_dampingRateFullThrottle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_set_dampingRateFullThrottle_1');
  _emscripten_bind_PxVehicleEngineParams_set_dampingRateFullThrottle_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_dampingRateFullThrottle_1'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_set_dampingRateFullThrottle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchEngaged_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchEngaged_0');
  _emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchEngaged_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchEngaged_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchEngaged_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchEngaged_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchEngaged_1');
  _emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchEngaged_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchEngaged_1'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchEngaged_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchDisengaged_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchDisengaged_0');
  _emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchDisengaged_0 = Module['_emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchDisengaged_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchDisengaged_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchDisengaged_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchDisengaged_1');
  _emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchDisengaged_1 = Module['_emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchDisengaged_1'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchDisengaged_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineParams___destroy___0');
  _emscripten_bind_PxVehicleEngineParams___destroy___0 = Module['_emscripten_bind_PxVehicleEngineParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleEngineParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineState_PxVehicleEngineState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineState_PxVehicleEngineState_0');
  _emscripten_bind_PxVehicleEngineState_PxVehicleEngineState_0 = Module['_emscripten_bind_PxVehicleEngineState_PxVehicleEngineState_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineState_PxVehicleEngineState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineState_setToDefault_0');
  _emscripten_bind_PxVehicleEngineState_setToDefault_0 = Module['_emscripten_bind_PxVehicleEngineState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineState_get_rotationSpeed_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineState_get_rotationSpeed_0');
  _emscripten_bind_PxVehicleEngineState_get_rotationSpeed_0 = Module['_emscripten_bind_PxVehicleEngineState_get_rotationSpeed_0'] = createExportWrapper('emscripten_bind_PxVehicleEngineState_get_rotationSpeed_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineState_set_rotationSpeed_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineState_set_rotationSpeed_1');
  _emscripten_bind_PxVehicleEngineState_set_rotationSpeed_1 = Module['_emscripten_bind_PxVehicleEngineState_set_rotationSpeed_1'] = createExportWrapper('emscripten_bind_PxVehicleEngineState_set_rotationSpeed_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleEngineState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleEngineState___destroy___0');
  _emscripten_bind_PxVehicleEngineState___destroy___0 = Module['_emscripten_bind_PxVehicleEngineState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleEngineState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_PxVehicleFixedSizeLookupTableFloat_3_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_PxVehicleFixedSizeLookupTableFloat_3_0');
  _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_PxVehicleFixedSizeLookupTableFloat_3_0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_PxVehicleFixedSizeLookupTableFloat_3_0'] = createExportWrapper('emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_PxVehicleFixedSizeLookupTableFloat_3_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_addPair_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_addPair_2');
  _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_addPair_2 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_addPair_2'] = createExportWrapper('emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_addPair_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_interpolate_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_interpolate_1');
  _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_interpolate_1 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_interpolate_1'] = createExportWrapper('emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_interpolate_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_clear_0');
  _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_clear_0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_clear_0'] = createExportWrapper('emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_isValid_0');
  _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_isValid_0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3___destroy___0');
  _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3___destroy___0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_PxVehicleFixedSizeLookupTableVec3_3_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_PxVehicleFixedSizeLookupTableVec3_3_0');
  _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_PxVehicleFixedSizeLookupTableVec3_3_0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_PxVehicleFixedSizeLookupTableVec3_3_0'] = createExportWrapper('emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_PxVehicleFixedSizeLookupTableVec3_3_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_addPair_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_addPair_2');
  _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_addPair_2 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_addPair_2'] = createExportWrapper('emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_addPair_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_interpolate_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_interpolate_1');
  _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_interpolate_1 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_interpolate_1'] = createExportWrapper('emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_interpolate_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_clear_0');
  _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_clear_0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_clear_0'] = createExportWrapper('emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_isValid_0');
  _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_isValid_0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3___destroy___0');
  _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3___destroy___0 = Module['_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_PxVehicleFourWheelDriveDifferentialParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_PxVehicleFourWheelDriveDifferentialParams_0');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_PxVehicleFourWheelDriveDifferentialParams_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_PxVehicleFourWheelDriveDifferentialParams_0'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_PxVehicleFourWheelDriveDifferentialParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_setToDefault_0');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_setToDefault_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_transformAndScale_4');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_isValid_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_isValid_1');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_isValid_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_isValid_1'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_isValid_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontWheelIds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontWheelIds_1');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontWheelIds_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontWheelIds_1'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontWheelIds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontWheelIds_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontWheelIds_2');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontWheelIds_2 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontWheelIds_2'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontWheelIds_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearWheelIds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearWheelIds_1');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearWheelIds_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearWheelIds_1'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearWheelIds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearWheelIds_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearWheelIds_2');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearWheelIds_2 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearWheelIds_2'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearWheelIds_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontBias_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontBias_0');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontBias_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontBias_0'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontBias_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontBias_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontBias_1');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontBias_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontBias_1'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontBias_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontTarget_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontTarget_0');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontTarget_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontTarget_0'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontTarget_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontTarget_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontTarget_1');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontTarget_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontTarget_1'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontTarget_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearBias_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearBias_0');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearBias_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearBias_0'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearBias_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearBias_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearBias_1');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearBias_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearBias_1'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearBias_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearTarget_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearTarget_0');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearTarget_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearTarget_0'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearTarget_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearTarget_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearTarget_1');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearTarget_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearTarget_1'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearTarget_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerBias_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerBias_0');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerBias_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerBias_0'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerBias_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerBias_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerBias_1');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerBias_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerBias_1'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerBias_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerTarget_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerTarget_0');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerTarget_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerTarget_0'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerTarget_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerTarget_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerTarget_1');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerTarget_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerTarget_1'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerTarget_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rate_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rate_0');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rate_0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rate_0'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rate_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rate_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rate_1');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rate_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rate_1'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rate_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_torqueRatios_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_torqueRatios_1');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_torqueRatios_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_torqueRatios_1'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_torqueRatios_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_torqueRatios_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_torqueRatios_2');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_torqueRatios_2 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_torqueRatios_2'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_torqueRatios_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFourWheelDriveDifferentialParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFourWheelDriveDifferentialParams___destroy___0');
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams___destroy___0 = Module['_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleFourWheelDriveDifferentialParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFrame_PxVehicleFrame_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFrame_PxVehicleFrame_0');
  _emscripten_bind_PxVehicleFrame_PxVehicleFrame_0 = Module['_emscripten_bind_PxVehicleFrame_PxVehicleFrame_0'] = createExportWrapper('emscripten_bind_PxVehicleFrame_PxVehicleFrame_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFrame_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFrame_setToDefault_0');
  _emscripten_bind_PxVehicleFrame_setToDefault_0 = Module['_emscripten_bind_PxVehicleFrame_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleFrame_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFrame_getFrame_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFrame_getFrame_0');
  _emscripten_bind_PxVehicleFrame_getFrame_0 = Module['_emscripten_bind_PxVehicleFrame_getFrame_0'] = createExportWrapper('emscripten_bind_PxVehicleFrame_getFrame_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFrame_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFrame_isValid_0');
  _emscripten_bind_PxVehicleFrame_isValid_0 = Module['_emscripten_bind_PxVehicleFrame_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleFrame_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFrame_get_lngAxis_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFrame_get_lngAxis_0');
  _emscripten_bind_PxVehicleFrame_get_lngAxis_0 = Module['_emscripten_bind_PxVehicleFrame_get_lngAxis_0'] = createExportWrapper('emscripten_bind_PxVehicleFrame_get_lngAxis_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFrame_set_lngAxis_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFrame_set_lngAxis_1');
  _emscripten_bind_PxVehicleFrame_set_lngAxis_1 = Module['_emscripten_bind_PxVehicleFrame_set_lngAxis_1'] = createExportWrapper('emscripten_bind_PxVehicleFrame_set_lngAxis_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFrame_get_latAxis_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFrame_get_latAxis_0');
  _emscripten_bind_PxVehicleFrame_get_latAxis_0 = Module['_emscripten_bind_PxVehicleFrame_get_latAxis_0'] = createExportWrapper('emscripten_bind_PxVehicleFrame_get_latAxis_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFrame_set_latAxis_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFrame_set_latAxis_1');
  _emscripten_bind_PxVehicleFrame_set_latAxis_1 = Module['_emscripten_bind_PxVehicleFrame_set_latAxis_1'] = createExportWrapper('emscripten_bind_PxVehicleFrame_set_latAxis_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFrame_get_vrtAxis_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFrame_get_vrtAxis_0');
  _emscripten_bind_PxVehicleFrame_get_vrtAxis_0 = Module['_emscripten_bind_PxVehicleFrame_get_vrtAxis_0'] = createExportWrapper('emscripten_bind_PxVehicleFrame_get_vrtAxis_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFrame_set_vrtAxis_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFrame_set_vrtAxis_1');
  _emscripten_bind_PxVehicleFrame_set_vrtAxis_1 = Module['_emscripten_bind_PxVehicleFrame_set_vrtAxis_1'] = createExportWrapper('emscripten_bind_PxVehicleFrame_set_vrtAxis_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleFrame___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleFrame___destroy___0');
  _emscripten_bind_PxVehicleFrame___destroy___0 = Module['_emscripten_bind_PxVehicleFrame___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleFrame___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxParams_PxVehicleGearboxParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxParams_PxVehicleGearboxParams_0');
  _emscripten_bind_PxVehicleGearboxParams_PxVehicleGearboxParams_0 = Module['_emscripten_bind_PxVehicleGearboxParams_PxVehicleGearboxParams_0'] = createExportWrapper('emscripten_bind_PxVehicleGearboxParams_PxVehicleGearboxParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxParams_transformAndScale_4');
  _emscripten_bind_PxVehicleGearboxParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleGearboxParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleGearboxParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxParams_isValid_0');
  _emscripten_bind_PxVehicleGearboxParams_isValid_0 = Module['_emscripten_bind_PxVehicleGearboxParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleGearboxParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxParams_get_neutralGear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxParams_get_neutralGear_0');
  _emscripten_bind_PxVehicleGearboxParams_get_neutralGear_0 = Module['_emscripten_bind_PxVehicleGearboxParams_get_neutralGear_0'] = createExportWrapper('emscripten_bind_PxVehicleGearboxParams_get_neutralGear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxParams_set_neutralGear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxParams_set_neutralGear_1');
  _emscripten_bind_PxVehicleGearboxParams_set_neutralGear_1 = Module['_emscripten_bind_PxVehicleGearboxParams_set_neutralGear_1'] = createExportWrapper('emscripten_bind_PxVehicleGearboxParams_set_neutralGear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxParams_get_ratios_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxParams_get_ratios_1');
  _emscripten_bind_PxVehicleGearboxParams_get_ratios_1 = Module['_emscripten_bind_PxVehicleGearboxParams_get_ratios_1'] = createExportWrapper('emscripten_bind_PxVehicleGearboxParams_get_ratios_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxParams_set_ratios_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxParams_set_ratios_2');
  _emscripten_bind_PxVehicleGearboxParams_set_ratios_2 = Module['_emscripten_bind_PxVehicleGearboxParams_set_ratios_2'] = createExportWrapper('emscripten_bind_PxVehicleGearboxParams_set_ratios_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxParams_get_finalRatio_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxParams_get_finalRatio_0');
  _emscripten_bind_PxVehicleGearboxParams_get_finalRatio_0 = Module['_emscripten_bind_PxVehicleGearboxParams_get_finalRatio_0'] = createExportWrapper('emscripten_bind_PxVehicleGearboxParams_get_finalRatio_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxParams_set_finalRatio_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxParams_set_finalRatio_1');
  _emscripten_bind_PxVehicleGearboxParams_set_finalRatio_1 = Module['_emscripten_bind_PxVehicleGearboxParams_set_finalRatio_1'] = createExportWrapper('emscripten_bind_PxVehicleGearboxParams_set_finalRatio_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxParams_get_nbRatios_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxParams_get_nbRatios_0');
  _emscripten_bind_PxVehicleGearboxParams_get_nbRatios_0 = Module['_emscripten_bind_PxVehicleGearboxParams_get_nbRatios_0'] = createExportWrapper('emscripten_bind_PxVehicleGearboxParams_get_nbRatios_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxParams_set_nbRatios_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxParams_set_nbRatios_1');
  _emscripten_bind_PxVehicleGearboxParams_set_nbRatios_1 = Module['_emscripten_bind_PxVehicleGearboxParams_set_nbRatios_1'] = createExportWrapper('emscripten_bind_PxVehicleGearboxParams_set_nbRatios_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxParams_get_switchTime_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxParams_get_switchTime_0');
  _emscripten_bind_PxVehicleGearboxParams_get_switchTime_0 = Module['_emscripten_bind_PxVehicleGearboxParams_get_switchTime_0'] = createExportWrapper('emscripten_bind_PxVehicleGearboxParams_get_switchTime_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxParams_set_switchTime_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxParams_set_switchTime_1');
  _emscripten_bind_PxVehicleGearboxParams_set_switchTime_1 = Module['_emscripten_bind_PxVehicleGearboxParams_set_switchTime_1'] = createExportWrapper('emscripten_bind_PxVehicleGearboxParams_set_switchTime_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxParams___destroy___0');
  _emscripten_bind_PxVehicleGearboxParams___destroy___0 = Module['_emscripten_bind_PxVehicleGearboxParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleGearboxParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxState_PxVehicleGearboxState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxState_PxVehicleGearboxState_0');
  _emscripten_bind_PxVehicleGearboxState_PxVehicleGearboxState_0 = Module['_emscripten_bind_PxVehicleGearboxState_PxVehicleGearboxState_0'] = createExportWrapper('emscripten_bind_PxVehicleGearboxState_PxVehicleGearboxState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxState_setToDefault_0');
  _emscripten_bind_PxVehicleGearboxState_setToDefault_0 = Module['_emscripten_bind_PxVehicleGearboxState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleGearboxState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxState_get_currentGear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxState_get_currentGear_0');
  _emscripten_bind_PxVehicleGearboxState_get_currentGear_0 = Module['_emscripten_bind_PxVehicleGearboxState_get_currentGear_0'] = createExportWrapper('emscripten_bind_PxVehicleGearboxState_get_currentGear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxState_set_currentGear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxState_set_currentGear_1');
  _emscripten_bind_PxVehicleGearboxState_set_currentGear_1 = Module['_emscripten_bind_PxVehicleGearboxState_set_currentGear_1'] = createExportWrapper('emscripten_bind_PxVehicleGearboxState_set_currentGear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxState_get_targetGear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxState_get_targetGear_0');
  _emscripten_bind_PxVehicleGearboxState_get_targetGear_0 = Module['_emscripten_bind_PxVehicleGearboxState_get_targetGear_0'] = createExportWrapper('emscripten_bind_PxVehicleGearboxState_get_targetGear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxState_set_targetGear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxState_set_targetGear_1');
  _emscripten_bind_PxVehicleGearboxState_set_targetGear_1 = Module['_emscripten_bind_PxVehicleGearboxState_set_targetGear_1'] = createExportWrapper('emscripten_bind_PxVehicleGearboxState_set_targetGear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxState_get_gearSwitchTime_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxState_get_gearSwitchTime_0');
  _emscripten_bind_PxVehicleGearboxState_get_gearSwitchTime_0 = Module['_emscripten_bind_PxVehicleGearboxState_get_gearSwitchTime_0'] = createExportWrapper('emscripten_bind_PxVehicleGearboxState_get_gearSwitchTime_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxState_set_gearSwitchTime_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxState_set_gearSwitchTime_1');
  _emscripten_bind_PxVehicleGearboxState_set_gearSwitchTime_1 = Module['_emscripten_bind_PxVehicleGearboxState_set_gearSwitchTime_1'] = createExportWrapper('emscripten_bind_PxVehicleGearboxState_set_gearSwitchTime_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleGearboxState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleGearboxState___destroy___0');
  _emscripten_bind_PxVehicleGearboxState___destroy___0 = Module['_emscripten_bind_PxVehicleGearboxState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleGearboxState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXActor_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXActor_setToDefault_0');
  _emscripten_bind_PxVehiclePhysXActor_setToDefault_0 = Module['_emscripten_bind_PxVehiclePhysXActor_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXActor_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXActor_get_rigidBody_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXActor_get_rigidBody_0');
  _emscripten_bind_PxVehiclePhysXActor_get_rigidBody_0 = Module['_emscripten_bind_PxVehiclePhysXActor_get_rigidBody_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXActor_get_rigidBody_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXActor_set_rigidBody_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXActor_set_rigidBody_1');
  _emscripten_bind_PxVehiclePhysXActor_set_rigidBody_1 = Module['_emscripten_bind_PxVehiclePhysXActor_set_rigidBody_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXActor_set_rigidBody_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXActor_get_wheelShapes_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXActor_get_wheelShapes_1');
  _emscripten_bind_PxVehiclePhysXActor_get_wheelShapes_1 = Module['_emscripten_bind_PxVehiclePhysXActor_get_wheelShapes_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXActor_get_wheelShapes_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXActor_set_wheelShapes_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXActor_set_wheelShapes_2');
  _emscripten_bind_PxVehiclePhysXActor_set_wheelShapes_2 = Module['_emscripten_bind_PxVehiclePhysXActor_set_wheelShapes_2'] = createExportWrapper('emscripten_bind_PxVehiclePhysXActor_set_wheelShapes_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXActor___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXActor___destroy___0');
  _emscripten_bind_PxVehiclePhysXActor___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXActor___destroy___0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXActor___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_PxVehiclePhysXConstraintState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_PxVehiclePhysXConstraintState_0');
  _emscripten_bind_PxVehiclePhysXConstraintState_PxVehiclePhysXConstraintState_0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_PxVehiclePhysXConstraintState_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_PxVehiclePhysXConstraintState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_setToDefault_0');
  _emscripten_bind_PxVehiclePhysXConstraintState_setToDefault_0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_get_tireActiveStatus_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_get_tireActiveStatus_1');
  _emscripten_bind_PxVehiclePhysXConstraintState_get_tireActiveStatus_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_tireActiveStatus_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_get_tireActiveStatus_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_set_tireActiveStatus_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_set_tireActiveStatus_2');
  _emscripten_bind_PxVehiclePhysXConstraintState_set_tireActiveStatus_2 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_tireActiveStatus_2'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_set_tireActiveStatus_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_get_tireLinears_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_get_tireLinears_1');
  _emscripten_bind_PxVehiclePhysXConstraintState_get_tireLinears_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_tireLinears_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_get_tireLinears_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_set_tireLinears_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_set_tireLinears_2');
  _emscripten_bind_PxVehiclePhysXConstraintState_set_tireLinears_2 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_tireLinears_2'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_set_tireLinears_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_get_tireAngulars_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_get_tireAngulars_1');
  _emscripten_bind_PxVehiclePhysXConstraintState_get_tireAngulars_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_tireAngulars_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_get_tireAngulars_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_set_tireAngulars_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_set_tireAngulars_2');
  _emscripten_bind_PxVehiclePhysXConstraintState_set_tireAngulars_2 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_tireAngulars_2'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_set_tireAngulars_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_get_tireDamping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_get_tireDamping_1');
  _emscripten_bind_PxVehiclePhysXConstraintState_get_tireDamping_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_tireDamping_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_get_tireDamping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_set_tireDamping_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_set_tireDamping_2');
  _emscripten_bind_PxVehiclePhysXConstraintState_set_tireDamping_2 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_tireDamping_2'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_set_tireDamping_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_get_suspActiveStatus_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_get_suspActiveStatus_0');
  _emscripten_bind_PxVehiclePhysXConstraintState_get_suspActiveStatus_0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_suspActiveStatus_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_get_suspActiveStatus_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_set_suspActiveStatus_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_set_suspActiveStatus_1');
  _emscripten_bind_PxVehiclePhysXConstraintState_set_suspActiveStatus_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_suspActiveStatus_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_set_suspActiveStatus_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_get_suspLinear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_get_suspLinear_0');
  _emscripten_bind_PxVehiclePhysXConstraintState_get_suspLinear_0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_suspLinear_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_get_suspLinear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_set_suspLinear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_set_suspLinear_1');
  _emscripten_bind_PxVehiclePhysXConstraintState_set_suspLinear_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_suspLinear_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_set_suspLinear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_get_suspAngular_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_get_suspAngular_0');
  _emscripten_bind_PxVehiclePhysXConstraintState_get_suspAngular_0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_suspAngular_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_get_suspAngular_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_set_suspAngular_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_set_suspAngular_1');
  _emscripten_bind_PxVehiclePhysXConstraintState_set_suspAngular_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_suspAngular_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_set_suspAngular_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_get_suspGeometricError_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_get_suspGeometricError_0');
  _emscripten_bind_PxVehiclePhysXConstraintState_get_suspGeometricError_0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_suspGeometricError_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_get_suspGeometricError_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_set_suspGeometricError_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_set_suspGeometricError_1');
  _emscripten_bind_PxVehiclePhysXConstraintState_set_suspGeometricError_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_suspGeometricError_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_set_suspGeometricError_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_get_restitution_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_get_restitution_0');
  _emscripten_bind_PxVehiclePhysXConstraintState_get_restitution_0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_get_restitution_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_get_restitution_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState_set_restitution_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState_set_restitution_1');
  _emscripten_bind_PxVehiclePhysXConstraintState_set_restitution_1 = Module['_emscripten_bind_PxVehiclePhysXConstraintState_set_restitution_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState_set_restitution_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraintState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraintState___destroy___0');
  _emscripten_bind_PxVehiclePhysXConstraintState___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXConstraintState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraintState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraints_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraints_setToDefault_0');
  _emscripten_bind_PxVehiclePhysXConstraints_setToDefault_0 = Module['_emscripten_bind_PxVehiclePhysXConstraints_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraints_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraints_get_constraintStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraints_get_constraintStates_1');
  _emscripten_bind_PxVehiclePhysXConstraints_get_constraintStates_1 = Module['_emscripten_bind_PxVehiclePhysXConstraints_get_constraintStates_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraints_get_constraintStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraints_set_constraintStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraints_set_constraintStates_2');
  _emscripten_bind_PxVehiclePhysXConstraints_set_constraintStates_2 = Module['_emscripten_bind_PxVehiclePhysXConstraints_set_constraintStates_2'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraints_set_constraintStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraints_get_constraints_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraints_get_constraints_1');
  _emscripten_bind_PxVehiclePhysXConstraints_get_constraints_1 = Module['_emscripten_bind_PxVehiclePhysXConstraints_get_constraints_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraints_get_constraints_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraints_set_constraints_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraints_set_constraints_2');
  _emscripten_bind_PxVehiclePhysXConstraints_set_constraints_2 = Module['_emscripten_bind_PxVehiclePhysXConstraints_set_constraints_2'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraints_set_constraints_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraints_get_constraintConnectors_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraints_get_constraintConnectors_1');
  _emscripten_bind_PxVehiclePhysXConstraints_get_constraintConnectors_1 = Module['_emscripten_bind_PxVehiclePhysXConstraints_get_constraintConnectors_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraints_get_constraintConnectors_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraints_set_constraintConnectors_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraints_set_constraintConnectors_2');
  _emscripten_bind_PxVehiclePhysXConstraints_set_constraintConnectors_2 = Module['_emscripten_bind_PxVehiclePhysXConstraints_set_constraintConnectors_2'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraints_set_constraintConnectors_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXConstraints___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXConstraints___destroy___0');
  _emscripten_bind_PxVehiclePhysXConstraints___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXConstraints___destroy___0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXConstraints___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFriction_PxVehiclePhysXMaterialFriction_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFriction_PxVehiclePhysXMaterialFriction_0');
  _emscripten_bind_PxVehiclePhysXMaterialFriction_PxVehiclePhysXMaterialFriction_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFriction_PxVehiclePhysXMaterialFriction_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFriction_PxVehiclePhysXMaterialFriction_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFriction_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFriction_isValid_0');
  _emscripten_bind_PxVehiclePhysXMaterialFriction_isValid_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFriction_isValid_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFriction_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFriction_get_material_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFriction_get_material_0');
  _emscripten_bind_PxVehiclePhysXMaterialFriction_get_material_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFriction_get_material_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFriction_get_material_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFriction_set_material_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFriction_set_material_1');
  _emscripten_bind_PxVehiclePhysXMaterialFriction_set_material_1 = Module['_emscripten_bind_PxVehiclePhysXMaterialFriction_set_material_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFriction_set_material_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFriction_get_friction_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFriction_get_friction_0');
  _emscripten_bind_PxVehiclePhysXMaterialFriction_get_friction_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFriction_get_friction_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFriction_get_friction_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFriction_set_friction_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFriction_set_friction_1');
  _emscripten_bind_PxVehiclePhysXMaterialFriction_set_friction_1 = Module['_emscripten_bind_PxVehiclePhysXMaterialFriction_set_friction_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFriction_set_friction_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFriction___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFriction___destroy___0');
  _emscripten_bind_PxVehiclePhysXMaterialFriction___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFriction___destroy___0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFriction___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFrictionParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFrictionParams_isValid_0');
  _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_isValid_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFrictionParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_materialFrictions_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_materialFrictions_0');
  _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_materialFrictions_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_materialFrictions_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_materialFrictions_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_materialFrictions_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_materialFrictions_1');
  _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_materialFrictions_1 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_materialFrictions_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_materialFrictions_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_nbMaterialFrictions_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_nbMaterialFrictions_0');
  _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_nbMaterialFrictions_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_nbMaterialFrictions_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_nbMaterialFrictions_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_nbMaterialFrictions_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_nbMaterialFrictions_1');
  _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_nbMaterialFrictions_1 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_nbMaterialFrictions_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_nbMaterialFrictions_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_defaultFriction_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_defaultFriction_0');
  _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_defaultFriction_0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_defaultFriction_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_defaultFriction_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_defaultFriction_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_defaultFriction_1');
  _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_defaultFriction_1 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_defaultFriction_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_defaultFriction_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXMaterialFrictionParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXMaterialFrictionParams___destroy___0');
  _emscripten_bind_PxVehiclePhysXMaterialFrictionParams___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXMaterialFrictionParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXMaterialFrictionParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_transformAndScale_4');
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_transformAndScale_4 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_isValid_0');
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_isValid_0 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_roadGeometryQueryType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_roadGeometryQueryType_0');
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_roadGeometryQueryType_0 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_roadGeometryQueryType_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_roadGeometryQueryType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_roadGeometryQueryType_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_roadGeometryQueryType_1');
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_roadGeometryQueryType_1 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_roadGeometryQueryType_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_roadGeometryQueryType_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_defaultFilterData_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_defaultFilterData_0');
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_defaultFilterData_0 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_defaultFilterData_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_defaultFilterData_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_defaultFilterData_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_defaultFilterData_1');
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_defaultFilterData_1 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_defaultFilterData_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_defaultFilterData_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterDataEntries_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterDataEntries_0');
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterDataEntries_0 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterDataEntries_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterDataEntries_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterDataEntries_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterDataEntries_1');
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterDataEntries_1 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterDataEntries_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterDataEntries_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterCallback_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterCallback_0');
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterCallback_0 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterCallback_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterCallback_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterCallback_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterCallback_1');
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterCallback_1 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterCallback_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterCallback_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams___destroy___0');
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_PxVehiclePhysXSimulationContext_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_PxVehiclePhysXSimulationContext_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_PxVehiclePhysXSimulationContext_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_PxVehiclePhysXSimulationContext_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_PxVehiclePhysXSimulationContext_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_transformAndScale_4');
  _emscripten_bind_PxVehiclePhysXSimulationContext_transformAndScale_4 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_getType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_getType_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_getType_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_getType_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_getType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_setToDefault_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_setToDefault_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_get_physxUnitCylinderSweepMesh_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_get_physxUnitCylinderSweepMesh_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_get_physxUnitCylinderSweepMesh_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxUnitCylinderSweepMesh_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_get_physxUnitCylinderSweepMesh_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_set_physxUnitCylinderSweepMesh_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_set_physxUnitCylinderSweepMesh_1');
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxUnitCylinderSweepMesh_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxUnitCylinderSweepMesh_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_set_physxUnitCylinderSweepMesh_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_get_physxScene_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_get_physxScene_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_get_physxScene_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxScene_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_get_physxScene_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_set_physxScene_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_set_physxScene_1');
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxScene_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxScene_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_set_physxScene_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorUpdateMode_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorUpdateMode_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorUpdateMode_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorUpdateMode_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorUpdateMode_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorUpdateMode_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorUpdateMode_1');
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorUpdateMode_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorUpdateMode_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorUpdateMode_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterResetValue_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterResetValue_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterResetValue_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterResetValue_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterResetValue_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterResetValue_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterResetValue_1');
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterResetValue_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterResetValue_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterResetValue_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterThreshold_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterThreshold_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterThreshold_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterThreshold_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterThreshold_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterThreshold_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterThreshold_1');
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterThreshold_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterThreshold_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterThreshold_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_get_gravity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_get_gravity_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_get_gravity_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_gravity_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_get_gravity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_set_gravity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_set_gravity_1');
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_gravity_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_gravity_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_set_gravity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_get_frame_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_get_frame_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_get_frame_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_frame_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_get_frame_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_set_frame_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_set_frame_1');
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_frame_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_frame_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_set_frame_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_get_scale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_get_scale_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_get_scale_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_scale_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_get_scale_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_set_scale_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_set_scale_1');
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_scale_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_scale_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_set_scale_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_get_tireSlipParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_get_tireSlipParams_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_get_tireSlipParams_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_tireSlipParams_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_get_tireSlipParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_set_tireSlipParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_set_tireSlipParams_1');
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_tireSlipParams_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_tireSlipParams_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_set_tireSlipParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_get_tireStickyParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_get_tireStickyParams_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_get_tireStickyParams_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_tireStickyParams_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_get_tireStickyParams_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_set_tireStickyParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_set_tireStickyParams_1');
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_tireStickyParams_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_tireStickyParams_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_set_tireStickyParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1');
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_get_pvdContext_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_get_pvdContext_0');
  _emscripten_bind_PxVehiclePhysXSimulationContext_get_pvdContext_0 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_get_pvdContext_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_get_pvdContext_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSimulationContext_set_pvdContext_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSimulationContext_set_pvdContext_1');
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_pvdContext_1 = Module['_emscripten_bind_PxVehiclePhysXSimulationContext_set_pvdContext_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSimulationContext_set_pvdContext_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSteerState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSteerState_setToDefault_0');
  _emscripten_bind_PxVehiclePhysXSteerState_setToDefault_0 = Module['_emscripten_bind_PxVehiclePhysXSteerState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSteerState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSteerState_get_previousSteerCommand_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSteerState_get_previousSteerCommand_0');
  _emscripten_bind_PxVehiclePhysXSteerState_get_previousSteerCommand_0 = Module['_emscripten_bind_PxVehiclePhysXSteerState_get_previousSteerCommand_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSteerState_get_previousSteerCommand_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSteerState_set_previousSteerCommand_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSteerState_set_previousSteerCommand_1');
  _emscripten_bind_PxVehiclePhysXSteerState_set_previousSteerCommand_1 = Module['_emscripten_bind_PxVehiclePhysXSteerState_set_previousSteerCommand_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSteerState_set_previousSteerCommand_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSteerState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSteerState___destroy___0');
  _emscripten_bind_PxVehiclePhysXSteerState___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXSteerState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSteerState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_transformAndScale_4');
  _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_transformAndScale_4 = Module['_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_isValid_0');
  _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_isValid_0 = Module['_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_restitution_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_restitution_0');
  _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_restitution_0 = Module['_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_restitution_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_restitution_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_restitution_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_restitution_1');
  _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_restitution_1 = Module['_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_restitution_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_restitution_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_directionForSuspensionLimitConstraint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_directionForSuspensionLimitConstraint_0');
  _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_directionForSuspensionLimitConstraint_0 = Module['_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_directionForSuspensionLimitConstraint_0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_directionForSuspensionLimitConstraint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_directionForSuspensionLimitConstraint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_directionForSuspensionLimitConstraint_1');
  _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_directionForSuspensionLimitConstraint_1 = Module['_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_directionForSuspensionLimitConstraint_1'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_directionForSuspensionLimitConstraint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams___destroy___0');
  _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams___destroy___0 = Module['_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyParams_PxVehicleRigidBodyParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyParams_PxVehicleRigidBodyParams_0');
  _emscripten_bind_PxVehicleRigidBodyParams_PxVehicleRigidBodyParams_0 = Module['_emscripten_bind_PxVehicleRigidBodyParams_PxVehicleRigidBodyParams_0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyParams_PxVehicleRigidBodyParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyParams_transformAndScale_4');
  _emscripten_bind_PxVehicleRigidBodyParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleRigidBodyParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyParams_isValid_0');
  _emscripten_bind_PxVehicleRigidBodyParams_isValid_0 = Module['_emscripten_bind_PxVehicleRigidBodyParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyParams_get_mass_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyParams_get_mass_0');
  _emscripten_bind_PxVehicleRigidBodyParams_get_mass_0 = Module['_emscripten_bind_PxVehicleRigidBodyParams_get_mass_0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyParams_get_mass_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyParams_set_mass_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyParams_set_mass_1');
  _emscripten_bind_PxVehicleRigidBodyParams_set_mass_1 = Module['_emscripten_bind_PxVehicleRigidBodyParams_set_mass_1'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyParams_set_mass_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyParams_get_moi_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyParams_get_moi_0');
  _emscripten_bind_PxVehicleRigidBodyParams_get_moi_0 = Module['_emscripten_bind_PxVehicleRigidBodyParams_get_moi_0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyParams_get_moi_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyParams_set_moi_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyParams_set_moi_1');
  _emscripten_bind_PxVehicleRigidBodyParams_set_moi_1 = Module['_emscripten_bind_PxVehicleRigidBodyParams_set_moi_1'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyParams_set_moi_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyParams___destroy___0');
  _emscripten_bind_PxVehicleRigidBodyParams___destroy___0 = Module['_emscripten_bind_PxVehicleRigidBodyParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_PxVehicleRigidBodyState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_PxVehicleRigidBodyState_0');
  _emscripten_bind_PxVehicleRigidBodyState_PxVehicleRigidBodyState_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_PxVehicleRigidBodyState_0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_PxVehicleRigidBodyState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_setToDefault_0');
  _emscripten_bind_PxVehicleRigidBodyState_setToDefault_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_getVerticalSpeed_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_getVerticalSpeed_1');
  _emscripten_bind_PxVehicleRigidBodyState_getVerticalSpeed_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_getVerticalSpeed_1'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_getVerticalSpeed_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_getLateralSpeed_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_getLateralSpeed_1');
  _emscripten_bind_PxVehicleRigidBodyState_getLateralSpeed_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_getLateralSpeed_1'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_getLateralSpeed_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_getLongitudinalSpeed_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_getLongitudinalSpeed_1');
  _emscripten_bind_PxVehicleRigidBodyState_getLongitudinalSpeed_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_getLongitudinalSpeed_1'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_getLongitudinalSpeed_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_get_pose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_get_pose_0');
  _emscripten_bind_PxVehicleRigidBodyState_get_pose_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_get_pose_0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_get_pose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_set_pose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_set_pose_1');
  _emscripten_bind_PxVehicleRigidBodyState_set_pose_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_set_pose_1'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_set_pose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_get_linearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_get_linearVelocity_0');
  _emscripten_bind_PxVehicleRigidBodyState_get_linearVelocity_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_get_linearVelocity_0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_get_linearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_set_linearVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_set_linearVelocity_1');
  _emscripten_bind_PxVehicleRigidBodyState_set_linearVelocity_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_set_linearVelocity_1'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_set_linearVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_get_angularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_get_angularVelocity_0');
  _emscripten_bind_PxVehicleRigidBodyState_get_angularVelocity_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_get_angularVelocity_0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_get_angularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_set_angularVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_set_angularVelocity_1');
  _emscripten_bind_PxVehicleRigidBodyState_set_angularVelocity_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_set_angularVelocity_1'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_set_angularVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_get_previousLinearVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_get_previousLinearVelocity_0');
  _emscripten_bind_PxVehicleRigidBodyState_get_previousLinearVelocity_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_get_previousLinearVelocity_0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_get_previousLinearVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_set_previousLinearVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_set_previousLinearVelocity_1');
  _emscripten_bind_PxVehicleRigidBodyState_set_previousLinearVelocity_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_set_previousLinearVelocity_1'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_set_previousLinearVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_get_previousAngularVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_get_previousAngularVelocity_0');
  _emscripten_bind_PxVehicleRigidBodyState_get_previousAngularVelocity_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_get_previousAngularVelocity_0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_get_previousAngularVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_set_previousAngularVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_set_previousAngularVelocity_1');
  _emscripten_bind_PxVehicleRigidBodyState_set_previousAngularVelocity_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_set_previousAngularVelocity_1'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_set_previousAngularVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_get_externalForce_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_get_externalForce_0');
  _emscripten_bind_PxVehicleRigidBodyState_get_externalForce_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_get_externalForce_0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_get_externalForce_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_set_externalForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_set_externalForce_1');
  _emscripten_bind_PxVehicleRigidBodyState_set_externalForce_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_set_externalForce_1'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_set_externalForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_get_externalTorque_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_get_externalTorque_0');
  _emscripten_bind_PxVehicleRigidBodyState_get_externalTorque_0 = Module['_emscripten_bind_PxVehicleRigidBodyState_get_externalTorque_0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_get_externalTorque_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState_set_externalTorque_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState_set_externalTorque_1');
  _emscripten_bind_PxVehicleRigidBodyState_set_externalTorque_1 = Module['_emscripten_bind_PxVehicleRigidBodyState_set_externalTorque_1'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState_set_externalTorque_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRigidBodyState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRigidBodyState___destroy___0');
  _emscripten_bind_PxVehicleRigidBodyState___destroy___0 = Module['_emscripten_bind_PxVehicleRigidBodyState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleRigidBodyState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRoadGeometryState_PxVehicleRoadGeometryState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRoadGeometryState_PxVehicleRoadGeometryState_0');
  _emscripten_bind_PxVehicleRoadGeometryState_PxVehicleRoadGeometryState_0 = Module['_emscripten_bind_PxVehicleRoadGeometryState_PxVehicleRoadGeometryState_0'] = createExportWrapper('emscripten_bind_PxVehicleRoadGeometryState_PxVehicleRoadGeometryState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRoadGeometryState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRoadGeometryState_setToDefault_0');
  _emscripten_bind_PxVehicleRoadGeometryState_setToDefault_0 = Module['_emscripten_bind_PxVehicleRoadGeometryState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleRoadGeometryState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRoadGeometryState_get_plane_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRoadGeometryState_get_plane_0');
  _emscripten_bind_PxVehicleRoadGeometryState_get_plane_0 = Module['_emscripten_bind_PxVehicleRoadGeometryState_get_plane_0'] = createExportWrapper('emscripten_bind_PxVehicleRoadGeometryState_get_plane_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRoadGeometryState_set_plane_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRoadGeometryState_set_plane_1');
  _emscripten_bind_PxVehicleRoadGeometryState_set_plane_1 = Module['_emscripten_bind_PxVehicleRoadGeometryState_set_plane_1'] = createExportWrapper('emscripten_bind_PxVehicleRoadGeometryState_set_plane_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRoadGeometryState_get_friction_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRoadGeometryState_get_friction_0');
  _emscripten_bind_PxVehicleRoadGeometryState_get_friction_0 = Module['_emscripten_bind_PxVehicleRoadGeometryState_get_friction_0'] = createExportWrapper('emscripten_bind_PxVehicleRoadGeometryState_get_friction_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRoadGeometryState_set_friction_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRoadGeometryState_set_friction_1');
  _emscripten_bind_PxVehicleRoadGeometryState_set_friction_1 = Module['_emscripten_bind_PxVehicleRoadGeometryState_set_friction_1'] = createExportWrapper('emscripten_bind_PxVehicleRoadGeometryState_set_friction_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRoadGeometryState_get_velocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRoadGeometryState_get_velocity_0');
  _emscripten_bind_PxVehicleRoadGeometryState_get_velocity_0 = Module['_emscripten_bind_PxVehicleRoadGeometryState_get_velocity_0'] = createExportWrapper('emscripten_bind_PxVehicleRoadGeometryState_get_velocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRoadGeometryState_set_velocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRoadGeometryState_set_velocity_1');
  _emscripten_bind_PxVehicleRoadGeometryState_set_velocity_1 = Module['_emscripten_bind_PxVehicleRoadGeometryState_set_velocity_1'] = createExportWrapper('emscripten_bind_PxVehicleRoadGeometryState_set_velocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRoadGeometryState_get_hitState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRoadGeometryState_get_hitState_0');
  _emscripten_bind_PxVehicleRoadGeometryState_get_hitState_0 = Module['_emscripten_bind_PxVehicleRoadGeometryState_get_hitState_0'] = createExportWrapper('emscripten_bind_PxVehicleRoadGeometryState_get_hitState_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRoadGeometryState_set_hitState_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRoadGeometryState_set_hitState_1');
  _emscripten_bind_PxVehicleRoadGeometryState_set_hitState_1 = Module['_emscripten_bind_PxVehicleRoadGeometryState_set_hitState_1'] = createExportWrapper('emscripten_bind_PxVehicleRoadGeometryState_set_hitState_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleRoadGeometryState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleRoadGeometryState___destroy___0');
  _emscripten_bind_PxVehicleRoadGeometryState___destroy___0 = Module['_emscripten_bind_PxVehicleRoadGeometryState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleRoadGeometryState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleScale_PxVehicleScale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleScale_PxVehicleScale_0');
  _emscripten_bind_PxVehicleScale_PxVehicleScale_0 = Module['_emscripten_bind_PxVehicleScale_PxVehicleScale_0'] = createExportWrapper('emscripten_bind_PxVehicleScale_PxVehicleScale_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleScale_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleScale_setToDefault_0');
  _emscripten_bind_PxVehicleScale_setToDefault_0 = Module['_emscripten_bind_PxVehicleScale_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleScale_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleScale_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleScale_isValid_0');
  _emscripten_bind_PxVehicleScale_isValid_0 = Module['_emscripten_bind_PxVehicleScale_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleScale_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleScale_get_scale_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleScale_get_scale_0');
  _emscripten_bind_PxVehicleScale_get_scale_0 = Module['_emscripten_bind_PxVehicleScale_get_scale_0'] = createExportWrapper('emscripten_bind_PxVehicleScale_get_scale_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleScale_set_scale_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleScale_set_scale_1');
  _emscripten_bind_PxVehicleScale_set_scale_1 = Module['_emscripten_bind_PxVehicleScale_set_scale_1'] = createExportWrapper('emscripten_bind_PxVehicleScale_set_scale_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleScale___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleScale___destroy___0');
  _emscripten_bind_PxVehicleScale___destroy___0 = Module['_emscripten_bind_PxVehicleScale___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleScale___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSteerCommandResponseParams_PxVehicleSteerCommandResponseParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSteerCommandResponseParams_PxVehicleSteerCommandResponseParams_0');
  _emscripten_bind_PxVehicleSteerCommandResponseParams_PxVehicleSteerCommandResponseParams_0 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_PxVehicleSteerCommandResponseParams_0'] = createExportWrapper('emscripten_bind_PxVehicleSteerCommandResponseParams_PxVehicleSteerCommandResponseParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSteerCommandResponseParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSteerCommandResponseParams_transformAndScale_4');
  _emscripten_bind_PxVehicleSteerCommandResponseParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleSteerCommandResponseParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSteerCommandResponseParams_isValid_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSteerCommandResponseParams_isValid_1');
  _emscripten_bind_PxVehicleSteerCommandResponseParams_isValid_1 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_isValid_1'] = createExportWrapper('emscripten_bind_PxVehicleSteerCommandResponseParams_isValid_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSteerCommandResponseParams_get_nonlinearResponse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSteerCommandResponseParams_get_nonlinearResponse_0');
  _emscripten_bind_PxVehicleSteerCommandResponseParams_get_nonlinearResponse_0 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_get_nonlinearResponse_0'] = createExportWrapper('emscripten_bind_PxVehicleSteerCommandResponseParams_get_nonlinearResponse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSteerCommandResponseParams_set_nonlinearResponse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSteerCommandResponseParams_set_nonlinearResponse_1');
  _emscripten_bind_PxVehicleSteerCommandResponseParams_set_nonlinearResponse_1 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_set_nonlinearResponse_1'] = createExportWrapper('emscripten_bind_PxVehicleSteerCommandResponseParams_set_nonlinearResponse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSteerCommandResponseParams_get_wheelResponseMultipliers_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSteerCommandResponseParams_get_wheelResponseMultipliers_1');
  _emscripten_bind_PxVehicleSteerCommandResponseParams_get_wheelResponseMultipliers_1 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_get_wheelResponseMultipliers_1'] = createExportWrapper('emscripten_bind_PxVehicleSteerCommandResponseParams_get_wheelResponseMultipliers_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSteerCommandResponseParams_set_wheelResponseMultipliers_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSteerCommandResponseParams_set_wheelResponseMultipliers_2');
  _emscripten_bind_PxVehicleSteerCommandResponseParams_set_wheelResponseMultipliers_2 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_set_wheelResponseMultipliers_2'] = createExportWrapper('emscripten_bind_PxVehicleSteerCommandResponseParams_set_wheelResponseMultipliers_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSteerCommandResponseParams_get_maxResponse_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSteerCommandResponseParams_get_maxResponse_0');
  _emscripten_bind_PxVehicleSteerCommandResponseParams_get_maxResponse_0 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_get_maxResponse_0'] = createExportWrapper('emscripten_bind_PxVehicleSteerCommandResponseParams_get_maxResponse_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSteerCommandResponseParams_set_maxResponse_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSteerCommandResponseParams_set_maxResponse_1');
  _emscripten_bind_PxVehicleSteerCommandResponseParams_set_maxResponse_1 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams_set_maxResponse_1'] = createExportWrapper('emscripten_bind_PxVehicleSteerCommandResponseParams_set_maxResponse_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSteerCommandResponseParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSteerCommandResponseParams___destroy___0');
  _emscripten_bind_PxVehicleSteerCommandResponseParams___destroy___0 = Module['_emscripten_bind_PxVehicleSteerCommandResponseParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleSteerCommandResponseParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceParams_PxVehicleSuspensionComplianceParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceParams_PxVehicleSuspensionComplianceParams_0');
  _emscripten_bind_PxVehicleSuspensionComplianceParams_PxVehicleSuspensionComplianceParams_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_PxVehicleSuspensionComplianceParams_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceParams_PxVehicleSuspensionComplianceParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceParams_transformAndScale_4');
  _emscripten_bind_PxVehicleSuspensionComplianceParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceParams_isValid_0');
  _emscripten_bind_PxVehicleSuspensionComplianceParams_isValid_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelToeAngle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelToeAngle_0');
  _emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelToeAngle_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelToeAngle_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelToeAngle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelToeAngle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelToeAngle_1');
  _emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelToeAngle_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelToeAngle_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelToeAngle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelCamberAngle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelCamberAngle_0');
  _emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelCamberAngle_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelCamberAngle_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelCamberAngle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelCamberAngle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelCamberAngle_1');
  _emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelCamberAngle_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelCamberAngle_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelCamberAngle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceParams_get_suspForceAppPoint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceParams_get_suspForceAppPoint_0');
  _emscripten_bind_PxVehicleSuspensionComplianceParams_get_suspForceAppPoint_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_get_suspForceAppPoint_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceParams_get_suspForceAppPoint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceParams_set_suspForceAppPoint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceParams_set_suspForceAppPoint_1');
  _emscripten_bind_PxVehicleSuspensionComplianceParams_set_suspForceAppPoint_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_set_suspForceAppPoint_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceParams_set_suspForceAppPoint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceParams_get_tireForceAppPoint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceParams_get_tireForceAppPoint_0');
  _emscripten_bind_PxVehicleSuspensionComplianceParams_get_tireForceAppPoint_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_get_tireForceAppPoint_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceParams_get_tireForceAppPoint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceParams_set_tireForceAppPoint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceParams_set_tireForceAppPoint_1');
  _emscripten_bind_PxVehicleSuspensionComplianceParams_set_tireForceAppPoint_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams_set_tireForceAppPoint_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceParams_set_tireForceAppPoint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceParams___destroy___0');
  _emscripten_bind_PxVehicleSuspensionComplianceParams___destroy___0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceState_PxVehicleSuspensionComplianceState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceState_PxVehicleSuspensionComplianceState_0');
  _emscripten_bind_PxVehicleSuspensionComplianceState_PxVehicleSuspensionComplianceState_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_PxVehicleSuspensionComplianceState_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceState_PxVehicleSuspensionComplianceState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceState_setToDefault_0');
  _emscripten_bind_PxVehicleSuspensionComplianceState_setToDefault_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceState_get_toe_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceState_get_toe_0');
  _emscripten_bind_PxVehicleSuspensionComplianceState_get_toe_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_get_toe_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceState_get_toe_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceState_set_toe_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceState_set_toe_1');
  _emscripten_bind_PxVehicleSuspensionComplianceState_set_toe_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_set_toe_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceState_set_toe_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceState_get_camber_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceState_get_camber_0');
  _emscripten_bind_PxVehicleSuspensionComplianceState_get_camber_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_get_camber_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceState_get_camber_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceState_set_camber_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceState_set_camber_1');
  _emscripten_bind_PxVehicleSuspensionComplianceState_set_camber_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_set_camber_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceState_set_camber_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceState_get_tireForceAppPoint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceState_get_tireForceAppPoint_0');
  _emscripten_bind_PxVehicleSuspensionComplianceState_get_tireForceAppPoint_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_get_tireForceAppPoint_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceState_get_tireForceAppPoint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceState_set_tireForceAppPoint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceState_set_tireForceAppPoint_1');
  _emscripten_bind_PxVehicleSuspensionComplianceState_set_tireForceAppPoint_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_set_tireForceAppPoint_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceState_set_tireForceAppPoint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceState_get_suspForceAppPoint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceState_get_suspForceAppPoint_0');
  _emscripten_bind_PxVehicleSuspensionComplianceState_get_suspForceAppPoint_0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_get_suspForceAppPoint_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceState_get_suspForceAppPoint_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceState_set_suspForceAppPoint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceState_set_suspForceAppPoint_1');
  _emscripten_bind_PxVehicleSuspensionComplianceState_set_suspForceAppPoint_1 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState_set_suspForceAppPoint_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceState_set_suspForceAppPoint_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionComplianceState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionComplianceState___destroy___0');
  _emscripten_bind_PxVehicleSuspensionComplianceState___destroy___0 = Module['_emscripten_bind_PxVehicleSuspensionComplianceState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionComplianceState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForce_PxVehicleSuspensionForce_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForce_PxVehicleSuspensionForce_0');
  _emscripten_bind_PxVehicleSuspensionForce_PxVehicleSuspensionForce_0 = Module['_emscripten_bind_PxVehicleSuspensionForce_PxVehicleSuspensionForce_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForce_PxVehicleSuspensionForce_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForce_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForce_setToDefault_0');
  _emscripten_bind_PxVehicleSuspensionForce_setToDefault_0 = Module['_emscripten_bind_PxVehicleSuspensionForce_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForce_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForce_get_force_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForce_get_force_0');
  _emscripten_bind_PxVehicleSuspensionForce_get_force_0 = Module['_emscripten_bind_PxVehicleSuspensionForce_get_force_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForce_get_force_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForce_set_force_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForce_set_force_1');
  _emscripten_bind_PxVehicleSuspensionForce_set_force_1 = Module['_emscripten_bind_PxVehicleSuspensionForce_set_force_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForce_set_force_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForce_get_torque_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForce_get_torque_0');
  _emscripten_bind_PxVehicleSuspensionForce_get_torque_0 = Module['_emscripten_bind_PxVehicleSuspensionForce_get_torque_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForce_get_torque_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForce_set_torque_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForce_set_torque_1');
  _emscripten_bind_PxVehicleSuspensionForce_set_torque_1 = Module['_emscripten_bind_PxVehicleSuspensionForce_set_torque_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForce_set_torque_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForce_get_normalForce_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForce_get_normalForce_0');
  _emscripten_bind_PxVehicleSuspensionForce_get_normalForce_0 = Module['_emscripten_bind_PxVehicleSuspensionForce_get_normalForce_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForce_get_normalForce_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForce_set_normalForce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForce_set_normalForce_1');
  _emscripten_bind_PxVehicleSuspensionForce_set_normalForce_1 = Module['_emscripten_bind_PxVehicleSuspensionForce_set_normalForce_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForce_set_normalForce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForce___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForce___destroy___0');
  _emscripten_bind_PxVehicleSuspensionForce___destroy___0 = Module['_emscripten_bind_PxVehicleSuspensionForce___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForce___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForceParams_PxVehicleSuspensionForceParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForceParams_PxVehicleSuspensionForceParams_0');
  _emscripten_bind_PxVehicleSuspensionForceParams_PxVehicleSuspensionForceParams_0 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_PxVehicleSuspensionForceParams_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForceParams_PxVehicleSuspensionForceParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForceParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForceParams_transformAndScale_4');
  _emscripten_bind_PxVehicleSuspensionForceParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForceParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForceParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForceParams_isValid_0');
  _emscripten_bind_PxVehicleSuspensionForceParams_isValid_0 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForceParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForceParams_get_stiffness_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForceParams_get_stiffness_0');
  _emscripten_bind_PxVehicleSuspensionForceParams_get_stiffness_0 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_get_stiffness_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForceParams_get_stiffness_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForceParams_set_stiffness_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForceParams_set_stiffness_1');
  _emscripten_bind_PxVehicleSuspensionForceParams_set_stiffness_1 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_set_stiffness_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForceParams_set_stiffness_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForceParams_get_damping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForceParams_get_damping_0');
  _emscripten_bind_PxVehicleSuspensionForceParams_get_damping_0 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_get_damping_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForceParams_get_damping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForceParams_set_damping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForceParams_set_damping_1');
  _emscripten_bind_PxVehicleSuspensionForceParams_set_damping_1 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_set_damping_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForceParams_set_damping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForceParams_get_sprungMass_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForceParams_get_sprungMass_0');
  _emscripten_bind_PxVehicleSuspensionForceParams_get_sprungMass_0 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_get_sprungMass_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForceParams_get_sprungMass_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForceParams_set_sprungMass_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForceParams_set_sprungMass_1');
  _emscripten_bind_PxVehicleSuspensionForceParams_set_sprungMass_1 = Module['_emscripten_bind_PxVehicleSuspensionForceParams_set_sprungMass_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForceParams_set_sprungMass_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionForceParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionForceParams___destroy___0');
  _emscripten_bind_PxVehicleSuspensionForceParams___destroy___0 = Module['_emscripten_bind_PxVehicleSuspensionForceParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionForceParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionParams_PxVehicleSuspensionParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionParams_PxVehicleSuspensionParams_0');
  _emscripten_bind_PxVehicleSuspensionParams_PxVehicleSuspensionParams_0 = Module['_emscripten_bind_PxVehicleSuspensionParams_PxVehicleSuspensionParams_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionParams_PxVehicleSuspensionParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionParams_transformAndScale_4');
  _emscripten_bind_PxVehicleSuspensionParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleSuspensionParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionParams_isValid_0');
  _emscripten_bind_PxVehicleSuspensionParams_isValid_0 = Module['_emscripten_bind_PxVehicleSuspensionParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionParams_get_suspensionAttachment_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionParams_get_suspensionAttachment_0');
  _emscripten_bind_PxVehicleSuspensionParams_get_suspensionAttachment_0 = Module['_emscripten_bind_PxVehicleSuspensionParams_get_suspensionAttachment_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionParams_get_suspensionAttachment_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionParams_set_suspensionAttachment_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionParams_set_suspensionAttachment_1');
  _emscripten_bind_PxVehicleSuspensionParams_set_suspensionAttachment_1 = Module['_emscripten_bind_PxVehicleSuspensionParams_set_suspensionAttachment_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionParams_set_suspensionAttachment_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDir_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDir_0');
  _emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDir_0 = Module['_emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDir_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDir_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDir_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDir_1');
  _emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDir_1 = Module['_emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDir_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDir_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDist_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDist_0');
  _emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDist_0 = Module['_emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDist_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDist_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDist_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDist_1');
  _emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDist_1 = Module['_emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDist_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDist_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionParams_get_wheelAttachment_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionParams_get_wheelAttachment_0');
  _emscripten_bind_PxVehicleSuspensionParams_get_wheelAttachment_0 = Module['_emscripten_bind_PxVehicleSuspensionParams_get_wheelAttachment_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionParams_get_wheelAttachment_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionParams_set_wheelAttachment_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionParams_set_wheelAttachment_1');
  _emscripten_bind_PxVehicleSuspensionParams_set_wheelAttachment_1 = Module['_emscripten_bind_PxVehicleSuspensionParams_set_wheelAttachment_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionParams_set_wheelAttachment_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionParams___destroy___0');
  _emscripten_bind_PxVehicleSuspensionParams___destroy___0 = Module['_emscripten_bind_PxVehicleSuspensionParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionState_PxVehicleSuspensionState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionState_PxVehicleSuspensionState_0');
  _emscripten_bind_PxVehicleSuspensionState_PxVehicleSuspensionState_0 = Module['_emscripten_bind_PxVehicleSuspensionState_PxVehicleSuspensionState_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionState_PxVehicleSuspensionState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionState_setToDefault_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionState_setToDefault_2');
  _emscripten_bind_PxVehicleSuspensionState_setToDefault_2 = Module['_emscripten_bind_PxVehicleSuspensionState_setToDefault_2'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionState_setToDefault_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionState_get_jounce_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionState_get_jounce_0');
  _emscripten_bind_PxVehicleSuspensionState_get_jounce_0 = Module['_emscripten_bind_PxVehicleSuspensionState_get_jounce_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionState_get_jounce_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionState_set_jounce_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionState_set_jounce_1');
  _emscripten_bind_PxVehicleSuspensionState_set_jounce_1 = Module['_emscripten_bind_PxVehicleSuspensionState_set_jounce_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionState_set_jounce_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionState_get_jounceSpeed_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionState_get_jounceSpeed_0');
  _emscripten_bind_PxVehicleSuspensionState_get_jounceSpeed_0 = Module['_emscripten_bind_PxVehicleSuspensionState_get_jounceSpeed_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionState_get_jounceSpeed_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionState_set_jounceSpeed_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionState_set_jounceSpeed_1');
  _emscripten_bind_PxVehicleSuspensionState_set_jounceSpeed_1 = Module['_emscripten_bind_PxVehicleSuspensionState_set_jounceSpeed_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionState_set_jounceSpeed_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionState_get_separation_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionState_get_separation_0');
  _emscripten_bind_PxVehicleSuspensionState_get_separation_0 = Module['_emscripten_bind_PxVehicleSuspensionState_get_separation_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionState_get_separation_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionState_set_separation_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionState_set_separation_1');
  _emscripten_bind_PxVehicleSuspensionState_set_separation_1 = Module['_emscripten_bind_PxVehicleSuspensionState_set_separation_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionState_set_separation_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionState___destroy___0');
  _emscripten_bind_PxVehicleSuspensionState___destroy___0 = Module['_emscripten_bind_PxVehicleSuspensionState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionStateCalculationParams_PxVehicleSuspensionStateCalculationParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionStateCalculationParams_PxVehicleSuspensionStateCalculationParams_0');
  _emscripten_bind_PxVehicleSuspensionStateCalculationParams_PxVehicleSuspensionStateCalculationParams_0 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams_PxVehicleSuspensionStateCalculationParams_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionStateCalculationParams_PxVehicleSuspensionStateCalculationParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionStateCalculationParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionStateCalculationParams_transformAndScale_4');
  _emscripten_bind_PxVehicleSuspensionStateCalculationParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionStateCalculationParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionStateCalculationParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionStateCalculationParams_isValid_0');
  _emscripten_bind_PxVehicleSuspensionStateCalculationParams_isValid_0 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionStateCalculationParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_suspensionJounceCalculationType_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_suspensionJounceCalculationType_0');
  _emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_suspensionJounceCalculationType_0 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_suspensionJounceCalculationType_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_suspensionJounceCalculationType_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_suspensionJounceCalculationType_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_suspensionJounceCalculationType_1');
  _emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_suspensionJounceCalculationType_1 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_suspensionJounceCalculationType_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_suspensionJounceCalculationType_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_limitSuspensionExpansionVelocity_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_limitSuspensionExpansionVelocity_0');
  _emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_limitSuspensionExpansionVelocity_0 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_limitSuspensionExpansionVelocity_0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_limitSuspensionExpansionVelocity_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_limitSuspensionExpansionVelocity_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_limitSuspensionExpansionVelocity_1');
  _emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_limitSuspensionExpansionVelocity_1 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_limitSuspensionExpansionVelocity_1'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_limitSuspensionExpansionVelocity_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleSuspensionStateCalculationParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleSuspensionStateCalculationParams___destroy___0');
  _emscripten_bind_PxVehicleSuspensionStateCalculationParams___destroy___0 = Module['_emscripten_bind_PxVehicleSuspensionStateCalculationParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleSuspensionStateCalculationParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_PxVehicleTankDriveDifferentialParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_PxVehicleTankDriveDifferentialParams_0');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_PxVehicleTankDriveDifferentialParams_0 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_PxVehicleTankDriveDifferentialParams_0'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_PxVehicleTankDriveDifferentialParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_setToDefault_0');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_setToDefault_0 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_getNbWheelsInTrack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_getNbWheelsInTrack_1');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_getNbWheelsInTrack_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_getNbWheelsInTrack_1'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_getNbWheelsInTrack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelsInTrack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelsInTrack_1');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelsInTrack_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelsInTrack_1'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelsInTrack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelInTrack_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelInTrack_2');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelInTrack_2 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelInTrack_2'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelInTrack_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_getThrustControllerIndex_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_getThrustControllerIndex_1');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_getThrustControllerIndex_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_getThrustControllerIndex_1'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_getThrustControllerIndex_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_transformAndScale_4');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_isValid_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_isValid_1');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_isValid_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_isValid_1'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_isValid_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbTracks_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbTracks_0');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbTracks_0 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbTracks_0'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbTracks_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbTracks_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbTracks_1');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbTracks_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbTracks_1'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbTracks_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_get_thrustIdPerTrack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_get_thrustIdPerTrack_1');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_thrustIdPerTrack_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_thrustIdPerTrack_1'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_get_thrustIdPerTrack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_set_thrustIdPerTrack_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_set_thrustIdPerTrack_2');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_thrustIdPerTrack_2 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_thrustIdPerTrack_2'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_set_thrustIdPerTrack_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbWheelsPerTrack_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbWheelsPerTrack_1');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbWheelsPerTrack_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbWheelsPerTrack_1'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbWheelsPerTrack_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbWheelsPerTrack_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbWheelsPerTrack_2');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbWheelsPerTrack_2 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbWheelsPerTrack_2'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbWheelsPerTrack_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_get_trackToWheelIds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_get_trackToWheelIds_1');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_trackToWheelIds_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_trackToWheelIds_1'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_get_trackToWheelIds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_set_trackToWheelIds_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_set_trackToWheelIds_2');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_trackToWheelIds_2 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_trackToWheelIds_2'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_set_trackToWheelIds_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_get_wheelIdsInTrackOrder_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_get_wheelIdsInTrackOrder_1');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_wheelIdsInTrackOrder_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_wheelIdsInTrackOrder_1'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_get_wheelIdsInTrackOrder_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_set_wheelIdsInTrackOrder_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_set_wheelIdsInTrackOrder_2');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_wheelIdsInTrackOrder_2 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_wheelIdsInTrackOrder_2'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_set_wheelIdsInTrackOrder_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_get_torqueRatios_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_get_torqueRatios_1');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_torqueRatios_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_torqueRatios_1'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_get_torqueRatios_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_set_torqueRatios_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_set_torqueRatios_2');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_torqueRatios_2 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_torqueRatios_2'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_set_torqueRatios_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_get_aveWheelSpeedRatios_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_get_aveWheelSpeedRatios_1');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_aveWheelSpeedRatios_1 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_get_aveWheelSpeedRatios_1'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_get_aveWheelSpeedRatios_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams_set_aveWheelSpeedRatios_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams_set_aveWheelSpeedRatios_2');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_aveWheelSpeedRatios_2 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams_set_aveWheelSpeedRatios_2'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams_set_aveWheelSpeedRatios_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveDifferentialParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveDifferentialParams___destroy___0');
  _emscripten_bind_PxVehicleTankDriveDifferentialParams___destroy___0 = Module['_emscripten_bind_PxVehicleTankDriveDifferentialParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveDifferentialParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveTransmissionCommandState_PxVehicleTankDriveTransmissionCommandState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveTransmissionCommandState_PxVehicleTankDriveTransmissionCommandState_0');
  _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_PxVehicleTankDriveTransmissionCommandState_0 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_PxVehicleTankDriveTransmissionCommandState_0'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveTransmissionCommandState_PxVehicleTankDriveTransmissionCommandState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveTransmissionCommandState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveTransmissionCommandState_setToDefault_0');
  _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_setToDefault_0 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveTransmissionCommandState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_thrusts_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_thrusts_1');
  _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_thrusts_1 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_thrusts_1'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_thrusts_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_thrusts_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_thrusts_2');
  _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_thrusts_2 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_thrusts_2'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_thrusts_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_clutch_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_clutch_0');
  _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_clutch_0 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_clutch_0'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_clutch_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_clutch_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_clutch_1');
  _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_clutch_1 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_clutch_1'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_clutch_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_targetGear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_targetGear_0');
  _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_targetGear_0 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_targetGear_0'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_targetGear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_targetGear_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_targetGear_1');
  _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_targetGear_1 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_targetGear_1'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_targetGear_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTankDriveTransmissionCommandState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTankDriveTransmissionCommandState___destroy___0');
  _emscripten_bind_PxVehicleTankDriveTransmissionCommandState___destroy___0 = Module['_emscripten_bind_PxVehicleTankDriveTransmissionCommandState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleTankDriveTransmissionCommandState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireAxisStickyParams_PxVehicleTireAxisStickyParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireAxisStickyParams_PxVehicleTireAxisStickyParams_0');
  _emscripten_bind_PxVehicleTireAxisStickyParams_PxVehicleTireAxisStickyParams_0 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_PxVehicleTireAxisStickyParams_0'] = createExportWrapper('emscripten_bind_PxVehicleTireAxisStickyParams_PxVehicleTireAxisStickyParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireAxisStickyParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireAxisStickyParams_transformAndScale_4');
  _emscripten_bind_PxVehicleTireAxisStickyParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleTireAxisStickyParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireAxisStickyParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireAxisStickyParams_isValid_0');
  _emscripten_bind_PxVehicleTireAxisStickyParams_isValid_0 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleTireAxisStickyParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdSpeed_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdSpeed_0');
  _emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdSpeed_0 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdSpeed_0'] = createExportWrapper('emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdSpeed_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdSpeed_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdSpeed_1');
  _emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdSpeed_1 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdSpeed_1'] = createExportWrapper('emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdSpeed_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdTime_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdTime_0');
  _emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdTime_0 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdTime_0'] = createExportWrapper('emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdTime_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdTime_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdTime_1');
  _emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdTime_1 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdTime_1'] = createExportWrapper('emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdTime_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireAxisStickyParams_get_damping_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireAxisStickyParams_get_damping_0');
  _emscripten_bind_PxVehicleTireAxisStickyParams_get_damping_0 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_get_damping_0'] = createExportWrapper('emscripten_bind_PxVehicleTireAxisStickyParams_get_damping_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireAxisStickyParams_set_damping_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireAxisStickyParams_set_damping_1');
  _emscripten_bind_PxVehicleTireAxisStickyParams_set_damping_1 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams_set_damping_1'] = createExportWrapper('emscripten_bind_PxVehicleTireAxisStickyParams_set_damping_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireAxisStickyParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireAxisStickyParams___destroy___0');
  _emscripten_bind_PxVehicleTireAxisStickyParams___destroy___0 = Module['_emscripten_bind_PxVehicleTireAxisStickyParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleTireAxisStickyParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireCamberAngleState_PxVehicleTireCamberAngleState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireCamberAngleState_PxVehicleTireCamberAngleState_0');
  _emscripten_bind_PxVehicleTireCamberAngleState_PxVehicleTireCamberAngleState_0 = Module['_emscripten_bind_PxVehicleTireCamberAngleState_PxVehicleTireCamberAngleState_0'] = createExportWrapper('emscripten_bind_PxVehicleTireCamberAngleState_PxVehicleTireCamberAngleState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireCamberAngleState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireCamberAngleState_setToDefault_0');
  _emscripten_bind_PxVehicleTireCamberAngleState_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireCamberAngleState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleTireCamberAngleState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireCamberAngleState_get_camberAngle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireCamberAngleState_get_camberAngle_0');
  _emscripten_bind_PxVehicleTireCamberAngleState_get_camberAngle_0 = Module['_emscripten_bind_PxVehicleTireCamberAngleState_get_camberAngle_0'] = createExportWrapper('emscripten_bind_PxVehicleTireCamberAngleState_get_camberAngle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireCamberAngleState_set_camberAngle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireCamberAngleState_set_camberAngle_1');
  _emscripten_bind_PxVehicleTireCamberAngleState_set_camberAngle_1 = Module['_emscripten_bind_PxVehicleTireCamberAngleState_set_camberAngle_1'] = createExportWrapper('emscripten_bind_PxVehicleTireCamberAngleState_set_camberAngle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireCamberAngleState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireCamberAngleState___destroy___0');
  _emscripten_bind_PxVehicleTireCamberAngleState___destroy___0 = Module['_emscripten_bind_PxVehicleTireCamberAngleState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleTireCamberAngleState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireDirectionState_PxVehicleTireDirectionState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireDirectionState_PxVehicleTireDirectionState_0');
  _emscripten_bind_PxVehicleTireDirectionState_PxVehicleTireDirectionState_0 = Module['_emscripten_bind_PxVehicleTireDirectionState_PxVehicleTireDirectionState_0'] = createExportWrapper('emscripten_bind_PxVehicleTireDirectionState_PxVehicleTireDirectionState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireDirectionState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireDirectionState_setToDefault_0');
  _emscripten_bind_PxVehicleTireDirectionState_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireDirectionState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleTireDirectionState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireDirectionState_get_directions_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireDirectionState_get_directions_1');
  _emscripten_bind_PxVehicleTireDirectionState_get_directions_1 = Module['_emscripten_bind_PxVehicleTireDirectionState_get_directions_1'] = createExportWrapper('emscripten_bind_PxVehicleTireDirectionState_get_directions_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireDirectionState_set_directions_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireDirectionState_set_directions_2');
  _emscripten_bind_PxVehicleTireDirectionState_set_directions_2 = Module['_emscripten_bind_PxVehicleTireDirectionState_set_directions_2'] = createExportWrapper('emscripten_bind_PxVehicleTireDirectionState_set_directions_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireDirectionState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireDirectionState___destroy___0');
  _emscripten_bind_PxVehicleTireDirectionState___destroy___0 = Module['_emscripten_bind_PxVehicleTireDirectionState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleTireDirectionState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForce_PxVehicleTireForce_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForce_PxVehicleTireForce_0');
  _emscripten_bind_PxVehicleTireForce_PxVehicleTireForce_0 = Module['_emscripten_bind_PxVehicleTireForce_PxVehicleTireForce_0'] = createExportWrapper('emscripten_bind_PxVehicleTireForce_PxVehicleTireForce_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForce_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForce_setToDefault_0');
  _emscripten_bind_PxVehicleTireForce_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireForce_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleTireForce_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForce_get_forces_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForce_get_forces_1');
  _emscripten_bind_PxVehicleTireForce_get_forces_1 = Module['_emscripten_bind_PxVehicleTireForce_get_forces_1'] = createExportWrapper('emscripten_bind_PxVehicleTireForce_get_forces_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForce_set_forces_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForce_set_forces_2');
  _emscripten_bind_PxVehicleTireForce_set_forces_2 = Module['_emscripten_bind_PxVehicleTireForce_set_forces_2'] = createExportWrapper('emscripten_bind_PxVehicleTireForce_set_forces_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForce_get_torques_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForce_get_torques_1');
  _emscripten_bind_PxVehicleTireForce_get_torques_1 = Module['_emscripten_bind_PxVehicleTireForce_get_torques_1'] = createExportWrapper('emscripten_bind_PxVehicleTireForce_get_torques_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForce_set_torques_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForce_set_torques_2');
  _emscripten_bind_PxVehicleTireForce_set_torques_2 = Module['_emscripten_bind_PxVehicleTireForce_set_torques_2'] = createExportWrapper('emscripten_bind_PxVehicleTireForce_set_torques_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForce_get_aligningMoment_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForce_get_aligningMoment_0');
  _emscripten_bind_PxVehicleTireForce_get_aligningMoment_0 = Module['_emscripten_bind_PxVehicleTireForce_get_aligningMoment_0'] = createExportWrapper('emscripten_bind_PxVehicleTireForce_get_aligningMoment_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForce_set_aligningMoment_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForce_set_aligningMoment_1');
  _emscripten_bind_PxVehicleTireForce_set_aligningMoment_1 = Module['_emscripten_bind_PxVehicleTireForce_set_aligningMoment_1'] = createExportWrapper('emscripten_bind_PxVehicleTireForce_set_aligningMoment_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForce_get_wheelTorque_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForce_get_wheelTorque_0');
  _emscripten_bind_PxVehicleTireForce_get_wheelTorque_0 = Module['_emscripten_bind_PxVehicleTireForce_get_wheelTorque_0'] = createExportWrapper('emscripten_bind_PxVehicleTireForce_get_wheelTorque_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForce_set_wheelTorque_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForce_set_wheelTorque_1');
  _emscripten_bind_PxVehicleTireForce_set_wheelTorque_1 = Module['_emscripten_bind_PxVehicleTireForce_set_wheelTorque_1'] = createExportWrapper('emscripten_bind_PxVehicleTireForce_set_wheelTorque_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForce___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForce___destroy___0');
  _emscripten_bind_PxVehicleTireForce___destroy___0 = Module['_emscripten_bind_PxVehicleTireForce___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleTireForce___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParams_PxVehicleTireForceParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParams_PxVehicleTireForceParams_0');
  _emscripten_bind_PxVehicleTireForceParams_PxVehicleTireForceParams_0 = Module['_emscripten_bind_PxVehicleTireForceParams_PxVehicleTireForceParams_0'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParams_PxVehicleTireForceParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParams_transformAndScale_4');
  _emscripten_bind_PxVehicleTireForceParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleTireForceParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParams_isValid_0');
  _emscripten_bind_PxVehicleTireForceParams_isValid_0 = Module['_emscripten_bind_PxVehicleTireForceParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParams_get_latStiffX_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParams_get_latStiffX_0');
  _emscripten_bind_PxVehicleTireForceParams_get_latStiffX_0 = Module['_emscripten_bind_PxVehicleTireForceParams_get_latStiffX_0'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParams_get_latStiffX_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParams_set_latStiffX_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParams_set_latStiffX_1');
  _emscripten_bind_PxVehicleTireForceParams_set_latStiffX_1 = Module['_emscripten_bind_PxVehicleTireForceParams_set_latStiffX_1'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParams_set_latStiffX_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParams_get_latStiffY_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParams_get_latStiffY_0');
  _emscripten_bind_PxVehicleTireForceParams_get_latStiffY_0 = Module['_emscripten_bind_PxVehicleTireForceParams_get_latStiffY_0'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParams_get_latStiffY_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParams_set_latStiffY_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParams_set_latStiffY_1');
  _emscripten_bind_PxVehicleTireForceParams_set_latStiffY_1 = Module['_emscripten_bind_PxVehicleTireForceParams_set_latStiffY_1'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParams_set_latStiffY_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParams_get_longStiff_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParams_get_longStiff_0');
  _emscripten_bind_PxVehicleTireForceParams_get_longStiff_0 = Module['_emscripten_bind_PxVehicleTireForceParams_get_longStiff_0'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParams_get_longStiff_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParams_set_longStiff_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParams_set_longStiff_1');
  _emscripten_bind_PxVehicleTireForceParams_set_longStiff_1 = Module['_emscripten_bind_PxVehicleTireForceParams_set_longStiff_1'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParams_set_longStiff_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParams_get_camberStiff_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParams_get_camberStiff_0');
  _emscripten_bind_PxVehicleTireForceParams_get_camberStiff_0 = Module['_emscripten_bind_PxVehicleTireForceParams_get_camberStiff_0'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParams_get_camberStiff_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParams_set_camberStiff_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParams_set_camberStiff_1');
  _emscripten_bind_PxVehicleTireForceParams_set_camberStiff_1 = Module['_emscripten_bind_PxVehicleTireForceParams_set_camberStiff_1'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParams_set_camberStiff_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParams_get_restLoad_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParams_get_restLoad_0');
  _emscripten_bind_PxVehicleTireForceParams_get_restLoad_0 = Module['_emscripten_bind_PxVehicleTireForceParams_get_restLoad_0'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParams_get_restLoad_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParams_set_restLoad_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParams_set_restLoad_1');
  _emscripten_bind_PxVehicleTireForceParams_set_restLoad_1 = Module['_emscripten_bind_PxVehicleTireForceParams_set_restLoad_1'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParams_set_restLoad_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParams___destroy___0');
  _emscripten_bind_PxVehicleTireForceParams___destroy___0 = Module['_emscripten_bind_PxVehicleTireForceParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParamsExt_setFrictionVsSlip_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParamsExt_setFrictionVsSlip_4');
  _emscripten_bind_PxVehicleTireForceParamsExt_setFrictionVsSlip_4 = Module['_emscripten_bind_PxVehicleTireForceParamsExt_setFrictionVsSlip_4'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParamsExt_setFrictionVsSlip_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireForceParamsExt_setLoadFilter_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireForceParamsExt_setLoadFilter_4');
  _emscripten_bind_PxVehicleTireForceParamsExt_setLoadFilter_4 = Module['_emscripten_bind_PxVehicleTireForceParamsExt_setLoadFilter_4'] = createExportWrapper('emscripten_bind_PxVehicleTireForceParamsExt_setLoadFilter_4', 4);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireGripState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireGripState_setToDefault_0');
  _emscripten_bind_PxVehicleTireGripState_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireGripState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleTireGripState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireGripState_get_load_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireGripState_get_load_0');
  _emscripten_bind_PxVehicleTireGripState_get_load_0 = Module['_emscripten_bind_PxVehicleTireGripState_get_load_0'] = createExportWrapper('emscripten_bind_PxVehicleTireGripState_get_load_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireGripState_set_load_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireGripState_set_load_1');
  _emscripten_bind_PxVehicleTireGripState_set_load_1 = Module['_emscripten_bind_PxVehicleTireGripState_set_load_1'] = createExportWrapper('emscripten_bind_PxVehicleTireGripState_set_load_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireGripState_get_friction_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireGripState_get_friction_0');
  _emscripten_bind_PxVehicleTireGripState_get_friction_0 = Module['_emscripten_bind_PxVehicleTireGripState_get_friction_0'] = createExportWrapper('emscripten_bind_PxVehicleTireGripState_get_friction_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireGripState_set_friction_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireGripState_set_friction_1');
  _emscripten_bind_PxVehicleTireGripState_set_friction_1 = Module['_emscripten_bind_PxVehicleTireGripState_set_friction_1'] = createExportWrapper('emscripten_bind_PxVehicleTireGripState_set_friction_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireGripState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireGripState___destroy___0');
  _emscripten_bind_PxVehicleTireGripState___destroy___0 = Module['_emscripten_bind_PxVehicleTireGripState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleTireGripState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipParams_PxVehicleTireSlipParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipParams_PxVehicleTireSlipParams_0');
  _emscripten_bind_PxVehicleTireSlipParams_PxVehicleTireSlipParams_0 = Module['_emscripten_bind_PxVehicleTireSlipParams_PxVehicleTireSlipParams_0'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipParams_PxVehicleTireSlipParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipParams_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipParams_setToDefault_0');
  _emscripten_bind_PxVehicleTireSlipParams_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireSlipParams_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipParams_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipParams_transformAndScale_4');
  _emscripten_bind_PxVehicleTireSlipParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleTireSlipParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipParams_isValid_0');
  _emscripten_bind_PxVehicleTireSlipParams_isValid_0 = Module['_emscripten_bind_PxVehicleTireSlipParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipParams_get_minLatSlipDenominator_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipParams_get_minLatSlipDenominator_0');
  _emscripten_bind_PxVehicleTireSlipParams_get_minLatSlipDenominator_0 = Module['_emscripten_bind_PxVehicleTireSlipParams_get_minLatSlipDenominator_0'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipParams_get_minLatSlipDenominator_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipParams_set_minLatSlipDenominator_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipParams_set_minLatSlipDenominator_1');
  _emscripten_bind_PxVehicleTireSlipParams_set_minLatSlipDenominator_1 = Module['_emscripten_bind_PxVehicleTireSlipParams_set_minLatSlipDenominator_1'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipParams_set_minLatSlipDenominator_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipParams_get_minPassiveLongSlipDenominator_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipParams_get_minPassiveLongSlipDenominator_0');
  _emscripten_bind_PxVehicleTireSlipParams_get_minPassiveLongSlipDenominator_0 = Module['_emscripten_bind_PxVehicleTireSlipParams_get_minPassiveLongSlipDenominator_0'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipParams_get_minPassiveLongSlipDenominator_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipParams_set_minPassiveLongSlipDenominator_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipParams_set_minPassiveLongSlipDenominator_1');
  _emscripten_bind_PxVehicleTireSlipParams_set_minPassiveLongSlipDenominator_1 = Module['_emscripten_bind_PxVehicleTireSlipParams_set_minPassiveLongSlipDenominator_1'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipParams_set_minPassiveLongSlipDenominator_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipParams_get_minActiveLongSlipDenominator_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipParams_get_minActiveLongSlipDenominator_0');
  _emscripten_bind_PxVehicleTireSlipParams_get_minActiveLongSlipDenominator_0 = Module['_emscripten_bind_PxVehicleTireSlipParams_get_minActiveLongSlipDenominator_0'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipParams_get_minActiveLongSlipDenominator_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipParams_set_minActiveLongSlipDenominator_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipParams_set_minActiveLongSlipDenominator_1');
  _emscripten_bind_PxVehicleTireSlipParams_set_minActiveLongSlipDenominator_1 = Module['_emscripten_bind_PxVehicleTireSlipParams_set_minActiveLongSlipDenominator_1'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipParams_set_minActiveLongSlipDenominator_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipParams___destroy___0');
  _emscripten_bind_PxVehicleTireSlipParams___destroy___0 = Module['_emscripten_bind_PxVehicleTireSlipParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipState_PxVehicleTireSlipState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipState_PxVehicleTireSlipState_0');
  _emscripten_bind_PxVehicleTireSlipState_PxVehicleTireSlipState_0 = Module['_emscripten_bind_PxVehicleTireSlipState_PxVehicleTireSlipState_0'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipState_PxVehicleTireSlipState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipState_setToDefault_0');
  _emscripten_bind_PxVehicleTireSlipState_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireSlipState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipState_get_slips_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipState_get_slips_1');
  _emscripten_bind_PxVehicleTireSlipState_get_slips_1 = Module['_emscripten_bind_PxVehicleTireSlipState_get_slips_1'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipState_get_slips_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipState_set_slips_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipState_set_slips_2');
  _emscripten_bind_PxVehicleTireSlipState_set_slips_2 = Module['_emscripten_bind_PxVehicleTireSlipState_set_slips_2'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipState_set_slips_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSlipState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSlipState___destroy___0');
  _emscripten_bind_PxVehicleTireSlipState___destroy___0 = Module['_emscripten_bind_PxVehicleTireSlipState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleTireSlipState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSpeedState_PxVehicleTireSpeedState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSpeedState_PxVehicleTireSpeedState_0');
  _emscripten_bind_PxVehicleTireSpeedState_PxVehicleTireSpeedState_0 = Module['_emscripten_bind_PxVehicleTireSpeedState_PxVehicleTireSpeedState_0'] = createExportWrapper('emscripten_bind_PxVehicleTireSpeedState_PxVehicleTireSpeedState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSpeedState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSpeedState_setToDefault_0');
  _emscripten_bind_PxVehicleTireSpeedState_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireSpeedState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleTireSpeedState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSpeedState_get_speedStates_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSpeedState_get_speedStates_1');
  _emscripten_bind_PxVehicleTireSpeedState_get_speedStates_1 = Module['_emscripten_bind_PxVehicleTireSpeedState_get_speedStates_1'] = createExportWrapper('emscripten_bind_PxVehicleTireSpeedState_get_speedStates_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSpeedState_set_speedStates_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSpeedState_set_speedStates_2');
  _emscripten_bind_PxVehicleTireSpeedState_set_speedStates_2 = Module['_emscripten_bind_PxVehicleTireSpeedState_set_speedStates_2'] = createExportWrapper('emscripten_bind_PxVehicleTireSpeedState_set_speedStates_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireSpeedState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireSpeedState___destroy___0');
  _emscripten_bind_PxVehicleTireSpeedState___destroy___0 = Module['_emscripten_bind_PxVehicleTireSpeedState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleTireSpeedState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireStickyParams_PxVehicleTireStickyParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireStickyParams_PxVehicleTireStickyParams_0');
  _emscripten_bind_PxVehicleTireStickyParams_PxVehicleTireStickyParams_0 = Module['_emscripten_bind_PxVehicleTireStickyParams_PxVehicleTireStickyParams_0'] = createExportWrapper('emscripten_bind_PxVehicleTireStickyParams_PxVehicleTireStickyParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireStickyParams_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireStickyParams_setToDefault_0');
  _emscripten_bind_PxVehicleTireStickyParams_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireStickyParams_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleTireStickyParams_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireStickyParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireStickyParams_transformAndScale_4');
  _emscripten_bind_PxVehicleTireStickyParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleTireStickyParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleTireStickyParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireStickyParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireStickyParams_isValid_0');
  _emscripten_bind_PxVehicleTireStickyParams_isValid_0 = Module['_emscripten_bind_PxVehicleTireStickyParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleTireStickyParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireStickyParams_get_stickyParams_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireStickyParams_get_stickyParams_1');
  _emscripten_bind_PxVehicleTireStickyParams_get_stickyParams_1 = Module['_emscripten_bind_PxVehicleTireStickyParams_get_stickyParams_1'] = createExportWrapper('emscripten_bind_PxVehicleTireStickyParams_get_stickyParams_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireStickyParams_set_stickyParams_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireStickyParams_set_stickyParams_2');
  _emscripten_bind_PxVehicleTireStickyParams_set_stickyParams_2 = Module['_emscripten_bind_PxVehicleTireStickyParams_set_stickyParams_2'] = createExportWrapper('emscripten_bind_PxVehicleTireStickyParams_set_stickyParams_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireStickyParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireStickyParams___destroy___0');
  _emscripten_bind_PxVehicleTireStickyParams___destroy___0 = Module['_emscripten_bind_PxVehicleTireStickyParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleTireStickyParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireStickyState_PxVehicleTireStickyState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireStickyState_PxVehicleTireStickyState_0');
  _emscripten_bind_PxVehicleTireStickyState_PxVehicleTireStickyState_0 = Module['_emscripten_bind_PxVehicleTireStickyState_PxVehicleTireStickyState_0'] = createExportWrapper('emscripten_bind_PxVehicleTireStickyState_PxVehicleTireStickyState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireStickyState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireStickyState_setToDefault_0');
  _emscripten_bind_PxVehicleTireStickyState_setToDefault_0 = Module['_emscripten_bind_PxVehicleTireStickyState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleTireStickyState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireStickyState_get_lowSpeedTime_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireStickyState_get_lowSpeedTime_1');
  _emscripten_bind_PxVehicleTireStickyState_get_lowSpeedTime_1 = Module['_emscripten_bind_PxVehicleTireStickyState_get_lowSpeedTime_1'] = createExportWrapper('emscripten_bind_PxVehicleTireStickyState_get_lowSpeedTime_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireStickyState_set_lowSpeedTime_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireStickyState_set_lowSpeedTime_2');
  _emscripten_bind_PxVehicleTireStickyState_set_lowSpeedTime_2 = Module['_emscripten_bind_PxVehicleTireStickyState_set_lowSpeedTime_2'] = createExportWrapper('emscripten_bind_PxVehicleTireStickyState_set_lowSpeedTime_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireStickyState_get_activeStatus_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireStickyState_get_activeStatus_1');
  _emscripten_bind_PxVehicleTireStickyState_get_activeStatus_1 = Module['_emscripten_bind_PxVehicleTireStickyState_get_activeStatus_1'] = createExportWrapper('emscripten_bind_PxVehicleTireStickyState_get_activeStatus_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireStickyState_set_activeStatus_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireStickyState_set_activeStatus_2');
  _emscripten_bind_PxVehicleTireStickyState_set_activeStatus_2 = Module['_emscripten_bind_PxVehicleTireStickyState_set_activeStatus_2'] = createExportWrapper('emscripten_bind_PxVehicleTireStickyState_set_activeStatus_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTireStickyState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTireStickyState___destroy___0');
  _emscripten_bind_PxVehicleTireStickyState___destroy___0 = Module['_emscripten_bind_PxVehicleTireStickyState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleTireStickyState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTopLevelFunctions_InitVehicleExtension_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTopLevelFunctions_InitVehicleExtension_1');
  _emscripten_bind_PxVehicleTopLevelFunctions_InitVehicleExtension_1 = Module['_emscripten_bind_PxVehicleTopLevelFunctions_InitVehicleExtension_1'] = createExportWrapper('emscripten_bind_PxVehicleTopLevelFunctions_InitVehicleExtension_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTopLevelFunctions_CloseVehicleExtension_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTopLevelFunctions_CloseVehicleExtension_0');
  _emscripten_bind_PxVehicleTopLevelFunctions_CloseVehicleExtension_0 = Module['_emscripten_bind_PxVehicleTopLevelFunctions_CloseVehicleExtension_0'] = createExportWrapper('emscripten_bind_PxVehicleTopLevelFunctions_CloseVehicleExtension_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTopLevelFunctions_VehicleComputeSprungMasses_5'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTopLevelFunctions_VehicleComputeSprungMasses_5');
  _emscripten_bind_PxVehicleTopLevelFunctions_VehicleComputeSprungMasses_5 = Module['_emscripten_bind_PxVehicleTopLevelFunctions_VehicleComputeSprungMasses_5'] = createExportWrapper('emscripten_bind_PxVehicleTopLevelFunctions_VehicleComputeSprungMasses_5', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshCreate_3'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshCreate_3');
  _emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshCreate_3 = Module['_emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshCreate_3'] = createExportWrapper('emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshCreate_3', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshDestroy_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshDestroy_1');
  _emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshDestroy_1 = Module['_emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshDestroy_1'] = createExportWrapper('emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshDestroy_1', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTopLevelFunctions_get_MAX_NB_ENGINE_TORQUE_CURVE_ENTRIES_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTopLevelFunctions_get_MAX_NB_ENGINE_TORQUE_CURVE_ENTRIES_0');
  _emscripten_bind_PxVehicleTopLevelFunctions_get_MAX_NB_ENGINE_TORQUE_CURVE_ENTRIES_0 = Module['_emscripten_bind_PxVehicleTopLevelFunctions_get_MAX_NB_ENGINE_TORQUE_CURVE_ENTRIES_0'] = createExportWrapper('emscripten_bind_PxVehicleTopLevelFunctions_get_MAX_NB_ENGINE_TORQUE_CURVE_ENTRIES_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTorqueCurveLookupTable_PxVehicleTorqueCurveLookupTable_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTorqueCurveLookupTable_PxVehicleTorqueCurveLookupTable_0');
  _emscripten_bind_PxVehicleTorqueCurveLookupTable_PxVehicleTorqueCurveLookupTable_0 = Module['_emscripten_bind_PxVehicleTorqueCurveLookupTable_PxVehicleTorqueCurveLookupTable_0'] = createExportWrapper('emscripten_bind_PxVehicleTorqueCurveLookupTable_PxVehicleTorqueCurveLookupTable_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTorqueCurveLookupTable_addPair_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTorqueCurveLookupTable_addPair_2');
  _emscripten_bind_PxVehicleTorqueCurveLookupTable_addPair_2 = Module['_emscripten_bind_PxVehicleTorqueCurveLookupTable_addPair_2'] = createExportWrapper('emscripten_bind_PxVehicleTorqueCurveLookupTable_addPair_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTorqueCurveLookupTable_interpolate_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTorqueCurveLookupTable_interpolate_1');
  _emscripten_bind_PxVehicleTorqueCurveLookupTable_interpolate_1 = Module['_emscripten_bind_PxVehicleTorqueCurveLookupTable_interpolate_1'] = createExportWrapper('emscripten_bind_PxVehicleTorqueCurveLookupTable_interpolate_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTorqueCurveLookupTable_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTorqueCurveLookupTable_clear_0');
  _emscripten_bind_PxVehicleTorqueCurveLookupTable_clear_0 = Module['_emscripten_bind_PxVehicleTorqueCurveLookupTable_clear_0'] = createExportWrapper('emscripten_bind_PxVehicleTorqueCurveLookupTable_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTorqueCurveLookupTable_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTorqueCurveLookupTable_isValid_0');
  _emscripten_bind_PxVehicleTorqueCurveLookupTable_isValid_0 = Module['_emscripten_bind_PxVehicleTorqueCurveLookupTable_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleTorqueCurveLookupTable_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleTorqueCurveLookupTable___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleTorqueCurveLookupTable___destroy___0');
  _emscripten_bind_PxVehicleTorqueCurveLookupTable___destroy___0 = Module['_emscripten_bind_PxVehicleTorqueCurveLookupTable___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleTorqueCurveLookupTable___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelActuationState_PxVehicleWheelActuationState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelActuationState_PxVehicleWheelActuationState_0');
  _emscripten_bind_PxVehicleWheelActuationState_PxVehicleWheelActuationState_0 = Module['_emscripten_bind_PxVehicleWheelActuationState_PxVehicleWheelActuationState_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelActuationState_PxVehicleWheelActuationState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelActuationState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelActuationState_setToDefault_0');
  _emscripten_bind_PxVehicleWheelActuationState_setToDefault_0 = Module['_emscripten_bind_PxVehicleWheelActuationState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelActuationState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelActuationState_get_isBrakeApplied_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelActuationState_get_isBrakeApplied_0');
  _emscripten_bind_PxVehicleWheelActuationState_get_isBrakeApplied_0 = Module['_emscripten_bind_PxVehicleWheelActuationState_get_isBrakeApplied_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelActuationState_get_isBrakeApplied_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelActuationState_set_isBrakeApplied_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelActuationState_set_isBrakeApplied_1');
  _emscripten_bind_PxVehicleWheelActuationState_set_isBrakeApplied_1 = Module['_emscripten_bind_PxVehicleWheelActuationState_set_isBrakeApplied_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelActuationState_set_isBrakeApplied_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelActuationState_get_isDriveApplied_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelActuationState_get_isDriveApplied_0');
  _emscripten_bind_PxVehicleWheelActuationState_get_isDriveApplied_0 = Module['_emscripten_bind_PxVehicleWheelActuationState_get_isDriveApplied_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelActuationState_get_isDriveApplied_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelActuationState_set_isDriveApplied_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelActuationState_set_isDriveApplied_1');
  _emscripten_bind_PxVehicleWheelActuationState_set_isDriveApplied_1 = Module['_emscripten_bind_PxVehicleWheelActuationState_set_isDriveApplied_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelActuationState_set_isDriveApplied_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelActuationState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelActuationState___destroy___0');
  _emscripten_bind_PxVehicleWheelActuationState___destroy___0 = Module['_emscripten_bind_PxVehicleWheelActuationState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleWheelActuationState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_PxVehicleWheelConstraintGroupState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_PxVehicleWheelConstraintGroupState_0');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_PxVehicleWheelConstraintGroupState_0 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_PxVehicleWheelConstraintGroupState_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_PxVehicleWheelConstraintGroupState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_setToDefault_0');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_setToDefault_0 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_getNbConstraintGroups_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_getNbConstraintGroups_0');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_getNbConstraintGroups_0 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_getNbConstraintGroups_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_getNbConstraintGroups_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_getNbWheelsInConstraintGroup_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_getNbWheelsInConstraintGroup_1');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_getNbWheelsInConstraintGroup_1 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_getNbWheelsInConstraintGroup_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_getNbWheelsInConstraintGroup_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_getWheelInConstraintGroup_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_getWheelInConstraintGroup_2');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_getWheelInConstraintGroup_2 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_getWheelInConstraintGroup_2'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_getWheelInConstraintGroup_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_getMultiplierInConstraintGroup_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_getMultiplierInConstraintGroup_2');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_getMultiplierInConstraintGroup_2 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_getMultiplierInConstraintGroup_2'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_getMultiplierInConstraintGroup_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbGroups_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbGroups_0');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbGroups_0 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbGroups_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbGroups_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbGroups_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbGroups_1');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbGroups_1 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbGroups_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbGroups_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsPerGroup_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsPerGroup_1');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsPerGroup_1 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsPerGroup_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsPerGroup_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsPerGroup_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsPerGroup_2');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsPerGroup_2 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsPerGroup_2'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsPerGroup_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_get_groupToWheelIds_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_get_groupToWheelIds_1');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_get_groupToWheelIds_1 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_get_groupToWheelIds_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_get_groupToWheelIds_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_set_groupToWheelIds_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_set_groupToWheelIds_2');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_set_groupToWheelIds_2 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_set_groupToWheelIds_2'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_set_groupToWheelIds_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelIdsInGroupOrder_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelIdsInGroupOrder_1');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelIdsInGroupOrder_1 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelIdsInGroupOrder_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelIdsInGroupOrder_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelIdsInGroupOrder_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelIdsInGroupOrder_2');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelIdsInGroupOrder_2 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelIdsInGroupOrder_2'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelIdsInGroupOrder_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelMultipliersInGroupOrder_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelMultipliersInGroupOrder_1');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelMultipliersInGroupOrder_1 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelMultipliersInGroupOrder_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelMultipliersInGroupOrder_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelMultipliersInGroupOrder_2'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelMultipliersInGroupOrder_2');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelMultipliersInGroupOrder_2 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelMultipliersInGroupOrder_2'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelMultipliersInGroupOrder_2', 3);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsInGroups_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsInGroups_0');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsInGroups_0 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsInGroups_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsInGroups_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsInGroups_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsInGroups_1');
  _emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsInGroups_1 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsInGroups_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsInGroups_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelConstraintGroupState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelConstraintGroupState___destroy___0');
  _emscripten_bind_PxVehicleWheelConstraintGroupState___destroy___0 = Module['_emscripten_bind_PxVehicleWheelConstraintGroupState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleWheelConstraintGroupState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelLocalPose_PxVehicleWheelLocalPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelLocalPose_PxVehicleWheelLocalPose_0');
  _emscripten_bind_PxVehicleWheelLocalPose_PxVehicleWheelLocalPose_0 = Module['_emscripten_bind_PxVehicleWheelLocalPose_PxVehicleWheelLocalPose_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelLocalPose_PxVehicleWheelLocalPose_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelLocalPose_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelLocalPose_setToDefault_0');
  _emscripten_bind_PxVehicleWheelLocalPose_setToDefault_0 = Module['_emscripten_bind_PxVehicleWheelLocalPose_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelLocalPose_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelLocalPose_get_localPose_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelLocalPose_get_localPose_0');
  _emscripten_bind_PxVehicleWheelLocalPose_get_localPose_0 = Module['_emscripten_bind_PxVehicleWheelLocalPose_get_localPose_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelLocalPose_get_localPose_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelLocalPose_set_localPose_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelLocalPose_set_localPose_1');
  _emscripten_bind_PxVehicleWheelLocalPose_set_localPose_1 = Module['_emscripten_bind_PxVehicleWheelLocalPose_set_localPose_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelLocalPose_set_localPose_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelLocalPose___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelLocalPose___destroy___0');
  _emscripten_bind_PxVehicleWheelLocalPose___destroy___0 = Module['_emscripten_bind_PxVehicleWheelLocalPose___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleWheelLocalPose___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelParams_PxVehicleWheelParams_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelParams_PxVehicleWheelParams_0');
  _emscripten_bind_PxVehicleWheelParams_PxVehicleWheelParams_0 = Module['_emscripten_bind_PxVehicleWheelParams_PxVehicleWheelParams_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelParams_PxVehicleWheelParams_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelParams_transformAndScale_4'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelParams_transformAndScale_4');
  _emscripten_bind_PxVehicleWheelParams_transformAndScale_4 = Module['_emscripten_bind_PxVehicleWheelParams_transformAndScale_4'] = createExportWrapper('emscripten_bind_PxVehicleWheelParams_transformAndScale_4', 5);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelParams_isValid_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelParams_isValid_0');
  _emscripten_bind_PxVehicleWheelParams_isValid_0 = Module['_emscripten_bind_PxVehicleWheelParams_isValid_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelParams_isValid_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelParams_get_radius_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelParams_get_radius_0');
  _emscripten_bind_PxVehicleWheelParams_get_radius_0 = Module['_emscripten_bind_PxVehicleWheelParams_get_radius_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelParams_get_radius_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelParams_set_radius_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelParams_set_radius_1');
  _emscripten_bind_PxVehicleWheelParams_set_radius_1 = Module['_emscripten_bind_PxVehicleWheelParams_set_radius_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelParams_set_radius_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelParams_get_halfWidth_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelParams_get_halfWidth_0');
  _emscripten_bind_PxVehicleWheelParams_get_halfWidth_0 = Module['_emscripten_bind_PxVehicleWheelParams_get_halfWidth_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelParams_get_halfWidth_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelParams_set_halfWidth_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelParams_set_halfWidth_1');
  _emscripten_bind_PxVehicleWheelParams_set_halfWidth_1 = Module['_emscripten_bind_PxVehicleWheelParams_set_halfWidth_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelParams_set_halfWidth_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelParams_get_mass_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelParams_get_mass_0');
  _emscripten_bind_PxVehicleWheelParams_get_mass_0 = Module['_emscripten_bind_PxVehicleWheelParams_get_mass_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelParams_get_mass_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelParams_set_mass_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelParams_set_mass_1');
  _emscripten_bind_PxVehicleWheelParams_set_mass_1 = Module['_emscripten_bind_PxVehicleWheelParams_set_mass_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelParams_set_mass_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelParams_get_moi_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelParams_get_moi_0');
  _emscripten_bind_PxVehicleWheelParams_get_moi_0 = Module['_emscripten_bind_PxVehicleWheelParams_get_moi_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelParams_get_moi_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelParams_set_moi_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelParams_set_moi_1');
  _emscripten_bind_PxVehicleWheelParams_set_moi_1 = Module['_emscripten_bind_PxVehicleWheelParams_set_moi_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelParams_set_moi_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelParams_get_dampingRate_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelParams_get_dampingRate_0');
  _emscripten_bind_PxVehicleWheelParams_get_dampingRate_0 = Module['_emscripten_bind_PxVehicleWheelParams_get_dampingRate_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelParams_get_dampingRate_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelParams_set_dampingRate_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelParams_set_dampingRate_1');
  _emscripten_bind_PxVehicleWheelParams_set_dampingRate_1 = Module['_emscripten_bind_PxVehicleWheelParams_set_dampingRate_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelParams_set_dampingRate_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelParams___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelParams___destroy___0');
  _emscripten_bind_PxVehicleWheelParams___destroy___0 = Module['_emscripten_bind_PxVehicleWheelParams___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleWheelParams___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelRigidBody1dState_PxVehicleWheelRigidBody1dState_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelRigidBody1dState_PxVehicleWheelRigidBody1dState_0');
  _emscripten_bind_PxVehicleWheelRigidBody1dState_PxVehicleWheelRigidBody1dState_0 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_PxVehicleWheelRigidBody1dState_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelRigidBody1dState_PxVehicleWheelRigidBody1dState_0', 0);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelRigidBody1dState_setToDefault_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelRigidBody1dState_setToDefault_0');
  _emscripten_bind_PxVehicleWheelRigidBody1dState_setToDefault_0 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_setToDefault_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelRigidBody1dState_setToDefault_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationSpeed_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationSpeed_0');
  _emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationSpeed_0 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationSpeed_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationSpeed_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationSpeed_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationSpeed_1');
  _emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationSpeed_1 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationSpeed_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationSpeed_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelRigidBody1dState_get_correctedRotationSpeed_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelRigidBody1dState_get_correctedRotationSpeed_0');
  _emscripten_bind_PxVehicleWheelRigidBody1dState_get_correctedRotationSpeed_0 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_get_correctedRotationSpeed_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelRigidBody1dState_get_correctedRotationSpeed_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelRigidBody1dState_set_correctedRotationSpeed_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelRigidBody1dState_set_correctedRotationSpeed_1');
  _emscripten_bind_PxVehicleWheelRigidBody1dState_set_correctedRotationSpeed_1 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_set_correctedRotationSpeed_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelRigidBody1dState_set_correctedRotationSpeed_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationAngle_0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationAngle_0');
  _emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationAngle_0 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationAngle_0'] = createExportWrapper('emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationAngle_0', 1);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationAngle_1'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationAngle_1');
  _emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationAngle_1 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationAngle_1'] = createExportWrapper('emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationAngle_1', 2);
  assert(typeof wasmExports['emscripten_bind_PxVehicleWheelRigidBody1dState___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_PxVehicleWheelRigidBody1dState___destroy___0');
  _emscripten_bind_PxVehicleWheelRigidBody1dState___destroy___0 = Module['_emscripten_bind_PxVehicleWheelRigidBody1dState___destroy___0'] = createExportWrapper('emscripten_bind_PxVehicleWheelRigidBody1dState___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_SimplPvdTransportImpl_SimplPvdTransportImpl_0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimplPvdTransportImpl_SimplPvdTransportImpl_0');
  _emscripten_bind_SimplPvdTransportImpl_SimplPvdTransportImpl_0 = Module['_emscripten_bind_SimplPvdTransportImpl_SimplPvdTransportImpl_0'] = createExportWrapper('emscripten_bind_SimplPvdTransportImpl_SimplPvdTransportImpl_0', 0);
  assert(typeof wasmExports['emscripten_bind_SimplPvdTransportImpl_connect_0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimplPvdTransportImpl_connect_0');
  _emscripten_bind_SimplPvdTransportImpl_connect_0 = Module['_emscripten_bind_SimplPvdTransportImpl_connect_0'] = createExportWrapper('emscripten_bind_SimplPvdTransportImpl_connect_0', 1);
  assert(typeof wasmExports['emscripten_bind_SimplPvdTransportImpl_isConnected_0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimplPvdTransportImpl_isConnected_0');
  _emscripten_bind_SimplPvdTransportImpl_isConnected_0 = Module['_emscripten_bind_SimplPvdTransportImpl_isConnected_0'] = createExportWrapper('emscripten_bind_SimplPvdTransportImpl_isConnected_0', 1);
  assert(typeof wasmExports['emscripten_bind_SimplPvdTransportImpl_disconnect_0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimplPvdTransportImpl_disconnect_0');
  _emscripten_bind_SimplPvdTransportImpl_disconnect_0 = Module['_emscripten_bind_SimplPvdTransportImpl_disconnect_0'] = createExportWrapper('emscripten_bind_SimplPvdTransportImpl_disconnect_0', 1);
  assert(typeof wasmExports['emscripten_bind_SimplPvdTransportImpl_send_2'] != 'undefined', 'missing Wasm export: emscripten_bind_SimplPvdTransportImpl_send_2');
  _emscripten_bind_SimplPvdTransportImpl_send_2 = Module['_emscripten_bind_SimplPvdTransportImpl_send_2'] = createExportWrapper('emscripten_bind_SimplPvdTransportImpl_send_2', 3);
  assert(typeof wasmExports['emscripten_bind_SimplPvdTransportImpl_flush_0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimplPvdTransportImpl_flush_0');
  _emscripten_bind_SimplPvdTransportImpl_flush_0 = Module['_emscripten_bind_SimplPvdTransportImpl_flush_0'] = createExportWrapper('emscripten_bind_SimplPvdTransportImpl_flush_0', 1);
  assert(typeof wasmExports['emscripten_bind_SimplPvdTransportImpl___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_SimplPvdTransportImpl___destroy___0');
  _emscripten_bind_SimplPvdTransportImpl___destroy___0 = Module['_emscripten_bind_SimplPvdTransportImpl___destroy___0'] = createExportWrapper('emscripten_bind_SimplPvdTransportImpl___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_SphereSupport_SphereSupport_1'] != 'undefined', 'missing Wasm export: emscripten_bind_SphereSupport_SphereSupport_1');
  _emscripten_bind_SphereSupport_SphereSupport_1 = Module['_emscripten_bind_SphereSupport_SphereSupport_1'] = createExportWrapper('emscripten_bind_SphereSupport_SphereSupport_1', 1);
  assert(typeof wasmExports['emscripten_bind_SphereSupport_getMargin_0'] != 'undefined', 'missing Wasm export: emscripten_bind_SphereSupport_getMargin_0');
  _emscripten_bind_SphereSupport_getMargin_0 = Module['_emscripten_bind_SphereSupport_getMargin_0'] = createExportWrapper('emscripten_bind_SphereSupport_getMargin_0', 1);
  assert(typeof wasmExports['emscripten_bind_SphereSupport_supportLocal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_SphereSupport_supportLocal_1');
  _emscripten_bind_SphereSupport_supportLocal_1 = Module['_emscripten_bind_SphereSupport_supportLocal_1'] = createExportWrapper('emscripten_bind_SphereSupport_supportLocal_1', 2);
  assert(typeof wasmExports['emscripten_bind_SphereSupport_get_radius_0'] != 'undefined', 'missing Wasm export: emscripten_bind_SphereSupport_get_radius_0');
  _emscripten_bind_SphereSupport_get_radius_0 = Module['_emscripten_bind_SphereSupport_get_radius_0'] = createExportWrapper('emscripten_bind_SphereSupport_get_radius_0', 1);
  assert(typeof wasmExports['emscripten_bind_SphereSupport_set_radius_1'] != 'undefined', 'missing Wasm export: emscripten_bind_SphereSupport_set_radius_1');
  _emscripten_bind_SphereSupport_set_radius_1 = Module['_emscripten_bind_SphereSupport_set_radius_1'] = createExportWrapper('emscripten_bind_SphereSupport_set_radius_1', 2);
  assert(typeof wasmExports['emscripten_bind_SphereSupport___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_SphereSupport___destroy___0');
  _emscripten_bind_SphereSupport___destroy___0 = Module['_emscripten_bind_SphereSupport___destroy___0'] = createExportWrapper('emscripten_bind_SphereSupport___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_SupportFunctions_PxActor_getShape_2'] != 'undefined', 'missing Wasm export: emscripten_bind_SupportFunctions_PxActor_getShape_2');
  _emscripten_bind_SupportFunctions_PxActor_getShape_2 = Module['_emscripten_bind_SupportFunctions_PxActor_getShape_2'] = createExportWrapper('emscripten_bind_SupportFunctions_PxActor_getShape_2', 2);
  assert(typeof wasmExports['emscripten_bind_SupportFunctions_PxScene_getActiveActors_1'] != 'undefined', 'missing Wasm export: emscripten_bind_SupportFunctions_PxScene_getActiveActors_1');
  _emscripten_bind_SupportFunctions_PxScene_getActiveActors_1 = Module['_emscripten_bind_SupportFunctions_PxScene_getActiveActors_1'] = createExportWrapper('emscripten_bind_SupportFunctions_PxScene_getActiveActors_1', 1);
  assert(typeof wasmExports['emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverPositionIterations_1'] != 'undefined', 'missing Wasm export: emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverPositionIterations_1');
  _emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverPositionIterations_1 = Module['_emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverPositionIterations_1'] = createExportWrapper('emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverPositionIterations_1', 1);
  assert(typeof wasmExports['emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverVelocityIterations_1'] != 'undefined', 'missing Wasm export: emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverVelocityIterations_1');
  _emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverVelocityIterations_1 = Module['_emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverVelocityIterations_1'] = createExportWrapper('emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverVelocityIterations_1', 1);
  assert(typeof wasmExports['emscripten_bind_SupportFunctions___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_SupportFunctions___destroy___0');
  _emscripten_bind_SupportFunctions___destroy___0 = Module['_emscripten_bind_SupportFunctions___destroy___0'] = createExportWrapper('emscripten_bind_SupportFunctions___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_0');
  _emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_0 = Module['_emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_0'] = createExportWrapper('emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_0', 0);
  assert(typeof wasmExports['emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_1');
  _emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_1 = Module['_emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_1'] = createExportWrapper('emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_1', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxActorPtr_at_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxActorPtr_at_1');
  _emscripten_bind_Vector_PxActorPtr_at_1 = Module['_emscripten_bind_Vector_PxActorPtr_at_1'] = createExportWrapper('emscripten_bind_Vector_PxActorPtr_at_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxActorPtr_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxActorPtr_data_0');
  _emscripten_bind_Vector_PxActorPtr_data_0 = Module['_emscripten_bind_Vector_PxActorPtr_data_0'] = createExportWrapper('emscripten_bind_Vector_PxActorPtr_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxActorPtr_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxActorPtr_size_0');
  _emscripten_bind_Vector_PxActorPtr_size_0 = Module['_emscripten_bind_Vector_PxActorPtr_size_0'] = createExportWrapper('emscripten_bind_Vector_PxActorPtr_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxActorPtr_push_back_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxActorPtr_push_back_1');
  _emscripten_bind_Vector_PxActorPtr_push_back_1 = Module['_emscripten_bind_Vector_PxActorPtr_push_back_1'] = createExportWrapper('emscripten_bind_Vector_PxActorPtr_push_back_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxActorPtr_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxActorPtr_clear_0');
  _emscripten_bind_Vector_PxActorPtr_clear_0 = Module['_emscripten_bind_Vector_PxActorPtr_clear_0'] = createExportWrapper('emscripten_bind_Vector_PxActorPtr_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxActorPtr___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxActorPtr___destroy___0');
  _emscripten_bind_Vector_PxActorPtr___destroy___0 = Module['_emscripten_bind_Vector_PxActorPtr___destroy___0'] = createExportWrapper('emscripten_bind_Vector_PxActorPtr___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_0');
  _emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_0 = Module['_emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_0'] = createExportWrapper('emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_0', 0);
  assert(typeof wasmExports['emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_1');
  _emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_1 = Module['_emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_1'] = createExportWrapper('emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_1', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxContactPairPoint_at_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxContactPairPoint_at_1');
  _emscripten_bind_Vector_PxContactPairPoint_at_1 = Module['_emscripten_bind_Vector_PxContactPairPoint_at_1'] = createExportWrapper('emscripten_bind_Vector_PxContactPairPoint_at_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxContactPairPoint_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxContactPairPoint_data_0');
  _emscripten_bind_Vector_PxContactPairPoint_data_0 = Module['_emscripten_bind_Vector_PxContactPairPoint_data_0'] = createExportWrapper('emscripten_bind_Vector_PxContactPairPoint_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxContactPairPoint_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxContactPairPoint_size_0');
  _emscripten_bind_Vector_PxContactPairPoint_size_0 = Module['_emscripten_bind_Vector_PxContactPairPoint_size_0'] = createExportWrapper('emscripten_bind_Vector_PxContactPairPoint_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxContactPairPoint_push_back_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxContactPairPoint_push_back_1');
  _emscripten_bind_Vector_PxContactPairPoint_push_back_1 = Module['_emscripten_bind_Vector_PxContactPairPoint_push_back_1'] = createExportWrapper('emscripten_bind_Vector_PxContactPairPoint_push_back_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxContactPairPoint_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxContactPairPoint_clear_0');
  _emscripten_bind_Vector_PxContactPairPoint_clear_0 = Module['_emscripten_bind_Vector_PxContactPairPoint_clear_0'] = createExportWrapper('emscripten_bind_Vector_PxContactPairPoint_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxContactPairPoint___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxContactPairPoint___destroy___0');
  _emscripten_bind_Vector_PxContactPairPoint___destroy___0 = Module['_emscripten_bind_Vector_PxContactPairPoint___destroy___0'] = createExportWrapper('emscripten_bind_Vector_PxContactPairPoint___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_0');
  _emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_0 = Module['_emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_0'] = createExportWrapper('emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_0', 0);
  assert(typeof wasmExports['emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_1');
  _emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_1 = Module['_emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_1'] = createExportWrapper('emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_1', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxHeightFieldSample_at_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxHeightFieldSample_at_1');
  _emscripten_bind_Vector_PxHeightFieldSample_at_1 = Module['_emscripten_bind_Vector_PxHeightFieldSample_at_1'] = createExportWrapper('emscripten_bind_Vector_PxHeightFieldSample_at_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxHeightFieldSample_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxHeightFieldSample_data_0');
  _emscripten_bind_Vector_PxHeightFieldSample_data_0 = Module['_emscripten_bind_Vector_PxHeightFieldSample_data_0'] = createExportWrapper('emscripten_bind_Vector_PxHeightFieldSample_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxHeightFieldSample_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxHeightFieldSample_size_0');
  _emscripten_bind_Vector_PxHeightFieldSample_size_0 = Module['_emscripten_bind_Vector_PxHeightFieldSample_size_0'] = createExportWrapper('emscripten_bind_Vector_PxHeightFieldSample_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxHeightFieldSample_push_back_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxHeightFieldSample_push_back_1');
  _emscripten_bind_Vector_PxHeightFieldSample_push_back_1 = Module['_emscripten_bind_Vector_PxHeightFieldSample_push_back_1'] = createExportWrapper('emscripten_bind_Vector_PxHeightFieldSample_push_back_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxHeightFieldSample_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxHeightFieldSample_clear_0');
  _emscripten_bind_Vector_PxHeightFieldSample_clear_0 = Module['_emscripten_bind_Vector_PxHeightFieldSample_clear_0'] = createExportWrapper('emscripten_bind_Vector_PxHeightFieldSample_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxHeightFieldSample___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxHeightFieldSample___destroy___0');
  _emscripten_bind_Vector_PxHeightFieldSample___destroy___0 = Module['_emscripten_bind_Vector_PxHeightFieldSample___destroy___0'] = createExportWrapper('emscripten_bind_Vector_PxHeightFieldSample___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_0');
  _emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_0 = Module['_emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_0'] = createExportWrapper('emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_0', 0);
  assert(typeof wasmExports['emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_1');
  _emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_1 = Module['_emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_1'] = createExportWrapper('emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_1', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxMaterialConst_at_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxMaterialConst_at_1');
  _emscripten_bind_Vector_PxMaterialConst_at_1 = Module['_emscripten_bind_Vector_PxMaterialConst_at_1'] = createExportWrapper('emscripten_bind_Vector_PxMaterialConst_at_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxMaterialConst_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxMaterialConst_data_0');
  _emscripten_bind_Vector_PxMaterialConst_data_0 = Module['_emscripten_bind_Vector_PxMaterialConst_data_0'] = createExportWrapper('emscripten_bind_Vector_PxMaterialConst_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxMaterialConst_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxMaterialConst_size_0');
  _emscripten_bind_Vector_PxMaterialConst_size_0 = Module['_emscripten_bind_Vector_PxMaterialConst_size_0'] = createExportWrapper('emscripten_bind_Vector_PxMaterialConst_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxMaterialConst_push_back_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxMaterialConst_push_back_1');
  _emscripten_bind_Vector_PxMaterialConst_push_back_1 = Module['_emscripten_bind_Vector_PxMaterialConst_push_back_1'] = createExportWrapper('emscripten_bind_Vector_PxMaterialConst_push_back_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxMaterialConst_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxMaterialConst_clear_0');
  _emscripten_bind_Vector_PxMaterialConst_clear_0 = Module['_emscripten_bind_Vector_PxMaterialConst_clear_0'] = createExportWrapper('emscripten_bind_Vector_PxMaterialConst_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxMaterialConst___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxMaterialConst___destroy___0');
  _emscripten_bind_Vector_PxMaterialConst___destroy___0 = Module['_emscripten_bind_Vector_PxMaterialConst___destroy___0'] = createExportWrapper('emscripten_bind_Vector_PxMaterialConst___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_0');
  _emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_0 = Module['_emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_0'] = createExportWrapper('emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_0', 0);
  assert(typeof wasmExports['emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_1');
  _emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_1 = Module['_emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_1'] = createExportWrapper('emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_1', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxRaycastHit_at_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxRaycastHit_at_1');
  _emscripten_bind_Vector_PxRaycastHit_at_1 = Module['_emscripten_bind_Vector_PxRaycastHit_at_1'] = createExportWrapper('emscripten_bind_Vector_PxRaycastHit_at_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxRaycastHit_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxRaycastHit_data_0');
  _emscripten_bind_Vector_PxRaycastHit_data_0 = Module['_emscripten_bind_Vector_PxRaycastHit_data_0'] = createExportWrapper('emscripten_bind_Vector_PxRaycastHit_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxRaycastHit_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxRaycastHit_size_0');
  _emscripten_bind_Vector_PxRaycastHit_size_0 = Module['_emscripten_bind_Vector_PxRaycastHit_size_0'] = createExportWrapper('emscripten_bind_Vector_PxRaycastHit_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxRaycastHit_push_back_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxRaycastHit_push_back_1');
  _emscripten_bind_Vector_PxRaycastHit_push_back_1 = Module['_emscripten_bind_Vector_PxRaycastHit_push_back_1'] = createExportWrapper('emscripten_bind_Vector_PxRaycastHit_push_back_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxRaycastHit_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxRaycastHit_clear_0');
  _emscripten_bind_Vector_PxRaycastHit_clear_0 = Module['_emscripten_bind_Vector_PxRaycastHit_clear_0'] = createExportWrapper('emscripten_bind_Vector_PxRaycastHit_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxRaycastHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxRaycastHit___destroy___0');
  _emscripten_bind_Vector_PxRaycastHit___destroy___0 = Module['_emscripten_bind_Vector_PxRaycastHit___destroy___0'] = createExportWrapper('emscripten_bind_Vector_PxRaycastHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxReal_Vector_PxReal_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxReal_Vector_PxReal_0');
  _emscripten_bind_Vector_PxReal_Vector_PxReal_0 = Module['_emscripten_bind_Vector_PxReal_Vector_PxReal_0'] = createExportWrapper('emscripten_bind_Vector_PxReal_Vector_PxReal_0', 0);
  assert(typeof wasmExports['emscripten_bind_Vector_PxReal_Vector_PxReal_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxReal_Vector_PxReal_1');
  _emscripten_bind_Vector_PxReal_Vector_PxReal_1 = Module['_emscripten_bind_Vector_PxReal_Vector_PxReal_1'] = createExportWrapper('emscripten_bind_Vector_PxReal_Vector_PxReal_1', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxReal_at_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxReal_at_1');
  _emscripten_bind_Vector_PxReal_at_1 = Module['_emscripten_bind_Vector_PxReal_at_1'] = createExportWrapper('emscripten_bind_Vector_PxReal_at_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxReal_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxReal_data_0');
  _emscripten_bind_Vector_PxReal_data_0 = Module['_emscripten_bind_Vector_PxReal_data_0'] = createExportWrapper('emscripten_bind_Vector_PxReal_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxReal_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxReal_size_0');
  _emscripten_bind_Vector_PxReal_size_0 = Module['_emscripten_bind_Vector_PxReal_size_0'] = createExportWrapper('emscripten_bind_Vector_PxReal_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxReal_push_back_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxReal_push_back_1');
  _emscripten_bind_Vector_PxReal_push_back_1 = Module['_emscripten_bind_Vector_PxReal_push_back_1'] = createExportWrapper('emscripten_bind_Vector_PxReal_push_back_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxReal_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxReal_clear_0');
  _emscripten_bind_Vector_PxReal_clear_0 = Module['_emscripten_bind_Vector_PxReal_clear_0'] = createExportWrapper('emscripten_bind_Vector_PxReal_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxReal___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxReal___destroy___0');
  _emscripten_bind_Vector_PxReal___destroy___0 = Module['_emscripten_bind_Vector_PxReal___destroy___0'] = createExportWrapper('emscripten_bind_Vector_PxReal___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_0');
  _emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_0 = Module['_emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_0'] = createExportWrapper('emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_0', 0);
  assert(typeof wasmExports['emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_1');
  _emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_1 = Module['_emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_1'] = createExportWrapper('emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_1', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxSweepHit_at_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxSweepHit_at_1');
  _emscripten_bind_Vector_PxSweepHit_at_1 = Module['_emscripten_bind_Vector_PxSweepHit_at_1'] = createExportWrapper('emscripten_bind_Vector_PxSweepHit_at_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxSweepHit_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxSweepHit_data_0');
  _emscripten_bind_Vector_PxSweepHit_data_0 = Module['_emscripten_bind_Vector_PxSweepHit_data_0'] = createExportWrapper('emscripten_bind_Vector_PxSweepHit_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxSweepHit_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxSweepHit_size_0');
  _emscripten_bind_Vector_PxSweepHit_size_0 = Module['_emscripten_bind_Vector_PxSweepHit_size_0'] = createExportWrapper('emscripten_bind_Vector_PxSweepHit_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxSweepHit_push_back_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxSweepHit_push_back_1');
  _emscripten_bind_Vector_PxSweepHit_push_back_1 = Module['_emscripten_bind_Vector_PxSweepHit_push_back_1'] = createExportWrapper('emscripten_bind_Vector_PxSweepHit_push_back_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxSweepHit_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxSweepHit_clear_0');
  _emscripten_bind_Vector_PxSweepHit_clear_0 = Module['_emscripten_bind_Vector_PxSweepHit_clear_0'] = createExportWrapper('emscripten_bind_Vector_PxSweepHit_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxSweepHit___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxSweepHit___destroy___0');
  _emscripten_bind_Vector_PxSweepHit___destroy___0 = Module['_emscripten_bind_Vector_PxSweepHit___destroy___0'] = createExportWrapper('emscripten_bind_Vector_PxSweepHit___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU16_Vector_PxU16_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU16_Vector_PxU16_0');
  _emscripten_bind_Vector_PxU16_Vector_PxU16_0 = Module['_emscripten_bind_Vector_PxU16_Vector_PxU16_0'] = createExportWrapper('emscripten_bind_Vector_PxU16_Vector_PxU16_0', 0);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU16_Vector_PxU16_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU16_Vector_PxU16_1');
  _emscripten_bind_Vector_PxU16_Vector_PxU16_1 = Module['_emscripten_bind_Vector_PxU16_Vector_PxU16_1'] = createExportWrapper('emscripten_bind_Vector_PxU16_Vector_PxU16_1', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU16_at_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU16_at_1');
  _emscripten_bind_Vector_PxU16_at_1 = Module['_emscripten_bind_Vector_PxU16_at_1'] = createExportWrapper('emscripten_bind_Vector_PxU16_at_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU16_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU16_data_0');
  _emscripten_bind_Vector_PxU16_data_0 = Module['_emscripten_bind_Vector_PxU16_data_0'] = createExportWrapper('emscripten_bind_Vector_PxU16_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU16_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU16_size_0');
  _emscripten_bind_Vector_PxU16_size_0 = Module['_emscripten_bind_Vector_PxU16_size_0'] = createExportWrapper('emscripten_bind_Vector_PxU16_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU16_push_back_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU16_push_back_1');
  _emscripten_bind_Vector_PxU16_push_back_1 = Module['_emscripten_bind_Vector_PxU16_push_back_1'] = createExportWrapper('emscripten_bind_Vector_PxU16_push_back_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU16_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU16_clear_0');
  _emscripten_bind_Vector_PxU16_clear_0 = Module['_emscripten_bind_Vector_PxU16_clear_0'] = createExportWrapper('emscripten_bind_Vector_PxU16_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU16___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU16___destroy___0');
  _emscripten_bind_Vector_PxU16___destroy___0 = Module['_emscripten_bind_Vector_PxU16___destroy___0'] = createExportWrapper('emscripten_bind_Vector_PxU16___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU32_Vector_PxU32_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU32_Vector_PxU32_0');
  _emscripten_bind_Vector_PxU32_Vector_PxU32_0 = Module['_emscripten_bind_Vector_PxU32_Vector_PxU32_0'] = createExportWrapper('emscripten_bind_Vector_PxU32_Vector_PxU32_0', 0);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU32_Vector_PxU32_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU32_Vector_PxU32_1');
  _emscripten_bind_Vector_PxU32_Vector_PxU32_1 = Module['_emscripten_bind_Vector_PxU32_Vector_PxU32_1'] = createExportWrapper('emscripten_bind_Vector_PxU32_Vector_PxU32_1', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU32_at_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU32_at_1');
  _emscripten_bind_Vector_PxU32_at_1 = Module['_emscripten_bind_Vector_PxU32_at_1'] = createExportWrapper('emscripten_bind_Vector_PxU32_at_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU32_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU32_data_0');
  _emscripten_bind_Vector_PxU32_data_0 = Module['_emscripten_bind_Vector_PxU32_data_0'] = createExportWrapper('emscripten_bind_Vector_PxU32_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU32_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU32_size_0');
  _emscripten_bind_Vector_PxU32_size_0 = Module['_emscripten_bind_Vector_PxU32_size_0'] = createExportWrapper('emscripten_bind_Vector_PxU32_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU32_push_back_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU32_push_back_1');
  _emscripten_bind_Vector_PxU32_push_back_1 = Module['_emscripten_bind_Vector_PxU32_push_back_1'] = createExportWrapper('emscripten_bind_Vector_PxU32_push_back_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU32_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU32_clear_0');
  _emscripten_bind_Vector_PxU32_clear_0 = Module['_emscripten_bind_Vector_PxU32_clear_0'] = createExportWrapper('emscripten_bind_Vector_PxU32_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU32___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU32___destroy___0');
  _emscripten_bind_Vector_PxU32___destroy___0 = Module['_emscripten_bind_Vector_PxU32___destroy___0'] = createExportWrapper('emscripten_bind_Vector_PxU32___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU8_Vector_PxU8_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU8_Vector_PxU8_0');
  _emscripten_bind_Vector_PxU8_Vector_PxU8_0 = Module['_emscripten_bind_Vector_PxU8_Vector_PxU8_0'] = createExportWrapper('emscripten_bind_Vector_PxU8_Vector_PxU8_0', 0);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU8_Vector_PxU8_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU8_Vector_PxU8_1');
  _emscripten_bind_Vector_PxU8_Vector_PxU8_1 = Module['_emscripten_bind_Vector_PxU8_Vector_PxU8_1'] = createExportWrapper('emscripten_bind_Vector_PxU8_Vector_PxU8_1', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU8_at_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU8_at_1');
  _emscripten_bind_Vector_PxU8_at_1 = Module['_emscripten_bind_Vector_PxU8_at_1'] = createExportWrapper('emscripten_bind_Vector_PxU8_at_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU8_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU8_data_0');
  _emscripten_bind_Vector_PxU8_data_0 = Module['_emscripten_bind_Vector_PxU8_data_0'] = createExportWrapper('emscripten_bind_Vector_PxU8_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU8_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU8_size_0');
  _emscripten_bind_Vector_PxU8_size_0 = Module['_emscripten_bind_Vector_PxU8_size_0'] = createExportWrapper('emscripten_bind_Vector_PxU8_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU8_push_back_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU8_push_back_1');
  _emscripten_bind_Vector_PxU8_push_back_1 = Module['_emscripten_bind_Vector_PxU8_push_back_1'] = createExportWrapper('emscripten_bind_Vector_PxU8_push_back_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU8_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU8_clear_0');
  _emscripten_bind_Vector_PxU8_clear_0 = Module['_emscripten_bind_Vector_PxU8_clear_0'] = createExportWrapper('emscripten_bind_Vector_PxU8_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxU8___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxU8___destroy___0');
  _emscripten_bind_Vector_PxU8___destroy___0 = Module['_emscripten_bind_Vector_PxU8___destroy___0'] = createExportWrapper('emscripten_bind_Vector_PxU8___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec3_Vector_PxVec3_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec3_Vector_PxVec3_0');
  _emscripten_bind_Vector_PxVec3_Vector_PxVec3_0 = Module['_emscripten_bind_Vector_PxVec3_Vector_PxVec3_0'] = createExportWrapper('emscripten_bind_Vector_PxVec3_Vector_PxVec3_0', 0);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec3_Vector_PxVec3_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec3_Vector_PxVec3_1');
  _emscripten_bind_Vector_PxVec3_Vector_PxVec3_1 = Module['_emscripten_bind_Vector_PxVec3_Vector_PxVec3_1'] = createExportWrapper('emscripten_bind_Vector_PxVec3_Vector_PxVec3_1', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec3_at_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec3_at_1');
  _emscripten_bind_Vector_PxVec3_at_1 = Module['_emscripten_bind_Vector_PxVec3_at_1'] = createExportWrapper('emscripten_bind_Vector_PxVec3_at_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec3_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec3_data_0');
  _emscripten_bind_Vector_PxVec3_data_0 = Module['_emscripten_bind_Vector_PxVec3_data_0'] = createExportWrapper('emscripten_bind_Vector_PxVec3_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec3_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec3_size_0');
  _emscripten_bind_Vector_PxVec3_size_0 = Module['_emscripten_bind_Vector_PxVec3_size_0'] = createExportWrapper('emscripten_bind_Vector_PxVec3_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec3_push_back_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec3_push_back_1');
  _emscripten_bind_Vector_PxVec3_push_back_1 = Module['_emscripten_bind_Vector_PxVec3_push_back_1'] = createExportWrapper('emscripten_bind_Vector_PxVec3_push_back_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec3_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec3_clear_0');
  _emscripten_bind_Vector_PxVec3_clear_0 = Module['_emscripten_bind_Vector_PxVec3_clear_0'] = createExportWrapper('emscripten_bind_Vector_PxVec3_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec3___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec3___destroy___0');
  _emscripten_bind_Vector_PxVec3___destroy___0 = Module['_emscripten_bind_Vector_PxVec3___destroy___0'] = createExportWrapper('emscripten_bind_Vector_PxVec3___destroy___0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec4_Vector_PxVec4_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec4_Vector_PxVec4_0');
  _emscripten_bind_Vector_PxVec4_Vector_PxVec4_0 = Module['_emscripten_bind_Vector_PxVec4_Vector_PxVec4_0'] = createExportWrapper('emscripten_bind_Vector_PxVec4_Vector_PxVec4_0', 0);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec4_Vector_PxVec4_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec4_Vector_PxVec4_1');
  _emscripten_bind_Vector_PxVec4_Vector_PxVec4_1 = Module['_emscripten_bind_Vector_PxVec4_Vector_PxVec4_1'] = createExportWrapper('emscripten_bind_Vector_PxVec4_Vector_PxVec4_1', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec4_at_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec4_at_1');
  _emscripten_bind_Vector_PxVec4_at_1 = Module['_emscripten_bind_Vector_PxVec4_at_1'] = createExportWrapper('emscripten_bind_Vector_PxVec4_at_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec4_data_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec4_data_0');
  _emscripten_bind_Vector_PxVec4_data_0 = Module['_emscripten_bind_Vector_PxVec4_data_0'] = createExportWrapper('emscripten_bind_Vector_PxVec4_data_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec4_size_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec4_size_0');
  _emscripten_bind_Vector_PxVec4_size_0 = Module['_emscripten_bind_Vector_PxVec4_size_0'] = createExportWrapper('emscripten_bind_Vector_PxVec4_size_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec4_push_back_1'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec4_push_back_1');
  _emscripten_bind_Vector_PxVec4_push_back_1 = Module['_emscripten_bind_Vector_PxVec4_push_back_1'] = createExportWrapper('emscripten_bind_Vector_PxVec4_push_back_1', 2);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec4_clear_0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec4_clear_0');
  _emscripten_bind_Vector_PxVec4_clear_0 = Module['_emscripten_bind_Vector_PxVec4_clear_0'] = createExportWrapper('emscripten_bind_Vector_PxVec4_clear_0', 1);
  assert(typeof wasmExports['emscripten_bind_Vector_PxVec4___destroy___0'] != 'undefined', 'missing Wasm export: emscripten_bind_Vector_PxVec4___destroy___0');
  _emscripten_bind_Vector_PxVec4___destroy___0 = Module['_emscripten_bind_Vector_PxVec4___destroy___0'] = createExportWrapper('emscripten_bind_Vector_PxVec4___destroy___0', 1);
  assert(typeof wasmExports['emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_FOURWHEELDRIVE'] != 'undefined', 'missing Wasm export: emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_FOURWHEELDRIVE');
  _emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_FOURWHEELDRIVE = Module['_emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_FOURWHEELDRIVE'] = createExportWrapper('emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_FOURWHEELDRIVE', 0);
  assert(typeof wasmExports['emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_MULTIWHEELDRIVE'] != 'undefined', 'missing Wasm export: emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_MULTIWHEELDRIVE');
  _emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_MULTIWHEELDRIVE = Module['_emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_MULTIWHEELDRIVE'] = createExportWrapper('emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_MULTIWHEELDRIVE', 0);
  assert(typeof wasmExports['emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_TANKDRIVE'] != 'undefined', 'missing Wasm export: emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_TANKDRIVE');
  _emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_TANKDRIVE = Module['_emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_TANKDRIVE'] = createExportWrapper('emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_TANKDRIVE', 0);
  assert(typeof wasmExports['emscripten_enum_PxActorFlagEnum_eVISUALIZATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxActorFlagEnum_eVISUALIZATION');
  _emscripten_enum_PxActorFlagEnum_eVISUALIZATION = Module['_emscripten_enum_PxActorFlagEnum_eVISUALIZATION'] = createExportWrapper('emscripten_enum_PxActorFlagEnum_eVISUALIZATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxActorFlagEnum_eDISABLE_GRAVITY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxActorFlagEnum_eDISABLE_GRAVITY');
  _emscripten_enum_PxActorFlagEnum_eDISABLE_GRAVITY = Module['_emscripten_enum_PxActorFlagEnum_eDISABLE_GRAVITY'] = createExportWrapper('emscripten_enum_PxActorFlagEnum_eDISABLE_GRAVITY', 0);
  assert(typeof wasmExports['emscripten_enum_PxActorFlagEnum_eSEND_SLEEP_NOTIFIES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxActorFlagEnum_eSEND_SLEEP_NOTIFIES');
  _emscripten_enum_PxActorFlagEnum_eSEND_SLEEP_NOTIFIES = Module['_emscripten_enum_PxActorFlagEnum_eSEND_SLEEP_NOTIFIES'] = createExportWrapper('emscripten_enum_PxActorFlagEnum_eSEND_SLEEP_NOTIFIES', 0);
  assert(typeof wasmExports['emscripten_enum_PxActorFlagEnum_eDISABLE_SIMULATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxActorFlagEnum_eDISABLE_SIMULATION');
  _emscripten_enum_PxActorFlagEnum_eDISABLE_SIMULATION = Module['_emscripten_enum_PxActorFlagEnum_eDISABLE_SIMULATION'] = createExportWrapper('emscripten_enum_PxActorFlagEnum_eDISABLE_SIMULATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxActorTypeEnum_eRIGID_STATIC'] != 'undefined', 'missing Wasm export: emscripten_enum_PxActorTypeEnum_eRIGID_STATIC');
  _emscripten_enum_PxActorTypeEnum_eRIGID_STATIC = Module['_emscripten_enum_PxActorTypeEnum_eRIGID_STATIC'] = createExportWrapper('emscripten_enum_PxActorTypeEnum_eRIGID_STATIC', 0);
  assert(typeof wasmExports['emscripten_enum_PxActorTypeEnum_eRIGID_DYNAMIC'] != 'undefined', 'missing Wasm export: emscripten_enum_PxActorTypeEnum_eRIGID_DYNAMIC');
  _emscripten_enum_PxActorTypeEnum_eRIGID_DYNAMIC = Module['_emscripten_enum_PxActorTypeEnum_eRIGID_DYNAMIC'] = createExportWrapper('emscripten_enum_PxActorTypeEnum_eRIGID_DYNAMIC', 0);
  assert(typeof wasmExports['emscripten_enum_PxActorTypeEnum_eARTICULATION_LINK'] != 'undefined', 'missing Wasm export: emscripten_enum_PxActorTypeEnum_eARTICULATION_LINK');
  _emscripten_enum_PxActorTypeEnum_eARTICULATION_LINK = Module['_emscripten_enum_PxActorTypeEnum_eARTICULATION_LINK'] = createExportWrapper('emscripten_enum_PxActorTypeEnum_eARTICULATION_LINK', 0);
  assert(typeof wasmExports['emscripten_enum_PxActorTypeEnum_eDEFORMABLE_SURFACE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxActorTypeEnum_eDEFORMABLE_SURFACE');
  _emscripten_enum_PxActorTypeEnum_eDEFORMABLE_SURFACE = Module['_emscripten_enum_PxActorTypeEnum_eDEFORMABLE_SURFACE'] = createExportWrapper('emscripten_enum_PxActorTypeEnum_eDEFORMABLE_SURFACE', 0);
  assert(typeof wasmExports['emscripten_enum_PxActorTypeEnum_eDEFORMABLE_VOLUME'] != 'undefined', 'missing Wasm export: emscripten_enum_PxActorTypeEnum_eDEFORMABLE_VOLUME');
  _emscripten_enum_PxActorTypeEnum_eDEFORMABLE_VOLUME = Module['_emscripten_enum_PxActorTypeEnum_eDEFORMABLE_VOLUME'] = createExportWrapper('emscripten_enum_PxActorTypeEnum_eDEFORMABLE_VOLUME', 0);
  assert(typeof wasmExports['emscripten_enum_PxActorTypeEnum_eSOFTBODY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxActorTypeEnum_eSOFTBODY');
  _emscripten_enum_PxActorTypeEnum_eSOFTBODY = Module['_emscripten_enum_PxActorTypeEnum_eSOFTBODY'] = createExportWrapper('emscripten_enum_PxActorTypeEnum_eSOFTBODY', 0);
  assert(typeof wasmExports['emscripten_enum_PxActorTypeEnum_ePBD_PARTICLESYSTEM'] != 'undefined', 'missing Wasm export: emscripten_enum_PxActorTypeEnum_ePBD_PARTICLESYSTEM');
  _emscripten_enum_PxActorTypeEnum_ePBD_PARTICLESYSTEM = Module['_emscripten_enum_PxActorTypeEnum_ePBD_PARTICLESYSTEM'] = createExportWrapper('emscripten_enum_PxActorTypeEnum_ePBD_PARTICLESYSTEM', 0);
  assert(typeof wasmExports['emscripten_enum_PxActorTypeFlagEnum_eRIGID_STATIC'] != 'undefined', 'missing Wasm export: emscripten_enum_PxActorTypeFlagEnum_eRIGID_STATIC');
  _emscripten_enum_PxActorTypeFlagEnum_eRIGID_STATIC = Module['_emscripten_enum_PxActorTypeFlagEnum_eRIGID_STATIC'] = createExportWrapper('emscripten_enum_PxActorTypeFlagEnum_eRIGID_STATIC', 0);
  assert(typeof wasmExports['emscripten_enum_PxActorTypeFlagEnum_eRIGID_DYNAMIC'] != 'undefined', 'missing Wasm export: emscripten_enum_PxActorTypeFlagEnum_eRIGID_DYNAMIC');
  _emscripten_enum_PxActorTypeFlagEnum_eRIGID_DYNAMIC = Module['_emscripten_enum_PxActorTypeFlagEnum_eRIGID_DYNAMIC'] = createExportWrapper('emscripten_enum_PxActorTypeFlagEnum_eRIGID_DYNAMIC', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationAxisEnum_eTWIST'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationAxisEnum_eTWIST');
  _emscripten_enum_PxArticulationAxisEnum_eTWIST = Module['_emscripten_enum_PxArticulationAxisEnum_eTWIST'] = createExportWrapper('emscripten_enum_PxArticulationAxisEnum_eTWIST', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationAxisEnum_eSWING1'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationAxisEnum_eSWING1');
  _emscripten_enum_PxArticulationAxisEnum_eSWING1 = Module['_emscripten_enum_PxArticulationAxisEnum_eSWING1'] = createExportWrapper('emscripten_enum_PxArticulationAxisEnum_eSWING1', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationAxisEnum_eSWING2'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationAxisEnum_eSWING2');
  _emscripten_enum_PxArticulationAxisEnum_eSWING2 = Module['_emscripten_enum_PxArticulationAxisEnum_eSWING2'] = createExportWrapper('emscripten_enum_PxArticulationAxisEnum_eSWING2', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationAxisEnum_eX'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationAxisEnum_eX');
  _emscripten_enum_PxArticulationAxisEnum_eX = Module['_emscripten_enum_PxArticulationAxisEnum_eX'] = createExportWrapper('emscripten_enum_PxArticulationAxisEnum_eX', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationAxisEnum_eY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationAxisEnum_eY');
  _emscripten_enum_PxArticulationAxisEnum_eY = Module['_emscripten_enum_PxArticulationAxisEnum_eY'] = createExportWrapper('emscripten_enum_PxArticulationAxisEnum_eY', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationAxisEnum_eZ'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationAxisEnum_eZ');
  _emscripten_enum_PxArticulationAxisEnum_eZ = Module['_emscripten_enum_PxArticulationAxisEnum_eZ'] = createExportWrapper('emscripten_enum_PxArticulationAxisEnum_eZ', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationCacheFlagEnum_eVELOCITY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationCacheFlagEnum_eVELOCITY');
  _emscripten_enum_PxArticulationCacheFlagEnum_eVELOCITY = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eVELOCITY'] = createExportWrapper('emscripten_enum_PxArticulationCacheFlagEnum_eVELOCITY', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationCacheFlagEnum_eACCELERATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationCacheFlagEnum_eACCELERATION');
  _emscripten_enum_PxArticulationCacheFlagEnum_eACCELERATION = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eACCELERATION'] = createExportWrapper('emscripten_enum_PxArticulationCacheFlagEnum_eACCELERATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationCacheFlagEnum_ePOSITION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationCacheFlagEnum_ePOSITION');
  _emscripten_enum_PxArticulationCacheFlagEnum_ePOSITION = Module['_emscripten_enum_PxArticulationCacheFlagEnum_ePOSITION'] = createExportWrapper('emscripten_enum_PxArticulationCacheFlagEnum_ePOSITION', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationCacheFlagEnum_eFORCE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationCacheFlagEnum_eFORCE');
  _emscripten_enum_PxArticulationCacheFlagEnum_eFORCE = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eFORCE'] = createExportWrapper('emscripten_enum_PxArticulationCacheFlagEnum_eFORCE', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationCacheFlagEnum_eLINK_VELOCITY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationCacheFlagEnum_eLINK_VELOCITY');
  _emscripten_enum_PxArticulationCacheFlagEnum_eLINK_VELOCITY = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eLINK_VELOCITY'] = createExportWrapper('emscripten_enum_PxArticulationCacheFlagEnum_eLINK_VELOCITY', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationCacheFlagEnum_eLINK_ACCELERATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationCacheFlagEnum_eLINK_ACCELERATION');
  _emscripten_enum_PxArticulationCacheFlagEnum_eLINK_ACCELERATION = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eLINK_ACCELERATION'] = createExportWrapper('emscripten_enum_PxArticulationCacheFlagEnum_eLINK_ACCELERATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationCacheFlagEnum_eROOT_TRANSFORM'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationCacheFlagEnum_eROOT_TRANSFORM');
  _emscripten_enum_PxArticulationCacheFlagEnum_eROOT_TRANSFORM = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eROOT_TRANSFORM'] = createExportWrapper('emscripten_enum_PxArticulationCacheFlagEnum_eROOT_TRANSFORM', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationCacheFlagEnum_eROOT_VELOCITIES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationCacheFlagEnum_eROOT_VELOCITIES');
  _emscripten_enum_PxArticulationCacheFlagEnum_eROOT_VELOCITIES = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eROOT_VELOCITIES'] = createExportWrapper('emscripten_enum_PxArticulationCacheFlagEnum_eROOT_VELOCITIES', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationCacheFlagEnum_eLINK_INCOMING_JOINT_FORCE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationCacheFlagEnum_eLINK_INCOMING_JOINT_FORCE');
  _emscripten_enum_PxArticulationCacheFlagEnum_eLINK_INCOMING_JOINT_FORCE = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eLINK_INCOMING_JOINT_FORCE'] = createExportWrapper('emscripten_enum_PxArticulationCacheFlagEnum_eLINK_INCOMING_JOINT_FORCE', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_POSITIONS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_POSITIONS');
  _emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_POSITIONS = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_POSITIONS'] = createExportWrapper('emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_POSITIONS', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_VELOCITIES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_VELOCITIES');
  _emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_VELOCITIES = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_VELOCITIES'] = createExportWrapper('emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_VELOCITIES', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationCacheFlagEnum_eALL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationCacheFlagEnum_eALL');
  _emscripten_enum_PxArticulationCacheFlagEnum_eALL = Module['_emscripten_enum_PxArticulationCacheFlagEnum_eALL'] = createExportWrapper('emscripten_enum_PxArticulationCacheFlagEnum_eALL', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationDriveTypeEnum_eFORCE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationDriveTypeEnum_eFORCE');
  _emscripten_enum_PxArticulationDriveTypeEnum_eFORCE = Module['_emscripten_enum_PxArticulationDriveTypeEnum_eFORCE'] = createExportWrapper('emscripten_enum_PxArticulationDriveTypeEnum_eFORCE', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationDriveTypeEnum_eACCELERATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationDriveTypeEnum_eACCELERATION');
  _emscripten_enum_PxArticulationDriveTypeEnum_eACCELERATION = Module['_emscripten_enum_PxArticulationDriveTypeEnum_eACCELERATION'] = createExportWrapper('emscripten_enum_PxArticulationDriveTypeEnum_eACCELERATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationDriveTypeEnum_eNONE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationDriveTypeEnum_eNONE');
  _emscripten_enum_PxArticulationDriveTypeEnum_eNONE = Module['_emscripten_enum_PxArticulationDriveTypeEnum_eNONE'] = createExportWrapper('emscripten_enum_PxArticulationDriveTypeEnum_eNONE', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationFlagEnum_eFIX_BASE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationFlagEnum_eFIX_BASE');
  _emscripten_enum_PxArticulationFlagEnum_eFIX_BASE = Module['_emscripten_enum_PxArticulationFlagEnum_eFIX_BASE'] = createExportWrapper('emscripten_enum_PxArticulationFlagEnum_eFIX_BASE', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationFlagEnum_eDRIVE_LIMITS_ARE_FORCES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationFlagEnum_eDRIVE_LIMITS_ARE_FORCES');
  _emscripten_enum_PxArticulationFlagEnum_eDRIVE_LIMITS_ARE_FORCES = Module['_emscripten_enum_PxArticulationFlagEnum_eDRIVE_LIMITS_ARE_FORCES'] = createExportWrapper('emscripten_enum_PxArticulationFlagEnum_eDRIVE_LIMITS_ARE_FORCES', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationFlagEnum_eDISABLE_SELF_COLLISION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationFlagEnum_eDISABLE_SELF_COLLISION');
  _emscripten_enum_PxArticulationFlagEnum_eDISABLE_SELF_COLLISION = Module['_emscripten_enum_PxArticulationFlagEnum_eDISABLE_SELF_COLLISION'] = createExportWrapper('emscripten_enum_PxArticulationFlagEnum_eDISABLE_SELF_COLLISION', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationJointTypeEnum_eFIX'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationJointTypeEnum_eFIX');
  _emscripten_enum_PxArticulationJointTypeEnum_eFIX = Module['_emscripten_enum_PxArticulationJointTypeEnum_eFIX'] = createExportWrapper('emscripten_enum_PxArticulationJointTypeEnum_eFIX', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationJointTypeEnum_ePRISMATIC'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationJointTypeEnum_ePRISMATIC');
  _emscripten_enum_PxArticulationJointTypeEnum_ePRISMATIC = Module['_emscripten_enum_PxArticulationJointTypeEnum_ePRISMATIC'] = createExportWrapper('emscripten_enum_PxArticulationJointTypeEnum_ePRISMATIC', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationJointTypeEnum_eREVOLUTE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationJointTypeEnum_eREVOLUTE');
  _emscripten_enum_PxArticulationJointTypeEnum_eREVOLUTE = Module['_emscripten_enum_PxArticulationJointTypeEnum_eREVOLUTE'] = createExportWrapper('emscripten_enum_PxArticulationJointTypeEnum_eREVOLUTE', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationJointTypeEnum_eSPHERICAL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationJointTypeEnum_eSPHERICAL');
  _emscripten_enum_PxArticulationJointTypeEnum_eSPHERICAL = Module['_emscripten_enum_PxArticulationJointTypeEnum_eSPHERICAL'] = createExportWrapper('emscripten_enum_PxArticulationJointTypeEnum_eSPHERICAL', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationJointTypeEnum_eUNDEFINED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationJointTypeEnum_eUNDEFINED');
  _emscripten_enum_PxArticulationJointTypeEnum_eUNDEFINED = Module['_emscripten_enum_PxArticulationJointTypeEnum_eUNDEFINED'] = createExportWrapper('emscripten_enum_PxArticulationJointTypeEnum_eUNDEFINED', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationKinematicFlagEnum_ePOSITION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationKinematicFlagEnum_ePOSITION');
  _emscripten_enum_PxArticulationKinematicFlagEnum_ePOSITION = Module['_emscripten_enum_PxArticulationKinematicFlagEnum_ePOSITION'] = createExportWrapper('emscripten_enum_PxArticulationKinematicFlagEnum_ePOSITION', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationKinematicFlagEnum_eVELOCITY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationKinematicFlagEnum_eVELOCITY');
  _emscripten_enum_PxArticulationKinematicFlagEnum_eVELOCITY = Module['_emscripten_enum_PxArticulationKinematicFlagEnum_eVELOCITY'] = createExportWrapper('emscripten_enum_PxArticulationKinematicFlagEnum_eVELOCITY', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationMotionEnum_eLOCKED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationMotionEnum_eLOCKED');
  _emscripten_enum_PxArticulationMotionEnum_eLOCKED = Module['_emscripten_enum_PxArticulationMotionEnum_eLOCKED'] = createExportWrapper('emscripten_enum_PxArticulationMotionEnum_eLOCKED', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationMotionEnum_eLIMITED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationMotionEnum_eLIMITED');
  _emscripten_enum_PxArticulationMotionEnum_eLIMITED = Module['_emscripten_enum_PxArticulationMotionEnum_eLIMITED'] = createExportWrapper('emscripten_enum_PxArticulationMotionEnum_eLIMITED', 0);
  assert(typeof wasmExports['emscripten_enum_PxArticulationMotionEnum_eFREE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxArticulationMotionEnum_eFREE');
  _emscripten_enum_PxArticulationMotionEnum_eFREE = Module['_emscripten_enum_PxArticulationMotionEnum_eFREE'] = createExportWrapper('emscripten_enum_PxArticulationMotionEnum_eFREE', 0);
  assert(typeof wasmExports['emscripten_enum_PxBVHBuildStrategyEnum_eFAST'] != 'undefined', 'missing Wasm export: emscripten_enum_PxBVHBuildStrategyEnum_eFAST');
  _emscripten_enum_PxBVHBuildStrategyEnum_eFAST = Module['_emscripten_enum_PxBVHBuildStrategyEnum_eFAST'] = createExportWrapper('emscripten_enum_PxBVHBuildStrategyEnum_eFAST', 0);
  assert(typeof wasmExports['emscripten_enum_PxBVHBuildStrategyEnum_eDEFAULT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxBVHBuildStrategyEnum_eDEFAULT');
  _emscripten_enum_PxBVHBuildStrategyEnum_eDEFAULT = Module['_emscripten_enum_PxBVHBuildStrategyEnum_eDEFAULT'] = createExportWrapper('emscripten_enum_PxBVHBuildStrategyEnum_eDEFAULT', 0);
  assert(typeof wasmExports['emscripten_enum_PxBVHBuildStrategyEnum_eSAH'] != 'undefined', 'missing Wasm export: emscripten_enum_PxBVHBuildStrategyEnum_eSAH');
  _emscripten_enum_PxBVHBuildStrategyEnum_eSAH = Module['_emscripten_enum_PxBVHBuildStrategyEnum_eSAH'] = createExportWrapper('emscripten_enum_PxBVHBuildStrategyEnum_eSAH', 0);
  assert(typeof wasmExports['emscripten_enum_PxBaseFlagEnum_eOWNS_MEMORY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxBaseFlagEnum_eOWNS_MEMORY');
  _emscripten_enum_PxBaseFlagEnum_eOWNS_MEMORY = Module['_emscripten_enum_PxBaseFlagEnum_eOWNS_MEMORY'] = createExportWrapper('emscripten_enum_PxBaseFlagEnum_eOWNS_MEMORY', 0);
  assert(typeof wasmExports['emscripten_enum_PxBaseFlagEnum_eIS_RELEASABLE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxBaseFlagEnum_eIS_RELEASABLE');
  _emscripten_enum_PxBaseFlagEnum_eIS_RELEASABLE = Module['_emscripten_enum_PxBaseFlagEnum_eIS_RELEASABLE'] = createExportWrapper('emscripten_enum_PxBaseFlagEnum_eIS_RELEASABLE', 0);
  assert(typeof wasmExports['emscripten_enum_PxBroadPhaseTypeEnum_eSAP'] != 'undefined', 'missing Wasm export: emscripten_enum_PxBroadPhaseTypeEnum_eSAP');
  _emscripten_enum_PxBroadPhaseTypeEnum_eSAP = Module['_emscripten_enum_PxBroadPhaseTypeEnum_eSAP'] = createExportWrapper('emscripten_enum_PxBroadPhaseTypeEnum_eSAP', 0);
  assert(typeof wasmExports['emscripten_enum_PxBroadPhaseTypeEnum_eMBP'] != 'undefined', 'missing Wasm export: emscripten_enum_PxBroadPhaseTypeEnum_eMBP');
  _emscripten_enum_PxBroadPhaseTypeEnum_eMBP = Module['_emscripten_enum_PxBroadPhaseTypeEnum_eMBP'] = createExportWrapper('emscripten_enum_PxBroadPhaseTypeEnum_eMBP', 0);
  assert(typeof wasmExports['emscripten_enum_PxBroadPhaseTypeEnum_eABP'] != 'undefined', 'missing Wasm export: emscripten_enum_PxBroadPhaseTypeEnum_eABP');
  _emscripten_enum_PxBroadPhaseTypeEnum_eABP = Module['_emscripten_enum_PxBroadPhaseTypeEnum_eABP'] = createExportWrapper('emscripten_enum_PxBroadPhaseTypeEnum_eABP', 0);
  assert(typeof wasmExports['emscripten_enum_PxBroadPhaseTypeEnum_ePABP'] != 'undefined', 'missing Wasm export: emscripten_enum_PxBroadPhaseTypeEnum_ePABP');
  _emscripten_enum_PxBroadPhaseTypeEnum_ePABP = Module['_emscripten_enum_PxBroadPhaseTypeEnum_ePABP'] = createExportWrapper('emscripten_enum_PxBroadPhaseTypeEnum_ePABP', 0);
  assert(typeof wasmExports['emscripten_enum_PxBroadPhaseTypeEnum_eGPU'] != 'undefined', 'missing Wasm export: emscripten_enum_PxBroadPhaseTypeEnum_eGPU');
  _emscripten_enum_PxBroadPhaseTypeEnum_eGPU = Module['_emscripten_enum_PxBroadPhaseTypeEnum_eGPU'] = createExportWrapper('emscripten_enum_PxBroadPhaseTypeEnum_eGPU', 0);
  assert(typeof wasmExports['emscripten_enum_PxCapsuleClimbingModeEnum_eEASY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxCapsuleClimbingModeEnum_eEASY');
  _emscripten_enum_PxCapsuleClimbingModeEnum_eEASY = Module['_emscripten_enum_PxCapsuleClimbingModeEnum_eEASY'] = createExportWrapper('emscripten_enum_PxCapsuleClimbingModeEnum_eEASY', 0);
  assert(typeof wasmExports['emscripten_enum_PxCapsuleClimbingModeEnum_eCONSTRAINED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxCapsuleClimbingModeEnum_eCONSTRAINED');
  _emscripten_enum_PxCapsuleClimbingModeEnum_eCONSTRAINED = Module['_emscripten_enum_PxCapsuleClimbingModeEnum_eCONSTRAINED'] = createExportWrapper('emscripten_enum_PxCapsuleClimbingModeEnum_eCONSTRAINED', 0);
  assert(typeof wasmExports['emscripten_enum_PxCombineModeEnum_eAVERAGE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxCombineModeEnum_eAVERAGE');
  _emscripten_enum_PxCombineModeEnum_eAVERAGE = Module['_emscripten_enum_PxCombineModeEnum_eAVERAGE'] = createExportWrapper('emscripten_enum_PxCombineModeEnum_eAVERAGE', 0);
  assert(typeof wasmExports['emscripten_enum_PxCombineModeEnum_eMIN'] != 'undefined', 'missing Wasm export: emscripten_enum_PxCombineModeEnum_eMIN');
  _emscripten_enum_PxCombineModeEnum_eMIN = Module['_emscripten_enum_PxCombineModeEnum_eMIN'] = createExportWrapper('emscripten_enum_PxCombineModeEnum_eMIN', 0);
  assert(typeof wasmExports['emscripten_enum_PxCombineModeEnum_eMULTIPLY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxCombineModeEnum_eMULTIPLY');
  _emscripten_enum_PxCombineModeEnum_eMULTIPLY = Module['_emscripten_enum_PxCombineModeEnum_eMULTIPLY'] = createExportWrapper('emscripten_enum_PxCombineModeEnum_eMULTIPLY', 0);
  assert(typeof wasmExports['emscripten_enum_PxCombineModeEnum_eMAX'] != 'undefined', 'missing Wasm export: emscripten_enum_PxCombineModeEnum_eMAX');
  _emscripten_enum_PxCombineModeEnum_eMAX = Module['_emscripten_enum_PxCombineModeEnum_eMAX'] = createExportWrapper('emscripten_enum_PxCombineModeEnum_eMAX', 0);
  assert(typeof wasmExports['emscripten_enum_PxConstraintFlagEnum_eBROKEN'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConstraintFlagEnum_eBROKEN');
  _emscripten_enum_PxConstraintFlagEnum_eBROKEN = Module['_emscripten_enum_PxConstraintFlagEnum_eBROKEN'] = createExportWrapper('emscripten_enum_PxConstraintFlagEnum_eBROKEN', 0);
  assert(typeof wasmExports['emscripten_enum_PxConstraintFlagEnum_eCOLLISION_ENABLED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConstraintFlagEnum_eCOLLISION_ENABLED');
  _emscripten_enum_PxConstraintFlagEnum_eCOLLISION_ENABLED = Module['_emscripten_enum_PxConstraintFlagEnum_eCOLLISION_ENABLED'] = createExportWrapper('emscripten_enum_PxConstraintFlagEnum_eCOLLISION_ENABLED', 0);
  assert(typeof wasmExports['emscripten_enum_PxConstraintFlagEnum_eVISUALIZATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConstraintFlagEnum_eVISUALIZATION');
  _emscripten_enum_PxConstraintFlagEnum_eVISUALIZATION = Module['_emscripten_enum_PxConstraintFlagEnum_eVISUALIZATION'] = createExportWrapper('emscripten_enum_PxConstraintFlagEnum_eVISUALIZATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxConstraintFlagEnum_eDRIVE_LIMITS_ARE_FORCES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConstraintFlagEnum_eDRIVE_LIMITS_ARE_FORCES');
  _emscripten_enum_PxConstraintFlagEnum_eDRIVE_LIMITS_ARE_FORCES = Module['_emscripten_enum_PxConstraintFlagEnum_eDRIVE_LIMITS_ARE_FORCES'] = createExportWrapper('emscripten_enum_PxConstraintFlagEnum_eDRIVE_LIMITS_ARE_FORCES', 0);
  assert(typeof wasmExports['emscripten_enum_PxConstraintFlagEnum_eIMPROVED_SLERP'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConstraintFlagEnum_eIMPROVED_SLERP');
  _emscripten_enum_PxConstraintFlagEnum_eIMPROVED_SLERP = Module['_emscripten_enum_PxConstraintFlagEnum_eIMPROVED_SLERP'] = createExportWrapper('emscripten_enum_PxConstraintFlagEnum_eIMPROVED_SLERP', 0);
  assert(typeof wasmExports['emscripten_enum_PxConstraintFlagEnum_eDISABLE_PREPROCESSING'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConstraintFlagEnum_eDISABLE_PREPROCESSING');
  _emscripten_enum_PxConstraintFlagEnum_eDISABLE_PREPROCESSING = Module['_emscripten_enum_PxConstraintFlagEnum_eDISABLE_PREPROCESSING'] = createExportWrapper('emscripten_enum_PxConstraintFlagEnum_eDISABLE_PREPROCESSING', 0);
  assert(typeof wasmExports['emscripten_enum_PxConstraintFlagEnum_eENABLE_EXTENDED_LIMITS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConstraintFlagEnum_eENABLE_EXTENDED_LIMITS');
  _emscripten_enum_PxConstraintFlagEnum_eENABLE_EXTENDED_LIMITS = Module['_emscripten_enum_PxConstraintFlagEnum_eENABLE_EXTENDED_LIMITS'] = createExportWrapper('emscripten_enum_PxConstraintFlagEnum_eENABLE_EXTENDED_LIMITS', 0);
  assert(typeof wasmExports['emscripten_enum_PxConstraintFlagEnum_eGPU_COMPATIBLE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConstraintFlagEnum_eGPU_COMPATIBLE');
  _emscripten_enum_PxConstraintFlagEnum_eGPU_COMPATIBLE = Module['_emscripten_enum_PxConstraintFlagEnum_eGPU_COMPATIBLE'] = createExportWrapper('emscripten_enum_PxConstraintFlagEnum_eGPU_COMPATIBLE', 0);
  assert(typeof wasmExports['emscripten_enum_PxConstraintFlagEnum_eALWAYS_UPDATE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConstraintFlagEnum_eALWAYS_UPDATE');
  _emscripten_enum_PxConstraintFlagEnum_eALWAYS_UPDATE = Module['_emscripten_enum_PxConstraintFlagEnum_eALWAYS_UPDATE'] = createExportWrapper('emscripten_enum_PxConstraintFlagEnum_eALWAYS_UPDATE', 0);
  assert(typeof wasmExports['emscripten_enum_PxConstraintFlagEnum_eDISABLE_CONSTRAINT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConstraintFlagEnum_eDISABLE_CONSTRAINT');
  _emscripten_enum_PxConstraintFlagEnum_eDISABLE_CONSTRAINT = Module['_emscripten_enum_PxConstraintFlagEnum_eDISABLE_CONSTRAINT'] = createExportWrapper('emscripten_enum_PxConstraintFlagEnum_eDISABLE_CONSTRAINT', 0);
  assert(typeof wasmExports['emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_0'] != 'undefined', 'missing Wasm export: emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_0');
  _emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_0 = Module['_emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_0'] = createExportWrapper('emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_0', 0);
  assert(typeof wasmExports['emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_1'] != 'undefined', 'missing Wasm export: emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_1');
  _emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_1 = Module['_emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_1'] = createExportWrapper('emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_1', 0);
  assert(typeof wasmExports['emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_HAS_FIRST_TOUCH'] != 'undefined', 'missing Wasm export: emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_HAS_FIRST_TOUCH');
  _emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_HAS_FIRST_TOUCH = Module['_emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_HAS_FIRST_TOUCH'] = createExportWrapper('emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_HAS_FIRST_TOUCH', 0);
  assert(typeof wasmExports['emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_LOST_TOUCH'] != 'undefined', 'missing Wasm export: emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_LOST_TOUCH');
  _emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_LOST_TOUCH = Module['_emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_LOST_TOUCH'] = createExportWrapper('emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_LOST_TOUCH', 0);
  assert(typeof wasmExports['emscripten_enum_PxContactPairFlagEnum_eINTERNAL_HAS_IMPULSES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxContactPairFlagEnum_eINTERNAL_HAS_IMPULSES');
  _emscripten_enum_PxContactPairFlagEnum_eINTERNAL_HAS_IMPULSES = Module['_emscripten_enum_PxContactPairFlagEnum_eINTERNAL_HAS_IMPULSES'] = createExportWrapper('emscripten_enum_PxContactPairFlagEnum_eINTERNAL_HAS_IMPULSES', 0);
  assert(typeof wasmExports['emscripten_enum_PxContactPairFlagEnum_eINTERNAL_CONTACTS_ARE_FLIPPED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxContactPairFlagEnum_eINTERNAL_CONTACTS_ARE_FLIPPED');
  _emscripten_enum_PxContactPairFlagEnum_eINTERNAL_CONTACTS_ARE_FLIPPED = Module['_emscripten_enum_PxContactPairFlagEnum_eINTERNAL_CONTACTS_ARE_FLIPPED'] = createExportWrapper('emscripten_enum_PxContactPairFlagEnum_eINTERNAL_CONTACTS_ARE_FLIPPED', 0);
  assert(typeof wasmExports['emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_0'] != 'undefined', 'missing Wasm export: emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_0');
  _emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_0 = Module['_emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_0'] = createExportWrapper('emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_0', 0);
  assert(typeof wasmExports['emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_1'] != 'undefined', 'missing Wasm export: emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_1');
  _emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_1 = Module['_emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_1'] = createExportWrapper('emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_1', 0);
  assert(typeof wasmExports['emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_CAN_RIDE_ON_OBJECT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_CAN_RIDE_ON_OBJECT');
  _emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_CAN_RIDE_ON_OBJECT = Module['_emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_CAN_RIDE_ON_OBJECT'] = createExportWrapper('emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_CAN_RIDE_ON_OBJECT', 0);
  assert(typeof wasmExports['emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_SLIDE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_SLIDE');
  _emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_SLIDE = Module['_emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_SLIDE'] = createExportWrapper('emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_SLIDE', 0);
  assert(typeof wasmExports['emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_USER_DEFINED_RIDE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_USER_DEFINED_RIDE');
  _emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_USER_DEFINED_RIDE = Module['_emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_USER_DEFINED_RIDE'] = createExportWrapper('emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_USER_DEFINED_RIDE', 0);
  assert(typeof wasmExports['emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_SIDES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_SIDES');
  _emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_SIDES = Module['_emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_SIDES'] = createExportWrapper('emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_SIDES', 0);
  assert(typeof wasmExports['emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_UP'] != 'undefined', 'missing Wasm export: emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_UP');
  _emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_UP = Module['_emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_UP'] = createExportWrapper('emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_UP', 0);
  assert(typeof wasmExports['emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_DOWN'] != 'undefined', 'missing Wasm export: emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_DOWN');
  _emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_DOWN = Module['_emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_DOWN'] = createExportWrapper('emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_DOWN', 0);
  assert(typeof wasmExports['emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING'] != 'undefined', 'missing Wasm export: emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING');
  _emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING = Module['_emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING'] = createExportWrapper('emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING', 0);
  assert(typeof wasmExports['emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING_AND_FORCE_SLIDING'] != 'undefined', 'missing Wasm export: emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING_AND_FORCE_SLIDING');
  _emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING_AND_FORCE_SLIDING = Module['_emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING_AND_FORCE_SLIDING'] = createExportWrapper('emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING_AND_FORCE_SLIDING', 0);
  assert(typeof wasmExports['emscripten_enum_PxControllerShapeTypeEnum_eBOX'] != 'undefined', 'missing Wasm export: emscripten_enum_PxControllerShapeTypeEnum_eBOX');
  _emscripten_enum_PxControllerShapeTypeEnum_eBOX = Module['_emscripten_enum_PxControllerShapeTypeEnum_eBOX'] = createExportWrapper('emscripten_enum_PxControllerShapeTypeEnum_eBOX', 0);
  assert(typeof wasmExports['emscripten_enum_PxControllerShapeTypeEnum_eCAPSULE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxControllerShapeTypeEnum_eCAPSULE');
  _emscripten_enum_PxControllerShapeTypeEnum_eCAPSULE = Module['_emscripten_enum_PxControllerShapeTypeEnum_eCAPSULE'] = createExportWrapper('emscripten_enum_PxControllerShapeTypeEnum_eCAPSULE', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexCoreTypeEnum_ePOINT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexCoreTypeEnum_ePOINT');
  _emscripten_enum_PxConvexCoreTypeEnum_ePOINT = Module['_emscripten_enum_PxConvexCoreTypeEnum_ePOINT'] = createExportWrapper('emscripten_enum_PxConvexCoreTypeEnum_ePOINT', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexCoreTypeEnum_eSEGMENT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexCoreTypeEnum_eSEGMENT');
  _emscripten_enum_PxConvexCoreTypeEnum_eSEGMENT = Module['_emscripten_enum_PxConvexCoreTypeEnum_eSEGMENT'] = createExportWrapper('emscripten_enum_PxConvexCoreTypeEnum_eSEGMENT', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexCoreTypeEnum_eBOX'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexCoreTypeEnum_eBOX');
  _emscripten_enum_PxConvexCoreTypeEnum_eBOX = Module['_emscripten_enum_PxConvexCoreTypeEnum_eBOX'] = createExportWrapper('emscripten_enum_PxConvexCoreTypeEnum_eBOX', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexCoreTypeEnum_eELLIPSOID'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexCoreTypeEnum_eELLIPSOID');
  _emscripten_enum_PxConvexCoreTypeEnum_eELLIPSOID = Module['_emscripten_enum_PxConvexCoreTypeEnum_eELLIPSOID'] = createExportWrapper('emscripten_enum_PxConvexCoreTypeEnum_eELLIPSOID', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexCoreTypeEnum_eCYLINDER'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexCoreTypeEnum_eCYLINDER');
  _emscripten_enum_PxConvexCoreTypeEnum_eCYLINDER = Module['_emscripten_enum_PxConvexCoreTypeEnum_eCYLINDER'] = createExportWrapper('emscripten_enum_PxConvexCoreTypeEnum_eCYLINDER', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexCoreTypeEnum_eCONE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexCoreTypeEnum_eCONE');
  _emscripten_enum_PxConvexCoreTypeEnum_eCONE = Module['_emscripten_enum_PxConvexCoreTypeEnum_eCONE'] = createExportWrapper('emscripten_enum_PxConvexCoreTypeEnum_eCONE', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexFlagEnum_e16_BIT_INDICES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexFlagEnum_e16_BIT_INDICES');
  _emscripten_enum_PxConvexFlagEnum_e16_BIT_INDICES = Module['_emscripten_enum_PxConvexFlagEnum_e16_BIT_INDICES'] = createExportWrapper('emscripten_enum_PxConvexFlagEnum_e16_BIT_INDICES', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexFlagEnum_eCOMPUTE_CONVEX'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexFlagEnum_eCOMPUTE_CONVEX');
  _emscripten_enum_PxConvexFlagEnum_eCOMPUTE_CONVEX = Module['_emscripten_enum_PxConvexFlagEnum_eCOMPUTE_CONVEX'] = createExportWrapper('emscripten_enum_PxConvexFlagEnum_eCOMPUTE_CONVEX', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexFlagEnum_eCHECK_ZERO_AREA_TRIANGLES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexFlagEnum_eCHECK_ZERO_AREA_TRIANGLES');
  _emscripten_enum_PxConvexFlagEnum_eCHECK_ZERO_AREA_TRIANGLES = Module['_emscripten_enum_PxConvexFlagEnum_eCHECK_ZERO_AREA_TRIANGLES'] = createExportWrapper('emscripten_enum_PxConvexFlagEnum_eCHECK_ZERO_AREA_TRIANGLES', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexFlagEnum_eQUANTIZE_INPUT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexFlagEnum_eQUANTIZE_INPUT');
  _emscripten_enum_PxConvexFlagEnum_eQUANTIZE_INPUT = Module['_emscripten_enum_PxConvexFlagEnum_eQUANTIZE_INPUT'] = createExportWrapper('emscripten_enum_PxConvexFlagEnum_eQUANTIZE_INPUT', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexFlagEnum_eDISABLE_MESH_VALIDATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexFlagEnum_eDISABLE_MESH_VALIDATION');
  _emscripten_enum_PxConvexFlagEnum_eDISABLE_MESH_VALIDATION = Module['_emscripten_enum_PxConvexFlagEnum_eDISABLE_MESH_VALIDATION'] = createExportWrapper('emscripten_enum_PxConvexFlagEnum_eDISABLE_MESH_VALIDATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexFlagEnum_ePLANE_SHIFTING'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexFlagEnum_ePLANE_SHIFTING');
  _emscripten_enum_PxConvexFlagEnum_ePLANE_SHIFTING = Module['_emscripten_enum_PxConvexFlagEnum_ePLANE_SHIFTING'] = createExportWrapper('emscripten_enum_PxConvexFlagEnum_ePLANE_SHIFTING', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexFlagEnum_eFAST_INERTIA_COMPUTATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexFlagEnum_eFAST_INERTIA_COMPUTATION');
  _emscripten_enum_PxConvexFlagEnum_eFAST_INERTIA_COMPUTATION = Module['_emscripten_enum_PxConvexFlagEnum_eFAST_INERTIA_COMPUTATION'] = createExportWrapper('emscripten_enum_PxConvexFlagEnum_eFAST_INERTIA_COMPUTATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexFlagEnum_eSHIFT_VERTICES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexFlagEnum_eSHIFT_VERTICES');
  _emscripten_enum_PxConvexFlagEnum_eSHIFT_VERTICES = Module['_emscripten_enum_PxConvexFlagEnum_eSHIFT_VERTICES'] = createExportWrapper('emscripten_enum_PxConvexFlagEnum_eSHIFT_VERTICES', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexMeshCookingTypeEnum_eQUICKHULL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexMeshCookingTypeEnum_eQUICKHULL');
  _emscripten_enum_PxConvexMeshCookingTypeEnum_eQUICKHULL = Module['_emscripten_enum_PxConvexMeshCookingTypeEnum_eQUICKHULL'] = createExportWrapper('emscripten_enum_PxConvexMeshCookingTypeEnum_eQUICKHULL', 0);
  assert(typeof wasmExports['emscripten_enum_PxConvexMeshGeometryFlagEnum_eTIGHT_BOUNDS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxConvexMeshGeometryFlagEnum_eTIGHT_BOUNDS');
  _emscripten_enum_PxConvexMeshGeometryFlagEnum_eTIGHT_BOUNDS = Module['_emscripten_enum_PxConvexMeshGeometryFlagEnum_eTIGHT_BOUNDS'] = createExportWrapper('emscripten_enum_PxConvexMeshGeometryFlagEnum_eTIGHT_BOUNDS', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6AngularDriveConfigEnum_eSWING_TWIST'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6AngularDriveConfigEnum_eSWING_TWIST');
  _emscripten_enum_PxD6AngularDriveConfigEnum_eSWING_TWIST = Module['_emscripten_enum_PxD6AngularDriveConfigEnum_eSWING_TWIST'] = createExportWrapper('emscripten_enum_PxD6AngularDriveConfigEnum_eSWING_TWIST', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6AngularDriveConfigEnum_eSLERP'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6AngularDriveConfigEnum_eSLERP');
  _emscripten_enum_PxD6AngularDriveConfigEnum_eSLERP = Module['_emscripten_enum_PxD6AngularDriveConfigEnum_eSLERP'] = createExportWrapper('emscripten_enum_PxD6AngularDriveConfigEnum_eSLERP', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6AngularDriveConfigEnum_eLEGACY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6AngularDriveConfigEnum_eLEGACY');
  _emscripten_enum_PxD6AngularDriveConfigEnum_eLEGACY = Module['_emscripten_enum_PxD6AngularDriveConfigEnum_eLEGACY'] = createExportWrapper('emscripten_enum_PxD6AngularDriveConfigEnum_eLEGACY', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6AxisEnum_eX'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6AxisEnum_eX');
  _emscripten_enum_PxD6AxisEnum_eX = Module['_emscripten_enum_PxD6AxisEnum_eX'] = createExportWrapper('emscripten_enum_PxD6AxisEnum_eX', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6AxisEnum_eY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6AxisEnum_eY');
  _emscripten_enum_PxD6AxisEnum_eY = Module['_emscripten_enum_PxD6AxisEnum_eY'] = createExportWrapper('emscripten_enum_PxD6AxisEnum_eY', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6AxisEnum_eZ'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6AxisEnum_eZ');
  _emscripten_enum_PxD6AxisEnum_eZ = Module['_emscripten_enum_PxD6AxisEnum_eZ'] = createExportWrapper('emscripten_enum_PxD6AxisEnum_eZ', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6AxisEnum_eTWIST'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6AxisEnum_eTWIST');
  _emscripten_enum_PxD6AxisEnum_eTWIST = Module['_emscripten_enum_PxD6AxisEnum_eTWIST'] = createExportWrapper('emscripten_enum_PxD6AxisEnum_eTWIST', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6AxisEnum_eSWING1'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6AxisEnum_eSWING1');
  _emscripten_enum_PxD6AxisEnum_eSWING1 = Module['_emscripten_enum_PxD6AxisEnum_eSWING1'] = createExportWrapper('emscripten_enum_PxD6AxisEnum_eSWING1', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6AxisEnum_eSWING2'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6AxisEnum_eSWING2');
  _emscripten_enum_PxD6AxisEnum_eSWING2 = Module['_emscripten_enum_PxD6AxisEnum_eSWING2'] = createExportWrapper('emscripten_enum_PxD6AxisEnum_eSWING2', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6DriveEnum_eX'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6DriveEnum_eX');
  _emscripten_enum_PxD6DriveEnum_eX = Module['_emscripten_enum_PxD6DriveEnum_eX'] = createExportWrapper('emscripten_enum_PxD6DriveEnum_eX', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6DriveEnum_eY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6DriveEnum_eY');
  _emscripten_enum_PxD6DriveEnum_eY = Module['_emscripten_enum_PxD6DriveEnum_eY'] = createExportWrapper('emscripten_enum_PxD6DriveEnum_eY', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6DriveEnum_eZ'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6DriveEnum_eZ');
  _emscripten_enum_PxD6DriveEnum_eZ = Module['_emscripten_enum_PxD6DriveEnum_eZ'] = createExportWrapper('emscripten_enum_PxD6DriveEnum_eZ', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6DriveEnum_eSWING'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6DriveEnum_eSWING');
  _emscripten_enum_PxD6DriveEnum_eSWING = Module['_emscripten_enum_PxD6DriveEnum_eSWING'] = createExportWrapper('emscripten_enum_PxD6DriveEnum_eSWING', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6DriveEnum_eTWIST'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6DriveEnum_eTWIST');
  _emscripten_enum_PxD6DriveEnum_eTWIST = Module['_emscripten_enum_PxD6DriveEnum_eTWIST'] = createExportWrapper('emscripten_enum_PxD6DriveEnum_eTWIST', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6DriveEnum_eSLERP'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6DriveEnum_eSLERP');
  _emscripten_enum_PxD6DriveEnum_eSLERP = Module['_emscripten_enum_PxD6DriveEnum_eSLERP'] = createExportWrapper('emscripten_enum_PxD6DriveEnum_eSLERP', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6DriveEnum_eSWING1'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6DriveEnum_eSWING1');
  _emscripten_enum_PxD6DriveEnum_eSWING1 = Module['_emscripten_enum_PxD6DriveEnum_eSWING1'] = createExportWrapper('emscripten_enum_PxD6DriveEnum_eSWING1', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6DriveEnum_eSWING2'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6DriveEnum_eSWING2');
  _emscripten_enum_PxD6DriveEnum_eSWING2 = Module['_emscripten_enum_PxD6DriveEnum_eSWING2'] = createExportWrapper('emscripten_enum_PxD6DriveEnum_eSWING2', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6JointDriveFlagEnum_eACCELERATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6JointDriveFlagEnum_eACCELERATION');
  _emscripten_enum_PxD6JointDriveFlagEnum_eACCELERATION = Module['_emscripten_enum_PxD6JointDriveFlagEnum_eACCELERATION'] = createExportWrapper('emscripten_enum_PxD6JointDriveFlagEnum_eACCELERATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6MotionEnum_eLOCKED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6MotionEnum_eLOCKED');
  _emscripten_enum_PxD6MotionEnum_eLOCKED = Module['_emscripten_enum_PxD6MotionEnum_eLOCKED'] = createExportWrapper('emscripten_enum_PxD6MotionEnum_eLOCKED', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6MotionEnum_eLIMITED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6MotionEnum_eLIMITED');
  _emscripten_enum_PxD6MotionEnum_eLIMITED = Module['_emscripten_enum_PxD6MotionEnum_eLIMITED'] = createExportWrapper('emscripten_enum_PxD6MotionEnum_eLIMITED', 0);
  assert(typeof wasmExports['emscripten_enum_PxD6MotionEnum_eFREE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxD6MotionEnum_eFREE');
  _emscripten_enum_PxD6MotionEnum_eFREE = Module['_emscripten_enum_PxD6MotionEnum_eFREE'] = createExportWrapper('emscripten_enum_PxD6MotionEnum_eFREE', 0);
  assert(typeof wasmExports['emscripten_enum_PxDebugColorEnum_eARGB_BLACK'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDebugColorEnum_eARGB_BLACK');
  _emscripten_enum_PxDebugColorEnum_eARGB_BLACK = Module['_emscripten_enum_PxDebugColorEnum_eARGB_BLACK'] = createExportWrapper('emscripten_enum_PxDebugColorEnum_eARGB_BLACK', 0);
  assert(typeof wasmExports['emscripten_enum_PxDebugColorEnum_eARGB_RED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDebugColorEnum_eARGB_RED');
  _emscripten_enum_PxDebugColorEnum_eARGB_RED = Module['_emscripten_enum_PxDebugColorEnum_eARGB_RED'] = createExportWrapper('emscripten_enum_PxDebugColorEnum_eARGB_RED', 0);
  assert(typeof wasmExports['emscripten_enum_PxDebugColorEnum_eARGB_GREEN'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDebugColorEnum_eARGB_GREEN');
  _emscripten_enum_PxDebugColorEnum_eARGB_GREEN = Module['_emscripten_enum_PxDebugColorEnum_eARGB_GREEN'] = createExportWrapper('emscripten_enum_PxDebugColorEnum_eARGB_GREEN', 0);
  assert(typeof wasmExports['emscripten_enum_PxDebugColorEnum_eARGB_BLUE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDebugColorEnum_eARGB_BLUE');
  _emscripten_enum_PxDebugColorEnum_eARGB_BLUE = Module['_emscripten_enum_PxDebugColorEnum_eARGB_BLUE'] = createExportWrapper('emscripten_enum_PxDebugColorEnum_eARGB_BLUE', 0);
  assert(typeof wasmExports['emscripten_enum_PxDebugColorEnum_eARGB_YELLOW'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDebugColorEnum_eARGB_YELLOW');
  _emscripten_enum_PxDebugColorEnum_eARGB_YELLOW = Module['_emscripten_enum_PxDebugColorEnum_eARGB_YELLOW'] = createExportWrapper('emscripten_enum_PxDebugColorEnum_eARGB_YELLOW', 0);
  assert(typeof wasmExports['emscripten_enum_PxDebugColorEnum_eARGB_MAGENTA'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDebugColorEnum_eARGB_MAGENTA');
  _emscripten_enum_PxDebugColorEnum_eARGB_MAGENTA = Module['_emscripten_enum_PxDebugColorEnum_eARGB_MAGENTA'] = createExportWrapper('emscripten_enum_PxDebugColorEnum_eARGB_MAGENTA', 0);
  assert(typeof wasmExports['emscripten_enum_PxDebugColorEnum_eARGB_CYAN'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDebugColorEnum_eARGB_CYAN');
  _emscripten_enum_PxDebugColorEnum_eARGB_CYAN = Module['_emscripten_enum_PxDebugColorEnum_eARGB_CYAN'] = createExportWrapper('emscripten_enum_PxDebugColorEnum_eARGB_CYAN', 0);
  assert(typeof wasmExports['emscripten_enum_PxDebugColorEnum_eARGB_WHITE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDebugColorEnum_eARGB_WHITE');
  _emscripten_enum_PxDebugColorEnum_eARGB_WHITE = Module['_emscripten_enum_PxDebugColorEnum_eARGB_WHITE'] = createExportWrapper('emscripten_enum_PxDebugColorEnum_eARGB_WHITE', 0);
  assert(typeof wasmExports['emscripten_enum_PxDebugColorEnum_eARGB_GREY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDebugColorEnum_eARGB_GREY');
  _emscripten_enum_PxDebugColorEnum_eARGB_GREY = Module['_emscripten_enum_PxDebugColorEnum_eARGB_GREY'] = createExportWrapper('emscripten_enum_PxDebugColorEnum_eARGB_GREY', 0);
  assert(typeof wasmExports['emscripten_enum_PxDebugColorEnum_eARGB_DARKRED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDebugColorEnum_eARGB_DARKRED');
  _emscripten_enum_PxDebugColorEnum_eARGB_DARKRED = Module['_emscripten_enum_PxDebugColorEnum_eARGB_DARKRED'] = createExportWrapper('emscripten_enum_PxDebugColorEnum_eARGB_DARKRED', 0);
  assert(typeof wasmExports['emscripten_enum_PxDebugColorEnum_eARGB_DARKGREEN'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDebugColorEnum_eARGB_DARKGREEN');
  _emscripten_enum_PxDebugColorEnum_eARGB_DARKGREEN = Module['_emscripten_enum_PxDebugColorEnum_eARGB_DARKGREEN'] = createExportWrapper('emscripten_enum_PxDebugColorEnum_eARGB_DARKGREEN', 0);
  assert(typeof wasmExports['emscripten_enum_PxDebugColorEnum_eARGB_DARKBLUE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDebugColorEnum_eARGB_DARKBLUE');
  _emscripten_enum_PxDebugColorEnum_eARGB_DARKBLUE = Module['_emscripten_enum_PxDebugColorEnum_eARGB_DARKBLUE'] = createExportWrapper('emscripten_enum_PxDebugColorEnum_eARGB_DARKBLUE', 0);
  assert(typeof wasmExports['emscripten_enum_PxDistanceJointFlagEnum_eMAX_DISTANCE_ENABLED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDistanceJointFlagEnum_eMAX_DISTANCE_ENABLED');
  _emscripten_enum_PxDistanceJointFlagEnum_eMAX_DISTANCE_ENABLED = Module['_emscripten_enum_PxDistanceJointFlagEnum_eMAX_DISTANCE_ENABLED'] = createExportWrapper('emscripten_enum_PxDistanceJointFlagEnum_eMAX_DISTANCE_ENABLED', 0);
  assert(typeof wasmExports['emscripten_enum_PxDistanceJointFlagEnum_eMIN_DISTANCE_ENABLED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDistanceJointFlagEnum_eMIN_DISTANCE_ENABLED');
  _emscripten_enum_PxDistanceJointFlagEnum_eMIN_DISTANCE_ENABLED = Module['_emscripten_enum_PxDistanceJointFlagEnum_eMIN_DISTANCE_ENABLED'] = createExportWrapper('emscripten_enum_PxDistanceJointFlagEnum_eMIN_DISTANCE_ENABLED', 0);
  assert(typeof wasmExports['emscripten_enum_PxDistanceJointFlagEnum_eSPRING_ENABLED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDistanceJointFlagEnum_eSPRING_ENABLED');
  _emscripten_enum_PxDistanceJointFlagEnum_eSPRING_ENABLED = Module['_emscripten_enum_PxDistanceJointFlagEnum_eSPRING_ENABLED'] = createExportWrapper('emscripten_enum_PxDistanceJointFlagEnum_eSPRING_ENABLED', 0);
  assert(typeof wasmExports['emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eNONE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eNONE');
  _emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eNONE = Module['_emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eNONE'] = createExportWrapper('emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eNONE', 0);
  assert(typeof wasmExports['emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBUCKET'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBUCKET');
  _emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBUCKET = Module['_emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBUCKET'] = createExportWrapper('emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBUCKET', 0);
  assert(typeof wasmExports['emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eINCREMENTAL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eINCREMENTAL');
  _emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eINCREMENTAL = Module['_emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eINCREMENTAL'] = createExportWrapper('emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eINCREMENTAL', 0);
  assert(typeof wasmExports['emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBVH'] != 'undefined', 'missing Wasm export: emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBVH');
  _emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBVH = Module['_emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBVH'] = createExportWrapper('emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBVH', 0);
  assert(typeof wasmExports['emscripten_enum_PxErrorCodeEnum_eNO_ERROR'] != 'undefined', 'missing Wasm export: emscripten_enum_PxErrorCodeEnum_eNO_ERROR');
  _emscripten_enum_PxErrorCodeEnum_eNO_ERROR = Module['_emscripten_enum_PxErrorCodeEnum_eNO_ERROR'] = createExportWrapper('emscripten_enum_PxErrorCodeEnum_eNO_ERROR', 0);
  assert(typeof wasmExports['emscripten_enum_PxErrorCodeEnum_eDEBUG_INFO'] != 'undefined', 'missing Wasm export: emscripten_enum_PxErrorCodeEnum_eDEBUG_INFO');
  _emscripten_enum_PxErrorCodeEnum_eDEBUG_INFO = Module['_emscripten_enum_PxErrorCodeEnum_eDEBUG_INFO'] = createExportWrapper('emscripten_enum_PxErrorCodeEnum_eDEBUG_INFO', 0);
  assert(typeof wasmExports['emscripten_enum_PxErrorCodeEnum_eDEBUG_WARNING'] != 'undefined', 'missing Wasm export: emscripten_enum_PxErrorCodeEnum_eDEBUG_WARNING');
  _emscripten_enum_PxErrorCodeEnum_eDEBUG_WARNING = Module['_emscripten_enum_PxErrorCodeEnum_eDEBUG_WARNING'] = createExportWrapper('emscripten_enum_PxErrorCodeEnum_eDEBUG_WARNING', 0);
  assert(typeof wasmExports['emscripten_enum_PxErrorCodeEnum_eINVALID_PARAMETER'] != 'undefined', 'missing Wasm export: emscripten_enum_PxErrorCodeEnum_eINVALID_PARAMETER');
  _emscripten_enum_PxErrorCodeEnum_eINVALID_PARAMETER = Module['_emscripten_enum_PxErrorCodeEnum_eINVALID_PARAMETER'] = createExportWrapper('emscripten_enum_PxErrorCodeEnum_eINVALID_PARAMETER', 0);
  assert(typeof wasmExports['emscripten_enum_PxErrorCodeEnum_eINVALID_OPERATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxErrorCodeEnum_eINVALID_OPERATION');
  _emscripten_enum_PxErrorCodeEnum_eINVALID_OPERATION = Module['_emscripten_enum_PxErrorCodeEnum_eINVALID_OPERATION'] = createExportWrapper('emscripten_enum_PxErrorCodeEnum_eINVALID_OPERATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxErrorCodeEnum_eOUT_OF_MEMORY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxErrorCodeEnum_eOUT_OF_MEMORY');
  _emscripten_enum_PxErrorCodeEnum_eOUT_OF_MEMORY = Module['_emscripten_enum_PxErrorCodeEnum_eOUT_OF_MEMORY'] = createExportWrapper('emscripten_enum_PxErrorCodeEnum_eOUT_OF_MEMORY', 0);
  assert(typeof wasmExports['emscripten_enum_PxErrorCodeEnum_eINTERNAL_ERROR'] != 'undefined', 'missing Wasm export: emscripten_enum_PxErrorCodeEnum_eINTERNAL_ERROR');
  _emscripten_enum_PxErrorCodeEnum_eINTERNAL_ERROR = Module['_emscripten_enum_PxErrorCodeEnum_eINTERNAL_ERROR'] = createExportWrapper('emscripten_enum_PxErrorCodeEnum_eINTERNAL_ERROR', 0);
  assert(typeof wasmExports['emscripten_enum_PxErrorCodeEnum_eABORT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxErrorCodeEnum_eABORT');
  _emscripten_enum_PxErrorCodeEnum_eABORT = Module['_emscripten_enum_PxErrorCodeEnum_eABORT'] = createExportWrapper('emscripten_enum_PxErrorCodeEnum_eABORT', 0);
  assert(typeof wasmExports['emscripten_enum_PxErrorCodeEnum_ePERF_WARNING'] != 'undefined', 'missing Wasm export: emscripten_enum_PxErrorCodeEnum_ePERF_WARNING');
  _emscripten_enum_PxErrorCodeEnum_ePERF_WARNING = Module['_emscripten_enum_PxErrorCodeEnum_ePERF_WARNING'] = createExportWrapper('emscripten_enum_PxErrorCodeEnum_ePERF_WARNING', 0);
  assert(typeof wasmExports['emscripten_enum_PxErrorCodeEnum_eMASK_ALL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxErrorCodeEnum_eMASK_ALL');
  _emscripten_enum_PxErrorCodeEnum_eMASK_ALL = Module['_emscripten_enum_PxErrorCodeEnum_eMASK_ALL'] = createExportWrapper('emscripten_enum_PxErrorCodeEnum_eMASK_ALL', 0);
  assert(typeof wasmExports['emscripten_enum_PxFilterFlagEnum_eKILL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxFilterFlagEnum_eKILL');
  _emscripten_enum_PxFilterFlagEnum_eKILL = Module['_emscripten_enum_PxFilterFlagEnum_eKILL'] = createExportWrapper('emscripten_enum_PxFilterFlagEnum_eKILL', 0);
  assert(typeof wasmExports['emscripten_enum_PxFilterFlagEnum_eSUPPRESS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxFilterFlagEnum_eSUPPRESS');
  _emscripten_enum_PxFilterFlagEnum_eSUPPRESS = Module['_emscripten_enum_PxFilterFlagEnum_eSUPPRESS'] = createExportWrapper('emscripten_enum_PxFilterFlagEnum_eSUPPRESS', 0);
  assert(typeof wasmExports['emscripten_enum_PxFilterFlagEnum_eCALLBACK'] != 'undefined', 'missing Wasm export: emscripten_enum_PxFilterFlagEnum_eCALLBACK');
  _emscripten_enum_PxFilterFlagEnum_eCALLBACK = Module['_emscripten_enum_PxFilterFlagEnum_eCALLBACK'] = createExportWrapper('emscripten_enum_PxFilterFlagEnum_eCALLBACK', 0);
  assert(typeof wasmExports['emscripten_enum_PxFilterFlagEnum_eNOTIFY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxFilterFlagEnum_eNOTIFY');
  _emscripten_enum_PxFilterFlagEnum_eNOTIFY = Module['_emscripten_enum_PxFilterFlagEnum_eNOTIFY'] = createExportWrapper('emscripten_enum_PxFilterFlagEnum_eNOTIFY', 0);
  assert(typeof wasmExports['emscripten_enum_PxFilterFlagEnum_eDEFAULT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxFilterFlagEnum_eDEFAULT');
  _emscripten_enum_PxFilterFlagEnum_eDEFAULT = Module['_emscripten_enum_PxFilterFlagEnum_eDEFAULT'] = createExportWrapper('emscripten_enum_PxFilterFlagEnum_eDEFAULT', 0);
  assert(typeof wasmExports['emscripten_enum_PxFilterObjectFlagEnum_eKINEMATIC'] != 'undefined', 'missing Wasm export: emscripten_enum_PxFilterObjectFlagEnum_eKINEMATIC');
  _emscripten_enum_PxFilterObjectFlagEnum_eKINEMATIC = Module['_emscripten_enum_PxFilterObjectFlagEnum_eKINEMATIC'] = createExportWrapper('emscripten_enum_PxFilterObjectFlagEnum_eKINEMATIC', 0);
  assert(typeof wasmExports['emscripten_enum_PxFilterObjectFlagEnum_eTRIGGER'] != 'undefined', 'missing Wasm export: emscripten_enum_PxFilterObjectFlagEnum_eTRIGGER');
  _emscripten_enum_PxFilterObjectFlagEnum_eTRIGGER = Module['_emscripten_enum_PxFilterObjectFlagEnum_eTRIGGER'] = createExportWrapper('emscripten_enum_PxFilterObjectFlagEnum_eTRIGGER', 0);
  assert(typeof wasmExports['emscripten_enum_PxForceModeEnum_eFORCE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxForceModeEnum_eFORCE');
  _emscripten_enum_PxForceModeEnum_eFORCE = Module['_emscripten_enum_PxForceModeEnum_eFORCE'] = createExportWrapper('emscripten_enum_PxForceModeEnum_eFORCE', 0);
  assert(typeof wasmExports['emscripten_enum_PxForceModeEnum_eIMPULSE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxForceModeEnum_eIMPULSE');
  _emscripten_enum_PxForceModeEnum_eIMPULSE = Module['_emscripten_enum_PxForceModeEnum_eIMPULSE'] = createExportWrapper('emscripten_enum_PxForceModeEnum_eIMPULSE', 0);
  assert(typeof wasmExports['emscripten_enum_PxForceModeEnum_eVELOCITY_CHANGE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxForceModeEnum_eVELOCITY_CHANGE');
  _emscripten_enum_PxForceModeEnum_eVELOCITY_CHANGE = Module['_emscripten_enum_PxForceModeEnum_eVELOCITY_CHANGE'] = createExportWrapper('emscripten_enum_PxForceModeEnum_eVELOCITY_CHANGE', 0);
  assert(typeof wasmExports['emscripten_enum_PxForceModeEnum_eACCELERATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxForceModeEnum_eACCELERATION');
  _emscripten_enum_PxForceModeEnum_eACCELERATION = Module['_emscripten_enum_PxForceModeEnum_eACCELERATION'] = createExportWrapper('emscripten_enum_PxForceModeEnum_eACCELERATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxFrictionTypeEnum_ePATCH'] != 'undefined', 'missing Wasm export: emscripten_enum_PxFrictionTypeEnum_ePATCH');
  _emscripten_enum_PxFrictionTypeEnum_ePATCH = Module['_emscripten_enum_PxFrictionTypeEnum_ePATCH'] = createExportWrapper('emscripten_enum_PxFrictionTypeEnum_ePATCH', 0);
  assert(typeof wasmExports['emscripten_enum_PxFrictionTypeEnum_eFRICTION_COUNT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxFrictionTypeEnum_eFRICTION_COUNT');
  _emscripten_enum_PxFrictionTypeEnum_eFRICTION_COUNT = Module['_emscripten_enum_PxFrictionTypeEnum_eFRICTION_COUNT'] = createExportWrapper('emscripten_enum_PxFrictionTypeEnum_eFRICTION_COUNT', 0);
  assert(typeof wasmExports['emscripten_enum_PxGeometryTypeEnum_eSPHERE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxGeometryTypeEnum_eSPHERE');
  _emscripten_enum_PxGeometryTypeEnum_eSPHERE = Module['_emscripten_enum_PxGeometryTypeEnum_eSPHERE'] = createExportWrapper('emscripten_enum_PxGeometryTypeEnum_eSPHERE', 0);
  assert(typeof wasmExports['emscripten_enum_PxGeometryTypeEnum_ePLANE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxGeometryTypeEnum_ePLANE');
  _emscripten_enum_PxGeometryTypeEnum_ePLANE = Module['_emscripten_enum_PxGeometryTypeEnum_ePLANE'] = createExportWrapper('emscripten_enum_PxGeometryTypeEnum_ePLANE', 0);
  assert(typeof wasmExports['emscripten_enum_PxGeometryTypeEnum_eCAPSULE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxGeometryTypeEnum_eCAPSULE');
  _emscripten_enum_PxGeometryTypeEnum_eCAPSULE = Module['_emscripten_enum_PxGeometryTypeEnum_eCAPSULE'] = createExportWrapper('emscripten_enum_PxGeometryTypeEnum_eCAPSULE', 0);
  assert(typeof wasmExports['emscripten_enum_PxGeometryTypeEnum_eBOX'] != 'undefined', 'missing Wasm export: emscripten_enum_PxGeometryTypeEnum_eBOX');
  _emscripten_enum_PxGeometryTypeEnum_eBOX = Module['_emscripten_enum_PxGeometryTypeEnum_eBOX'] = createExportWrapper('emscripten_enum_PxGeometryTypeEnum_eBOX', 0);
  assert(typeof wasmExports['emscripten_enum_PxGeometryTypeEnum_eCONVEXCORE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxGeometryTypeEnum_eCONVEXCORE');
  _emscripten_enum_PxGeometryTypeEnum_eCONVEXCORE = Module['_emscripten_enum_PxGeometryTypeEnum_eCONVEXCORE'] = createExportWrapper('emscripten_enum_PxGeometryTypeEnum_eCONVEXCORE', 0);
  assert(typeof wasmExports['emscripten_enum_PxGeometryTypeEnum_eCONVEXMESH'] != 'undefined', 'missing Wasm export: emscripten_enum_PxGeometryTypeEnum_eCONVEXMESH');
  _emscripten_enum_PxGeometryTypeEnum_eCONVEXMESH = Module['_emscripten_enum_PxGeometryTypeEnum_eCONVEXMESH'] = createExportWrapper('emscripten_enum_PxGeometryTypeEnum_eCONVEXMESH', 0);
  assert(typeof wasmExports['emscripten_enum_PxGeometryTypeEnum_ePARTICLESYSTEM'] != 'undefined', 'missing Wasm export: emscripten_enum_PxGeometryTypeEnum_ePARTICLESYSTEM');
  _emscripten_enum_PxGeometryTypeEnum_ePARTICLESYSTEM = Module['_emscripten_enum_PxGeometryTypeEnum_ePARTICLESYSTEM'] = createExportWrapper('emscripten_enum_PxGeometryTypeEnum_ePARTICLESYSTEM', 0);
  assert(typeof wasmExports['emscripten_enum_PxGeometryTypeEnum_eTETRAHEDRONMESH'] != 'undefined', 'missing Wasm export: emscripten_enum_PxGeometryTypeEnum_eTETRAHEDRONMESH');
  _emscripten_enum_PxGeometryTypeEnum_eTETRAHEDRONMESH = Module['_emscripten_enum_PxGeometryTypeEnum_eTETRAHEDRONMESH'] = createExportWrapper('emscripten_enum_PxGeometryTypeEnum_eTETRAHEDRONMESH', 0);
  assert(typeof wasmExports['emscripten_enum_PxGeometryTypeEnum_eTRIANGLEMESH'] != 'undefined', 'missing Wasm export: emscripten_enum_PxGeometryTypeEnum_eTRIANGLEMESH');
  _emscripten_enum_PxGeometryTypeEnum_eTRIANGLEMESH = Module['_emscripten_enum_PxGeometryTypeEnum_eTRIANGLEMESH'] = createExportWrapper('emscripten_enum_PxGeometryTypeEnum_eTRIANGLEMESH', 0);
  assert(typeof wasmExports['emscripten_enum_PxGeometryTypeEnum_eHEIGHTFIELD'] != 'undefined', 'missing Wasm export: emscripten_enum_PxGeometryTypeEnum_eHEIGHTFIELD');
  _emscripten_enum_PxGeometryTypeEnum_eHEIGHTFIELD = Module['_emscripten_enum_PxGeometryTypeEnum_eHEIGHTFIELD'] = createExportWrapper('emscripten_enum_PxGeometryTypeEnum_eHEIGHTFIELD', 0);
  assert(typeof wasmExports['emscripten_enum_PxGeometryTypeEnum_eCUSTOM'] != 'undefined', 'missing Wasm export: emscripten_enum_PxGeometryTypeEnum_eCUSTOM');
  _emscripten_enum_PxGeometryTypeEnum_eCUSTOM = Module['_emscripten_enum_PxGeometryTypeEnum_eCUSTOM'] = createExportWrapper('emscripten_enum_PxGeometryTypeEnum_eCUSTOM', 0);
  assert(typeof wasmExports['emscripten_enum_PxHeightFieldFlagEnum_eNO_BOUNDARY_EDGES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxHeightFieldFlagEnum_eNO_BOUNDARY_EDGES');
  _emscripten_enum_PxHeightFieldFlagEnum_eNO_BOUNDARY_EDGES = Module['_emscripten_enum_PxHeightFieldFlagEnum_eNO_BOUNDARY_EDGES'] = createExportWrapper('emscripten_enum_PxHeightFieldFlagEnum_eNO_BOUNDARY_EDGES', 0);
  assert(typeof wasmExports['emscripten_enum_PxHeightFieldFormatEnum_eS16_TM'] != 'undefined', 'missing Wasm export: emscripten_enum_PxHeightFieldFormatEnum_eS16_TM');
  _emscripten_enum_PxHeightFieldFormatEnum_eS16_TM = Module['_emscripten_enum_PxHeightFieldFormatEnum_eS16_TM'] = createExportWrapper('emscripten_enum_PxHeightFieldFormatEnum_eS16_TM', 0);
  assert(typeof wasmExports['emscripten_enum_PxHitFlagEnum_ePOSITION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxHitFlagEnum_ePOSITION');
  _emscripten_enum_PxHitFlagEnum_ePOSITION = Module['_emscripten_enum_PxHitFlagEnum_ePOSITION'] = createExportWrapper('emscripten_enum_PxHitFlagEnum_ePOSITION', 0);
  assert(typeof wasmExports['emscripten_enum_PxHitFlagEnum_eNORMAL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxHitFlagEnum_eNORMAL');
  _emscripten_enum_PxHitFlagEnum_eNORMAL = Module['_emscripten_enum_PxHitFlagEnum_eNORMAL'] = createExportWrapper('emscripten_enum_PxHitFlagEnum_eNORMAL', 0);
  assert(typeof wasmExports['emscripten_enum_PxHitFlagEnum_eUV'] != 'undefined', 'missing Wasm export: emscripten_enum_PxHitFlagEnum_eUV');
  _emscripten_enum_PxHitFlagEnum_eUV = Module['_emscripten_enum_PxHitFlagEnum_eUV'] = createExportWrapper('emscripten_enum_PxHitFlagEnum_eUV', 0);
  assert(typeof wasmExports['emscripten_enum_PxHitFlagEnum_eASSUME_NO_INITIAL_OVERLAP'] != 'undefined', 'missing Wasm export: emscripten_enum_PxHitFlagEnum_eASSUME_NO_INITIAL_OVERLAP');
  _emscripten_enum_PxHitFlagEnum_eASSUME_NO_INITIAL_OVERLAP = Module['_emscripten_enum_PxHitFlagEnum_eASSUME_NO_INITIAL_OVERLAP'] = createExportWrapper('emscripten_enum_PxHitFlagEnum_eASSUME_NO_INITIAL_OVERLAP', 0);
  assert(typeof wasmExports['emscripten_enum_PxHitFlagEnum_eANY_HIT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxHitFlagEnum_eANY_HIT');
  _emscripten_enum_PxHitFlagEnum_eANY_HIT = Module['_emscripten_enum_PxHitFlagEnum_eANY_HIT'] = createExportWrapper('emscripten_enum_PxHitFlagEnum_eANY_HIT', 0);
  assert(typeof wasmExports['emscripten_enum_PxHitFlagEnum_eMESH_MULTIPLE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxHitFlagEnum_eMESH_MULTIPLE');
  _emscripten_enum_PxHitFlagEnum_eMESH_MULTIPLE = Module['_emscripten_enum_PxHitFlagEnum_eMESH_MULTIPLE'] = createExportWrapper('emscripten_enum_PxHitFlagEnum_eMESH_MULTIPLE', 0);
  assert(typeof wasmExports['emscripten_enum_PxHitFlagEnum_eMESH_BOTH_SIDES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxHitFlagEnum_eMESH_BOTH_SIDES');
  _emscripten_enum_PxHitFlagEnum_eMESH_BOTH_SIDES = Module['_emscripten_enum_PxHitFlagEnum_eMESH_BOTH_SIDES'] = createExportWrapper('emscripten_enum_PxHitFlagEnum_eMESH_BOTH_SIDES', 0);
  assert(typeof wasmExports['emscripten_enum_PxHitFlagEnum_ePRECISE_SWEEP'] != 'undefined', 'missing Wasm export: emscripten_enum_PxHitFlagEnum_ePRECISE_SWEEP');
  _emscripten_enum_PxHitFlagEnum_ePRECISE_SWEEP = Module['_emscripten_enum_PxHitFlagEnum_ePRECISE_SWEEP'] = createExportWrapper('emscripten_enum_PxHitFlagEnum_ePRECISE_SWEEP', 0);
  assert(typeof wasmExports['emscripten_enum_PxHitFlagEnum_eMTD'] != 'undefined', 'missing Wasm export: emscripten_enum_PxHitFlagEnum_eMTD');
  _emscripten_enum_PxHitFlagEnum_eMTD = Module['_emscripten_enum_PxHitFlagEnum_eMTD'] = createExportWrapper('emscripten_enum_PxHitFlagEnum_eMTD', 0);
  assert(typeof wasmExports['emscripten_enum_PxHitFlagEnum_eFACE_INDEX'] != 'undefined', 'missing Wasm export: emscripten_enum_PxHitFlagEnum_eFACE_INDEX');
  _emscripten_enum_PxHitFlagEnum_eFACE_INDEX = Module['_emscripten_enum_PxHitFlagEnum_eFACE_INDEX'] = createExportWrapper('emscripten_enum_PxHitFlagEnum_eFACE_INDEX', 0);
  assert(typeof wasmExports['emscripten_enum_PxHitFlagEnum_eDEFAULT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxHitFlagEnum_eDEFAULT');
  _emscripten_enum_PxHitFlagEnum_eDEFAULT = Module['_emscripten_enum_PxHitFlagEnum_eDEFAULT'] = createExportWrapper('emscripten_enum_PxHitFlagEnum_eDEFAULT', 0);
  assert(typeof wasmExports['emscripten_enum_PxHitFlagEnum_eMODIFIABLE_FLAGS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxHitFlagEnum_eMODIFIABLE_FLAGS');
  _emscripten_enum_PxHitFlagEnum_eMODIFIABLE_FLAGS = Module['_emscripten_enum_PxHitFlagEnum_eMODIFIABLE_FLAGS'] = createExportWrapper('emscripten_enum_PxHitFlagEnum_eMODIFIABLE_FLAGS', 0);
  assert(typeof wasmExports['emscripten_enum_PxIDENTITYEnum_PxIdentity'] != 'undefined', 'missing Wasm export: emscripten_enum_PxIDENTITYEnum_PxIdentity');
  _emscripten_enum_PxIDENTITYEnum_PxIdentity = Module['_emscripten_enum_PxIDENTITYEnum_PxIdentity'] = createExportWrapper('emscripten_enum_PxIDENTITYEnum_PxIdentity', 0);
  assert(typeof wasmExports['emscripten_enum_PxJointActorIndexEnum_eACTOR0'] != 'undefined', 'missing Wasm export: emscripten_enum_PxJointActorIndexEnum_eACTOR0');
  _emscripten_enum_PxJointActorIndexEnum_eACTOR0 = Module['_emscripten_enum_PxJointActorIndexEnum_eACTOR0'] = createExportWrapper('emscripten_enum_PxJointActorIndexEnum_eACTOR0', 0);
  assert(typeof wasmExports['emscripten_enum_PxJointActorIndexEnum_eACTOR1'] != 'undefined', 'missing Wasm export: emscripten_enum_PxJointActorIndexEnum_eACTOR1');
  _emscripten_enum_PxJointActorIndexEnum_eACTOR1 = Module['_emscripten_enum_PxJointActorIndexEnum_eACTOR1'] = createExportWrapper('emscripten_enum_PxJointActorIndexEnum_eACTOR1', 0);
  assert(typeof wasmExports['emscripten_enum_PxMaterialFlagEnum_eDISABLE_FRICTION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMaterialFlagEnum_eDISABLE_FRICTION');
  _emscripten_enum_PxMaterialFlagEnum_eDISABLE_FRICTION = Module['_emscripten_enum_PxMaterialFlagEnum_eDISABLE_FRICTION'] = createExportWrapper('emscripten_enum_PxMaterialFlagEnum_eDISABLE_FRICTION', 0);
  assert(typeof wasmExports['emscripten_enum_PxMaterialFlagEnum_eDISABLE_STRONG_FRICTION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMaterialFlagEnum_eDISABLE_STRONG_FRICTION');
  _emscripten_enum_PxMaterialFlagEnum_eDISABLE_STRONG_FRICTION = Module['_emscripten_enum_PxMaterialFlagEnum_eDISABLE_STRONG_FRICTION'] = createExportWrapper('emscripten_enum_PxMaterialFlagEnum_eDISABLE_STRONG_FRICTION', 0);
  assert(typeof wasmExports['emscripten_enum_PxMaterialFlagEnum_eCOMPLIANT_ACCELERATION_SPRING'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMaterialFlagEnum_eCOMPLIANT_ACCELERATION_SPRING');
  _emscripten_enum_PxMaterialFlagEnum_eCOMPLIANT_ACCELERATION_SPRING = Module['_emscripten_enum_PxMaterialFlagEnum_eCOMPLIANT_ACCELERATION_SPRING'] = createExportWrapper('emscripten_enum_PxMaterialFlagEnum_eCOMPLIANT_ACCELERATION_SPRING', 0);
  assert(typeof wasmExports['emscripten_enum_PxMeshCookingHintEnum_eSIM_PERFORMANCE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMeshCookingHintEnum_eSIM_PERFORMANCE');
  _emscripten_enum_PxMeshCookingHintEnum_eSIM_PERFORMANCE = Module['_emscripten_enum_PxMeshCookingHintEnum_eSIM_PERFORMANCE'] = createExportWrapper('emscripten_enum_PxMeshCookingHintEnum_eSIM_PERFORMANCE', 0);
  assert(typeof wasmExports['emscripten_enum_PxMeshCookingHintEnum_eCOOKING_PERFORMANCE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMeshCookingHintEnum_eCOOKING_PERFORMANCE');
  _emscripten_enum_PxMeshCookingHintEnum_eCOOKING_PERFORMANCE = Module['_emscripten_enum_PxMeshCookingHintEnum_eCOOKING_PERFORMANCE'] = createExportWrapper('emscripten_enum_PxMeshCookingHintEnum_eCOOKING_PERFORMANCE', 0);
  assert(typeof wasmExports['emscripten_enum_PxMeshFlagEnum_eFLIPNORMALS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMeshFlagEnum_eFLIPNORMALS');
  _emscripten_enum_PxMeshFlagEnum_eFLIPNORMALS = Module['_emscripten_enum_PxMeshFlagEnum_eFLIPNORMALS'] = createExportWrapper('emscripten_enum_PxMeshFlagEnum_eFLIPNORMALS', 0);
  assert(typeof wasmExports['emscripten_enum_PxMeshFlagEnum_e16_BIT_INDICES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMeshFlagEnum_e16_BIT_INDICES');
  _emscripten_enum_PxMeshFlagEnum_e16_BIT_INDICES = Module['_emscripten_enum_PxMeshFlagEnum_e16_BIT_INDICES'] = createExportWrapper('emscripten_enum_PxMeshFlagEnum_e16_BIT_INDICES', 0);
  assert(typeof wasmExports['emscripten_enum_PxMeshGeometryFlagEnum_eDOUBLE_SIDED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMeshGeometryFlagEnum_eDOUBLE_SIDED');
  _emscripten_enum_PxMeshGeometryFlagEnum_eDOUBLE_SIDED = Module['_emscripten_enum_PxMeshGeometryFlagEnum_eDOUBLE_SIDED'] = createExportWrapper('emscripten_enum_PxMeshGeometryFlagEnum_eDOUBLE_SIDED', 0);
  assert(typeof wasmExports['emscripten_enum_PxMeshMidPhaseEnum_eBVH33'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMeshMidPhaseEnum_eBVH33');
  _emscripten_enum_PxMeshMidPhaseEnum_eBVH33 = Module['_emscripten_enum_PxMeshMidPhaseEnum_eBVH33'] = createExportWrapper('emscripten_enum_PxMeshMidPhaseEnum_eBVH33', 0);
  assert(typeof wasmExports['emscripten_enum_PxMeshMidPhaseEnum_eBVH34'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMeshMidPhaseEnum_eBVH34');
  _emscripten_enum_PxMeshMidPhaseEnum_eBVH34 = Module['_emscripten_enum_PxMeshMidPhaseEnum_eBVH34'] = createExportWrapper('emscripten_enum_PxMeshMidPhaseEnum_eBVH34', 0);
  assert(typeof wasmExports['emscripten_enum_PxMeshPreprocessingFlagEnum_eWELD_VERTICES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMeshPreprocessingFlagEnum_eWELD_VERTICES');
  _emscripten_enum_PxMeshPreprocessingFlagEnum_eWELD_VERTICES = Module['_emscripten_enum_PxMeshPreprocessingFlagEnum_eWELD_VERTICES'] = createExportWrapper('emscripten_enum_PxMeshPreprocessingFlagEnum_eWELD_VERTICES', 0);
  assert(typeof wasmExports['emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_CLEAN_MESH'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_CLEAN_MESH');
  _emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_CLEAN_MESH = Module['_emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_CLEAN_MESH'] = createExportWrapper('emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_CLEAN_MESH', 0);
  assert(typeof wasmExports['emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_ACTIVE_EDGES_PRECOMPUTE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_ACTIVE_EDGES_PRECOMPUTE');
  _emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_ACTIVE_EDGES_PRECOMPUTE = Module['_emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_ACTIVE_EDGES_PRECOMPUTE'] = createExportWrapper('emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_ACTIVE_EDGES_PRECOMPUTE', 0);
  assert(typeof wasmExports['emscripten_enum_PxMeshPreprocessingFlagEnum_eFORCE_32BIT_INDICES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMeshPreprocessingFlagEnum_eFORCE_32BIT_INDICES');
  _emscripten_enum_PxMeshPreprocessingFlagEnum_eFORCE_32BIT_INDICES = Module['_emscripten_enum_PxMeshPreprocessingFlagEnum_eFORCE_32BIT_INDICES'] = createExportWrapper('emscripten_enum_PxMeshPreprocessingFlagEnum_eFORCE_32BIT_INDICES', 0);
  assert(typeof wasmExports['emscripten_enum_PxMeshPreprocessingFlagEnum_eENABLE_INERTIA'] != 'undefined', 'missing Wasm export: emscripten_enum_PxMeshPreprocessingFlagEnum_eENABLE_INERTIA');
  _emscripten_enum_PxMeshPreprocessingFlagEnum_eENABLE_INERTIA = Module['_emscripten_enum_PxMeshPreprocessingFlagEnum_eENABLE_INERTIA'] = createExportWrapper('emscripten_enum_PxMeshPreprocessingFlagEnum_eENABLE_INERTIA', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFilteringModeEnum_eKEEP'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFilteringModeEnum_eKEEP');
  _emscripten_enum_PxPairFilteringModeEnum_eKEEP = Module['_emscripten_enum_PxPairFilteringModeEnum_eKEEP'] = createExportWrapper('emscripten_enum_PxPairFilteringModeEnum_eKEEP', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFilteringModeEnum_eSUPPRESS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFilteringModeEnum_eSUPPRESS');
  _emscripten_enum_PxPairFilteringModeEnum_eSUPPRESS = Module['_emscripten_enum_PxPairFilteringModeEnum_eSUPPRESS'] = createExportWrapper('emscripten_enum_PxPairFilteringModeEnum_eSUPPRESS', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFilteringModeEnum_eKILL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFilteringModeEnum_eKILL');
  _emscripten_enum_PxPairFilteringModeEnum_eKILL = Module['_emscripten_enum_PxPairFilteringModeEnum_eKILL'] = createExportWrapper('emscripten_enum_PxPairFilteringModeEnum_eKILL', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFilteringModeEnum_eDEFAULT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFilteringModeEnum_eDEFAULT');
  _emscripten_enum_PxPairFilteringModeEnum_eDEFAULT = Module['_emscripten_enum_PxPairFilteringModeEnum_eDEFAULT'] = createExportWrapper('emscripten_enum_PxPairFilteringModeEnum_eDEFAULT', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eSOLVE_CONTACT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eSOLVE_CONTACT');
  _emscripten_enum_PxPairFlagEnum_eSOLVE_CONTACT = Module['_emscripten_enum_PxPairFlagEnum_eSOLVE_CONTACT'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eSOLVE_CONTACT', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eMODIFY_CONTACTS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eMODIFY_CONTACTS');
  _emscripten_enum_PxPairFlagEnum_eMODIFY_CONTACTS = Module['_emscripten_enum_PxPairFlagEnum_eMODIFY_CONTACTS'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eMODIFY_CONTACTS', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_FOUND'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_FOUND');
  _emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_FOUND = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_FOUND'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_FOUND', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_PERSISTS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_PERSISTS');
  _emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_PERSISTS = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_PERSISTS'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_PERSISTS', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_LOST'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_LOST');
  _emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_LOST = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_LOST'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_LOST', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_CCD'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_CCD');
  _emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_CCD = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_CCD'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_CCD', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_FOUND'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_FOUND');
  _emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_FOUND = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_FOUND'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_FOUND', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_PERSISTS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_PERSISTS');
  _emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_PERSISTS = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_PERSISTS'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_PERSISTS', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_LOST'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_LOST');
  _emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_LOST = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_LOST'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_LOST', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eNOTIFY_CONTACT_POINTS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eNOTIFY_CONTACT_POINTS');
  _emscripten_enum_PxPairFlagEnum_eNOTIFY_CONTACT_POINTS = Module['_emscripten_enum_PxPairFlagEnum_eNOTIFY_CONTACT_POINTS'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eNOTIFY_CONTACT_POINTS', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eDETECT_DISCRETE_CONTACT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eDETECT_DISCRETE_CONTACT');
  _emscripten_enum_PxPairFlagEnum_eDETECT_DISCRETE_CONTACT = Module['_emscripten_enum_PxPairFlagEnum_eDETECT_DISCRETE_CONTACT'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eDETECT_DISCRETE_CONTACT', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eDETECT_CCD_CONTACT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eDETECT_CCD_CONTACT');
  _emscripten_enum_PxPairFlagEnum_eDETECT_CCD_CONTACT = Module['_emscripten_enum_PxPairFlagEnum_eDETECT_CCD_CONTACT'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eDETECT_CCD_CONTACT', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_ePRE_SOLVER_VELOCITY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_ePRE_SOLVER_VELOCITY');
  _emscripten_enum_PxPairFlagEnum_ePRE_SOLVER_VELOCITY = Module['_emscripten_enum_PxPairFlagEnum_ePRE_SOLVER_VELOCITY'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_ePRE_SOLVER_VELOCITY', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_ePOST_SOLVER_VELOCITY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_ePOST_SOLVER_VELOCITY');
  _emscripten_enum_PxPairFlagEnum_ePOST_SOLVER_VELOCITY = Module['_emscripten_enum_PxPairFlagEnum_ePOST_SOLVER_VELOCITY'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_ePOST_SOLVER_VELOCITY', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eCONTACT_EVENT_POSE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eCONTACT_EVENT_POSE');
  _emscripten_enum_PxPairFlagEnum_eCONTACT_EVENT_POSE = Module['_emscripten_enum_PxPairFlagEnum_eCONTACT_EVENT_POSE'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eCONTACT_EVENT_POSE', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eNEXT_FREE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eNEXT_FREE');
  _emscripten_enum_PxPairFlagEnum_eNEXT_FREE = Module['_emscripten_enum_PxPairFlagEnum_eNEXT_FREE'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eNEXT_FREE', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eCONTACT_DEFAULT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eCONTACT_DEFAULT');
  _emscripten_enum_PxPairFlagEnum_eCONTACT_DEFAULT = Module['_emscripten_enum_PxPairFlagEnum_eCONTACT_DEFAULT'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eCONTACT_DEFAULT', 0);
  assert(typeof wasmExports['emscripten_enum_PxPairFlagEnum_eTRIGGER_DEFAULT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPairFlagEnum_eTRIGGER_DEFAULT');
  _emscripten_enum_PxPairFlagEnum_eTRIGGER_DEFAULT = Module['_emscripten_enum_PxPairFlagEnum_eTRIGGER_DEFAULT'] = createExportWrapper('emscripten_enum_PxPairFlagEnum_eTRIGGER_DEFAULT', 0);
  assert(typeof wasmExports['emscripten_enum_PxPrismaticJointFlagEnum_eLIMIT_ENABLED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPrismaticJointFlagEnum_eLIMIT_ENABLED');
  _emscripten_enum_PxPrismaticJointFlagEnum_eLIMIT_ENABLED = Module['_emscripten_enum_PxPrismaticJointFlagEnum_eLIMIT_ENABLED'] = createExportWrapper('emscripten_enum_PxPrismaticJointFlagEnum_eLIMIT_ENABLED', 0);
  assert(typeof wasmExports['emscripten_enum_PxPruningStructureTypeEnum_eNONE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPruningStructureTypeEnum_eNONE');
  _emscripten_enum_PxPruningStructureTypeEnum_eNONE = Module['_emscripten_enum_PxPruningStructureTypeEnum_eNONE'] = createExportWrapper('emscripten_enum_PxPruningStructureTypeEnum_eNONE', 0);
  assert(typeof wasmExports['emscripten_enum_PxPruningStructureTypeEnum_eDYNAMIC_AABB_TREE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPruningStructureTypeEnum_eDYNAMIC_AABB_TREE');
  _emscripten_enum_PxPruningStructureTypeEnum_eDYNAMIC_AABB_TREE = Module['_emscripten_enum_PxPruningStructureTypeEnum_eDYNAMIC_AABB_TREE'] = createExportWrapper('emscripten_enum_PxPruningStructureTypeEnum_eDYNAMIC_AABB_TREE', 0);
  assert(typeof wasmExports['emscripten_enum_PxPruningStructureTypeEnum_eSTATIC_AABB_TREE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPruningStructureTypeEnum_eSTATIC_AABB_TREE');
  _emscripten_enum_PxPruningStructureTypeEnum_eSTATIC_AABB_TREE = Module['_emscripten_enum_PxPruningStructureTypeEnum_eSTATIC_AABB_TREE'] = createExportWrapper('emscripten_enum_PxPruningStructureTypeEnum_eSTATIC_AABB_TREE', 0);
  assert(typeof wasmExports['emscripten_enum_PxPvdInstrumentationFlagEnum_eDEBUG'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPvdInstrumentationFlagEnum_eDEBUG');
  _emscripten_enum_PxPvdInstrumentationFlagEnum_eDEBUG = Module['_emscripten_enum_PxPvdInstrumentationFlagEnum_eDEBUG'] = createExportWrapper('emscripten_enum_PxPvdInstrumentationFlagEnum_eDEBUG', 0);
  assert(typeof wasmExports['emscripten_enum_PxPvdInstrumentationFlagEnum_ePROFILE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPvdInstrumentationFlagEnum_ePROFILE');
  _emscripten_enum_PxPvdInstrumentationFlagEnum_ePROFILE = Module['_emscripten_enum_PxPvdInstrumentationFlagEnum_ePROFILE'] = createExportWrapper('emscripten_enum_PxPvdInstrumentationFlagEnum_ePROFILE', 0);
  assert(typeof wasmExports['emscripten_enum_PxPvdInstrumentationFlagEnum_eMEMORY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPvdInstrumentationFlagEnum_eMEMORY');
  _emscripten_enum_PxPvdInstrumentationFlagEnum_eMEMORY = Module['_emscripten_enum_PxPvdInstrumentationFlagEnum_eMEMORY'] = createExportWrapper('emscripten_enum_PxPvdInstrumentationFlagEnum_eMEMORY', 0);
  assert(typeof wasmExports['emscripten_enum_PxPvdInstrumentationFlagEnum_eALL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPvdInstrumentationFlagEnum_eALL');
  _emscripten_enum_PxPvdInstrumentationFlagEnum_eALL = Module['_emscripten_enum_PxPvdInstrumentationFlagEnum_eALL'] = createExportWrapper('emscripten_enum_PxPvdInstrumentationFlagEnum_eALL', 0);
  assert(typeof wasmExports['emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONTACTS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONTACTS');
  _emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONTACTS = Module['_emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONTACTS'] = createExportWrapper('emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONTACTS', 0);
  assert(typeof wasmExports['emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_SCENEQUERIES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_SCENEQUERIES');
  _emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_SCENEQUERIES = Module['_emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_SCENEQUERIES'] = createExportWrapper('emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_SCENEQUERIES', 0);
  assert(typeof wasmExports['emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONSTRAINTS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONSTRAINTS');
  _emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONSTRAINTS = Module['_emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONSTRAINTS'] = createExportWrapper('emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONSTRAINTS', 0);
  assert(typeof wasmExports['emscripten_enum_PxQueryFlagEnum_eSTATIC'] != 'undefined', 'missing Wasm export: emscripten_enum_PxQueryFlagEnum_eSTATIC');
  _emscripten_enum_PxQueryFlagEnum_eSTATIC = Module['_emscripten_enum_PxQueryFlagEnum_eSTATIC'] = createExportWrapper('emscripten_enum_PxQueryFlagEnum_eSTATIC', 0);
  assert(typeof wasmExports['emscripten_enum_PxQueryFlagEnum_eDYNAMIC'] != 'undefined', 'missing Wasm export: emscripten_enum_PxQueryFlagEnum_eDYNAMIC');
  _emscripten_enum_PxQueryFlagEnum_eDYNAMIC = Module['_emscripten_enum_PxQueryFlagEnum_eDYNAMIC'] = createExportWrapper('emscripten_enum_PxQueryFlagEnum_eDYNAMIC', 0);
  assert(typeof wasmExports['emscripten_enum_PxQueryFlagEnum_ePREFILTER'] != 'undefined', 'missing Wasm export: emscripten_enum_PxQueryFlagEnum_ePREFILTER');
  _emscripten_enum_PxQueryFlagEnum_ePREFILTER = Module['_emscripten_enum_PxQueryFlagEnum_ePREFILTER'] = createExportWrapper('emscripten_enum_PxQueryFlagEnum_ePREFILTER', 0);
  assert(typeof wasmExports['emscripten_enum_PxQueryFlagEnum_ePOSTFILTER'] != 'undefined', 'missing Wasm export: emscripten_enum_PxQueryFlagEnum_ePOSTFILTER');
  _emscripten_enum_PxQueryFlagEnum_ePOSTFILTER = Module['_emscripten_enum_PxQueryFlagEnum_ePOSTFILTER'] = createExportWrapper('emscripten_enum_PxQueryFlagEnum_ePOSTFILTER', 0);
  assert(typeof wasmExports['emscripten_enum_PxQueryFlagEnum_eANY_HIT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxQueryFlagEnum_eANY_HIT');
  _emscripten_enum_PxQueryFlagEnum_eANY_HIT = Module['_emscripten_enum_PxQueryFlagEnum_eANY_HIT'] = createExportWrapper('emscripten_enum_PxQueryFlagEnum_eANY_HIT', 0);
  assert(typeof wasmExports['emscripten_enum_PxQueryFlagEnum_eNO_BLOCK'] != 'undefined', 'missing Wasm export: emscripten_enum_PxQueryFlagEnum_eNO_BLOCK');
  _emscripten_enum_PxQueryFlagEnum_eNO_BLOCK = Module['_emscripten_enum_PxQueryFlagEnum_eNO_BLOCK'] = createExportWrapper('emscripten_enum_PxQueryFlagEnum_eNO_BLOCK', 0);
  assert(typeof wasmExports['emscripten_enum_PxQueryHitType_eNONE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxQueryHitType_eNONE');
  _emscripten_enum_PxQueryHitType_eNONE = Module['_emscripten_enum_PxQueryHitType_eNONE'] = createExportWrapper('emscripten_enum_PxQueryHitType_eNONE', 0);
  assert(typeof wasmExports['emscripten_enum_PxQueryHitType_eBLOCK'] != 'undefined', 'missing Wasm export: emscripten_enum_PxQueryHitType_eBLOCK');
  _emscripten_enum_PxQueryHitType_eBLOCK = Module['_emscripten_enum_PxQueryHitType_eBLOCK'] = createExportWrapper('emscripten_enum_PxQueryHitType_eBLOCK', 0);
  assert(typeof wasmExports['emscripten_enum_PxQueryHitType_eTOUCH'] != 'undefined', 'missing Wasm export: emscripten_enum_PxQueryHitType_eTOUCH');
  _emscripten_enum_PxQueryHitType_eTOUCH = Module['_emscripten_enum_PxQueryHitType_eTOUCH'] = createExportWrapper('emscripten_enum_PxQueryHitType_eTOUCH', 0);
  assert(typeof wasmExports['emscripten_enum_PxRevoluteJointFlagEnum_eLIMIT_ENABLED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRevoluteJointFlagEnum_eLIMIT_ENABLED');
  _emscripten_enum_PxRevoluteJointFlagEnum_eLIMIT_ENABLED = Module['_emscripten_enum_PxRevoluteJointFlagEnum_eLIMIT_ENABLED'] = createExportWrapper('emscripten_enum_PxRevoluteJointFlagEnum_eLIMIT_ENABLED', 0);
  assert(typeof wasmExports['emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_ENABLED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_ENABLED');
  _emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_ENABLED = Module['_emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_ENABLED'] = createExportWrapper('emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_ENABLED', 0);
  assert(typeof wasmExports['emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_FREESPIN'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_FREESPIN');
  _emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_FREESPIN = Module['_emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_FREESPIN'] = createExportWrapper('emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_FREESPIN', 0);
  assert(typeof wasmExports['emscripten_enum_PxRigidBodyFlagEnum_eKINEMATIC'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRigidBodyFlagEnum_eKINEMATIC');
  _emscripten_enum_PxRigidBodyFlagEnum_eKINEMATIC = Module['_emscripten_enum_PxRigidBodyFlagEnum_eKINEMATIC'] = createExportWrapper('emscripten_enum_PxRigidBodyFlagEnum_eKINEMATIC', 0);
  assert(typeof wasmExports['emscripten_enum_PxRigidBodyFlagEnum_eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRigidBodyFlagEnum_eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES');
  _emscripten_enum_PxRigidBodyFlagEnum_eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES = Module['_emscripten_enum_PxRigidBodyFlagEnum_eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES'] = createExportWrapper('emscripten_enum_PxRigidBodyFlagEnum_eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES', 0);
  assert(typeof wasmExports['emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD');
  _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD = Module['_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD'] = createExportWrapper('emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD', 0);
  assert(typeof wasmExports['emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_FRICTION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_FRICTION');
  _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_FRICTION = Module['_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_FRICTION'] = createExportWrapper('emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_FRICTION', 0);
  assert(typeof wasmExports['emscripten_enum_PxRigidBodyFlagEnum_eENABLE_POSE_INTEGRATION_PREVIEW'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRigidBodyFlagEnum_eENABLE_POSE_INTEGRATION_PREVIEW');
  _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_POSE_INTEGRATION_PREVIEW = Module['_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_POSE_INTEGRATION_PREVIEW'] = createExportWrapper('emscripten_enum_PxRigidBodyFlagEnum_eENABLE_POSE_INTEGRATION_PREVIEW', 0);
  assert(typeof wasmExports['emscripten_enum_PxRigidBodyFlagEnum_eENABLE_SPECULATIVE_CCD'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRigidBodyFlagEnum_eENABLE_SPECULATIVE_CCD');
  _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_SPECULATIVE_CCD = Module['_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_SPECULATIVE_CCD'] = createExportWrapper('emscripten_enum_PxRigidBodyFlagEnum_eENABLE_SPECULATIVE_CCD', 0);
  assert(typeof wasmExports['emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_MAX_CONTACT_IMPULSE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_MAX_CONTACT_IMPULSE');
  _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_MAX_CONTACT_IMPULSE = Module['_emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_MAX_CONTACT_IMPULSE'] = createExportWrapper('emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_MAX_CONTACT_IMPULSE', 0);
  assert(typeof wasmExports['emscripten_enum_PxRigidBodyFlagEnum_eRETAIN_ACCELERATIONS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRigidBodyFlagEnum_eRETAIN_ACCELERATIONS');
  _emscripten_enum_PxRigidBodyFlagEnum_eRETAIN_ACCELERATIONS = Module['_emscripten_enum_PxRigidBodyFlagEnum_eRETAIN_ACCELERATIONS'] = createExportWrapper('emscripten_enum_PxRigidBodyFlagEnum_eRETAIN_ACCELERATIONS', 0);
  assert(typeof wasmExports['emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_X'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_X');
  _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_X = Module['_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_X'] = createExportWrapper('emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_X', 0);
  assert(typeof wasmExports['emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Y'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Y');
  _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Y = Module['_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Y'] = createExportWrapper('emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Y', 0);
  assert(typeof wasmExports['emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Z'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Z');
  _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Z = Module['_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Z'] = createExportWrapper('emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Z', 0);
  assert(typeof wasmExports['emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_X'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_X');
  _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_X = Module['_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_X'] = createExportWrapper('emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_X', 0);
  assert(typeof wasmExports['emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Y'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Y');
  _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Y = Module['_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Y'] = createExportWrapper('emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Y', 0);
  assert(typeof wasmExports['emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Z'] != 'undefined', 'missing Wasm export: emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Z');
  _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Z = Module['_emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Z'] = createExportWrapper('emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Z', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eENABLE_ACTIVE_ACTORS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eENABLE_ACTIVE_ACTORS');
  _emscripten_enum_PxSceneFlagEnum_eENABLE_ACTIVE_ACTORS = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_ACTIVE_ACTORS'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eENABLE_ACTIVE_ACTORS', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eENABLE_CCD'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eENABLE_CCD');
  _emscripten_enum_PxSceneFlagEnum_eENABLE_CCD = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_CCD'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eENABLE_CCD', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eDISABLE_CCD_RESWEEP'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eDISABLE_CCD_RESWEEP');
  _emscripten_enum_PxSceneFlagEnum_eDISABLE_CCD_RESWEEP = Module['_emscripten_enum_PxSceneFlagEnum_eDISABLE_CCD_RESWEEP'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eDISABLE_CCD_RESWEEP', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eENABLE_PCM'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eENABLE_PCM');
  _emscripten_enum_PxSceneFlagEnum_eENABLE_PCM = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_PCM'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eENABLE_PCM', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_REPORT_BUFFER_RESIZE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_REPORT_BUFFER_RESIZE');
  _emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_REPORT_BUFFER_RESIZE = Module['_emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_REPORT_BUFFER_RESIZE'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_REPORT_BUFFER_RESIZE', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_CACHE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_CACHE');
  _emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_CACHE = Module['_emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_CACHE'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_CACHE', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eREQUIRE_RW_LOCK'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eREQUIRE_RW_LOCK');
  _emscripten_enum_PxSceneFlagEnum_eREQUIRE_RW_LOCK = Module['_emscripten_enum_PxSceneFlagEnum_eREQUIRE_RW_LOCK'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eREQUIRE_RW_LOCK', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eENABLE_STABILIZATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eENABLE_STABILIZATION');
  _emscripten_enum_PxSceneFlagEnum_eENABLE_STABILIZATION = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_STABILIZATION'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eENABLE_STABILIZATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eENABLE_AVERAGE_POINT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eENABLE_AVERAGE_POINT');
  _emscripten_enum_PxSceneFlagEnum_eENABLE_AVERAGE_POINT = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_AVERAGE_POINT'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eENABLE_AVERAGE_POINT', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS');
  _emscripten_enum_PxSceneFlagEnum_eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS = Module['_emscripten_enum_PxSceneFlagEnum_eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eENABLE_GPU_DYNAMICS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eENABLE_GPU_DYNAMICS');
  _emscripten_enum_PxSceneFlagEnum_eENABLE_GPU_DYNAMICS = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_GPU_DYNAMICS'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eENABLE_GPU_DYNAMICS', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eENABLE_ENHANCED_DETERMINISM'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eENABLE_ENHANCED_DETERMINISM');
  _emscripten_enum_PxSceneFlagEnum_eENABLE_ENHANCED_DETERMINISM = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_ENHANCED_DETERMINISM'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eENABLE_ENHANCED_DETERMINISM', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eENABLE_FRICTION_EVERY_ITERATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eENABLE_FRICTION_EVERY_ITERATION');
  _emscripten_enum_PxSceneFlagEnum_eENABLE_FRICTION_EVERY_ITERATION = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_FRICTION_EVERY_ITERATION'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eENABLE_FRICTION_EVERY_ITERATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eENABLE_DIRECT_GPU_API'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eENABLE_DIRECT_GPU_API');
  _emscripten_enum_PxSceneFlagEnum_eENABLE_DIRECT_GPU_API = Module['_emscripten_enum_PxSceneFlagEnum_eENABLE_DIRECT_GPU_API'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eENABLE_DIRECT_GPU_API', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneFlagEnum_eMUTABLE_FLAGS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneFlagEnum_eMUTABLE_FLAGS');
  _emscripten_enum_PxSceneFlagEnum_eMUTABLE_FLAGS = Module['_emscripten_enum_PxSceneFlagEnum_eMUTABLE_FLAGS'] = createExportWrapper('emscripten_enum_PxSceneFlagEnum_eMUTABLE_FLAGS', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_ENABLED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_ENABLED');
  _emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_ENABLED = Module['_emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_ENABLED'] = createExportWrapper('emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_ENABLED', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_DISABLED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_DISABLED');
  _emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_DISABLED = Module['_emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_DISABLED'] = createExportWrapper('emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_DISABLED', 0);
  assert(typeof wasmExports['emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_DISABLED_COMMIT_DISABLED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_DISABLED_COMMIT_DISABLED');
  _emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_DISABLED_COMMIT_DISABLED = Module['_emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_DISABLED_COMMIT_DISABLED'] = createExportWrapper('emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_DISABLED_COMMIT_DISABLED', 0);
  assert(typeof wasmExports['emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e8_BIT_PER_PIXEL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e8_BIT_PER_PIXEL');
  _emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e8_BIT_PER_PIXEL = Module['_emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e8_BIT_PER_PIXEL'] = createExportWrapper('emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e8_BIT_PER_PIXEL', 0);
  assert(typeof wasmExports['emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e16_BIT_PER_PIXEL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e16_BIT_PER_PIXEL');
  _emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e16_BIT_PER_PIXEL = Module['_emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e16_BIT_PER_PIXEL'] = createExportWrapper('emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e16_BIT_PER_PIXEL', 0);
  assert(typeof wasmExports['emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e32_BIT_PER_PIXEL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e32_BIT_PER_PIXEL');
  _emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e32_BIT_PER_PIXEL = Module['_emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e32_BIT_PER_PIXEL'] = createExportWrapper('emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e32_BIT_PER_PIXEL', 0);
  assert(typeof wasmExports['emscripten_enum_PxShapeFlagEnum_eSIMULATION_SHAPE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxShapeFlagEnum_eSIMULATION_SHAPE');
  _emscripten_enum_PxShapeFlagEnum_eSIMULATION_SHAPE = Module['_emscripten_enum_PxShapeFlagEnum_eSIMULATION_SHAPE'] = createExportWrapper('emscripten_enum_PxShapeFlagEnum_eSIMULATION_SHAPE', 0);
  assert(typeof wasmExports['emscripten_enum_PxShapeFlagEnum_eSCENE_QUERY_SHAPE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxShapeFlagEnum_eSCENE_QUERY_SHAPE');
  _emscripten_enum_PxShapeFlagEnum_eSCENE_QUERY_SHAPE = Module['_emscripten_enum_PxShapeFlagEnum_eSCENE_QUERY_SHAPE'] = createExportWrapper('emscripten_enum_PxShapeFlagEnum_eSCENE_QUERY_SHAPE', 0);
  assert(typeof wasmExports['emscripten_enum_PxShapeFlagEnum_eTRIGGER_SHAPE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxShapeFlagEnum_eTRIGGER_SHAPE');
  _emscripten_enum_PxShapeFlagEnum_eTRIGGER_SHAPE = Module['_emscripten_enum_PxShapeFlagEnum_eTRIGGER_SHAPE'] = createExportWrapper('emscripten_enum_PxShapeFlagEnum_eTRIGGER_SHAPE', 0);
  assert(typeof wasmExports['emscripten_enum_PxShapeFlagEnum_eVISUALIZATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxShapeFlagEnum_eVISUALIZATION');
  _emscripten_enum_PxShapeFlagEnum_eVISUALIZATION = Module['_emscripten_enum_PxShapeFlagEnum_eVISUALIZATION'] = createExportWrapper('emscripten_enum_PxShapeFlagEnum_eVISUALIZATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxSolverTypeEnum_ePGS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSolverTypeEnum_ePGS');
  _emscripten_enum_PxSolverTypeEnum_ePGS = Module['_emscripten_enum_PxSolverTypeEnum_ePGS'] = createExportWrapper('emscripten_enum_PxSolverTypeEnum_ePGS', 0);
  assert(typeof wasmExports['emscripten_enum_PxSolverTypeEnum_eTGS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSolverTypeEnum_eTGS');
  _emscripten_enum_PxSolverTypeEnum_eTGS = Module['_emscripten_enum_PxSolverTypeEnum_eTGS'] = createExportWrapper('emscripten_enum_PxSolverTypeEnum_eTGS', 0);
  assert(typeof wasmExports['emscripten_enum_PxSphericalJointFlagEnum_eLIMIT_ENABLED'] != 'undefined', 'missing Wasm export: emscripten_enum_PxSphericalJointFlagEnum_eLIMIT_ENABLED');
  _emscripten_enum_PxSphericalJointFlagEnum_eLIMIT_ENABLED = Module['_emscripten_enum_PxSphericalJointFlagEnum_eLIMIT_ENABLED'] = createExportWrapper('emscripten_enum_PxSphericalJointFlagEnum_eLIMIT_ENABLED', 0);
  assert(typeof wasmExports['emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eVALID'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eVALID');
  _emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eVALID = Module['_emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eVALID'] = createExportWrapper('emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eVALID', 0);
  assert(typeof wasmExports['emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eDEGENERATE_TETRAHEDRON'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eDEGENERATE_TETRAHEDRON');
  _emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eDEGENERATE_TETRAHEDRON = Module['_emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eDEGENERATE_TETRAHEDRON'] = createExportWrapper('emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eDEGENERATE_TETRAHEDRON', 0);
  assert(typeof wasmExports['emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC');
  _emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC = Module['_emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC'] = createExportWrapper('emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC', 0);
  assert(typeof wasmExports['emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_INVALID'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_INVALID');
  _emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_INVALID = Module['_emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_INVALID'] = createExportWrapper('emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_INVALID', 0);
  assert(typeof wasmExports['emscripten_enum_PxTetrahedronMeshFlagEnum_e16_BIT_INDICES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTetrahedronMeshFlagEnum_e16_BIT_INDICES');
  _emscripten_enum_PxTetrahedronMeshFlagEnum_e16_BIT_INDICES = Module['_emscripten_enum_PxTetrahedronMeshFlagEnum_e16_BIT_INDICES'] = createExportWrapper('emscripten_enum_PxTetrahedronMeshFlagEnum_e16_BIT_INDICES', 0);
  assert(typeof wasmExports['emscripten_enum_PxTetrahedronMeshFormatEnum_eTET_MESH'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTetrahedronMeshFormatEnum_eTET_MESH');
  _emscripten_enum_PxTetrahedronMeshFormatEnum_eTET_MESH = Module['_emscripten_enum_PxTetrahedronMeshFormatEnum_eTET_MESH'] = createExportWrapper('emscripten_enum_PxTetrahedronMeshFormatEnum_eTET_MESH', 0);
  assert(typeof wasmExports['emscripten_enum_PxTetrahedronMeshFormatEnum_eHEX_MESH'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTetrahedronMeshFormatEnum_eHEX_MESH');
  _emscripten_enum_PxTetrahedronMeshFormatEnum_eHEX_MESH = Module['_emscripten_enum_PxTetrahedronMeshFormatEnum_eHEX_MESH'] = createExportWrapper('emscripten_enum_PxTetrahedronMeshFormatEnum_eHEX_MESH', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshAnalysisResultEnum_eVALID'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshAnalysisResultEnum_eVALID');
  _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eVALID = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eVALID'] = createExportWrapper('emscripten_enum_PxTriangleMeshAnalysisResultEnum_eVALID', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshAnalysisResultEnum_eZERO_VOLUME'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshAnalysisResultEnum_eZERO_VOLUME');
  _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eZERO_VOLUME = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eZERO_VOLUME'] = createExportWrapper('emscripten_enum_PxTriangleMeshAnalysisResultEnum_eZERO_VOLUME', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshAnalysisResultEnum_eOPEN_BOUNDARIES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshAnalysisResultEnum_eOPEN_BOUNDARIES');
  _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eOPEN_BOUNDARIES = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eOPEN_BOUNDARIES'] = createExportWrapper('emscripten_enum_PxTriangleMeshAnalysisResultEnum_eOPEN_BOUNDARIES', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshAnalysisResultEnum_eSELF_INTERSECTIONS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshAnalysisResultEnum_eSELF_INTERSECTIONS');
  _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eSELF_INTERSECTIONS = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eSELF_INTERSECTIONS'] = createExportWrapper('emscripten_enum_PxTriangleMeshAnalysisResultEnum_eSELF_INTERSECTIONS', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshAnalysisResultEnum_eINCONSISTENT_TRIANGLE_ORIENTATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshAnalysisResultEnum_eINCONSISTENT_TRIANGLE_ORIENTATION');
  _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eINCONSISTENT_TRIANGLE_ORIENTATION = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eINCONSISTENT_TRIANGLE_ORIENTATION'] = createExportWrapper('emscripten_enum_PxTriangleMeshAnalysisResultEnum_eINCONSISTENT_TRIANGLE_ORIENTATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_ACUTE_ANGLED_TRIANGLES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_ACUTE_ANGLED_TRIANGLES');
  _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_ACUTE_ANGLED_TRIANGLES = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_ACUTE_ANGLED_TRIANGLES'] = createExportWrapper('emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_ACUTE_ANGLED_TRIANGLES', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshAnalysisResultEnum_eEDGE_SHARED_BY_MORE_THAN_TWO_TRIANGLES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshAnalysisResultEnum_eEDGE_SHARED_BY_MORE_THAN_TWO_TRIANGLES');
  _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eEDGE_SHARED_BY_MORE_THAN_TWO_TRIANGLES = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eEDGE_SHARED_BY_MORE_THAN_TWO_TRIANGLES'] = createExportWrapper('emscripten_enum_PxTriangleMeshAnalysisResultEnum_eEDGE_SHARED_BY_MORE_THAN_TWO_TRIANGLES', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_DUPLICATE_POINTS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_DUPLICATE_POINTS');
  _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_DUPLICATE_POINTS = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_DUPLICATE_POINTS'] = createExportWrapper('emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_DUPLICATE_POINTS', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_INVALID_POINTS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_INVALID_POINTS');
  _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_INVALID_POINTS = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_INVALID_POINTS'] = createExportWrapper('emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_INVALID_POINTS', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshAnalysisResultEnum_eREQUIRES_32BIT_INDEX_BUFFER'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshAnalysisResultEnum_eREQUIRES_32BIT_INDEX_BUFFER');
  _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eREQUIRES_32BIT_INDEX_BUFFER = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eREQUIRES_32BIT_INDEX_BUFFER'] = createExportWrapper('emscripten_enum_PxTriangleMeshAnalysisResultEnum_eREQUIRES_32BIT_INDEX_BUFFER', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshAnalysisResultEnum_eTRIANGLE_INDEX_OUT_OF_RANGE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshAnalysisResultEnum_eTRIANGLE_INDEX_OUT_OF_RANGE');
  _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eTRIANGLE_INDEX_OUT_OF_RANGE = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eTRIANGLE_INDEX_OUT_OF_RANGE'] = createExportWrapper('emscripten_enum_PxTriangleMeshAnalysisResultEnum_eTRIANGLE_INDEX_OUT_OF_RANGE', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC');
  _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC'] = createExportWrapper('emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_INVALID'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_INVALID');
  _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_INVALID = Module['_emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_INVALID'] = createExportWrapper('emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_INVALID', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshFlagEnum_e16_BIT_INDICES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshFlagEnum_e16_BIT_INDICES');
  _emscripten_enum_PxTriangleMeshFlagEnum_e16_BIT_INDICES = Module['_emscripten_enum_PxTriangleMeshFlagEnum_e16_BIT_INDICES'] = createExportWrapper('emscripten_enum_PxTriangleMeshFlagEnum_e16_BIT_INDICES', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriangleMeshFlagEnum_eADJACENCY_INFO'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriangleMeshFlagEnum_eADJACENCY_INFO');
  _emscripten_enum_PxTriangleMeshFlagEnum_eADJACENCY_INFO = Module['_emscripten_enum_PxTriangleMeshFlagEnum_eADJACENCY_INFO'] = createExportWrapper('emscripten_enum_PxTriangleMeshFlagEnum_eADJACENCY_INFO', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_TRIGGER'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_TRIGGER');
  _emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_TRIGGER = Module['_emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_TRIGGER'] = createExportWrapper('emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_TRIGGER', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_OTHER'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_OTHER');
  _emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_OTHER = Module['_emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_OTHER'] = createExportWrapper('emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_OTHER', 0);
  assert(typeof wasmExports['emscripten_enum_PxTriggerPairFlagEnum_eNEXT_FREE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxTriggerPairFlagEnum_eNEXT_FREE');
  _emscripten_enum_PxTriggerPairFlagEnum_eNEXT_FREE = Module['_emscripten_enum_PxTriggerPairFlagEnum_eNEXT_FREE'] = createExportWrapper('emscripten_enum_PxTriggerPairFlagEnum_eNEXT_FREE', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleAxesEnum_ePosX'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleAxesEnum_ePosX');
  _emscripten_enum_PxVehicleAxesEnum_ePosX = Module['_emscripten_enum_PxVehicleAxesEnum_ePosX'] = createExportWrapper('emscripten_enum_PxVehicleAxesEnum_ePosX', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleAxesEnum_eNegX'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleAxesEnum_eNegX');
  _emscripten_enum_PxVehicleAxesEnum_eNegX = Module['_emscripten_enum_PxVehicleAxesEnum_eNegX'] = createExportWrapper('emscripten_enum_PxVehicleAxesEnum_eNegX', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleAxesEnum_ePosY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleAxesEnum_ePosY');
  _emscripten_enum_PxVehicleAxesEnum_ePosY = Module['_emscripten_enum_PxVehicleAxesEnum_ePosY'] = createExportWrapper('emscripten_enum_PxVehicleAxesEnum_ePosY', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleAxesEnum_eNegY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleAxesEnum_eNegY');
  _emscripten_enum_PxVehicleAxesEnum_eNegY = Module['_emscripten_enum_PxVehicleAxesEnum_eNegY'] = createExportWrapper('emscripten_enum_PxVehicleAxesEnum_eNegY', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleAxesEnum_ePosZ'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleAxesEnum_ePosZ');
  _emscripten_enum_PxVehicleAxesEnum_ePosZ = Module['_emscripten_enum_PxVehicleAxesEnum_ePosZ'] = createExportWrapper('emscripten_enum_PxVehicleAxesEnum_ePosZ', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleAxesEnum_eNegZ'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleAxesEnum_eNegZ');
  _emscripten_enum_PxVehicleAxesEnum_eNegZ = Module['_emscripten_enum_PxVehicleAxesEnum_eNegZ'] = createExportWrapper('emscripten_enum_PxVehicleAxesEnum_eNegZ', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleClutchAccuracyModeEnum_eESTIMATE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleClutchAccuracyModeEnum_eESTIMATE');
  _emscripten_enum_PxVehicleClutchAccuracyModeEnum_eESTIMATE = Module['_emscripten_enum_PxVehicleClutchAccuracyModeEnum_eESTIMATE'] = createExportWrapper('emscripten_enum_PxVehicleClutchAccuracyModeEnum_eESTIMATE', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleClutchAccuracyModeEnum_eBEST_POSSIBLE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleClutchAccuracyModeEnum_eBEST_POSSIBLE');
  _emscripten_enum_PxVehicleClutchAccuracyModeEnum_eBEST_POSSIBLE = Module['_emscripten_enum_PxVehicleClutchAccuracyModeEnum_eBEST_POSSIBLE'] = createExportWrapper('emscripten_enum_PxVehicleClutchAccuracyModeEnum_eBEST_POSSIBLE', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleCommandNonLinearResponseParamsEnum_eMAX_NB_COMMAND_VALUES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleCommandNonLinearResponseParamsEnum_eMAX_NB_COMMAND_VALUES');
  _emscripten_enum_PxVehicleCommandNonLinearResponseParamsEnum_eMAX_NB_COMMAND_VALUES = Module['_emscripten_enum_PxVehicleCommandNonLinearResponseParamsEnum_eMAX_NB_COMMAND_VALUES'] = createExportWrapper('emscripten_enum_PxVehicleCommandNonLinearResponseParamsEnum_eMAX_NB_COMMAND_VALUES', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleCommandValueResponseTableEnum_eMAX_NB_SPEED_RESPONSES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleCommandValueResponseTableEnum_eMAX_NB_SPEED_RESPONSES');
  _emscripten_enum_PxVehicleCommandValueResponseTableEnum_eMAX_NB_SPEED_RESPONSES = Module['_emscripten_enum_PxVehicleCommandValueResponseTableEnum_eMAX_NB_SPEED_RESPONSES'] = createExportWrapper('emscripten_enum_PxVehicleCommandValueResponseTableEnum_eMAX_NB_SPEED_RESPONSES', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eREVERSE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eREVERSE');
  _emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eREVERSE = Module['_emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eREVERSE'] = createExportWrapper('emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eREVERSE', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eNEUTRAL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eNEUTRAL');
  _emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eNEUTRAL = Module['_emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eNEUTRAL'] = createExportWrapper('emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eNEUTRAL', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eFORWARD'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eFORWARD');
  _emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eFORWARD = Module['_emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eFORWARD'] = createExportWrapper('emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eFORWARD', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleEngineDriveTransmissionCommandStateEnum_eAUTOMATIC_GEAR'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleEngineDriveTransmissionCommandStateEnum_eAUTOMATIC_GEAR');
  _emscripten_enum_PxVehicleEngineDriveTransmissionCommandStateEnum_eAUTOMATIC_GEAR = Module['_emscripten_enum_PxVehicleEngineDriveTransmissionCommandStateEnum_eAUTOMATIC_GEAR'] = createExportWrapper('emscripten_enum_PxVehicleEngineDriveTransmissionCommandStateEnum_eAUTOMATIC_GEAR', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleGearboxParamsEnum_eMAX_NB_GEARS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleGearboxParamsEnum_eMAX_NB_GEARS');
  _emscripten_enum_PxVehicleGearboxParamsEnum_eMAX_NB_GEARS = Module['_emscripten_enum_PxVehicleGearboxParamsEnum_eMAX_NB_GEARS'] = createExportWrapper('emscripten_enum_PxVehicleGearboxParamsEnum_eMAX_NB_GEARS', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_WHEELS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_WHEELS');
  _emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_WHEELS = Module['_emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_WHEELS'] = createExportWrapper('emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_WHEELS', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_AXLES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_AXLES');
  _emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_AXLES = Module['_emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_AXLES'] = createExportWrapper('emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_AXLES', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_VELOCITY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_VELOCITY');
  _emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_VELOCITY = Module['_emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_VELOCITY'] = createExportWrapper('emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_VELOCITY', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_ACCELERATION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_ACCELERATION');
  _emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_ACCELERATION = Module['_emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_ACCELERATION'] = createExportWrapper('emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_ACCELERATION', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_PXCONSTRAINT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_PXCONSTRAINT');
  _emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_PXCONSTRAINT = Module['_emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_PXCONSTRAINT'] = createExportWrapper('emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_PXCONSTRAINT', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_WHEEL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_WHEEL');
  _emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_WHEEL = Module['_emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_WHEEL'] = createExportWrapper('emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_WHEEL', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_WHEELS_PER_PXCONSTRAINT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_WHEELS_PER_PXCONSTRAINT');
  _emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_WHEELS_PER_PXCONSTRAINT = Module['_emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_WHEELS_PER_PXCONSTRAINT'] = createExportWrapper('emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_WHEELS_PER_PXCONSTRAINT', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_CONSTRAINTS_PER_VEHICLE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_CONSTRAINTS_PER_VEHICLE');
  _emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_CONSTRAINTS_PER_VEHICLE = Module['_emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_CONSTRAINTS_PER_VEHICLE'] = createExportWrapper('emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_CONSTRAINTS_PER_VEHICLE', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eNONE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eNONE');
  _emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eNONE = Module['_emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eNONE'] = createExportWrapper('emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eNONE', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eRAYCAST'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eRAYCAST');
  _emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eRAYCAST = Module['_emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eRAYCAST'] = createExportWrapper('emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eRAYCAST', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eSWEEP'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eSWEEP');
  _emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eSWEEP = Module['_emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eSWEEP'] = createExportWrapper('emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eSWEEP', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eSUSPENSION'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eSUSPENSION');
  _emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eSUSPENSION = Module['_emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eSUSPENSION'] = createExportWrapper('emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eSUSPENSION', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eROAD_GEOMETRY_NORMAL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eROAD_GEOMETRY_NORMAL');
  _emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eROAD_GEOMETRY_NORMAL = Module['_emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eROAD_GEOMETRY_NORMAL'] = createExportWrapper('emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eROAD_GEOMETRY_NORMAL', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eNONE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eNONE');
  _emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eNONE = Module['_emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eNONE'] = createExportWrapper('emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eNONE', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleSimulationContextTypeEnum_eDEFAULT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleSimulationContextTypeEnum_eDEFAULT');
  _emscripten_enum_PxVehicleSimulationContextTypeEnum_eDEFAULT = Module['_emscripten_enum_PxVehicleSimulationContextTypeEnum_eDEFAULT'] = createExportWrapper('emscripten_enum_PxVehicleSimulationContextTypeEnum_eDEFAULT', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleSimulationContextTypeEnum_ePHYSX'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleSimulationContextTypeEnum_ePHYSX');
  _emscripten_enum_PxVehicleSimulationContextTypeEnum_ePHYSX = Module['_emscripten_enum_PxVehicleSimulationContextTypeEnum_ePHYSX'] = createExportWrapper('emscripten_enum_PxVehicleSimulationContextTypeEnum_ePHYSX', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eRAYCAST'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eRAYCAST');
  _emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eRAYCAST = Module['_emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eRAYCAST'] = createExportWrapper('emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eRAYCAST', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eSWEEP'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eSWEEP');
  _emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eSWEEP = Module['_emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eSWEEP'] = createExportWrapper('emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eSWEEP', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleTireDirectionModesEnum_eLONGITUDINAL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleTireDirectionModesEnum_eLONGITUDINAL');
  _emscripten_enum_PxVehicleTireDirectionModesEnum_eLONGITUDINAL = Module['_emscripten_enum_PxVehicleTireDirectionModesEnum_eLONGITUDINAL'] = createExportWrapper('emscripten_enum_PxVehicleTireDirectionModesEnum_eLONGITUDINAL', 0);
  assert(typeof wasmExports['emscripten_enum_PxVehicleTireDirectionModesEnum_eLATERAL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVehicleTireDirectionModesEnum_eLATERAL');
  _emscripten_enum_PxVehicleTireDirectionModesEnum_eLATERAL = Module['_emscripten_enum_PxVehicleTireDirectionModesEnum_eLATERAL'] = createExportWrapper('emscripten_enum_PxVehicleTireDirectionModesEnum_eLATERAL', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eSCALE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eSCALE');
  _emscripten_enum_PxVisualizationParameterEnum_eSCALE = Module['_emscripten_enum_PxVisualizationParameterEnum_eSCALE'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eSCALE', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eWORLD_AXES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eWORLD_AXES');
  _emscripten_enum_PxVisualizationParameterEnum_eWORLD_AXES = Module['_emscripten_enum_PxVisualizationParameterEnum_eWORLD_AXES'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eWORLD_AXES', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eBODY_AXES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eBODY_AXES');
  _emscripten_enum_PxVisualizationParameterEnum_eBODY_AXES = Module['_emscripten_enum_PxVisualizationParameterEnum_eBODY_AXES'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eBODY_AXES', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eBODY_MASS_AXES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eBODY_MASS_AXES');
  _emscripten_enum_PxVisualizationParameterEnum_eBODY_MASS_AXES = Module['_emscripten_enum_PxVisualizationParameterEnum_eBODY_MASS_AXES'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eBODY_MASS_AXES', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eBODY_LIN_VELOCITY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eBODY_LIN_VELOCITY');
  _emscripten_enum_PxVisualizationParameterEnum_eBODY_LIN_VELOCITY = Module['_emscripten_enum_PxVisualizationParameterEnum_eBODY_LIN_VELOCITY'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eBODY_LIN_VELOCITY', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eBODY_ANG_VELOCITY'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eBODY_ANG_VELOCITY');
  _emscripten_enum_PxVisualizationParameterEnum_eBODY_ANG_VELOCITY = Module['_emscripten_enum_PxVisualizationParameterEnum_eBODY_ANG_VELOCITY'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eBODY_ANG_VELOCITY', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eCONTACT_POINT'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eCONTACT_POINT');
  _emscripten_enum_PxVisualizationParameterEnum_eCONTACT_POINT = Module['_emscripten_enum_PxVisualizationParameterEnum_eCONTACT_POINT'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eCONTACT_POINT', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eCONTACT_NORMAL'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eCONTACT_NORMAL');
  _emscripten_enum_PxVisualizationParameterEnum_eCONTACT_NORMAL = Module['_emscripten_enum_PxVisualizationParameterEnum_eCONTACT_NORMAL'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eCONTACT_NORMAL', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eCONTACT_ERROR'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eCONTACT_ERROR');
  _emscripten_enum_PxVisualizationParameterEnum_eCONTACT_ERROR = Module['_emscripten_enum_PxVisualizationParameterEnum_eCONTACT_ERROR'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eCONTACT_ERROR', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eCONTACT_FORCE'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eCONTACT_FORCE');
  _emscripten_enum_PxVisualizationParameterEnum_eCONTACT_FORCE = Module['_emscripten_enum_PxVisualizationParameterEnum_eCONTACT_FORCE'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eCONTACT_FORCE', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eACTOR_AXES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eACTOR_AXES');
  _emscripten_enum_PxVisualizationParameterEnum_eACTOR_AXES = Module['_emscripten_enum_PxVisualizationParameterEnum_eACTOR_AXES'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eACTOR_AXES', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AABBS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AABBS');
  _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AABBS = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AABBS'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AABBS', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_SHAPES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_SHAPES');
  _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_SHAPES = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_SHAPES'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_SHAPES', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AXES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AXES');
  _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AXES = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AXES'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AXES', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_COMPOUNDS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_COMPOUNDS');
  _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_COMPOUNDS = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_COMPOUNDS'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_COMPOUNDS', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_FNORMALS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_FNORMALS');
  _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_FNORMALS = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_FNORMALS'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_FNORMALS', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_EDGES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_EDGES');
  _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_EDGES = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_EDGES'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_EDGES', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_STATIC'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_STATIC');
  _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_STATIC = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_STATIC'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_STATIC', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_DYNAMIC'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_DYNAMIC');
  _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_DYNAMIC = Module['_emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_DYNAMIC'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_DYNAMIC', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eJOINT_LOCAL_FRAMES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eJOINT_LOCAL_FRAMES');
  _emscripten_enum_PxVisualizationParameterEnum_eJOINT_LOCAL_FRAMES = Module['_emscripten_enum_PxVisualizationParameterEnum_eJOINT_LOCAL_FRAMES'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eJOINT_LOCAL_FRAMES', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eJOINT_LIMITS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eJOINT_LIMITS');
  _emscripten_enum_PxVisualizationParameterEnum_eJOINT_LIMITS = Module['_emscripten_enum_PxVisualizationParameterEnum_eJOINT_LIMITS'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eJOINT_LIMITS', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eCULL_BOX'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eCULL_BOX');
  _emscripten_enum_PxVisualizationParameterEnum_eCULL_BOX = Module['_emscripten_enum_PxVisualizationParameterEnum_eCULL_BOX'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eCULL_BOX', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eMBP_REGIONS'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eMBP_REGIONS');
  _emscripten_enum_PxVisualizationParameterEnum_eMBP_REGIONS = Module['_emscripten_enum_PxVisualizationParameterEnum_eMBP_REGIONS'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eMBP_REGIONS', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eSIMULATION_MESH'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eSIMULATION_MESH');
  _emscripten_enum_PxVisualizationParameterEnum_eSIMULATION_MESH = Module['_emscripten_enum_PxVisualizationParameterEnum_eSIMULATION_MESH'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eSIMULATION_MESH', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eSDF'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eSDF');
  _emscripten_enum_PxVisualizationParameterEnum_eSDF = Module['_emscripten_enum_PxVisualizationParameterEnum_eSDF'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eSDF', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eNUM_VALUES'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eNUM_VALUES');
  _emscripten_enum_PxVisualizationParameterEnum_eNUM_VALUES = Module['_emscripten_enum_PxVisualizationParameterEnum_eNUM_VALUES'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eNUM_VALUES', 0);
  assert(typeof wasmExports['emscripten_enum_PxVisualizationParameterEnum_eFORCE_DWORD'] != 'undefined', 'missing Wasm export: emscripten_enum_PxVisualizationParameterEnum_eFORCE_DWORD');
  _emscripten_enum_PxVisualizationParameterEnum_eFORCE_DWORD = Module['_emscripten_enum_PxVisualizationParameterEnum_eFORCE_DWORD'] = createExportWrapper('emscripten_enum_PxVisualizationParameterEnum_eFORCE_DWORD', 0);
  assert(typeof wasmExports['fflush'] != 'undefined', 'missing Wasm export: fflush');
  _fflush = createExportWrapper('fflush', 1);
  assert(typeof wasmExports['emscripten_stack_get_end'] != 'undefined', 'missing Wasm export: emscripten_stack_get_end');
  _emscripten_stack_get_end = wasmExports['emscripten_stack_get_end'];
  assert(typeof wasmExports['emscripten_stack_get_base'] != 'undefined', 'missing Wasm export: emscripten_stack_get_base');
  _emscripten_stack_get_base = wasmExports['emscripten_stack_get_base'];
  assert(typeof wasmExports['emscripten_stack_init'] != 'undefined', 'missing Wasm export: emscripten_stack_init');
  _emscripten_stack_init = wasmExports['emscripten_stack_init'];
  assert(typeof wasmExports['emscripten_stack_get_free'] != 'undefined', 'missing Wasm export: emscripten_stack_get_free');
  _emscripten_stack_get_free = wasmExports['emscripten_stack_get_free'];
  assert(typeof wasmExports['_emscripten_stack_restore'] != 'undefined', 'missing Wasm export: _emscripten_stack_restore');
  __emscripten_stack_restore = wasmExports['_emscripten_stack_restore'];
  assert(typeof wasmExports['_emscripten_stack_alloc'] != 'undefined', 'missing Wasm export: _emscripten_stack_alloc');
  __emscripten_stack_alloc = wasmExports['_emscripten_stack_alloc'];
  assert(typeof wasmExports['emscripten_stack_get_current'] != 'undefined', 'missing Wasm export: emscripten_stack_get_current');
  _emscripten_stack_get_current = wasmExports['emscripten_stack_get_current'];
  assert(typeof wasmExports['memory'] != 'undefined', 'missing Wasm export: memory');
  memory = wasmMemory = wasmExports['memory'];
  assert(typeof wasmExports['__indirect_function_table'] != 'undefined', 'missing Wasm export: __indirect_function_table');
  __indirect_function_table = wasmExports['__indirect_function_table'];
}

var wasmImports = {
  /** @export */
  _abort_js: __abort_js,
  /** @export */
  clock_time_get: _clock_time_get,
  /** @export */
  emscripten_asm_const_double: _emscripten_asm_const_double,
  /** @export */
  emscripten_asm_const_int: _emscripten_asm_const_int,
  /** @export */
  emscripten_date_now: _emscripten_date_now,
  /** @export */
  emscripten_get_now: _emscripten_get_now,
  /** @export */
  emscripten_resize_heap: _emscripten_resize_heap,
  /** @export */
  exit: _exit,
  /** @export */
  fd_close: _fd_close,
  /** @export */
  fd_seek: _fd_seek,
  /** @export */
  fd_write: _fd_write
};


// include: postamble.js
// === Auto-generated postamble setup entry stuff ===

var calledRun;

function stackCheckInit() {
  // This is normally called automatically during __wasm_call_ctors but need to
  // get these values before even running any of the ctors so we call it redundantly
  // here.
  _emscripten_stack_init();
  // TODO(sbc): Move writeStackCookie to native to to avoid this.
  writeStackCookie();
}

function run() {

  stackCheckInit();

  preRun();

  function doRun() {
    // run may have just been called through dependencies being fulfilled just in this very frame,
    // or while the async setStatus time below was happening
    assert(!calledRun);
    calledRun = true;
    Module['calledRun'] = true;

    if (ABORT) return;

    initRuntime();

    readyPromiseResolve?.(Module);
    Module['onRuntimeInitialized']?.();
    consumedModuleProp('onRuntimeInitialized');

    assert(!Module['_main'], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]');

    postRun();
  }

  if (Module['setStatus']) {
    Module['setStatus']('Running...');
    setTimeout(() => {
      setTimeout(() => Module['setStatus'](''), 1);
      doRun();
    }, 1);
  } else
  {
    doRun();
  }
  checkStackCookie();
}

function checkUnflushedContent() {
  // Compiler settings do not allow exiting the runtime, so flushing
  // the streams is not possible. but in ASSERTIONS mode we check
  // if there was something to flush, and if so tell the user they
  // should request that the runtime be exitable.
  // Normally we would not even include flush() at all, but in ASSERTIONS
  // builds we do so just for this check, and here we see if there is any
  // content to flush, that is, we check if there would have been
  // something a non-ASSERTIONS build would have not seen.
  // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0
  // mode (which has its own special function for this; otherwise, all
  // the code is inside libc)
  var oldOut = out;
  var oldErr = err;
  var has = false;
  out = err = (x) => {
    has = true;
  }
  try { // it doesn't matter if it fails
    flush_NO_FILESYSTEM();
  } catch(e) {}
  out = oldOut;
  err = oldErr;
  if (has) {
    warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.');
    warnOnce('(this may also be due to not including full filesystem support - try building with -sFORCE_FILESYSTEM)');
  }
}

var wasmExports;

// In modularize mode the generated code is within a factory function so we
// can use await here (since it's not top-level-await).
wasmExports = await (createWasm());

run();

// end include: postamble.js

// include: glue.js

// Bindings utilities

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function WrapperObject() {
}
WrapperObject.prototype = Object.create(WrapperObject.prototype);
WrapperObject.prototype.constructor = WrapperObject;
WrapperObject.prototype.__class__ = WrapperObject;
WrapperObject.__cache__ = {};
Module['WrapperObject'] = WrapperObject;

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant)
    @param {*=} __class__ */
function getCache(__class__) {
  return (__class__ || WrapperObject).__cache__;
}
Module['getCache'] = getCache;

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant)
    @param {*=} __class__ */
function wrapPointer(ptr, __class__) {
  var cache = getCache(__class__);
  var ret = cache[ptr];
  if (ret) return ret;
  ret = Object.create((__class__ || WrapperObject).prototype);
  ret.ptr = ptr;
  return cache[ptr] = ret;
}
Module['wrapPointer'] = wrapPointer;

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function castObject(obj, __class__) {
  return wrapPointer(obj.ptr, __class__);
}
Module['castObject'] = castObject;

Module['NULL'] = wrapPointer(0);

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function destroy(obj) {
  if (!obj['__destroy__']) throw 'Error: Cannot destroy object. (Did you create it yourself?)';
  obj['__destroy__']();
  // Remove from cache, so the object can be GC'd and refs added onto it released
  delete getCache(obj.__class__)[obj.ptr];
}
Module['destroy'] = destroy;

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function compare(obj1, obj2) {
  return obj1.ptr === obj2.ptr;
}
Module['compare'] = compare;

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function getPointer(obj) {
  return obj.ptr;
}
Module['getPointer'] = getPointer;

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function getClass(obj) {
  return obj.__class__;
}
Module['getClass'] = getClass;

// Converts big (string or array) values into a C-style storage, in temporary space

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
var ensureCache = {
  buffer: 0,  // the main buffer of temporary storage
  size: 0,   // the size of buffer
  pos: 0,    // the next free offset in buffer
  temps: [], // extra allocations
  needed: 0, // the total size we need next time

  prepare() {
    if (ensureCache.needed) {
      // clear the temps
      for (var i = 0; i < ensureCache.temps.length; i++) {
        Module['_webidl_free'](ensureCache.temps[i]);
      }
      ensureCache.temps.length = 0;
      // prepare to allocate a bigger buffer
      Module['_webidl_free'](ensureCache.buffer);
      ensureCache.buffer = 0;
      ensureCache.size += ensureCache.needed;
      // clean up
      ensureCache.needed = 0;
    }
    if (!ensureCache.buffer) { // happens first time, or when we need to grow
      ensureCache.size += 128; // heuristic, avoid many small grow events
      ensureCache.buffer = Module['_webidl_malloc'](ensureCache.size);
      assert(ensureCache.buffer);
    }
    ensureCache.pos = 0;
  },
  alloc(array, view) {
    assert(ensureCache.buffer);
    var bytes = view.BYTES_PER_ELEMENT;
    var len = array.length * bytes;
    len = alignMemory(len, 8); // keep things aligned to 8 byte boundaries
    var ret;
    if (ensureCache.pos + len >= ensureCache.size) {
      // we failed to allocate in the buffer, ensureCache time around :(
      assert(len > 0); // null terminator, at least
      ensureCache.needed += len;
      ret = Module['_webidl_malloc'](len);
      ensureCache.temps.push(ret);
    } else {
      // we can allocate in the buffer
      ret = ensureCache.buffer + ensureCache.pos;
      ensureCache.pos += len;
    }
    return ret;
  },
};

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function ensureString(value) {
  if (typeof value === 'string') {
    var intArray = intArrayFromString(value);
    var offset = ensureCache.alloc(intArray, HEAP8);
    for (var i = 0; i < intArray.length; i++) {
      HEAP8[offset + i] = intArray[i];
    }
    return offset;
  }
  return value;
}

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function ensureInt8(value) {
  if (typeof value === 'object') {
    var offset = ensureCache.alloc(value, HEAP8);
    for (var i = 0; i < value.length; i++) {
      HEAP8[offset + i] = value[i];
    }
    return offset;
  }
  return value;
}

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function ensureInt16(value) {
  if (typeof value === 'object') {
    var offset = ensureCache.alloc(value, HEAP16);
    var heapOffset = offset / 2;
    for (var i = 0; i < value.length; i++) {
      HEAP16[heapOffset + i] = value[i];
    }
    return offset;
  }
  return value;
}

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function ensureInt32(value) {
  if (typeof value === 'object') {
    var offset = ensureCache.alloc(value, HEAP32);
    var heapOffset = offset / 4;
    for (var i = 0; i < value.length; i++) {
      HEAP32[heapOffset + i] = value[i];
    }
    return offset;
  }
  return value;
}

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function ensureFloat32(value) {
  if (typeof value === 'object') {
    var offset = ensureCache.alloc(value, HEAPF32);
    var heapOffset = offset / 4;
    for (var i = 0; i < value.length; i++) {
      HEAPF32[heapOffset + i] = value[i];
    }
    return offset;
  }
  return value;
}

/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function ensureFloat64(value) {
  if (typeof value === 'object') {
    var offset = ensureCache.alloc(value, HEAPF64);
    var heapOffset = offset / 8;
    for (var i = 0; i < value.length; i++) {
      HEAPF64[heapOffset + i] = value[i];
    }
    return offset;
  }
  return value;
}

// Interface: PxBase

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBase() { throw "cannot construct a PxBase, no constructor in IDL" }
PxBase.prototype = Object.create(WrapperObject.prototype);
PxBase.prototype.constructor = PxBase;
PxBase.prototype.__class__ = PxBase;
PxBase.__cache__ = {};
Module['PxBase'] = PxBase;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBase.prototype['release'] = PxBase.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxBase_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBase.prototype['getConcreteTypeName'] = PxBase.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxBase_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBase.prototype['getConcreteType'] = PxBase.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBase_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBase.prototype['setBaseFlag'] = PxBase.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxBase_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBase.prototype['setBaseFlags'] = PxBase.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxBase_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBase.prototype['getBaseFlags'] = PxBase.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBase_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBase.prototype['isReleasable'] = PxBase.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxBase_isReleasable_0(self));
};


// Interface: PxActor

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxActor() { throw "cannot construct a PxActor, no constructor in IDL" }
PxActor.prototype = Object.create(PxBase.prototype);
PxActor.prototype.constructor = PxActor;
PxActor.prototype.__class__ = PxActor;
PxActor.__cache__ = {};
Module['PxActor'] = PxActor;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['getType'] = PxActor.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxActor_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['getScene'] = PxActor.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxActor_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['setName'] = PxActor.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxActor_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['getName'] = PxActor.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxActor_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['getWorldBounds'] = PxActor.prototype.getWorldBounds = function(inflation) {
  var self = this.ptr;
  if (inflation && typeof inflation === 'object') inflation = inflation.ptr;
  if (inflation === undefined) { return wrapPointer(_emscripten_bind_PxActor_getWorldBounds_0(self), PxBounds3) }
  return wrapPointer(_emscripten_bind_PxActor_getWorldBounds_1(self, inflation), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['setActorFlag'] = PxActor.prototype.setActorFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxActor_setActorFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['setActorFlags'] = PxActor.prototype.setActorFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxActor_setActorFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['getActorFlags'] = PxActor.prototype.getActorFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxActor_getActorFlags_0(self), PxActorFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['setDominanceGroup'] = PxActor.prototype.setDominanceGroup = function(dominanceGroup) {
  var self = this.ptr;
  if (dominanceGroup && typeof dominanceGroup === 'object') dominanceGroup = dominanceGroup.ptr;
  _emscripten_bind_PxActor_setDominanceGroup_1(self, dominanceGroup);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['getDominanceGroup'] = PxActor.prototype.getDominanceGroup = function() {
  var self = this.ptr;
  return _emscripten_bind_PxActor_getDominanceGroup_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['setOwnerClient'] = PxActor.prototype.setOwnerClient = function(inClient) {
  var self = this.ptr;
  if (inClient && typeof inClient === 'object') inClient = inClient.ptr;
  _emscripten_bind_PxActor_setOwnerClient_1(self, inClient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['getOwnerClient'] = PxActor.prototype.getOwnerClient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxActor_getOwnerClient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['release'] = PxActor.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxActor_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['getConcreteTypeName'] = PxActor.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxActor_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['getConcreteType'] = PxActor.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxActor_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['setBaseFlag'] = PxActor.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxActor_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['setBaseFlags'] = PxActor.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxActor_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['getBaseFlags'] = PxActor.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxActor_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['isReleasable'] = PxActor.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxActor_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['get_userData'] = PxActor.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxActor_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActor.prototype['set_userData'] = PxActor.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxActor_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxActor.prototype, 'userData', { get: PxActor.prototype.get_userData, set: PxActor.prototype.set_userData });

// Interface: PxQueryHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxQueryHit() { throw "cannot construct a PxQueryHit, no constructor in IDL" }
PxQueryHit.prototype = Object.create(WrapperObject.prototype);
PxQueryHit.prototype.constructor = PxQueryHit;
PxQueryHit.prototype.__class__ = PxQueryHit;
PxQueryHit.__cache__ = {};
Module['PxQueryHit'] = PxQueryHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryHit.prototype['get_faceIndex'] = PxQueryHit.prototype.get_faceIndex = function() {
  var self = this.ptr;
  return _emscripten_bind_PxQueryHit_get_faceIndex_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryHit.prototype['set_faceIndex'] = PxQueryHit.prototype.set_faceIndex = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxQueryHit_set_faceIndex_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxQueryHit.prototype, 'faceIndex', { get: PxQueryHit.prototype.get_faceIndex, set: PxQueryHit.prototype.set_faceIndex });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryHit.prototype['__destroy__'] = PxQueryHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxQueryHit___destroy___0(self);
};

// Interface: BaseVehicle

/** @suppress {undefinedVars, duplicate} @this{Object} */
function BaseVehicle() { throw "cannot construct a BaseVehicle, no constructor in IDL" }
BaseVehicle.prototype = Object.create(WrapperObject.prototype);
BaseVehicle.prototype.constructor = BaseVehicle;
BaseVehicle.prototype.__class__ = BaseVehicle;
BaseVehicle.__cache__ = {};
Module['BaseVehicle'] = BaseVehicle;
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicle.prototype['initialize'] = BaseVehicle.prototype.initialize = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_BaseVehicle_initialize_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicle.prototype['destroyState'] = BaseVehicle.prototype.destroyState = function() {
  var self = this.ptr;
  _emscripten_bind_BaseVehicle_destroyState_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicle.prototype['initComponentSequence'] = BaseVehicle.prototype.initComponentSequence = function(addPhysXBeginEndComponents) {
  var self = this.ptr;
  if (addPhysXBeginEndComponents && typeof addPhysXBeginEndComponents === 'object') addPhysXBeginEndComponents = addPhysXBeginEndComponents.ptr;
  _emscripten_bind_BaseVehicle_initComponentSequence_1(self, addPhysXBeginEndComponents);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicle.prototype['step'] = BaseVehicle.prototype.step = function(dt, context) {
  var self = this.ptr;
  if (dt && typeof dt === 'object') dt = dt.ptr;
  if (context && typeof context === 'object') context = context.ptr;
  _emscripten_bind_BaseVehicle_step_2(self, dt, context);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicle.prototype['get_baseParams'] = BaseVehicle.prototype.get_baseParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicle_get_baseParams_0(self), BaseVehicleParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicle.prototype['set_baseParams'] = BaseVehicle.prototype.set_baseParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BaseVehicle_set_baseParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicle.prototype, 'baseParams', { get: BaseVehicle.prototype.get_baseParams, set: BaseVehicle.prototype.set_baseParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicle.prototype['get_baseState'] = BaseVehicle.prototype.get_baseState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicle_get_baseState_0(self), BaseVehicleState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicle.prototype['set_baseState'] = BaseVehicle.prototype.set_baseState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BaseVehicle_set_baseState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicle.prototype, 'baseState', { get: BaseVehicle.prototype.get_baseState, set: BaseVehicle.prototype.set_baseState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicle.prototype['get_componentSequence'] = BaseVehicle.prototype.get_componentSequence = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicle_get_componentSequence_0(self), PxVehicleComponentSequence);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicle.prototype['set_componentSequence'] = BaseVehicle.prototype.set_componentSequence = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BaseVehicle_set_componentSequence_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicle.prototype, 'componentSequence', { get: BaseVehicle.prototype.get_componentSequence, set: BaseVehicle.prototype.set_componentSequence });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicle.prototype['get_componentSequenceSubstepGroupHandle'] = BaseVehicle.prototype.get_componentSequenceSubstepGroupHandle = function() {
  var self = this.ptr;
  return _emscripten_bind_BaseVehicle_get_componentSequenceSubstepGroupHandle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicle.prototype['set_componentSequenceSubstepGroupHandle'] = BaseVehicle.prototype.set_componentSequenceSubstepGroupHandle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BaseVehicle_set_componentSequenceSubstepGroupHandle_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicle.prototype, 'componentSequenceSubstepGroupHandle', { get: BaseVehicle.prototype.get_componentSequenceSubstepGroupHandle, set: BaseVehicle.prototype.set_componentSequenceSubstepGroupHandle });

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicle.prototype['__destroy__'] = BaseVehicle.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_BaseVehicle___destroy___0(self);
};

// Interface: PxControllerBehaviorCallback

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllerBehaviorCallback() { throw "cannot construct a PxControllerBehaviorCallback, no constructor in IDL" }
PxControllerBehaviorCallback.prototype = Object.create(WrapperObject.prototype);
PxControllerBehaviorCallback.prototype.constructor = PxControllerBehaviorCallback;
PxControllerBehaviorCallback.prototype.__class__ = PxControllerBehaviorCallback;
PxControllerBehaviorCallback.__cache__ = {};
Module['PxControllerBehaviorCallback'] = PxControllerBehaviorCallback;

// Interface: PxLocationHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxLocationHit() { throw "cannot construct a PxLocationHit, no constructor in IDL" }
PxLocationHit.prototype = Object.create(PxQueryHit.prototype);
PxLocationHit.prototype.constructor = PxLocationHit;
PxLocationHit.prototype.__class__ = PxLocationHit;
PxLocationHit.__cache__ = {};
Module['PxLocationHit'] = PxLocationHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxLocationHit.prototype['get_flags'] = PxLocationHit.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxLocationHit_get_flags_0(self), PxHitFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxLocationHit.prototype['set_flags'] = PxLocationHit.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxLocationHit_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxLocationHit.prototype, 'flags', { get: PxLocationHit.prototype.get_flags, set: PxLocationHit.prototype.set_flags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxLocationHit.prototype['get_position'] = PxLocationHit.prototype.get_position = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxLocationHit_get_position_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxLocationHit.prototype['set_position'] = PxLocationHit.prototype.set_position = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxLocationHit_set_position_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxLocationHit.prototype, 'position', { get: PxLocationHit.prototype.get_position, set: PxLocationHit.prototype.set_position });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxLocationHit.prototype['get_normal'] = PxLocationHit.prototype.get_normal = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxLocationHit_get_normal_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxLocationHit.prototype['set_normal'] = PxLocationHit.prototype.set_normal = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxLocationHit_set_normal_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxLocationHit.prototype, 'normal', { get: PxLocationHit.prototype.get_normal, set: PxLocationHit.prototype.set_normal });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxLocationHit.prototype['get_distance'] = PxLocationHit.prototype.get_distance = function() {
  var self = this.ptr;
  return _emscripten_bind_PxLocationHit_get_distance_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxLocationHit.prototype['set_distance'] = PxLocationHit.prototype.set_distance = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxLocationHit_set_distance_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxLocationHit.prototype, 'distance', { get: PxLocationHit.prototype.get_distance, set: PxLocationHit.prototype.set_distance });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxLocationHit.prototype['get_faceIndex'] = PxLocationHit.prototype.get_faceIndex = function() {
  var self = this.ptr;
  return _emscripten_bind_PxLocationHit_get_faceIndex_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxLocationHit.prototype['set_faceIndex'] = PxLocationHit.prototype.set_faceIndex = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxLocationHit_set_faceIndex_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxLocationHit.prototype, 'faceIndex', { get: PxLocationHit.prototype.get_faceIndex, set: PxLocationHit.prototype.set_faceIndex });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxLocationHit.prototype['__destroy__'] = PxLocationHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxLocationHit___destroy___0(self);
};

// Interface: PxPvdTransport

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxPvdTransport() { throw "cannot construct a PxPvdTransport, no constructor in IDL" }
PxPvdTransport.prototype = Object.create(WrapperObject.prototype);
PxPvdTransport.prototype.constructor = PxPvdTransport;
PxPvdTransport.prototype.__class__ = PxPvdTransport;
PxPvdTransport.__cache__ = {};
Module['PxPvdTransport'] = PxPvdTransport;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdTransport.prototype['connect'] = PxPvdTransport.prototype.connect = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxPvdTransport_connect_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdTransport.prototype['isConnected'] = PxPvdTransport.prototype.isConnected = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxPvdTransport_isConnected_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdTransport.prototype['disconnect'] = PxPvdTransport.prototype.disconnect = function() {
  var self = this.ptr;
  _emscripten_bind_PxPvdTransport_disconnect_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdTransport.prototype['release'] = PxPvdTransport.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxPvdTransport_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdTransport.prototype['flush'] = PxPvdTransport.prototype.flush = function() {
  var self = this.ptr;
  _emscripten_bind_PxPvdTransport_flush_0(self);
};


// Interface: PxQueryFilterCallback

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxQueryFilterCallback() { throw "cannot construct a PxQueryFilterCallback, no constructor in IDL" }
PxQueryFilterCallback.prototype = Object.create(WrapperObject.prototype);
PxQueryFilterCallback.prototype.constructor = PxQueryFilterCallback;
PxQueryFilterCallback.prototype.__class__ = PxQueryFilterCallback;
PxQueryFilterCallback.__cache__ = {};
Module['PxQueryFilterCallback'] = PxQueryFilterCallback;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryFilterCallback.prototype['__destroy__'] = PxQueryFilterCallback.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxQueryFilterCallback___destroy___0(self);
};

// Interface: PxRefCounted

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRefCounted() { throw "cannot construct a PxRefCounted, no constructor in IDL" }
PxRefCounted.prototype = Object.create(PxBase.prototype);
PxRefCounted.prototype.constructor = PxRefCounted;
PxRefCounted.prototype.__class__ = PxRefCounted;
PxRefCounted.__cache__ = {};
Module['PxRefCounted'] = PxRefCounted;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRefCounted.prototype['getReferenceCount'] = PxRefCounted.prototype.getReferenceCount = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRefCounted_getReferenceCount_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRefCounted.prototype['acquireReference'] = PxRefCounted.prototype.acquireReference = function() {
  var self = this.ptr;
  _emscripten_bind_PxRefCounted_acquireReference_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRefCounted.prototype['release'] = PxRefCounted.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxRefCounted_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRefCounted.prototype['getConcreteTypeName'] = PxRefCounted.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxRefCounted_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRefCounted.prototype['getConcreteType'] = PxRefCounted.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRefCounted_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRefCounted.prototype['setBaseFlag'] = PxRefCounted.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRefCounted_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRefCounted.prototype['setBaseFlags'] = PxRefCounted.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxRefCounted_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRefCounted.prototype['getBaseFlags'] = PxRefCounted.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRefCounted_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRefCounted.prototype['isReleasable'] = PxRefCounted.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRefCounted_isReleasable_0(self));
};


// Interface: PxRigidActor

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRigidActor() { throw "cannot construct a PxRigidActor, no constructor in IDL" }
PxRigidActor.prototype = Object.create(PxActor.prototype);
PxRigidActor.prototype.constructor = PxRigidActor;
PxRigidActor.prototype.__class__ = PxRigidActor;
PxRigidActor.__cache__ = {};
Module['PxRigidActor'] = PxRigidActor;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['getGlobalPose'] = PxRigidActor.prototype.getGlobalPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidActor_getGlobalPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['setGlobalPose'] = PxRigidActor.prototype.setGlobalPose = function(pose, autowake) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxRigidActor_setGlobalPose_1(self, pose); return }
  _emscripten_bind_PxRigidActor_setGlobalPose_2(self, pose, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['attachShape'] = PxRigidActor.prototype.attachShape = function(shape) {
  var self = this.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  return !!(_emscripten_bind_PxRigidActor_attachShape_1(self, shape));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['detachShape'] = PxRigidActor.prototype.detachShape = function(shape, wakeOnLostTouch) {
  var self = this.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (wakeOnLostTouch && typeof wakeOnLostTouch === 'object') wakeOnLostTouch = wakeOnLostTouch.ptr;
  if (wakeOnLostTouch === undefined) { _emscripten_bind_PxRigidActor_detachShape_1(self, shape); return }
  _emscripten_bind_PxRigidActor_detachShape_2(self, shape, wakeOnLostTouch);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['getNbShapes'] = PxRigidActor.prototype.getNbShapes = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidActor_getNbShapes_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['getShapes'] = PxRigidActor.prototype.getShapes = function(userBuffer, bufferSize, startIndex) {
  var self = this.ptr;
  if (userBuffer && typeof userBuffer === 'object') userBuffer = userBuffer.ptr;
  if (bufferSize && typeof bufferSize === 'object') bufferSize = bufferSize.ptr;
  if (startIndex && typeof startIndex === 'object') startIndex = startIndex.ptr;
  return _emscripten_bind_PxRigidActor_getShapes_3(self, userBuffer, bufferSize, startIndex);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['getNbConstraints'] = PxRigidActor.prototype.getNbConstraints = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidActor_getNbConstraints_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['getType'] = PxRigidActor.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidActor_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['getScene'] = PxRigidActor.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidActor_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['setName'] = PxRigidActor.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxRigidActor_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['getName'] = PxRigidActor.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxRigidActor_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['getWorldBounds'] = PxRigidActor.prototype.getWorldBounds = function(inflation) {
  var self = this.ptr;
  if (inflation && typeof inflation === 'object') inflation = inflation.ptr;
  if (inflation === undefined) { return wrapPointer(_emscripten_bind_PxRigidActor_getWorldBounds_0(self), PxBounds3) }
  return wrapPointer(_emscripten_bind_PxRigidActor_getWorldBounds_1(self, inflation), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['setActorFlag'] = PxRigidActor.prototype.setActorFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRigidActor_setActorFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['setActorFlags'] = PxRigidActor.prototype.setActorFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxRigidActor_setActorFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['getActorFlags'] = PxRigidActor.prototype.getActorFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidActor_getActorFlags_0(self), PxActorFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['setDominanceGroup'] = PxRigidActor.prototype.setDominanceGroup = function(dominanceGroup) {
  var self = this.ptr;
  if (dominanceGroup && typeof dominanceGroup === 'object') dominanceGroup = dominanceGroup.ptr;
  _emscripten_bind_PxRigidActor_setDominanceGroup_1(self, dominanceGroup);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['getDominanceGroup'] = PxRigidActor.prototype.getDominanceGroup = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidActor_getDominanceGroup_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['setOwnerClient'] = PxRigidActor.prototype.setOwnerClient = function(inClient) {
  var self = this.ptr;
  if (inClient && typeof inClient === 'object') inClient = inClient.ptr;
  _emscripten_bind_PxRigidActor_setOwnerClient_1(self, inClient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['getOwnerClient'] = PxRigidActor.prototype.getOwnerClient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidActor_getOwnerClient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['release'] = PxRigidActor.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxRigidActor_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['getConcreteTypeName'] = PxRigidActor.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxRigidActor_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['getConcreteType'] = PxRigidActor.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidActor_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['setBaseFlag'] = PxRigidActor.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRigidActor_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['setBaseFlags'] = PxRigidActor.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxRigidActor_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['getBaseFlags'] = PxRigidActor.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidActor_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['isReleasable'] = PxRigidActor.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRigidActor_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['get_userData'] = PxRigidActor.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidActor_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActor.prototype['set_userData'] = PxRigidActor.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRigidActor_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRigidActor.prototype, 'userData', { get: PxRigidActor.prototype.get_userData, set: PxRigidActor.prototype.set_userData });

// Interface: PxSceneQuerySystemBase

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSceneQuerySystemBase() { throw "cannot construct a PxSceneQuerySystemBase, no constructor in IDL" }
PxSceneQuerySystemBase.prototype = Object.create(WrapperObject.prototype);
PxSceneQuerySystemBase.prototype.constructor = PxSceneQuerySystemBase;
PxSceneQuerySystemBase.prototype.__class__ = PxSceneQuerySystemBase;
PxSceneQuerySystemBase.__cache__ = {};
Module['PxSceneQuerySystemBase'] = PxSceneQuerySystemBase;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneQuerySystemBase.prototype['setDynamicTreeRebuildRateHint'] = PxSceneQuerySystemBase.prototype.setDynamicTreeRebuildRateHint = function(dynamicTreeRebuildRateHint) {
  var self = this.ptr;
  if (dynamicTreeRebuildRateHint && typeof dynamicTreeRebuildRateHint === 'object') dynamicTreeRebuildRateHint = dynamicTreeRebuildRateHint.ptr;
  _emscripten_bind_PxSceneQuerySystemBase_setDynamicTreeRebuildRateHint_1(self, dynamicTreeRebuildRateHint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneQuerySystemBase.prototype['getDynamicTreeRebuildRateHint'] = PxSceneQuerySystemBase.prototype.getDynamicTreeRebuildRateHint = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneQuerySystemBase_getDynamicTreeRebuildRateHint_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneQuerySystemBase.prototype['forceRebuildDynamicTree'] = PxSceneQuerySystemBase.prototype.forceRebuildDynamicTree = function(prunerIndex) {
  var self = this.ptr;
  if (prunerIndex && typeof prunerIndex === 'object') prunerIndex = prunerIndex.ptr;
  _emscripten_bind_PxSceneQuerySystemBase_forceRebuildDynamicTree_1(self, prunerIndex);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneQuerySystemBase.prototype['setUpdateMode'] = PxSceneQuerySystemBase.prototype.setUpdateMode = function(updateMode) {
  var self = this.ptr;
  if (updateMode && typeof updateMode === 'object') updateMode = updateMode.ptr;
  _emscripten_bind_PxSceneQuerySystemBase_setUpdateMode_1(self, updateMode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneQuerySystemBase.prototype['getUpdateMode'] = PxSceneQuerySystemBase.prototype.getUpdateMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneQuerySystemBase_getUpdateMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneQuerySystemBase.prototype['getStaticTimestamp'] = PxSceneQuerySystemBase.prototype.getStaticTimestamp = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneQuerySystemBase_getStaticTimestamp_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneQuerySystemBase.prototype['flushUpdates'] = PxSceneQuerySystemBase.prototype.flushUpdates = function() {
  var self = this.ptr;
  _emscripten_bind_PxSceneQuerySystemBase_flushUpdates_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneQuerySystemBase.prototype['raycast'] = PxSceneQuerySystemBase.prototype.raycast = function(origin, unitDir, distance, hitCall, hitFlags, filterData) {
  var self = this.ptr;
  if (origin && typeof origin === 'object') origin = origin.ptr;
  if (unitDir && typeof unitDir === 'object') unitDir = unitDir.ptr;
  if (distance && typeof distance === 'object') distance = distance.ptr;
  if (hitCall && typeof hitCall === 'object') hitCall = hitCall.ptr;
  if (hitFlags && typeof hitFlags === 'object') hitFlags = hitFlags.ptr;
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  if (hitFlags === undefined) { return !!(_emscripten_bind_PxSceneQuerySystemBase_raycast_4(self, origin, unitDir, distance, hitCall)) }
  if (filterData === undefined) { return !!(_emscripten_bind_PxSceneQuerySystemBase_raycast_5(self, origin, unitDir, distance, hitCall, hitFlags)) }
  return !!(_emscripten_bind_PxSceneQuerySystemBase_raycast_6(self, origin, unitDir, distance, hitCall, hitFlags, filterData));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneQuerySystemBase.prototype['sweep'] = PxSceneQuerySystemBase.prototype.sweep = function(geometry, pose, unitDir, distance, hitCall, hitFlags, filterData) {
  var self = this.ptr;
  if (geometry && typeof geometry === 'object') geometry = geometry.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (unitDir && typeof unitDir === 'object') unitDir = unitDir.ptr;
  if (distance && typeof distance === 'object') distance = distance.ptr;
  if (hitCall && typeof hitCall === 'object') hitCall = hitCall.ptr;
  if (hitFlags && typeof hitFlags === 'object') hitFlags = hitFlags.ptr;
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  if (hitFlags === undefined) { return !!(_emscripten_bind_PxSceneQuerySystemBase_sweep_5(self, geometry, pose, unitDir, distance, hitCall)) }
  if (filterData === undefined) { return !!(_emscripten_bind_PxSceneQuerySystemBase_sweep_6(self, geometry, pose, unitDir, distance, hitCall, hitFlags)) }
  return !!(_emscripten_bind_PxSceneQuerySystemBase_sweep_7(self, geometry, pose, unitDir, distance, hitCall, hitFlags, filterData));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneQuerySystemBase.prototype['overlap'] = PxSceneQuerySystemBase.prototype.overlap = function(geometry, pose, hitCall, filterData) {
  var self = this.ptr;
  if (geometry && typeof geometry === 'object') geometry = geometry.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (hitCall && typeof hitCall === 'object') hitCall = hitCall.ptr;
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  if (filterData === undefined) { return !!(_emscripten_bind_PxSceneQuerySystemBase_overlap_3(self, geometry, pose, hitCall)) }
  return !!(_emscripten_bind_PxSceneQuerySystemBase_overlap_4(self, geometry, pose, hitCall, filterData));
};


// Interface: PxSimulationEventCallback

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSimulationEventCallback() { throw "cannot construct a PxSimulationEventCallback, no constructor in IDL" }
PxSimulationEventCallback.prototype = Object.create(WrapperObject.prototype);
PxSimulationEventCallback.prototype.constructor = PxSimulationEventCallback;
PxSimulationEventCallback.prototype.__class__ = PxSimulationEventCallback;
PxSimulationEventCallback.__cache__ = {};
Module['PxSimulationEventCallback'] = PxSimulationEventCallback;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationEventCallback.prototype['__destroy__'] = PxSimulationEventCallback.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSimulationEventCallback___destroy___0(self);
};

// Interface: PxSimulationFilterShader

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSimulationFilterShader() { throw "cannot construct a PxSimulationFilterShader, no constructor in IDL" }
PxSimulationFilterShader.prototype = Object.create(WrapperObject.prototype);
PxSimulationFilterShader.prototype.constructor = PxSimulationFilterShader;
PxSimulationFilterShader.prototype.__class__ = PxSimulationFilterShader;
PxSimulationFilterShader.__cache__ = {};
Module['PxSimulationFilterShader'] = PxSimulationFilterShader;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationFilterShader.prototype['__destroy__'] = PxSimulationFilterShader.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSimulationFilterShader___destroy___0(self);
};

// Interface: Support

/** @suppress {undefinedVars, duplicate} @this{Object} */
function Support() { throw "cannot construct a Support, no constructor in IDL" }
Support.prototype = Object.create(WrapperObject.prototype);
Support.prototype.constructor = Support;
Support.prototype.__class__ = Support;
Support.__cache__ = {};
Module['Support'] = Support;
/** @suppress {undefinedVars, duplicate} @this{Object} */
Support.prototype['getMargin'] = Support.prototype.getMargin = function() {
  var self = this.ptr;
  return _emscripten_bind_Support_getMargin_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Support.prototype['supportLocal'] = Support.prototype.supportLocal = function(dir) {
  var self = this.ptr;
  if (dir && typeof dir === 'object') dir = dir.ptr;
  return wrapPointer(_emscripten_bind_Support_supportLocal_1(self, dir), PxVec3);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
Support.prototype['__destroy__'] = Support.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_Support___destroy___0(self);
};

// Interface: CustomSupport

/** @suppress {undefinedVars, duplicate} @this{Object} */
function CustomSupport() { throw "cannot construct a CustomSupport, no constructor in IDL" }
CustomSupport.prototype = Object.create(Support.prototype);
CustomSupport.prototype.constructor = CustomSupport;
CustomSupport.prototype.__class__ = CustomSupport;
CustomSupport.__cache__ = {};
Module['CustomSupport'] = CustomSupport;
/** @suppress {undefinedVars, duplicate} @this{Object} */
CustomSupport.prototype['getCustomMargin'] = CustomSupport.prototype.getCustomMargin = function() {
  var self = this.ptr;
  return _emscripten_bind_CustomSupport_getCustomMargin_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
CustomSupport.prototype['getCustomSupportLocal'] = CustomSupport.prototype.getCustomSupportLocal = function(dir, result) {
  var self = this.ptr;
  if (dir && typeof dir === 'object') dir = dir.ptr;
  if (result && typeof result === 'object') result = result.ptr;
  _emscripten_bind_CustomSupport_getCustomSupportLocal_2(self, dir, result);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
CustomSupport.prototype['getMargin'] = CustomSupport.prototype.getMargin = function() {
  var self = this.ptr;
  return _emscripten_bind_CustomSupport_getMargin_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
CustomSupport.prototype['supportLocal'] = CustomSupport.prototype.supportLocal = function(dir) {
  var self = this.ptr;
  if (dir && typeof dir === 'object') dir = dir.ptr;
  return wrapPointer(_emscripten_bind_CustomSupport_supportLocal_1(self, dir), PxVec3);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
CustomSupport.prototype['__destroy__'] = CustomSupport.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_CustomSupport___destroy___0(self);
};

// Interface: PassThroughFilterShader

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PassThroughFilterShader() { throw "cannot construct a PassThroughFilterShader, no constructor in IDL" }
PassThroughFilterShader.prototype = Object.create(PxSimulationFilterShader.prototype);
PassThroughFilterShader.prototype.constructor = PassThroughFilterShader;
PassThroughFilterShader.prototype.__class__ = PassThroughFilterShader;
PassThroughFilterShader.__cache__ = {};
Module['PassThroughFilterShader'] = PassThroughFilterShader;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PassThroughFilterShader.prototype['filterShader'] = PassThroughFilterShader.prototype.filterShader = function(attributes0, filterData0w0, filterData0w1, filterData0w2, filterData0w3, attributes1, filterData1w0, filterData1w1, filterData1w2, filterData1w3) {
  var self = this.ptr;
  if (attributes0 && typeof attributes0 === 'object') attributes0 = attributes0.ptr;
  if (filterData0w0 && typeof filterData0w0 === 'object') filterData0w0 = filterData0w0.ptr;
  if (filterData0w1 && typeof filterData0w1 === 'object') filterData0w1 = filterData0w1.ptr;
  if (filterData0w2 && typeof filterData0w2 === 'object') filterData0w2 = filterData0w2.ptr;
  if (filterData0w3 && typeof filterData0w3 === 'object') filterData0w3 = filterData0w3.ptr;
  if (attributes1 && typeof attributes1 === 'object') attributes1 = attributes1.ptr;
  if (filterData1w0 && typeof filterData1w0 === 'object') filterData1w0 = filterData1w0.ptr;
  if (filterData1w1 && typeof filterData1w1 === 'object') filterData1w1 = filterData1w1.ptr;
  if (filterData1w2 && typeof filterData1w2 === 'object') filterData1w2 = filterData1w2.ptr;
  if (filterData1w3 && typeof filterData1w3 === 'object') filterData1w3 = filterData1w3.ptr;
  return _emscripten_bind_PassThroughFilterShader_filterShader_10(self, attributes0, filterData0w0, filterData0w1, filterData0w2, filterData0w3, attributes1, filterData1w0, filterData1w1, filterData1w2, filterData1w3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PassThroughFilterShader.prototype['get_outputPairFlags'] = PassThroughFilterShader.prototype.get_outputPairFlags = function() {
  var self = this.ptr;
  return _emscripten_bind_PassThroughFilterShader_get_outputPairFlags_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PassThroughFilterShader.prototype['set_outputPairFlags'] = PassThroughFilterShader.prototype.set_outputPairFlags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PassThroughFilterShader_set_outputPairFlags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PassThroughFilterShader.prototype, 'outputPairFlags', { get: PassThroughFilterShader.prototype.get_outputPairFlags, set: PassThroughFilterShader.prototype.set_outputPairFlags });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PassThroughFilterShader.prototype['__destroy__'] = PassThroughFilterShader.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PassThroughFilterShader___destroy___0(self);
};

// Interface: PhysXActorVehicle

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PhysXActorVehicle() { throw "cannot construct a PhysXActorVehicle, no constructor in IDL" }
PhysXActorVehicle.prototype = Object.create(BaseVehicle.prototype);
PhysXActorVehicle.prototype.constructor = PhysXActorVehicle;
PhysXActorVehicle.prototype.__class__ = PhysXActorVehicle;
PhysXActorVehicle.__cache__ = {};
Module['PhysXActorVehicle'] = PhysXActorVehicle;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['initialize'] = PhysXActorVehicle.prototype.initialize = function(physics, params, defaultMaterial) {
  var self = this.ptr;
  if (physics && typeof physics === 'object') physics = physics.ptr;
  if (params && typeof params === 'object') params = params.ptr;
  if (defaultMaterial && typeof defaultMaterial === 'object') defaultMaterial = defaultMaterial.ptr;
  return !!(_emscripten_bind_PhysXActorVehicle_initialize_3(self, physics, params, defaultMaterial));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['destroyState'] = PhysXActorVehicle.prototype.destroyState = function() {
  var self = this.ptr;
  _emscripten_bind_PhysXActorVehicle_destroyState_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['initComponentSequence'] = PhysXActorVehicle.prototype.initComponentSequence = function(addPhysXBeginEndComponents) {
  var self = this.ptr;
  if (addPhysXBeginEndComponents && typeof addPhysXBeginEndComponents === 'object') addPhysXBeginEndComponents = addPhysXBeginEndComponents.ptr;
  _emscripten_bind_PhysXActorVehicle_initComponentSequence_1(self, addPhysXBeginEndComponents);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['step'] = PhysXActorVehicle.prototype.step = function(dt, context) {
  var self = this.ptr;
  if (dt && typeof dt === 'object') dt = dt.ptr;
  if (context && typeof context === 'object') context = context.ptr;
  _emscripten_bind_PhysXActorVehicle_step_2(self, dt, context);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['get_physXParams'] = PhysXActorVehicle.prototype.get_physXParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXActorVehicle_get_physXParams_0(self), PhysXIntegrationParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['set_physXParams'] = PhysXActorVehicle.prototype.set_physXParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXActorVehicle_set_physXParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXActorVehicle.prototype, 'physXParams', { get: PhysXActorVehicle.prototype.get_physXParams, set: PhysXActorVehicle.prototype.set_physXParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['get_physXState'] = PhysXActorVehicle.prototype.get_physXState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXActorVehicle_get_physXState_0(self), PhysXIntegrationState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['set_physXState'] = PhysXActorVehicle.prototype.set_physXState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXActorVehicle_set_physXState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXActorVehicle.prototype, 'physXState', { get: PhysXActorVehicle.prototype.get_physXState, set: PhysXActorVehicle.prototype.set_physXState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['get_commandState'] = PhysXActorVehicle.prototype.get_commandState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXActorVehicle_get_commandState_0(self), PxVehicleCommandState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['set_commandState'] = PhysXActorVehicle.prototype.set_commandState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXActorVehicle_set_commandState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXActorVehicle.prototype, 'commandState', { get: PhysXActorVehicle.prototype.get_commandState, set: PhysXActorVehicle.prototype.set_commandState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['get_baseParams'] = PhysXActorVehicle.prototype.get_baseParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXActorVehicle_get_baseParams_0(self), BaseVehicleParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['set_baseParams'] = PhysXActorVehicle.prototype.set_baseParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXActorVehicle_set_baseParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXActorVehicle.prototype, 'baseParams', { get: PhysXActorVehicle.prototype.get_baseParams, set: PhysXActorVehicle.prototype.set_baseParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['get_baseState'] = PhysXActorVehicle.prototype.get_baseState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXActorVehicle_get_baseState_0(self), BaseVehicleState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['set_baseState'] = PhysXActorVehicle.prototype.set_baseState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXActorVehicle_set_baseState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXActorVehicle.prototype, 'baseState', { get: PhysXActorVehicle.prototype.get_baseState, set: PhysXActorVehicle.prototype.set_baseState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['get_componentSequence'] = PhysXActorVehicle.prototype.get_componentSequence = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXActorVehicle_get_componentSequence_0(self), PxVehicleComponentSequence);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['set_componentSequence'] = PhysXActorVehicle.prototype.set_componentSequence = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXActorVehicle_set_componentSequence_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXActorVehicle.prototype, 'componentSequence', { get: PhysXActorVehicle.prototype.get_componentSequence, set: PhysXActorVehicle.prototype.set_componentSequence });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['get_componentSequenceSubstepGroupHandle'] = PhysXActorVehicle.prototype.get_componentSequenceSubstepGroupHandle = function() {
  var self = this.ptr;
  return _emscripten_bind_PhysXActorVehicle_get_componentSequenceSubstepGroupHandle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['set_componentSequenceSubstepGroupHandle'] = PhysXActorVehicle.prototype.set_componentSequenceSubstepGroupHandle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXActorVehicle_set_componentSequenceSubstepGroupHandle_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXActorVehicle.prototype, 'componentSequenceSubstepGroupHandle', { get: PhysXActorVehicle.prototype.get_componentSequenceSubstepGroupHandle, set: PhysXActorVehicle.prototype.set_componentSequenceSubstepGroupHandle });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXActorVehicle.prototype['__destroy__'] = PhysXActorVehicle.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PhysXActorVehicle___destroy___0(self);
};

// Interface: PxArticulationTendon

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationTendon() { throw "cannot construct a PxArticulationTendon, no constructor in IDL" }
PxArticulationTendon.prototype = Object.create(PxBase.prototype);
PxArticulationTendon.prototype.constructor = PxArticulationTendon;
PxArticulationTendon.prototype.__class__ = PxArticulationTendon;
PxArticulationTendon.__cache__ = {};
Module['PxArticulationTendon'] = PxArticulationTendon;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['setStiffness'] = PxArticulationTendon.prototype.setStiffness = function(stiffness) {
  var self = this.ptr;
  if (stiffness && typeof stiffness === 'object') stiffness = stiffness.ptr;
  _emscripten_bind_PxArticulationTendon_setStiffness_1(self, stiffness);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['getStiffness'] = PxArticulationTendon.prototype.getStiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationTendon_getStiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['setDamping'] = PxArticulationTendon.prototype.setDamping = function(damping) {
  var self = this.ptr;
  if (damping && typeof damping === 'object') damping = damping.ptr;
  _emscripten_bind_PxArticulationTendon_setDamping_1(self, damping);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['getDamping'] = PxArticulationTendon.prototype.getDamping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationTendon_getDamping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['setLimitStiffness'] = PxArticulationTendon.prototype.setLimitStiffness = function(stiffness) {
  var self = this.ptr;
  if (stiffness && typeof stiffness === 'object') stiffness = stiffness.ptr;
  _emscripten_bind_PxArticulationTendon_setLimitStiffness_1(self, stiffness);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['getLimitStiffness'] = PxArticulationTendon.prototype.getLimitStiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationTendon_getLimitStiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['setOffset'] = PxArticulationTendon.prototype.setOffset = function(offset, autowake) {
  var self = this.ptr;
  if (offset && typeof offset === 'object') offset = offset.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxArticulationTendon_setOffset_1(self, offset); return }
  _emscripten_bind_PxArticulationTendon_setOffset_2(self, offset, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['getOffset'] = PxArticulationTendon.prototype.getOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationTendon_getOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['getArticulation'] = PxArticulationTendon.prototype.getArticulation = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationTendon_getArticulation_0(self), PxArticulationReducedCoordinate);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['release'] = PxArticulationTendon.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationTendon_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['getConcreteTypeName'] = PxArticulationTendon.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxArticulationTendon_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['getConcreteType'] = PxArticulationTendon.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationTendon_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['setBaseFlag'] = PxArticulationTendon.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArticulationTendon_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['setBaseFlags'] = PxArticulationTendon.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxArticulationTendon_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['getBaseFlags'] = PxArticulationTendon.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationTendon_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['isReleasable'] = PxArticulationTendon.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxArticulationTendon_isReleasable_0(self));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendon.prototype['__destroy__'] = PxArticulationTendon.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationTendon___destroy___0(self);
};

// Interface: PxBaseMaterial

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBaseMaterial() { throw "cannot construct a PxBaseMaterial, no constructor in IDL" }
PxBaseMaterial.prototype = Object.create(PxRefCounted.prototype);
PxBaseMaterial.prototype.constructor = PxBaseMaterial;
PxBaseMaterial.prototype.__class__ = PxBaseMaterial;
PxBaseMaterial.__cache__ = {};
Module['PxBaseMaterial'] = PxBaseMaterial;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseMaterial.prototype['release'] = PxBaseMaterial.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxBaseMaterial_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseMaterial.prototype['getConcreteTypeName'] = PxBaseMaterial.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxBaseMaterial_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseMaterial.prototype['getConcreteType'] = PxBaseMaterial.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBaseMaterial_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseMaterial.prototype['setBaseFlag'] = PxBaseMaterial.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxBaseMaterial_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseMaterial.prototype['setBaseFlags'] = PxBaseMaterial.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxBaseMaterial_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseMaterial.prototype['getBaseFlags'] = PxBaseMaterial.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBaseMaterial_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseMaterial.prototype['isReleasable'] = PxBaseMaterial.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxBaseMaterial_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseMaterial.prototype['getReferenceCount'] = PxBaseMaterial.prototype.getReferenceCount = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBaseMaterial_getReferenceCount_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseMaterial.prototype['acquireReference'] = PxBaseMaterial.prototype.acquireReference = function() {
  var self = this.ptr;
  _emscripten_bind_PxBaseMaterial_acquireReference_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseMaterial.prototype['__destroy__'] = PxBaseMaterial.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxBaseMaterial___destroy___0(self);
};

// Interface: PxConstraintConnector

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConstraintConnector() { throw "cannot construct a PxConstraintConnector, no constructor in IDL" }
PxConstraintConnector.prototype = Object.create(WrapperObject.prototype);
PxConstraintConnector.prototype.constructor = PxConstraintConnector;
PxConstraintConnector.prototype.__class__ = PxConstraintConnector;
PxConstraintConnector.__cache__ = {};
Module['PxConstraintConnector'] = PxConstraintConnector;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintConnector.prototype['prepareData'] = PxConstraintConnector.prototype.prepareData = function() {
  var self = this.ptr;
  _emscripten_bind_PxConstraintConnector_prepareData_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintConnector.prototype['updateOmniPvdProperties'] = PxConstraintConnector.prototype.updateOmniPvdProperties = function() {
  var self = this.ptr;
  _emscripten_bind_PxConstraintConnector_updateOmniPvdProperties_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintConnector.prototype['onConstraintRelease'] = PxConstraintConnector.prototype.onConstraintRelease = function() {
  var self = this.ptr;
  _emscripten_bind_PxConstraintConnector_onConstraintRelease_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintConnector.prototype['onComShift'] = PxConstraintConnector.prototype.onComShift = function(actor) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  _emscripten_bind_PxConstraintConnector_onComShift_1(self, actor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintConnector.prototype['onOriginShift'] = PxConstraintConnector.prototype.onOriginShift = function(shift) {
  var self = this.ptr;
  if (shift && typeof shift === 'object') shift = shift.ptr;
  _emscripten_bind_PxConstraintConnector_onOriginShift_1(self, shift);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintConnector.prototype['getSerializable'] = PxConstraintConnector.prototype.getSerializable = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConstraintConnector_getSerializable_0(self), PxBase);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintConnector.prototype['getPrep'] = PxConstraintConnector.prototype.getPrep = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConstraintConnector_getPrep_0(self), PxConstraintSolverPrep);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintConnector.prototype['getConstantBlock'] = PxConstraintConnector.prototype.getConstantBlock = function() {
  var self = this.ptr;
  _emscripten_bind_PxConstraintConnector_getConstantBlock_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintConnector.prototype['connectToConstraint'] = PxConstraintConnector.prototype.connectToConstraint = function(constraint) {
  var self = this.ptr;
  if (constraint && typeof constraint === 'object') constraint = constraint.ptr;
  _emscripten_bind_PxConstraintConnector_connectToConstraint_1(self, constraint);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintConnector.prototype['__destroy__'] = PxConstraintConnector.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConstraintConnector___destroy___0(self);
};

// Interface: PxController

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxController() { throw "cannot construct a PxController, no constructor in IDL" }
PxController.prototype = Object.create(WrapperObject.prototype);
PxController.prototype.constructor = PxController;
PxController.prototype.__class__ = PxController;
PxController.__cache__ = {};
Module['PxController'] = PxController;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['getType'] = PxController.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxController_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['release'] = PxController.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxController_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['move'] = PxController.prototype.move = function(disp, minDist, elapsedTime, filters, obstacles) {
  var self = this.ptr;
  if (disp && typeof disp === 'object') disp = disp.ptr;
  if (minDist && typeof minDist === 'object') minDist = minDist.ptr;
  if (elapsedTime && typeof elapsedTime === 'object') elapsedTime = elapsedTime.ptr;
  if (filters && typeof filters === 'object') filters = filters.ptr;
  if (obstacles && typeof obstacles === 'object') obstacles = obstacles.ptr;
  if (obstacles === undefined) { return wrapPointer(_emscripten_bind_PxController_move_4(self, disp, minDist, elapsedTime, filters), PxControllerCollisionFlags) }
  return wrapPointer(_emscripten_bind_PxController_move_5(self, disp, minDist, elapsedTime, filters, obstacles), PxControllerCollisionFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['setPosition'] = PxController.prototype.setPosition = function(position) {
  var self = this.ptr;
  if (position && typeof position === 'object') position = position.ptr;
  return !!(_emscripten_bind_PxController_setPosition_1(self, position));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['getPosition'] = PxController.prototype.getPosition = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxController_getPosition_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['setFootPosition'] = PxController.prototype.setFootPosition = function(position) {
  var self = this.ptr;
  if (position && typeof position === 'object') position = position.ptr;
  return !!(_emscripten_bind_PxController_setFootPosition_1(self, position));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['getFootPosition'] = PxController.prototype.getFootPosition = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxController_getFootPosition_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['getActor'] = PxController.prototype.getActor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxController_getActor_0(self), PxRigidDynamic);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['setStepOffset'] = PxController.prototype.setStepOffset = function(offset) {
  var self = this.ptr;
  if (offset && typeof offset === 'object') offset = offset.ptr;
  _emscripten_bind_PxController_setStepOffset_1(self, offset);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['getStepOffset'] = PxController.prototype.getStepOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxController_getStepOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['setNonWalkableMode'] = PxController.prototype.setNonWalkableMode = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxController_setNonWalkableMode_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['getNonWalkableMode'] = PxController.prototype.getNonWalkableMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxController_getNonWalkableMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['getContactOffset'] = PxController.prototype.getContactOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxController_getContactOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['setContactOffset'] = PxController.prototype.setContactOffset = function(offset) {
  var self = this.ptr;
  if (offset && typeof offset === 'object') offset = offset.ptr;
  _emscripten_bind_PxController_setContactOffset_1(self, offset);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['getUpDirection'] = PxController.prototype.getUpDirection = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxController_getUpDirection_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['setUpDirection'] = PxController.prototype.setUpDirection = function(up) {
  var self = this.ptr;
  if (up && typeof up === 'object') up = up.ptr;
  _emscripten_bind_PxController_setUpDirection_1(self, up);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['getSlopeLimit'] = PxController.prototype.getSlopeLimit = function() {
  var self = this.ptr;
  return _emscripten_bind_PxController_getSlopeLimit_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['setSlopeLimit'] = PxController.prototype.setSlopeLimit = function(slopeLimit) {
  var self = this.ptr;
  if (slopeLimit && typeof slopeLimit === 'object') slopeLimit = slopeLimit.ptr;
  _emscripten_bind_PxController_setSlopeLimit_1(self, slopeLimit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['invalidateCache'] = PxController.prototype.invalidateCache = function() {
  var self = this.ptr;
  _emscripten_bind_PxController_invalidateCache_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['getScene'] = PxController.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxController_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['getUserData'] = PxController.prototype.getUserData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxController_getUserData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['setUserData'] = PxController.prototype.setUserData = function(userData) {
  var self = this.ptr;
  if (userData && typeof userData === 'object') userData = userData.ptr;
  _emscripten_bind_PxController_setUserData_1(self, userData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['getState'] = PxController.prototype.getState = function(state) {
  var self = this.ptr;
  if (state && typeof state === 'object') state = state.ptr;
  _emscripten_bind_PxController_getState_1(self, state);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['getStats'] = PxController.prototype.getStats = function(stats) {
  var self = this.ptr;
  if (stats && typeof stats === 'object') stats = stats.ptr;
  _emscripten_bind_PxController_getStats_1(self, stats);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxController.prototype['resize'] = PxController.prototype.resize = function(height) {
  var self = this.ptr;
  if (height && typeof height === 'object') height = height.ptr;
  _emscripten_bind_PxController_resize_1(self, height);
};


// Interface: PxControllerDesc

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllerDesc() { throw "cannot construct a PxControllerDesc, no constructor in IDL" }
PxControllerDesc.prototype = Object.create(WrapperObject.prototype);
PxControllerDesc.prototype.constructor = PxControllerDesc;
PxControllerDesc.prototype.__class__ = PxControllerDesc;
PxControllerDesc.__cache__ = {};
Module['PxControllerDesc'] = PxControllerDesc;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['isValid'] = PxControllerDesc.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxControllerDesc_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['getType'] = PxControllerDesc.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerDesc_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_position'] = PxControllerDesc.prototype.get_position = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerDesc_get_position_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_position'] = PxControllerDesc.prototype.set_position = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_position_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'position', { get: PxControllerDesc.prototype.get_position, set: PxControllerDesc.prototype.set_position });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_upDirection'] = PxControllerDesc.prototype.get_upDirection = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerDesc_get_upDirection_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_upDirection'] = PxControllerDesc.prototype.set_upDirection = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_upDirection_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'upDirection', { get: PxControllerDesc.prototype.get_upDirection, set: PxControllerDesc.prototype.set_upDirection });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_slopeLimit'] = PxControllerDesc.prototype.get_slopeLimit = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerDesc_get_slopeLimit_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_slopeLimit'] = PxControllerDesc.prototype.set_slopeLimit = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_slopeLimit_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'slopeLimit', { get: PxControllerDesc.prototype.get_slopeLimit, set: PxControllerDesc.prototype.set_slopeLimit });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_invisibleWallHeight'] = PxControllerDesc.prototype.get_invisibleWallHeight = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerDesc_get_invisibleWallHeight_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_invisibleWallHeight'] = PxControllerDesc.prototype.set_invisibleWallHeight = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_invisibleWallHeight_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'invisibleWallHeight', { get: PxControllerDesc.prototype.get_invisibleWallHeight, set: PxControllerDesc.prototype.set_invisibleWallHeight });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_maxJumpHeight'] = PxControllerDesc.prototype.get_maxJumpHeight = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerDesc_get_maxJumpHeight_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_maxJumpHeight'] = PxControllerDesc.prototype.set_maxJumpHeight = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_maxJumpHeight_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'maxJumpHeight', { get: PxControllerDesc.prototype.get_maxJumpHeight, set: PxControllerDesc.prototype.set_maxJumpHeight });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_contactOffset'] = PxControllerDesc.prototype.get_contactOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerDesc_get_contactOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_contactOffset'] = PxControllerDesc.prototype.set_contactOffset = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_contactOffset_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'contactOffset', { get: PxControllerDesc.prototype.get_contactOffset, set: PxControllerDesc.prototype.set_contactOffset });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_stepOffset'] = PxControllerDesc.prototype.get_stepOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerDesc_get_stepOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_stepOffset'] = PxControllerDesc.prototype.set_stepOffset = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_stepOffset_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'stepOffset', { get: PxControllerDesc.prototype.get_stepOffset, set: PxControllerDesc.prototype.set_stepOffset });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_density'] = PxControllerDesc.prototype.get_density = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerDesc_get_density_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_density'] = PxControllerDesc.prototype.set_density = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_density_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'density', { get: PxControllerDesc.prototype.get_density, set: PxControllerDesc.prototype.set_density });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_scaleCoeff'] = PxControllerDesc.prototype.get_scaleCoeff = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerDesc_get_scaleCoeff_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_scaleCoeff'] = PxControllerDesc.prototype.set_scaleCoeff = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_scaleCoeff_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'scaleCoeff', { get: PxControllerDesc.prototype.get_scaleCoeff, set: PxControllerDesc.prototype.set_scaleCoeff });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_volumeGrowth'] = PxControllerDesc.prototype.get_volumeGrowth = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerDesc_get_volumeGrowth_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_volumeGrowth'] = PxControllerDesc.prototype.set_volumeGrowth = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_volumeGrowth_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'volumeGrowth', { get: PxControllerDesc.prototype.get_volumeGrowth, set: PxControllerDesc.prototype.set_volumeGrowth });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_reportCallback'] = PxControllerDesc.prototype.get_reportCallback = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerDesc_get_reportCallback_0(self), PxUserControllerHitReport);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_reportCallback'] = PxControllerDesc.prototype.set_reportCallback = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_reportCallback_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'reportCallback', { get: PxControllerDesc.prototype.get_reportCallback, set: PxControllerDesc.prototype.set_reportCallback });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_behaviorCallback'] = PxControllerDesc.prototype.get_behaviorCallback = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerDesc_get_behaviorCallback_0(self), PxControllerBehaviorCallback);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_behaviorCallback'] = PxControllerDesc.prototype.set_behaviorCallback = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_behaviorCallback_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'behaviorCallback', { get: PxControllerDesc.prototype.get_behaviorCallback, set: PxControllerDesc.prototype.set_behaviorCallback });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_nonWalkableMode'] = PxControllerDesc.prototype.get_nonWalkableMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerDesc_get_nonWalkableMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_nonWalkableMode'] = PxControllerDesc.prototype.set_nonWalkableMode = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_nonWalkableMode_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'nonWalkableMode', { get: PxControllerDesc.prototype.get_nonWalkableMode, set: PxControllerDesc.prototype.set_nonWalkableMode });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_material'] = PxControllerDesc.prototype.get_material = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerDesc_get_material_0(self), PxMaterial);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_material'] = PxControllerDesc.prototype.set_material = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_material_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'material', { get: PxControllerDesc.prototype.get_material, set: PxControllerDesc.prototype.set_material });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_registerDeletionListener'] = PxControllerDesc.prototype.get_registerDeletionListener = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxControllerDesc_get_registerDeletionListener_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_registerDeletionListener'] = PxControllerDesc.prototype.set_registerDeletionListener = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_registerDeletionListener_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'registerDeletionListener', { get: PxControllerDesc.prototype.get_registerDeletionListener, set: PxControllerDesc.prototype.set_registerDeletionListener });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['get_userData'] = PxControllerDesc.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerDesc_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerDesc.prototype['set_userData'] = PxControllerDesc.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerDesc_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerDesc.prototype, 'userData', { get: PxControllerDesc.prototype.get_userData, set: PxControllerDesc.prototype.set_userData });

// Interface: PxControllerFilterCallback

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllerFilterCallback() { throw "cannot construct a PxControllerFilterCallback, no constructor in IDL" }
PxControllerFilterCallback.prototype = Object.create(WrapperObject.prototype);
PxControllerFilterCallback.prototype.constructor = PxControllerFilterCallback;
PxControllerFilterCallback.prototype.__class__ = PxControllerFilterCallback;
PxControllerFilterCallback.__cache__ = {};
Module['PxControllerFilterCallback'] = PxControllerFilterCallback;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerFilterCallback.prototype['filter'] = PxControllerFilterCallback.prototype.filter = function(a, b) {
  var self = this.ptr;
  if (a && typeof a === 'object') a = a.ptr;
  if (b && typeof b === 'object') b = b.ptr;
  return !!(_emscripten_bind_PxControllerFilterCallback_filter_2(self, a, b));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerFilterCallback.prototype['__destroy__'] = PxControllerFilterCallback.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxControllerFilterCallback___destroy___0(self);
};

// Interface: PxControllerHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllerHit() { throw "cannot construct a PxControllerHit, no constructor in IDL" }
PxControllerHit.prototype = Object.create(WrapperObject.prototype);
PxControllerHit.prototype.constructor = PxControllerHit;
PxControllerHit.prototype.__class__ = PxControllerHit;
PxControllerHit.__cache__ = {};
Module['PxControllerHit'] = PxControllerHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerHit.prototype['get_controller'] = PxControllerHit.prototype.get_controller = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerHit_get_controller_0(self), PxController);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerHit.prototype['set_controller'] = PxControllerHit.prototype.set_controller = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerHit_set_controller_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerHit.prototype, 'controller', { get: PxControllerHit.prototype.get_controller, set: PxControllerHit.prototype.set_controller });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerHit.prototype['get_worldPos'] = PxControllerHit.prototype.get_worldPos = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerHit_get_worldPos_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerHit.prototype['set_worldPos'] = PxControllerHit.prototype.set_worldPos = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerHit_set_worldPos_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerHit.prototype, 'worldPos', { get: PxControllerHit.prototype.get_worldPos, set: PxControllerHit.prototype.set_worldPos });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerHit.prototype['get_worldNormal'] = PxControllerHit.prototype.get_worldNormal = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerHit_get_worldNormal_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerHit.prototype['set_worldNormal'] = PxControllerHit.prototype.set_worldNormal = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerHit_set_worldNormal_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerHit.prototype, 'worldNormal', { get: PxControllerHit.prototype.get_worldNormal, set: PxControllerHit.prototype.set_worldNormal });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerHit.prototype['get_dir'] = PxControllerHit.prototype.get_dir = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerHit_get_dir_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerHit.prototype['set_dir'] = PxControllerHit.prototype.set_dir = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerHit_set_dir_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerHit.prototype, 'dir', { get: PxControllerHit.prototype.get_dir, set: PxControllerHit.prototype.set_dir });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerHit.prototype['get_length'] = PxControllerHit.prototype.get_length = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerHit_get_length_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerHit.prototype['set_length'] = PxControllerHit.prototype.set_length = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerHit_set_length_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerHit.prototype, 'length', { get: PxControllerHit.prototype.get_length, set: PxControllerHit.prototype.set_length });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerHit.prototype['__destroy__'] = PxControllerHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxControllerHit___destroy___0(self);
};

// Interface: PxCpuDispatcher

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxCpuDispatcher() { throw "cannot construct a PxCpuDispatcher, no constructor in IDL" }
PxCpuDispatcher.prototype = Object.create(WrapperObject.prototype);
PxCpuDispatcher.prototype.constructor = PxCpuDispatcher;
PxCpuDispatcher.prototype.__class__ = PxCpuDispatcher;
PxCpuDispatcher.__cache__ = {};
Module['PxCpuDispatcher'] = PxCpuDispatcher;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCpuDispatcher.prototype['__destroy__'] = PxCpuDispatcher.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxCpuDispatcher___destroy___0(self);
};

// Interface: PxErrorCallback

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxErrorCallback() { throw "cannot construct a PxErrorCallback, no constructor in IDL" }
PxErrorCallback.prototype = Object.create(WrapperObject.prototype);
PxErrorCallback.prototype.constructor = PxErrorCallback;
PxErrorCallback.prototype.__class__ = PxErrorCallback;
PxErrorCallback.__cache__ = {};
Module['PxErrorCallback'] = PxErrorCallback;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxErrorCallback.prototype['reportError'] = PxErrorCallback.prototype.reportError = function(code, message, file, line) {
  var self = this.ptr;
  ensureCache.prepare();
  if (code && typeof code === 'object') code = code.ptr;
  if (message && typeof message === 'object') message = message.ptr;
  else message = ensureString(message);
  if (file && typeof file === 'object') file = file.ptr;
  else file = ensureString(file);
  if (line && typeof line === 'object') line = line.ptr;
  _emscripten_bind_PxErrorCallback_reportError_4(self, code, message, file, line);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxErrorCallback.prototype['__destroy__'] = PxErrorCallback.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxErrorCallback___destroy___0(self);
};

// Interface: PxGeomRaycastHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxGeomRaycastHit() { throw "cannot construct a PxGeomRaycastHit, no constructor in IDL" }
PxGeomRaycastHit.prototype = Object.create(PxLocationHit.prototype);
PxGeomRaycastHit.prototype.constructor = PxGeomRaycastHit;
PxGeomRaycastHit.prototype.__class__ = PxGeomRaycastHit;
PxGeomRaycastHit.__cache__ = {};
Module['PxGeomRaycastHit'] = PxGeomRaycastHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['hadInitialOverlap'] = PxGeomRaycastHit.prototype.hadInitialOverlap = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxGeomRaycastHit_hadInitialOverlap_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['get_u'] = PxGeomRaycastHit.prototype.get_u = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGeomRaycastHit_get_u_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['set_u'] = PxGeomRaycastHit.prototype.set_u = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGeomRaycastHit_set_u_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGeomRaycastHit.prototype, 'u', { get: PxGeomRaycastHit.prototype.get_u, set: PxGeomRaycastHit.prototype.set_u });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['get_v'] = PxGeomRaycastHit.prototype.get_v = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGeomRaycastHit_get_v_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['set_v'] = PxGeomRaycastHit.prototype.set_v = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGeomRaycastHit_set_v_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGeomRaycastHit.prototype, 'v', { get: PxGeomRaycastHit.prototype.get_v, set: PxGeomRaycastHit.prototype.set_v });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['get_flags'] = PxGeomRaycastHit.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGeomRaycastHit_get_flags_0(self), PxHitFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['set_flags'] = PxGeomRaycastHit.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGeomRaycastHit_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGeomRaycastHit.prototype, 'flags', { get: PxGeomRaycastHit.prototype.get_flags, set: PxGeomRaycastHit.prototype.set_flags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['get_position'] = PxGeomRaycastHit.prototype.get_position = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGeomRaycastHit_get_position_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['set_position'] = PxGeomRaycastHit.prototype.set_position = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGeomRaycastHit_set_position_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGeomRaycastHit.prototype, 'position', { get: PxGeomRaycastHit.prototype.get_position, set: PxGeomRaycastHit.prototype.set_position });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['get_normal'] = PxGeomRaycastHit.prototype.get_normal = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGeomRaycastHit_get_normal_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['set_normal'] = PxGeomRaycastHit.prototype.set_normal = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGeomRaycastHit_set_normal_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGeomRaycastHit.prototype, 'normal', { get: PxGeomRaycastHit.prototype.get_normal, set: PxGeomRaycastHit.prototype.set_normal });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['get_distance'] = PxGeomRaycastHit.prototype.get_distance = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGeomRaycastHit_get_distance_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['set_distance'] = PxGeomRaycastHit.prototype.set_distance = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGeomRaycastHit_set_distance_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGeomRaycastHit.prototype, 'distance', { get: PxGeomRaycastHit.prototype.get_distance, set: PxGeomRaycastHit.prototype.set_distance });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['get_faceIndex'] = PxGeomRaycastHit.prototype.get_faceIndex = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGeomRaycastHit_get_faceIndex_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['set_faceIndex'] = PxGeomRaycastHit.prototype.set_faceIndex = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGeomRaycastHit_set_faceIndex_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGeomRaycastHit.prototype, 'faceIndex', { get: PxGeomRaycastHit.prototype.get_faceIndex, set: PxGeomRaycastHit.prototype.set_faceIndex });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomRaycastHit.prototype['__destroy__'] = PxGeomRaycastHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxGeomRaycastHit___destroy___0(self);
};

// Interface: PxGeomSweepHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxGeomSweepHit() { throw "cannot construct a PxGeomSweepHit, no constructor in IDL" }
PxGeomSweepHit.prototype = Object.create(PxLocationHit.prototype);
PxGeomSweepHit.prototype.constructor = PxGeomSweepHit;
PxGeomSweepHit.prototype.__class__ = PxGeomSweepHit;
PxGeomSweepHit.__cache__ = {};
Module['PxGeomSweepHit'] = PxGeomSweepHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomSweepHit.prototype['hadInitialOverlap'] = PxGeomSweepHit.prototype.hadInitialOverlap = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxGeomSweepHit_hadInitialOverlap_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomSweepHit.prototype['get_flags'] = PxGeomSweepHit.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGeomSweepHit_get_flags_0(self), PxHitFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomSweepHit.prototype['set_flags'] = PxGeomSweepHit.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGeomSweepHit_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGeomSweepHit.prototype, 'flags', { get: PxGeomSweepHit.prototype.get_flags, set: PxGeomSweepHit.prototype.set_flags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomSweepHit.prototype['get_position'] = PxGeomSweepHit.prototype.get_position = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGeomSweepHit_get_position_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomSweepHit.prototype['set_position'] = PxGeomSweepHit.prototype.set_position = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGeomSweepHit_set_position_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGeomSweepHit.prototype, 'position', { get: PxGeomSweepHit.prototype.get_position, set: PxGeomSweepHit.prototype.set_position });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomSweepHit.prototype['get_normal'] = PxGeomSweepHit.prototype.get_normal = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGeomSweepHit_get_normal_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomSweepHit.prototype['set_normal'] = PxGeomSweepHit.prototype.set_normal = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGeomSweepHit_set_normal_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGeomSweepHit.prototype, 'normal', { get: PxGeomSweepHit.prototype.get_normal, set: PxGeomSweepHit.prototype.set_normal });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomSweepHit.prototype['get_distance'] = PxGeomSweepHit.prototype.get_distance = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGeomSweepHit_get_distance_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomSweepHit.prototype['set_distance'] = PxGeomSweepHit.prototype.set_distance = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGeomSweepHit_set_distance_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGeomSweepHit.prototype, 'distance', { get: PxGeomSweepHit.prototype.get_distance, set: PxGeomSweepHit.prototype.set_distance });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomSweepHit.prototype['get_faceIndex'] = PxGeomSweepHit.prototype.get_faceIndex = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGeomSweepHit_get_faceIndex_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomSweepHit.prototype['set_faceIndex'] = PxGeomSweepHit.prototype.set_faceIndex = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGeomSweepHit_set_faceIndex_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGeomSweepHit.prototype, 'faceIndex', { get: PxGeomSweepHit.prototype.get_faceIndex, set: PxGeomSweepHit.prototype.set_faceIndex });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeomSweepHit.prototype['__destroy__'] = PxGeomSweepHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxGeomSweepHit___destroy___0(self);
};

// Interface: PxGeometry

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxGeometry() { throw "cannot construct a PxGeometry, no constructor in IDL" }
PxGeometry.prototype = Object.create(WrapperObject.prototype);
PxGeometry.prototype.constructor = PxGeometry;
PxGeometry.prototype.__class__ = PxGeometry;
PxGeometry.__cache__ = {};
Module['PxGeometry'] = PxGeometry;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometry.prototype['getType'] = PxGeometry.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGeometry_getType_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometry.prototype['__destroy__'] = PxGeometry.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxGeometry___destroy___0(self);
};

// Interface: PxI32ConstPtr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxI32ConstPtr() { throw "cannot construct a PxI32ConstPtr, no constructor in IDL" }
PxI32ConstPtr.prototype = Object.create(WrapperObject.prototype);
PxI32ConstPtr.prototype.constructor = PxI32ConstPtr;
PxI32ConstPtr.prototype.__class__ = PxI32ConstPtr;
PxI32ConstPtr.__cache__ = {};
Module['PxI32ConstPtr'] = PxI32ConstPtr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxI32ConstPtr.prototype['__destroy__'] = PxI32ConstPtr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxI32ConstPtr___destroy___0(self);
};

// Interface: PxInputData

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxInputData() { throw "cannot construct a PxInputData, no constructor in IDL" }
PxInputData.prototype = Object.create(WrapperObject.prototype);
PxInputData.prototype.constructor = PxInputData;
PxInputData.prototype.__class__ = PxInputData;
PxInputData.__cache__ = {};
Module['PxInputData'] = PxInputData;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxInputData.prototype['__destroy__'] = PxInputData.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxInputData___destroy___0(self);
};

// Interface: PxJoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxJoint() { throw "cannot construct a PxJoint, no constructor in IDL" }
PxJoint.prototype = Object.create(PxBase.prototype);
PxJoint.prototype.constructor = PxJoint;
PxJoint.prototype.__class__ = PxJoint;
PxJoint.__cache__ = {};
Module['PxJoint'] = PxJoint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['setActors'] = PxJoint.prototype.setActors = function(actor0, actor1) {
  var self = this.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  _emscripten_bind_PxJoint_setActors_2(self, actor0, actor1);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['setLocalPose'] = PxJoint.prototype.setLocalPose = function(actor, localPose) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (localPose && typeof localPose === 'object') localPose = localPose.ptr;
  _emscripten_bind_PxJoint_setLocalPose_2(self, actor, localPose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getLocalPose'] = PxJoint.prototype.getLocalPose = function(actor) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return wrapPointer(_emscripten_bind_PxJoint_getLocalPose_1(self, actor), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getRelativeTransform'] = PxJoint.prototype.getRelativeTransform = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxJoint_getRelativeTransform_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getRelativeLinearVelocity'] = PxJoint.prototype.getRelativeLinearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxJoint_getRelativeLinearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getRelativeAngularVelocity'] = PxJoint.prototype.getRelativeAngularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxJoint_getRelativeAngularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['setBreakForce'] = PxJoint.prototype.setBreakForce = function(force, torque) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  _emscripten_bind_PxJoint_setBreakForce_2(self, force, torque);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['setConstraintFlags'] = PxJoint.prototype.setConstraintFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxJoint_setConstraintFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['setConstraintFlag'] = PxJoint.prototype.setConstraintFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxJoint_setConstraintFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getConstraintFlags'] = PxJoint.prototype.getConstraintFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxJoint_getConstraintFlags_0(self), PxConstraintFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['setInvMassScale0'] = PxJoint.prototype.setInvMassScale0 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxJoint_setInvMassScale0_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getInvMassScale0'] = PxJoint.prototype.getInvMassScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJoint_getInvMassScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['setInvMassScale1'] = PxJoint.prototype.setInvMassScale1 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxJoint_setInvMassScale1_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getInvMassScale1'] = PxJoint.prototype.getInvMassScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJoint_getInvMassScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['setInvInertiaScale0'] = PxJoint.prototype.setInvInertiaScale0 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxJoint_setInvInertiaScale0_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getInvInertiaScale0'] = PxJoint.prototype.getInvInertiaScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJoint_getInvInertiaScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['setInvInertiaScale1'] = PxJoint.prototype.setInvInertiaScale1 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxJoint_setInvInertiaScale1_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getInvInertiaScale1'] = PxJoint.prototype.getInvInertiaScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJoint_getInvInertiaScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getConstraint'] = PxJoint.prototype.getConstraint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxJoint_getConstraint_0(self), PxConstraint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['setName'] = PxJoint.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxJoint_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getName'] = PxJoint.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxJoint_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getScene'] = PxJoint.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxJoint_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['release'] = PxJoint.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxJoint_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getConcreteTypeName'] = PxJoint.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxJoint_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getConcreteType'] = PxJoint.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJoint_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['setBaseFlag'] = PxJoint.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxJoint_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['setBaseFlags'] = PxJoint.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxJoint_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['getBaseFlags'] = PxJoint.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxJoint_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['isReleasable'] = PxJoint.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxJoint_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['get_userData'] = PxJoint.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxJoint_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJoint.prototype['set_userData'] = PxJoint.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJoint_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJoint.prototype, 'userData', { get: PxJoint.prototype.get_userData, set: PxJoint.prototype.set_userData });

// Interface: PxJointLimitParameters

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxJointLimitParameters() { throw "cannot construct a PxJointLimitParameters, no constructor in IDL" }
PxJointLimitParameters.prototype = Object.create(WrapperObject.prototype);
PxJointLimitParameters.prototype.constructor = PxJointLimitParameters;
PxJointLimitParameters.prototype.__class__ = PxJointLimitParameters;
PxJointLimitParameters.__cache__ = {};
Module['PxJointLimitParameters'] = PxJointLimitParameters;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitParameters.prototype['isValid'] = PxJointLimitParameters.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxJointLimitParameters_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitParameters.prototype['isSoft'] = PxJointLimitParameters.prototype.isSoft = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxJointLimitParameters_isSoft_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitParameters.prototype['get_restitution'] = PxJointLimitParameters.prototype.get_restitution = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitParameters_get_restitution_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitParameters.prototype['set_restitution'] = PxJointLimitParameters.prototype.set_restitution = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitParameters_set_restitution_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitParameters.prototype, 'restitution', { get: PxJointLimitParameters.prototype.get_restitution, set: PxJointLimitParameters.prototype.set_restitution });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitParameters.prototype['get_bounceThreshold'] = PxJointLimitParameters.prototype.get_bounceThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitParameters_get_bounceThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitParameters.prototype['set_bounceThreshold'] = PxJointLimitParameters.prototype.set_bounceThreshold = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitParameters_set_bounceThreshold_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitParameters.prototype, 'bounceThreshold', { get: PxJointLimitParameters.prototype.get_bounceThreshold, set: PxJointLimitParameters.prototype.set_bounceThreshold });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitParameters.prototype['get_stiffness'] = PxJointLimitParameters.prototype.get_stiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitParameters_get_stiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitParameters.prototype['set_stiffness'] = PxJointLimitParameters.prototype.set_stiffness = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitParameters_set_stiffness_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitParameters.prototype, 'stiffness', { get: PxJointLimitParameters.prototype.get_stiffness, set: PxJointLimitParameters.prototype.set_stiffness });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitParameters.prototype['get_damping'] = PxJointLimitParameters.prototype.get_damping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitParameters_get_damping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitParameters.prototype['set_damping'] = PxJointLimitParameters.prototype.set_damping = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitParameters_set_damping_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitParameters.prototype, 'damping', { get: PxJointLimitParameters.prototype.get_damping, set: PxJointLimitParameters.prototype.set_damping });

// Interface: PxObstacle

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxObstacle() { throw "cannot construct a PxObstacle, no constructor in IDL" }
PxObstacle.prototype = Object.create(WrapperObject.prototype);
PxObstacle.prototype.constructor = PxObstacle;
PxObstacle.prototype.__class__ = PxObstacle;
PxObstacle.__cache__ = {};
Module['PxObstacle'] = PxObstacle;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacle.prototype['getType'] = PxObstacle.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxObstacle_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacle.prototype['get_mUserData'] = PxObstacle.prototype.get_mUserData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxObstacle_get_mUserData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacle.prototype['set_mUserData'] = PxObstacle.prototype.set_mUserData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxObstacle_set_mUserData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxObstacle.prototype, 'mUserData', { get: PxObstacle.prototype.get_mUserData, set: PxObstacle.prototype.set_mUserData });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacle.prototype['get_mPos'] = PxObstacle.prototype.get_mPos = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxObstacle_get_mPos_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacle.prototype['set_mPos'] = PxObstacle.prototype.set_mPos = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxObstacle_set_mPos_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxObstacle.prototype, 'mPos', { get: PxObstacle.prototype.get_mPos, set: PxObstacle.prototype.set_mPos });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacle.prototype['get_mRot'] = PxObstacle.prototype.get_mRot = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxObstacle_get_mRot_0(self), PxQuat);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacle.prototype['set_mRot'] = PxObstacle.prototype.set_mRot = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxObstacle_set_mRot_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxObstacle.prototype, 'mRot', { get: PxObstacle.prototype.get_mRot, set: PxObstacle.prototype.set_mRot });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacle.prototype['__destroy__'] = PxObstacle.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxObstacle___destroy___0(self);
};

// Interface: PxOutputStream

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxOutputStream() { throw "cannot construct a PxOutputStream, no constructor in IDL" }
PxOutputStream.prototype = Object.create(WrapperObject.prototype);
PxOutputStream.prototype.constructor = PxOutputStream;
PxOutputStream.prototype.__class__ = PxOutputStream;
PxOutputStream.__cache__ = {};
Module['PxOutputStream'] = PxOutputStream;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOutputStream.prototype['__destroy__'] = PxOutputStream.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxOutputStream___destroy___0(self);
};

// Interface: PxOverlapCallback

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxOverlapCallback() { throw "cannot construct a PxOverlapCallback, no constructor in IDL" }
PxOverlapCallback.prototype = Object.create(WrapperObject.prototype);
PxOverlapCallback.prototype.constructor = PxOverlapCallback;
PxOverlapCallback.prototype.__class__ = PxOverlapCallback;
PxOverlapCallback.__cache__ = {};
Module['PxOverlapCallback'] = PxOverlapCallback;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapCallback.prototype['hasAnyHits'] = PxOverlapCallback.prototype.hasAnyHits = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxOverlapCallback_hasAnyHits_0(self));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapCallback.prototype['__destroy__'] = PxOverlapCallback.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxOverlapCallback___destroy___0(self);
};

// Interface: PxRaycastCallback

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRaycastCallback() { throw "cannot construct a PxRaycastCallback, no constructor in IDL" }
PxRaycastCallback.prototype = Object.create(WrapperObject.prototype);
PxRaycastCallback.prototype.constructor = PxRaycastCallback;
PxRaycastCallback.prototype.__class__ = PxRaycastCallback;
PxRaycastCallback.__cache__ = {};
Module['PxRaycastCallback'] = PxRaycastCallback;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastCallback.prototype['hasAnyHits'] = PxRaycastCallback.prototype.hasAnyHits = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRaycastCallback_hasAnyHits_0(self));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastCallback.prototype['__destroy__'] = PxRaycastCallback.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxRaycastCallback___destroy___0(self);
};

// Interface: PxRealConstPtr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRealConstPtr() { throw "cannot construct a PxRealConstPtr, no constructor in IDL" }
PxRealConstPtr.prototype = Object.create(WrapperObject.prototype);
PxRealConstPtr.prototype.constructor = PxRealConstPtr;
PxRealConstPtr.prototype.__class__ = PxRealConstPtr;
PxRealConstPtr.__cache__ = {};
Module['PxRealConstPtr'] = PxRealConstPtr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRealConstPtr.prototype['__destroy__'] = PxRealConstPtr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxRealConstPtr___destroy___0(self);
};

// Interface: PxRigidBody

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRigidBody() { throw "cannot construct a PxRigidBody, no constructor in IDL" }
PxRigidBody.prototype = Object.create(PxRigidActor.prototype);
PxRigidBody.prototype.constructor = PxRigidBody;
PxRigidBody.prototype.__class__ = PxRigidBody;
PxRigidBody.__cache__ = {};
Module['PxRigidBody'] = PxRigidBody;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setCMassLocalPose'] = PxRigidBody.prototype.setCMassLocalPose = function(pose) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  _emscripten_bind_PxRigidBody_setCMassLocalPose_1(self, pose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getCMassLocalPose'] = PxRigidBody.prototype.getCMassLocalPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidBody_getCMassLocalPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setMass'] = PxRigidBody.prototype.setMass = function(mass) {
  var self = this.ptr;
  if (mass && typeof mass === 'object') mass = mass.ptr;
  _emscripten_bind_PxRigidBody_setMass_1(self, mass);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getMass'] = PxRigidBody.prototype.getMass = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getMass_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getInvMass'] = PxRigidBody.prototype.getInvMass = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getInvMass_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setMassSpaceInertiaTensor'] = PxRigidBody.prototype.setMassSpaceInertiaTensor = function(m) {
  var self = this.ptr;
  if (m && typeof m === 'object') m = m.ptr;
  _emscripten_bind_PxRigidBody_setMassSpaceInertiaTensor_1(self, m);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getMassSpaceInertiaTensor'] = PxRigidBody.prototype.getMassSpaceInertiaTensor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidBody_getMassSpaceInertiaTensor_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getMassSpaceInvInertiaTensor'] = PxRigidBody.prototype.getMassSpaceInvInertiaTensor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidBody_getMassSpaceInvInertiaTensor_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setLinearDamping'] = PxRigidBody.prototype.setLinearDamping = function(linDamp) {
  var self = this.ptr;
  if (linDamp && typeof linDamp === 'object') linDamp = linDamp.ptr;
  _emscripten_bind_PxRigidBody_setLinearDamping_1(self, linDamp);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getLinearDamping'] = PxRigidBody.prototype.getLinearDamping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getLinearDamping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setAngularDamping'] = PxRigidBody.prototype.setAngularDamping = function(angDamp) {
  var self = this.ptr;
  if (angDamp && typeof angDamp === 'object') angDamp = angDamp.ptr;
  _emscripten_bind_PxRigidBody_setAngularDamping_1(self, angDamp);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getAngularDamping'] = PxRigidBody.prototype.getAngularDamping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getAngularDamping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getLinearVelocity'] = PxRigidBody.prototype.getLinearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidBody_getLinearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getAngularVelocity'] = PxRigidBody.prototype.getAngularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidBody_getAngularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setMaxLinearVelocity'] = PxRigidBody.prototype.setMaxLinearVelocity = function(maxLinVel) {
  var self = this.ptr;
  if (maxLinVel && typeof maxLinVel === 'object') maxLinVel = maxLinVel.ptr;
  _emscripten_bind_PxRigidBody_setMaxLinearVelocity_1(self, maxLinVel);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getMaxLinearVelocity'] = PxRigidBody.prototype.getMaxLinearVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getMaxLinearVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setMaxAngularVelocity'] = PxRigidBody.prototype.setMaxAngularVelocity = function(maxAngVel) {
  var self = this.ptr;
  if (maxAngVel && typeof maxAngVel === 'object') maxAngVel = maxAngVel.ptr;
  _emscripten_bind_PxRigidBody_setMaxAngularVelocity_1(self, maxAngVel);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getMaxAngularVelocity'] = PxRigidBody.prototype.getMaxAngularVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getMaxAngularVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['addForce'] = PxRigidBody.prototype.addForce = function(force, mode, autowake) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (mode === undefined) { _emscripten_bind_PxRigidBody_addForce_1(self, force); return }
  if (autowake === undefined) { _emscripten_bind_PxRigidBody_addForce_2(self, force, mode); return }
  _emscripten_bind_PxRigidBody_addForce_3(self, force, mode, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['addTorque'] = PxRigidBody.prototype.addTorque = function(torque, mode, autowake) {
  var self = this.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (mode === undefined) { _emscripten_bind_PxRigidBody_addTorque_1(self, torque); return }
  if (autowake === undefined) { _emscripten_bind_PxRigidBody_addTorque_2(self, torque, mode); return }
  _emscripten_bind_PxRigidBody_addTorque_3(self, torque, mode, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['clearForce'] = PxRigidBody.prototype.clearForce = function(mode) {
  var self = this.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  _emscripten_bind_PxRigidBody_clearForce_1(self, mode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['clearTorque'] = PxRigidBody.prototype.clearTorque = function(mode) {
  var self = this.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  _emscripten_bind_PxRigidBody_clearTorque_1(self, mode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setForceAndTorque'] = PxRigidBody.prototype.setForceAndTorque = function(force, torque, mode) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  if (mode === undefined) { _emscripten_bind_PxRigidBody_setForceAndTorque_2(self, force, torque); return }
  _emscripten_bind_PxRigidBody_setForceAndTorque_3(self, force, torque, mode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setRigidBodyFlag'] = PxRigidBody.prototype.setRigidBodyFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRigidBody_setRigidBodyFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setRigidBodyFlags'] = PxRigidBody.prototype.setRigidBodyFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxRigidBody_setRigidBodyFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getRigidBodyFlags'] = PxRigidBody.prototype.getRigidBodyFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidBody_getRigidBodyFlags_0(self), PxRigidBodyFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setMinCCDAdvanceCoefficient'] = PxRigidBody.prototype.setMinCCDAdvanceCoefficient = function(advanceCoefficient) {
  var self = this.ptr;
  if (advanceCoefficient && typeof advanceCoefficient === 'object') advanceCoefficient = advanceCoefficient.ptr;
  _emscripten_bind_PxRigidBody_setMinCCDAdvanceCoefficient_1(self, advanceCoefficient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getMinCCDAdvanceCoefficient'] = PxRigidBody.prototype.getMinCCDAdvanceCoefficient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getMinCCDAdvanceCoefficient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setMaxDepenetrationVelocity'] = PxRigidBody.prototype.setMaxDepenetrationVelocity = function(biasClamp) {
  var self = this.ptr;
  if (biasClamp && typeof biasClamp === 'object') biasClamp = biasClamp.ptr;
  _emscripten_bind_PxRigidBody_setMaxDepenetrationVelocity_1(self, biasClamp);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getMaxDepenetrationVelocity'] = PxRigidBody.prototype.getMaxDepenetrationVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getMaxDepenetrationVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setMaxContactImpulse'] = PxRigidBody.prototype.setMaxContactImpulse = function(maxImpulse) {
  var self = this.ptr;
  if (maxImpulse && typeof maxImpulse === 'object') maxImpulse = maxImpulse.ptr;
  _emscripten_bind_PxRigidBody_setMaxContactImpulse_1(self, maxImpulse);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getMaxContactImpulse'] = PxRigidBody.prototype.getMaxContactImpulse = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getMaxContactImpulse_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setContactSlopCoefficient'] = PxRigidBody.prototype.setContactSlopCoefficient = function(slopCoefficient) {
  var self = this.ptr;
  if (slopCoefficient && typeof slopCoefficient === 'object') slopCoefficient = slopCoefficient.ptr;
  _emscripten_bind_PxRigidBody_setContactSlopCoefficient_1(self, slopCoefficient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getContactSlopCoefficient'] = PxRigidBody.prototype.getContactSlopCoefficient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getContactSlopCoefficient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getType'] = PxRigidBody.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getScene'] = PxRigidBody.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidBody_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setName'] = PxRigidBody.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxRigidBody_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getName'] = PxRigidBody.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxRigidBody_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getWorldBounds'] = PxRigidBody.prototype.getWorldBounds = function(inflation) {
  var self = this.ptr;
  if (inflation && typeof inflation === 'object') inflation = inflation.ptr;
  if (inflation === undefined) { return wrapPointer(_emscripten_bind_PxRigidBody_getWorldBounds_0(self), PxBounds3) }
  return wrapPointer(_emscripten_bind_PxRigidBody_getWorldBounds_1(self, inflation), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setActorFlag'] = PxRigidBody.prototype.setActorFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRigidBody_setActorFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setActorFlags'] = PxRigidBody.prototype.setActorFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxRigidBody_setActorFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getActorFlags'] = PxRigidBody.prototype.getActorFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidBody_getActorFlags_0(self), PxActorFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setDominanceGroup'] = PxRigidBody.prototype.setDominanceGroup = function(dominanceGroup) {
  var self = this.ptr;
  if (dominanceGroup && typeof dominanceGroup === 'object') dominanceGroup = dominanceGroup.ptr;
  _emscripten_bind_PxRigidBody_setDominanceGroup_1(self, dominanceGroup);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getDominanceGroup'] = PxRigidBody.prototype.getDominanceGroup = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getDominanceGroup_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setOwnerClient'] = PxRigidBody.prototype.setOwnerClient = function(inClient) {
  var self = this.ptr;
  if (inClient && typeof inClient === 'object') inClient = inClient.ptr;
  _emscripten_bind_PxRigidBody_setOwnerClient_1(self, inClient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getOwnerClient'] = PxRigidBody.prototype.getOwnerClient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getOwnerClient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['release'] = PxRigidBody.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxRigidBody_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getConcreteTypeName'] = PxRigidBody.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxRigidBody_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getConcreteType'] = PxRigidBody.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setBaseFlag'] = PxRigidBody.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRigidBody_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setBaseFlags'] = PxRigidBody.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxRigidBody_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getBaseFlags'] = PxRigidBody.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidBody_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['isReleasable'] = PxRigidBody.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRigidBody_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getGlobalPose'] = PxRigidBody.prototype.getGlobalPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidBody_getGlobalPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['setGlobalPose'] = PxRigidBody.prototype.setGlobalPose = function(pose, autowake) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxRigidBody_setGlobalPose_1(self, pose); return }
  _emscripten_bind_PxRigidBody_setGlobalPose_2(self, pose, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['attachShape'] = PxRigidBody.prototype.attachShape = function(shape) {
  var self = this.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  return !!(_emscripten_bind_PxRigidBody_attachShape_1(self, shape));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['detachShape'] = PxRigidBody.prototype.detachShape = function(shape, wakeOnLostTouch) {
  var self = this.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (wakeOnLostTouch && typeof wakeOnLostTouch === 'object') wakeOnLostTouch = wakeOnLostTouch.ptr;
  if (wakeOnLostTouch === undefined) { _emscripten_bind_PxRigidBody_detachShape_1(self, shape); return }
  _emscripten_bind_PxRigidBody_detachShape_2(self, shape, wakeOnLostTouch);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getNbShapes'] = PxRigidBody.prototype.getNbShapes = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getNbShapes_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getShapes'] = PxRigidBody.prototype.getShapes = function(userBuffer, bufferSize, startIndex) {
  var self = this.ptr;
  if (userBuffer && typeof userBuffer === 'object') userBuffer = userBuffer.ptr;
  if (bufferSize && typeof bufferSize === 'object') bufferSize = bufferSize.ptr;
  if (startIndex && typeof startIndex === 'object') startIndex = startIndex.ptr;
  return _emscripten_bind_PxRigidBody_getShapes_3(self, userBuffer, bufferSize, startIndex);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['getNbConstraints'] = PxRigidBody.prototype.getNbConstraints = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidBody_getNbConstraints_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['get_userData'] = PxRigidBody.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidBody_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBody.prototype['set_userData'] = PxRigidBody.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRigidBody_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRigidBody.prototype, 'userData', { get: PxRigidBody.prototype.get_userData, set: PxRigidBody.prototype.set_userData });

// Interface: PxSceneSQSystem

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSceneSQSystem() { throw "cannot construct a PxSceneSQSystem, no constructor in IDL" }
PxSceneSQSystem.prototype = Object.create(PxSceneQuerySystemBase.prototype);
PxSceneSQSystem.prototype.constructor = PxSceneSQSystem;
PxSceneSQSystem.prototype.__class__ = PxSceneSQSystem;
PxSceneSQSystem.__cache__ = {};
Module['PxSceneSQSystem'] = PxSceneSQSystem;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['setSceneQueryUpdateMode'] = PxSceneSQSystem.prototype.setSceneQueryUpdateMode = function(updateMode) {
  var self = this.ptr;
  if (updateMode && typeof updateMode === 'object') updateMode = updateMode.ptr;
  _emscripten_bind_PxSceneSQSystem_setSceneQueryUpdateMode_1(self, updateMode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['getSceneQueryUpdateMode'] = PxSceneSQSystem.prototype.getSceneQueryUpdateMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneSQSystem_getSceneQueryUpdateMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['getSceneQueryStaticTimestamp'] = PxSceneSQSystem.prototype.getSceneQueryStaticTimestamp = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneSQSystem_getSceneQueryStaticTimestamp_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['flushQueryUpdates'] = PxSceneSQSystem.prototype.flushQueryUpdates = function() {
  var self = this.ptr;
  _emscripten_bind_PxSceneSQSystem_flushQueryUpdates_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['forceDynamicTreeRebuild'] = PxSceneSQSystem.prototype.forceDynamicTreeRebuild = function(rebuildStaticStructure, rebuildDynamicStructure) {
  var self = this.ptr;
  if (rebuildStaticStructure && typeof rebuildStaticStructure === 'object') rebuildStaticStructure = rebuildStaticStructure.ptr;
  if (rebuildDynamicStructure && typeof rebuildDynamicStructure === 'object') rebuildDynamicStructure = rebuildDynamicStructure.ptr;
  _emscripten_bind_PxSceneSQSystem_forceDynamicTreeRebuild_2(self, rebuildStaticStructure, rebuildDynamicStructure);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['getStaticStructure'] = PxSceneSQSystem.prototype.getStaticStructure = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneSQSystem_getStaticStructure_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['getDynamicStructure'] = PxSceneSQSystem.prototype.getDynamicStructure = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneSQSystem_getDynamicStructure_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['sceneQueriesUpdate'] = PxSceneSQSystem.prototype.sceneQueriesUpdate = function(completionTask, controlSimulation) {
  var self = this.ptr;
  if (completionTask && typeof completionTask === 'object') completionTask = completionTask.ptr;
  if (controlSimulation && typeof controlSimulation === 'object') controlSimulation = controlSimulation.ptr;
  if (completionTask === undefined) { _emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_0(self); return }
  if (controlSimulation === undefined) { _emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_1(self, completionTask); return }
  _emscripten_bind_PxSceneSQSystem_sceneQueriesUpdate_2(self, completionTask, controlSimulation);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['checkQueries'] = PxSceneSQSystem.prototype.checkQueries = function(block) {
  var self = this.ptr;
  if (block && typeof block === 'object') block = block.ptr;
  if (block === undefined) { return !!(_emscripten_bind_PxSceneSQSystem_checkQueries_0(self)) }
  return !!(_emscripten_bind_PxSceneSQSystem_checkQueries_1(self, block));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['fetchQueries'] = PxSceneSQSystem.prototype.fetchQueries = function(block) {
  var self = this.ptr;
  if (block && typeof block === 'object') block = block.ptr;
  if (block === undefined) { return !!(_emscripten_bind_PxSceneSQSystem_fetchQueries_0(self)) }
  return !!(_emscripten_bind_PxSceneSQSystem_fetchQueries_1(self, block));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['setDynamicTreeRebuildRateHint'] = PxSceneSQSystem.prototype.setDynamicTreeRebuildRateHint = function(dynamicTreeRebuildRateHint) {
  var self = this.ptr;
  if (dynamicTreeRebuildRateHint && typeof dynamicTreeRebuildRateHint === 'object') dynamicTreeRebuildRateHint = dynamicTreeRebuildRateHint.ptr;
  _emscripten_bind_PxSceneSQSystem_setDynamicTreeRebuildRateHint_1(self, dynamicTreeRebuildRateHint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['getDynamicTreeRebuildRateHint'] = PxSceneSQSystem.prototype.getDynamicTreeRebuildRateHint = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneSQSystem_getDynamicTreeRebuildRateHint_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['forceRebuildDynamicTree'] = PxSceneSQSystem.prototype.forceRebuildDynamicTree = function(prunerIndex) {
  var self = this.ptr;
  if (prunerIndex && typeof prunerIndex === 'object') prunerIndex = prunerIndex.ptr;
  _emscripten_bind_PxSceneSQSystem_forceRebuildDynamicTree_1(self, prunerIndex);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['setUpdateMode'] = PxSceneSQSystem.prototype.setUpdateMode = function(updateMode) {
  var self = this.ptr;
  if (updateMode && typeof updateMode === 'object') updateMode = updateMode.ptr;
  _emscripten_bind_PxSceneSQSystem_setUpdateMode_1(self, updateMode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['getUpdateMode'] = PxSceneSQSystem.prototype.getUpdateMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneSQSystem_getUpdateMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['getStaticTimestamp'] = PxSceneSQSystem.prototype.getStaticTimestamp = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneSQSystem_getStaticTimestamp_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['flushUpdates'] = PxSceneSQSystem.prototype.flushUpdates = function() {
  var self = this.ptr;
  _emscripten_bind_PxSceneSQSystem_flushUpdates_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['raycast'] = PxSceneSQSystem.prototype.raycast = function(origin, unitDir, distance, hitCall, hitFlags, filterData) {
  var self = this.ptr;
  if (origin && typeof origin === 'object') origin = origin.ptr;
  if (unitDir && typeof unitDir === 'object') unitDir = unitDir.ptr;
  if (distance && typeof distance === 'object') distance = distance.ptr;
  if (hitCall && typeof hitCall === 'object') hitCall = hitCall.ptr;
  if (hitFlags && typeof hitFlags === 'object') hitFlags = hitFlags.ptr;
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  if (hitFlags === undefined) { return !!(_emscripten_bind_PxSceneSQSystem_raycast_4(self, origin, unitDir, distance, hitCall)) }
  if (filterData === undefined) { return !!(_emscripten_bind_PxSceneSQSystem_raycast_5(self, origin, unitDir, distance, hitCall, hitFlags)) }
  return !!(_emscripten_bind_PxSceneSQSystem_raycast_6(self, origin, unitDir, distance, hitCall, hitFlags, filterData));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['sweep'] = PxSceneSQSystem.prototype.sweep = function(geometry, pose, unitDir, distance, hitCall, hitFlags, filterData) {
  var self = this.ptr;
  if (geometry && typeof geometry === 'object') geometry = geometry.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (unitDir && typeof unitDir === 'object') unitDir = unitDir.ptr;
  if (distance && typeof distance === 'object') distance = distance.ptr;
  if (hitCall && typeof hitCall === 'object') hitCall = hitCall.ptr;
  if (hitFlags && typeof hitFlags === 'object') hitFlags = hitFlags.ptr;
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  if (hitFlags === undefined) { return !!(_emscripten_bind_PxSceneSQSystem_sweep_5(self, geometry, pose, unitDir, distance, hitCall)) }
  if (filterData === undefined) { return !!(_emscripten_bind_PxSceneSQSystem_sweep_6(self, geometry, pose, unitDir, distance, hitCall, hitFlags)) }
  return !!(_emscripten_bind_PxSceneSQSystem_sweep_7(self, geometry, pose, unitDir, distance, hitCall, hitFlags, filterData));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneSQSystem.prototype['overlap'] = PxSceneSQSystem.prototype.overlap = function(geometry, pose, hitCall, filterData) {
  var self = this.ptr;
  if (geometry && typeof geometry === 'object') geometry = geometry.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (hitCall && typeof hitCall === 'object') hitCall = hitCall.ptr;
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  if (filterData === undefined) { return !!(_emscripten_bind_PxSceneSQSystem_overlap_3(self, geometry, pose, hitCall)) }
  return !!(_emscripten_bind_PxSceneSQSystem_overlap_4(self, geometry, pose, hitCall, filterData));
};


// Interface: PxSimpleTriangleMesh

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSimpleTriangleMesh() {
  this.ptr = _emscripten_bind_PxSimpleTriangleMesh_PxSimpleTriangleMesh_0();
  getCache(PxSimpleTriangleMesh)[this.ptr] = this;
};

PxSimpleTriangleMesh.prototype = Object.create(WrapperObject.prototype);
PxSimpleTriangleMesh.prototype.constructor = PxSimpleTriangleMesh;
PxSimpleTriangleMesh.prototype.__class__ = PxSimpleTriangleMesh;
PxSimpleTriangleMesh.__cache__ = {};
Module['PxSimpleTriangleMesh'] = PxSimpleTriangleMesh;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimpleTriangleMesh.prototype['setToDefault'] = PxSimpleTriangleMesh.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxSimpleTriangleMesh_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimpleTriangleMesh.prototype['isValid'] = PxSimpleTriangleMesh.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxSimpleTriangleMesh_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimpleTriangleMesh.prototype['get_points'] = PxSimpleTriangleMesh.prototype.get_points = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSimpleTriangleMesh_get_points_0(self), PxBoundedData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimpleTriangleMesh.prototype['set_points'] = PxSimpleTriangleMesh.prototype.set_points = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimpleTriangleMesh_set_points_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimpleTriangleMesh.prototype, 'points', { get: PxSimpleTriangleMesh.prototype.get_points, set: PxSimpleTriangleMesh.prototype.set_points });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimpleTriangleMesh.prototype['get_triangles'] = PxSimpleTriangleMesh.prototype.get_triangles = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSimpleTriangleMesh_get_triangles_0(self), PxBoundedData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimpleTriangleMesh.prototype['set_triangles'] = PxSimpleTriangleMesh.prototype.set_triangles = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimpleTriangleMesh_set_triangles_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimpleTriangleMesh.prototype, 'triangles', { get: PxSimpleTriangleMesh.prototype.get_triangles, set: PxSimpleTriangleMesh.prototype.set_triangles });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimpleTriangleMesh.prototype['get_flags'] = PxSimpleTriangleMesh.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSimpleTriangleMesh_get_flags_0(self), PxMeshFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimpleTriangleMesh.prototype['set_flags'] = PxSimpleTriangleMesh.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimpleTriangleMesh_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimpleTriangleMesh.prototype, 'flags', { get: PxSimpleTriangleMesh.prototype.get_flags, set: PxSimpleTriangleMesh.prototype.set_flags });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimpleTriangleMesh.prototype['__destroy__'] = PxSimpleTriangleMesh.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSimpleTriangleMesh___destroy___0(self);
};

// Interface: PxSpring

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSpring(stiffness, damping) {
  if (stiffness && typeof stiffness === 'object') stiffness = stiffness.ptr;
  if (damping && typeof damping === 'object') damping = damping.ptr;
  this.ptr = _emscripten_bind_PxSpring_PxSpring_2(stiffness, damping);
  getCache(PxSpring)[this.ptr] = this;
};

PxSpring.prototype = Object.create(WrapperObject.prototype);
PxSpring.prototype.constructor = PxSpring;
PxSpring.prototype.__class__ = PxSpring;
PxSpring.__cache__ = {};
Module['PxSpring'] = PxSpring;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpring.prototype['get_stiffness'] = PxSpring.prototype.get_stiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSpring_get_stiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpring.prototype['set_stiffness'] = PxSpring.prototype.set_stiffness = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSpring_set_stiffness_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSpring.prototype, 'stiffness', { get: PxSpring.prototype.get_stiffness, set: PxSpring.prototype.set_stiffness });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpring.prototype['get_damping'] = PxSpring.prototype.get_damping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSpring_get_damping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpring.prototype['set_damping'] = PxSpring.prototype.set_damping = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSpring_set_damping_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSpring.prototype, 'damping', { get: PxSpring.prototype.get_damping, set: PxSpring.prototype.set_damping });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpring.prototype['__destroy__'] = PxSpring.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSpring___destroy___0(self);
};

// Interface: PxStridedData

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxStridedData() { throw "cannot construct a PxStridedData, no constructor in IDL" }
PxStridedData.prototype = Object.create(WrapperObject.prototype);
PxStridedData.prototype.constructor = PxStridedData;
PxStridedData.prototype.__class__ = PxStridedData;
PxStridedData.__cache__ = {};
Module['PxStridedData'] = PxStridedData;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxStridedData.prototype['get_stride'] = PxStridedData.prototype.get_stride = function() {
  var self = this.ptr;
  return _emscripten_bind_PxStridedData_get_stride_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxStridedData.prototype['set_stride'] = PxStridedData.prototype.set_stride = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxStridedData_set_stride_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxStridedData.prototype, 'stride', { get: PxStridedData.prototype.get_stride, set: PxStridedData.prototype.set_stride });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxStridedData.prototype['get_data'] = PxStridedData.prototype.get_data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxStridedData_get_data_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxStridedData.prototype['set_data'] = PxStridedData.prototype.set_data = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxStridedData_set_data_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxStridedData.prototype, 'data', { get: PxStridedData.prototype.get_data, set: PxStridedData.prototype.set_data });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxStridedData.prototype['__destroy__'] = PxStridedData.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxStridedData___destroy___0(self);
};

// Interface: PxSweepCallback

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSweepCallback() { throw "cannot construct a PxSweepCallback, no constructor in IDL" }
PxSweepCallback.prototype = Object.create(WrapperObject.prototype);
PxSweepCallback.prototype.constructor = PxSweepCallback;
PxSweepCallback.prototype.__class__ = PxSweepCallback;
PxSweepCallback.__cache__ = {};
Module['PxSweepCallback'] = PxSweepCallback;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepCallback.prototype['hasAnyHits'] = PxSweepCallback.prototype.hasAnyHits = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxSweepCallback_hasAnyHits_0(self));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepCallback.prototype['__destroy__'] = PxSweepCallback.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSweepCallback___destroy___0(self);
};

// Interface: PxU16ConstPtr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxU16ConstPtr() { throw "cannot construct a PxU16ConstPtr, no constructor in IDL" }
PxU16ConstPtr.prototype = Object.create(WrapperObject.prototype);
PxU16ConstPtr.prototype.constructor = PxU16ConstPtr;
PxU16ConstPtr.prototype.__class__ = PxU16ConstPtr;
PxU16ConstPtr.__cache__ = {};
Module['PxU16ConstPtr'] = PxU16ConstPtr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxU16ConstPtr.prototype['__destroy__'] = PxU16ConstPtr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxU16ConstPtr___destroy___0(self);
};

// Interface: PxU32ConstPtr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxU32ConstPtr() { throw "cannot construct a PxU32ConstPtr, no constructor in IDL" }
PxU32ConstPtr.prototype = Object.create(WrapperObject.prototype);
PxU32ConstPtr.prototype.constructor = PxU32ConstPtr;
PxU32ConstPtr.prototype.__class__ = PxU32ConstPtr;
PxU32ConstPtr.__cache__ = {};
Module['PxU32ConstPtr'] = PxU32ConstPtr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxU32ConstPtr.prototype['__destroy__'] = PxU32ConstPtr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxU32ConstPtr___destroy___0(self);
};

// Interface: PxU8ConstPtr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxU8ConstPtr() { throw "cannot construct a PxU8ConstPtr, no constructor in IDL" }
PxU8ConstPtr.prototype = Object.create(WrapperObject.prototype);
PxU8ConstPtr.prototype.constructor = PxU8ConstPtr;
PxU8ConstPtr.prototype.__class__ = PxU8ConstPtr;
PxU8ConstPtr.__cache__ = {};
Module['PxU8ConstPtr'] = PxU8ConstPtr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxU8ConstPtr.prototype['__destroy__'] = PxU8ConstPtr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxU8ConstPtr___destroy___0(self);
};

// Interface: PxUserControllerHitReport

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxUserControllerHitReport() { throw "cannot construct a PxUserControllerHitReport, no constructor in IDL" }
PxUserControllerHitReport.prototype = Object.create(WrapperObject.prototype);
PxUserControllerHitReport.prototype.constructor = PxUserControllerHitReport;
PxUserControllerHitReport.prototype.__class__ = PxUserControllerHitReport;
PxUserControllerHitReport.__cache__ = {};
Module['PxUserControllerHitReport'] = PxUserControllerHitReport;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxUserControllerHitReport.prototype['onShapeHit'] = PxUserControllerHitReport.prototype.onShapeHit = function(hit) {
  var self = this.ptr;
  if (hit && typeof hit === 'object') hit = hit.ptr;
  _emscripten_bind_PxUserControllerHitReport_onShapeHit_1(self, hit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxUserControllerHitReport.prototype['onControllerHit'] = PxUserControllerHitReport.prototype.onControllerHit = function(hit) {
  var self = this.ptr;
  if (hit && typeof hit === 'object') hit = hit.ptr;
  _emscripten_bind_PxUserControllerHitReport_onControllerHit_1(self, hit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxUserControllerHitReport.prototype['onObstacleHit'] = PxUserControllerHitReport.prototype.onObstacleHit = function(hit) {
  var self = this.ptr;
  if (hit && typeof hit === 'object') hit = hit.ptr;
  _emscripten_bind_PxUserControllerHitReport_onObstacleHit_1(self, hit);
};


// Interface: PxVehicleCommandResponseParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleCommandResponseParams() {
  this.ptr = _emscripten_bind_PxVehicleCommandResponseParams_PxVehicleCommandResponseParams_0();
  getCache(PxVehicleCommandResponseParams)[this.ptr] = this;
};

PxVehicleCommandResponseParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleCommandResponseParams.prototype.constructor = PxVehicleCommandResponseParams;
PxVehicleCommandResponseParams.prototype.__class__ = PxVehicleCommandResponseParams;
PxVehicleCommandResponseParams.__cache__ = {};
Module['PxVehicleCommandResponseParams'] = PxVehicleCommandResponseParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandResponseParams.prototype['get_nonlinearResponse'] = PxVehicleCommandResponseParams.prototype.get_nonlinearResponse = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleCommandResponseParams_get_nonlinearResponse_0(self), PxVehicleCommandNonLinearResponseParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandResponseParams.prototype['set_nonlinearResponse'] = PxVehicleCommandResponseParams.prototype.set_nonlinearResponse = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleCommandResponseParams_set_nonlinearResponse_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleCommandResponseParams.prototype, 'nonlinearResponse', { get: PxVehicleCommandResponseParams.prototype.get_nonlinearResponse, set: PxVehicleCommandResponseParams.prototype.set_nonlinearResponse });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandResponseParams.prototype['get_wheelResponseMultipliers'] = PxVehicleCommandResponseParams.prototype.get_wheelResponseMultipliers = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleCommandResponseParams_get_wheelResponseMultipliers_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandResponseParams.prototype['set_wheelResponseMultipliers'] = PxVehicleCommandResponseParams.prototype.set_wheelResponseMultipliers = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleCommandResponseParams_set_wheelResponseMultipliers_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleCommandResponseParams.prototype, 'wheelResponseMultipliers', { get: PxVehicleCommandResponseParams.prototype.get_wheelResponseMultipliers, set: PxVehicleCommandResponseParams.prototype.set_wheelResponseMultipliers });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandResponseParams.prototype['get_maxResponse'] = PxVehicleCommandResponseParams.prototype.get_maxResponse = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleCommandResponseParams_get_maxResponse_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandResponseParams.prototype['set_maxResponse'] = PxVehicleCommandResponseParams.prototype.set_maxResponse = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleCommandResponseParams_set_maxResponse_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleCommandResponseParams.prototype, 'maxResponse', { get: PxVehicleCommandResponseParams.prototype.get_maxResponse, set: PxVehicleCommandResponseParams.prototype.set_maxResponse });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandResponseParams.prototype['__destroy__'] = PxVehicleCommandResponseParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleCommandResponseParams___destroy___0(self);
};

// Interface: PxVehicleEngineDriveTransmissionCommandState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleEngineDriveTransmissionCommandState() {
  this.ptr = _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_PxVehicleEngineDriveTransmissionCommandState_0();
  getCache(PxVehicleEngineDriveTransmissionCommandState)[this.ptr] = this;
};

PxVehicleEngineDriveTransmissionCommandState.prototype = Object.create(WrapperObject.prototype);
PxVehicleEngineDriveTransmissionCommandState.prototype.constructor = PxVehicleEngineDriveTransmissionCommandState;
PxVehicleEngineDriveTransmissionCommandState.prototype.__class__ = PxVehicleEngineDriveTransmissionCommandState;
PxVehicleEngineDriveTransmissionCommandState.__cache__ = {};
Module['PxVehicleEngineDriveTransmissionCommandState'] = PxVehicleEngineDriveTransmissionCommandState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineDriveTransmissionCommandState.prototype['setToDefault'] = PxVehicleEngineDriveTransmissionCommandState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineDriveTransmissionCommandState.prototype['get_clutch'] = PxVehicleEngineDriveTransmissionCommandState.prototype.get_clutch = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_clutch_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineDriveTransmissionCommandState.prototype['set_clutch'] = PxVehicleEngineDriveTransmissionCommandState.prototype.set_clutch = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_clutch_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleEngineDriveTransmissionCommandState.prototype, 'clutch', { get: PxVehicleEngineDriveTransmissionCommandState.prototype.get_clutch, set: PxVehicleEngineDriveTransmissionCommandState.prototype.set_clutch });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineDriveTransmissionCommandState.prototype['get_targetGear'] = PxVehicleEngineDriveTransmissionCommandState.prototype.get_targetGear = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_get_targetGear_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineDriveTransmissionCommandState.prototype['set_targetGear'] = PxVehicleEngineDriveTransmissionCommandState.prototype.set_targetGear = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState_set_targetGear_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleEngineDriveTransmissionCommandState.prototype, 'targetGear', { get: PxVehicleEngineDriveTransmissionCommandState.prototype.get_targetGear, set: PxVehicleEngineDriveTransmissionCommandState.prototype.set_targetGear });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineDriveTransmissionCommandState.prototype['__destroy__'] = PxVehicleEngineDriveTransmissionCommandState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleEngineDriveTransmissionCommandState___destroy___0(self);
};

// Interface: PxVehicleMultiWheelDriveDifferentialParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleMultiWheelDriveDifferentialParams() {
  this.ptr = _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_PxVehicleMultiWheelDriveDifferentialParams_0();
  getCache(PxVehicleMultiWheelDriveDifferentialParams)[this.ptr] = this;
};

PxVehicleMultiWheelDriveDifferentialParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleMultiWheelDriveDifferentialParams.prototype.constructor = PxVehicleMultiWheelDriveDifferentialParams;
PxVehicleMultiWheelDriveDifferentialParams.prototype.__class__ = PxVehicleMultiWheelDriveDifferentialParams;
PxVehicleMultiWheelDriveDifferentialParams.__cache__ = {};
Module['PxVehicleMultiWheelDriveDifferentialParams'] = PxVehicleMultiWheelDriveDifferentialParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleMultiWheelDriveDifferentialParams.prototype['setToDefault'] = PxVehicleMultiWheelDriveDifferentialParams.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleMultiWheelDriveDifferentialParams.prototype['transformAndScale'] = PxVehicleMultiWheelDriveDifferentialParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleMultiWheelDriveDifferentialParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleMultiWheelDriveDifferentialParams.prototype['isValid'] = PxVehicleMultiWheelDriveDifferentialParams.prototype.isValid = function(axleDesc) {
  var self = this.ptr;
  if (axleDesc && typeof axleDesc === 'object') axleDesc = axleDesc.ptr;
  return !!(_emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_isValid_1(self, axleDesc));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleMultiWheelDriveDifferentialParams.prototype['get_torqueRatios'] = PxVehicleMultiWheelDriveDifferentialParams.prototype.get_torqueRatios = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_torqueRatios_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleMultiWheelDriveDifferentialParams.prototype['set_torqueRatios'] = PxVehicleMultiWheelDriveDifferentialParams.prototype.set_torqueRatios = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_torqueRatios_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleMultiWheelDriveDifferentialParams.prototype, 'torqueRatios', { get: PxVehicleMultiWheelDriveDifferentialParams.prototype.get_torqueRatios, set: PxVehicleMultiWheelDriveDifferentialParams.prototype.set_torqueRatios });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleMultiWheelDriveDifferentialParams.prototype['get_aveWheelSpeedRatios'] = PxVehicleMultiWheelDriveDifferentialParams.prototype.get_aveWheelSpeedRatios = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleMultiWheelDriveDifferentialParams.prototype['set_aveWheelSpeedRatios'] = PxVehicleMultiWheelDriveDifferentialParams.prototype.set_aveWheelSpeedRatios = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleMultiWheelDriveDifferentialParams.prototype, 'aveWheelSpeedRatios', { get: PxVehicleMultiWheelDriveDifferentialParams.prototype.get_aveWheelSpeedRatios, set: PxVehicleMultiWheelDriveDifferentialParams.prototype.set_aveWheelSpeedRatios });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleMultiWheelDriveDifferentialParams.prototype['__destroy__'] = PxVehicleMultiWheelDriveDifferentialParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleMultiWheelDriveDifferentialParams___destroy___0(self);
};

// Interface: PxVehicleSimulationContext

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleSimulationContext() {
  this.ptr = _emscripten_bind_PxVehicleSimulationContext_PxVehicleSimulationContext_0();
  getCache(PxVehicleSimulationContext)[this.ptr] = this;
};

PxVehicleSimulationContext.prototype = Object.create(WrapperObject.prototype);
PxVehicleSimulationContext.prototype.constructor = PxVehicleSimulationContext;
PxVehicleSimulationContext.prototype.__class__ = PxVehicleSimulationContext;
PxVehicleSimulationContext.__cache__ = {};
Module['PxVehicleSimulationContext'] = PxVehicleSimulationContext;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['getType'] = PxVehicleSimulationContext.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleSimulationContext_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['setToDefault'] = PxVehicleSimulationContext.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleSimulationContext_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['transformAndScale'] = PxVehicleSimulationContext.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSimulationContext_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleSimulationContext);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['get_gravity'] = PxVehicleSimulationContext.prototype.get_gravity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSimulationContext_get_gravity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['set_gravity'] = PxVehicleSimulationContext.prototype.set_gravity = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSimulationContext_set_gravity_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSimulationContext.prototype, 'gravity', { get: PxVehicleSimulationContext.prototype.get_gravity, set: PxVehicleSimulationContext.prototype.set_gravity });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['get_frame'] = PxVehicleSimulationContext.prototype.get_frame = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSimulationContext_get_frame_0(self), PxVehicleFrame);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['set_frame'] = PxVehicleSimulationContext.prototype.set_frame = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSimulationContext_set_frame_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSimulationContext.prototype, 'frame', { get: PxVehicleSimulationContext.prototype.get_frame, set: PxVehicleSimulationContext.prototype.set_frame });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['get_scale'] = PxVehicleSimulationContext.prototype.get_scale = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSimulationContext_get_scale_0(self), PxVehicleScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['set_scale'] = PxVehicleSimulationContext.prototype.set_scale = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSimulationContext_set_scale_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSimulationContext.prototype, 'scale', { get: PxVehicleSimulationContext.prototype.get_scale, set: PxVehicleSimulationContext.prototype.set_scale });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['get_tireSlipParams'] = PxVehicleSimulationContext.prototype.get_tireSlipParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSimulationContext_get_tireSlipParams_0(self), PxVehicleTireSlipParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['set_tireSlipParams'] = PxVehicleSimulationContext.prototype.set_tireSlipParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSimulationContext_set_tireSlipParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSimulationContext.prototype, 'tireSlipParams', { get: PxVehicleSimulationContext.prototype.get_tireSlipParams, set: PxVehicleSimulationContext.prototype.set_tireSlipParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['get_tireStickyParams'] = PxVehicleSimulationContext.prototype.get_tireStickyParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSimulationContext_get_tireStickyParams_0(self), PxVehicleTireStickyParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['set_tireStickyParams'] = PxVehicleSimulationContext.prototype.set_tireStickyParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSimulationContext_set_tireStickyParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSimulationContext.prototype, 'tireStickyParams', { get: PxVehicleSimulationContext.prototype.get_tireStickyParams, set: PxVehicleSimulationContext.prototype.set_tireStickyParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['get_thresholdForwardSpeedForWheelAngleIntegration'] = PxVehicleSimulationContext.prototype.get_thresholdForwardSpeedForWheelAngleIntegration = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['set_thresholdForwardSpeedForWheelAngleIntegration'] = PxVehicleSimulationContext.prototype.set_thresholdForwardSpeedForWheelAngleIntegration = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSimulationContext.prototype, 'thresholdForwardSpeedForWheelAngleIntegration', { get: PxVehicleSimulationContext.prototype.get_thresholdForwardSpeedForWheelAngleIntegration, set: PxVehicleSimulationContext.prototype.set_thresholdForwardSpeedForWheelAngleIntegration });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['get_pvdContext'] = PxVehicleSimulationContext.prototype.get_pvdContext = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSimulationContext_get_pvdContext_0(self), PxVehiclePvdContext);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['set_pvdContext'] = PxVehicleSimulationContext.prototype.set_pvdContext = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSimulationContext_set_pvdContext_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSimulationContext.prototype, 'pvdContext', { get: PxVehicleSimulationContext.prototype.get_pvdContext, set: PxVehicleSimulationContext.prototype.set_pvdContext });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSimulationContext.prototype['__destroy__'] = PxVehicleSimulationContext.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleSimulationContext___destroy___0(self);
};

// Interface: SimpleControllerBehaviorCallback

/** @suppress {undefinedVars, duplicate} @this{Object} */
function SimpleControllerBehaviorCallback() { throw "cannot construct a SimpleControllerBehaviorCallback, no constructor in IDL" }
SimpleControllerBehaviorCallback.prototype = Object.create(PxControllerBehaviorCallback.prototype);
SimpleControllerBehaviorCallback.prototype.constructor = SimpleControllerBehaviorCallback;
SimpleControllerBehaviorCallback.prototype.__class__ = SimpleControllerBehaviorCallback;
SimpleControllerBehaviorCallback.__cache__ = {};
Module['SimpleControllerBehaviorCallback'] = SimpleControllerBehaviorCallback;
/** @suppress {undefinedVars, duplicate} @this{Object} */
SimpleControllerBehaviorCallback.prototype['getShapeBehaviorFlags'] = SimpleControllerBehaviorCallback.prototype.getShapeBehaviorFlags = function(shape, actor) {
  var self = this.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return _emscripten_bind_SimpleControllerBehaviorCallback_getShapeBehaviorFlags_2(self, shape, actor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimpleControllerBehaviorCallback.prototype['getControllerBehaviorFlags'] = SimpleControllerBehaviorCallback.prototype.getControllerBehaviorFlags = function(controller) {
  var self = this.ptr;
  if (controller && typeof controller === 'object') controller = controller.ptr;
  return _emscripten_bind_SimpleControllerBehaviorCallback_getControllerBehaviorFlags_1(self, controller);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimpleControllerBehaviorCallback.prototype['getObstacleBehaviorFlags'] = SimpleControllerBehaviorCallback.prototype.getObstacleBehaviorFlags = function(obstacle) {
  var self = this.ptr;
  if (obstacle && typeof obstacle === 'object') obstacle = obstacle.ptr;
  return _emscripten_bind_SimpleControllerBehaviorCallback_getObstacleBehaviorFlags_1(self, obstacle);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
SimpleControllerBehaviorCallback.prototype['__destroy__'] = SimpleControllerBehaviorCallback.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_SimpleControllerBehaviorCallback___destroy___0(self);
};

// Interface: SimplePvdTransport

/** @suppress {undefinedVars, duplicate} @this{Object} */
function SimplePvdTransport() { throw "cannot construct a SimplePvdTransport, no constructor in IDL" }
SimplePvdTransport.prototype = Object.create(PxPvdTransport.prototype);
SimplePvdTransport.prototype.constructor = SimplePvdTransport;
SimplePvdTransport.prototype.__class__ = SimplePvdTransport;
SimplePvdTransport.__cache__ = {};
Module['SimplePvdTransport'] = SimplePvdTransport;
/** @suppress {undefinedVars, duplicate} @this{Object} */
SimplePvdTransport.prototype['send'] = SimplePvdTransport.prototype.send = function(inBytes, inLength) {
  var self = this.ptr;
  if (inBytes && typeof inBytes === 'object') inBytes = inBytes.ptr;
  if (inLength && typeof inLength === 'object') inLength = inLength.ptr;
  _emscripten_bind_SimplePvdTransport_send_2(self, inBytes, inLength);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimplePvdTransport.prototype['connect'] = SimplePvdTransport.prototype.connect = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_SimplePvdTransport_connect_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimplePvdTransport.prototype['isConnected'] = SimplePvdTransport.prototype.isConnected = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_SimplePvdTransport_isConnected_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimplePvdTransport.prototype['disconnect'] = SimplePvdTransport.prototype.disconnect = function() {
  var self = this.ptr;
  _emscripten_bind_SimplePvdTransport_disconnect_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimplePvdTransport.prototype['release'] = SimplePvdTransport.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_SimplePvdTransport_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimplePvdTransport.prototype['flush'] = SimplePvdTransport.prototype.flush = function() {
  var self = this.ptr;
  _emscripten_bind_SimplePvdTransport_flush_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
SimplePvdTransport.prototype['__destroy__'] = SimplePvdTransport.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_SimplePvdTransport___destroy___0(self);
};

// Interface: SimpleQueryFilterCallback

/** @suppress {undefinedVars, duplicate} @this{Object} */
function SimpleQueryFilterCallback() { throw "cannot construct a SimpleQueryFilterCallback, no constructor in IDL" }
SimpleQueryFilterCallback.prototype = Object.create(PxQueryFilterCallback.prototype);
SimpleQueryFilterCallback.prototype.constructor = SimpleQueryFilterCallback;
SimpleQueryFilterCallback.prototype.__class__ = SimpleQueryFilterCallback;
SimpleQueryFilterCallback.__cache__ = {};
Module['SimpleQueryFilterCallback'] = SimpleQueryFilterCallback;
/** @suppress {undefinedVars, duplicate} @this{Object} */
SimpleQueryFilterCallback.prototype['simplePreFilter'] = SimpleQueryFilterCallback.prototype.simplePreFilter = function(filterData, shape, actor, queryFlags) {
  var self = this.ptr;
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (queryFlags && typeof queryFlags === 'object') queryFlags = queryFlags.ptr;
  return _emscripten_bind_SimpleQueryFilterCallback_simplePreFilter_4(self, filterData, shape, actor, queryFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimpleQueryFilterCallback.prototype['simplePostFilter'] = SimpleQueryFilterCallback.prototype.simplePostFilter = function(filterData, hit, shape, actor) {
  var self = this.ptr;
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  if (hit && typeof hit === 'object') hit = hit.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return _emscripten_bind_SimpleQueryFilterCallback_simplePostFilter_4(self, filterData, hit, shape, actor);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
SimpleQueryFilterCallback.prototype['__destroy__'] = SimpleQueryFilterCallback.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_SimpleQueryFilterCallback___destroy___0(self);
};

// Interface: SimpleSimulationEventCallback

/** @suppress {undefinedVars, duplicate} @this{Object} */
function SimpleSimulationEventCallback() { throw "cannot construct a SimpleSimulationEventCallback, no constructor in IDL" }
SimpleSimulationEventCallback.prototype = Object.create(PxSimulationEventCallback.prototype);
SimpleSimulationEventCallback.prototype.constructor = SimpleSimulationEventCallback;
SimpleSimulationEventCallback.prototype.__class__ = SimpleSimulationEventCallback;
SimpleSimulationEventCallback.__cache__ = {};
Module['SimpleSimulationEventCallback'] = SimpleSimulationEventCallback;
/** @suppress {undefinedVars, duplicate} @this{Object} */
SimpleSimulationEventCallback.prototype['onConstraintBreak'] = SimpleSimulationEventCallback.prototype.onConstraintBreak = function(constraints, count) {
  var self = this.ptr;
  if (constraints && typeof constraints === 'object') constraints = constraints.ptr;
  if (count && typeof count === 'object') count = count.ptr;
  _emscripten_bind_SimpleSimulationEventCallback_onConstraintBreak_2(self, constraints, count);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimpleSimulationEventCallback.prototype['onWake'] = SimpleSimulationEventCallback.prototype.onWake = function(actors, count) {
  var self = this.ptr;
  if (actors && typeof actors === 'object') actors = actors.ptr;
  if (count && typeof count === 'object') count = count.ptr;
  _emscripten_bind_SimpleSimulationEventCallback_onWake_2(self, actors, count);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimpleSimulationEventCallback.prototype['onSleep'] = SimpleSimulationEventCallback.prototype.onSleep = function(actors, count) {
  var self = this.ptr;
  if (actors && typeof actors === 'object') actors = actors.ptr;
  if (count && typeof count === 'object') count = count.ptr;
  _emscripten_bind_SimpleSimulationEventCallback_onSleep_2(self, actors, count);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimpleSimulationEventCallback.prototype['onContact'] = SimpleSimulationEventCallback.prototype.onContact = function(pairHeader, pairs, nbPairs) {
  var self = this.ptr;
  if (pairHeader && typeof pairHeader === 'object') pairHeader = pairHeader.ptr;
  if (pairs && typeof pairs === 'object') pairs = pairs.ptr;
  if (nbPairs && typeof nbPairs === 'object') nbPairs = nbPairs.ptr;
  _emscripten_bind_SimpleSimulationEventCallback_onContact_3(self, pairHeader, pairs, nbPairs);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimpleSimulationEventCallback.prototype['onTrigger'] = SimpleSimulationEventCallback.prototype.onTrigger = function(pairs, count) {
  var self = this.ptr;
  if (pairs && typeof pairs === 'object') pairs = pairs.ptr;
  if (count && typeof count === 'object') count = count.ptr;
  _emscripten_bind_SimpleSimulationEventCallback_onTrigger_2(self, pairs, count);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
SimpleSimulationEventCallback.prototype['__destroy__'] = SimpleSimulationEventCallback.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_SimpleSimulationEventCallback___destroy___0(self);
};

// Interface: VoidPtr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function VoidPtr() { throw "cannot construct a VoidPtr, no constructor in IDL" }
VoidPtr.prototype = Object.create(WrapperObject.prototype);
VoidPtr.prototype.constructor = VoidPtr;
VoidPtr.prototype.__class__ = VoidPtr;
VoidPtr.__cache__ = {};
Module['VoidPtr'] = VoidPtr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
VoidPtr.prototype['__destroy__'] = VoidPtr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_VoidPtr___destroy___0(self);
};

// Interface: BaseVehicleParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function BaseVehicleParams() {
  this.ptr = _emscripten_bind_BaseVehicleParams_BaseVehicleParams_0();
  getCache(BaseVehicleParams)[this.ptr] = this;
};

BaseVehicleParams.prototype = Object.create(WrapperObject.prototype);
BaseVehicleParams.prototype.constructor = BaseVehicleParams;
BaseVehicleParams.prototype.__class__ = BaseVehicleParams;
BaseVehicleParams.__cache__ = {};
Module['BaseVehicleParams'] = BaseVehicleParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['transformAndScale'] = BaseVehicleParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), BaseVehicleParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['isValid'] = BaseVehicleParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_BaseVehicleParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_axleDescription'] = BaseVehicleParams.prototype.get_axleDescription = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_get_axleDescription_0(self), PxVehicleAxleDescription);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_axleDescription'] = BaseVehicleParams.prototype.set_axleDescription = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BaseVehicleParams_set_axleDescription_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'axleDescription', { get: BaseVehicleParams.prototype.get_axleDescription, set: BaseVehicleParams.prototype.set_axleDescription });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_frame'] = BaseVehicleParams.prototype.get_frame = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_get_frame_0(self), PxVehicleFrame);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_frame'] = BaseVehicleParams.prototype.set_frame = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BaseVehicleParams_set_frame_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'frame', { get: BaseVehicleParams.prototype.get_frame, set: BaseVehicleParams.prototype.set_frame });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_scale'] = BaseVehicleParams.prototype.get_scale = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_get_scale_0(self), PxVehicleScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_scale'] = BaseVehicleParams.prototype.set_scale = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BaseVehicleParams_set_scale_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'scale', { get: BaseVehicleParams.prototype.get_scale, set: BaseVehicleParams.prototype.set_scale });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_suspensionStateCalculationParams'] = BaseVehicleParams.prototype.get_suspensionStateCalculationParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_get_suspensionStateCalculationParams_0(self), PxVehicleSuspensionStateCalculationParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_suspensionStateCalculationParams'] = BaseVehicleParams.prototype.set_suspensionStateCalculationParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BaseVehicleParams_set_suspensionStateCalculationParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'suspensionStateCalculationParams', { get: BaseVehicleParams.prototype.get_suspensionStateCalculationParams, set: BaseVehicleParams.prototype.set_suspensionStateCalculationParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_brakeResponseParams'] = BaseVehicleParams.prototype.get_brakeResponseParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_get_brakeResponseParams_1(self, arg0), PxVehicleBrakeCommandResponseParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_brakeResponseParams'] = BaseVehicleParams.prototype.set_brakeResponseParams = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleParams_set_brakeResponseParams_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'brakeResponseParams', { get: BaseVehicleParams.prototype.get_brakeResponseParams, set: BaseVehicleParams.prototype.set_brakeResponseParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_steerResponseParams'] = BaseVehicleParams.prototype.get_steerResponseParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_get_steerResponseParams_0(self), PxVehicleSteerCommandResponseParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_steerResponseParams'] = BaseVehicleParams.prototype.set_steerResponseParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BaseVehicleParams_set_steerResponseParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'steerResponseParams', { get: BaseVehicleParams.prototype.get_steerResponseParams, set: BaseVehicleParams.prototype.set_steerResponseParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_ackermannParams'] = BaseVehicleParams.prototype.get_ackermannParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_get_ackermannParams_1(self, arg0), PxVehicleAckermannParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_ackermannParams'] = BaseVehicleParams.prototype.set_ackermannParams = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleParams_set_ackermannParams_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'ackermannParams', { get: BaseVehicleParams.prototype.get_ackermannParams, set: BaseVehicleParams.prototype.set_ackermannParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_suspensionParams'] = BaseVehicleParams.prototype.get_suspensionParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_get_suspensionParams_1(self, arg0), PxVehicleSuspensionParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_suspensionParams'] = BaseVehicleParams.prototype.set_suspensionParams = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleParams_set_suspensionParams_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'suspensionParams', { get: BaseVehicleParams.prototype.get_suspensionParams, set: BaseVehicleParams.prototype.set_suspensionParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_suspensionComplianceParams'] = BaseVehicleParams.prototype.get_suspensionComplianceParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_get_suspensionComplianceParams_1(self, arg0), PxVehicleSuspensionComplianceParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_suspensionComplianceParams'] = BaseVehicleParams.prototype.set_suspensionComplianceParams = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleParams_set_suspensionComplianceParams_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'suspensionComplianceParams', { get: BaseVehicleParams.prototype.get_suspensionComplianceParams, set: BaseVehicleParams.prototype.set_suspensionComplianceParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_suspensionForceParams'] = BaseVehicleParams.prototype.get_suspensionForceParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_get_suspensionForceParams_1(self, arg0), PxVehicleSuspensionForceParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_suspensionForceParams'] = BaseVehicleParams.prototype.set_suspensionForceParams = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleParams_set_suspensionForceParams_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'suspensionForceParams', { get: BaseVehicleParams.prototype.get_suspensionForceParams, set: BaseVehicleParams.prototype.set_suspensionForceParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_antiRollForceParams'] = BaseVehicleParams.prototype.get_antiRollForceParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_get_antiRollForceParams_1(self, arg0), PxVehicleAntiRollForceParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_antiRollForceParams'] = BaseVehicleParams.prototype.set_antiRollForceParams = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleParams_set_antiRollForceParams_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'antiRollForceParams', { get: BaseVehicleParams.prototype.get_antiRollForceParams, set: BaseVehicleParams.prototype.set_antiRollForceParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_nbAntiRollForceParams'] = BaseVehicleParams.prototype.get_nbAntiRollForceParams = function() {
  var self = this.ptr;
  return _emscripten_bind_BaseVehicleParams_get_nbAntiRollForceParams_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_nbAntiRollForceParams'] = BaseVehicleParams.prototype.set_nbAntiRollForceParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BaseVehicleParams_set_nbAntiRollForceParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'nbAntiRollForceParams', { get: BaseVehicleParams.prototype.get_nbAntiRollForceParams, set: BaseVehicleParams.prototype.set_nbAntiRollForceParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_tireForceParams'] = BaseVehicleParams.prototype.get_tireForceParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_get_tireForceParams_1(self, arg0), PxVehicleTireForceParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_tireForceParams'] = BaseVehicleParams.prototype.set_tireForceParams = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleParams_set_tireForceParams_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'tireForceParams', { get: BaseVehicleParams.prototype.get_tireForceParams, set: BaseVehicleParams.prototype.set_tireForceParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_wheelParams'] = BaseVehicleParams.prototype.get_wheelParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_get_wheelParams_1(self, arg0), PxVehicleWheelParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_wheelParams'] = BaseVehicleParams.prototype.set_wheelParams = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleParams_set_wheelParams_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'wheelParams', { get: BaseVehicleParams.prototype.get_wheelParams, set: BaseVehicleParams.prototype.set_wheelParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['get_rigidBodyParams'] = BaseVehicleParams.prototype.get_rigidBodyParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleParams_get_rigidBodyParams_0(self), PxVehicleRigidBodyParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['set_rigidBodyParams'] = BaseVehicleParams.prototype.set_rigidBodyParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BaseVehicleParams_set_rigidBodyParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleParams.prototype, 'rigidBodyParams', { get: BaseVehicleParams.prototype.get_rigidBodyParams, set: BaseVehicleParams.prototype.set_rigidBodyParams });

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleParams.prototype['__destroy__'] = BaseVehicleParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_BaseVehicleParams___destroy___0(self);
};

// Interface: BaseVehicleState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function BaseVehicleState() {
  this.ptr = _emscripten_bind_BaseVehicleState_BaseVehicleState_0();
  getCache(BaseVehicleState)[this.ptr] = this;
};

BaseVehicleState.prototype = Object.create(WrapperObject.prototype);
BaseVehicleState.prototype.constructor = BaseVehicleState;
BaseVehicleState.prototype.__class__ = BaseVehicleState;
BaseVehicleState.__cache__ = {};
Module['BaseVehicleState'] = BaseVehicleState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['setToDefault'] = BaseVehicleState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_BaseVehicleState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_brakeCommandResponseStates'] = BaseVehicleState.prototype.get_brakeCommandResponseStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_BaseVehicleState_get_brakeCommandResponseStates_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_brakeCommandResponseStates'] = BaseVehicleState.prototype.set_brakeCommandResponseStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_brakeCommandResponseStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'brakeCommandResponseStates', { get: BaseVehicleState.prototype.get_brakeCommandResponseStates, set: BaseVehicleState.prototype.set_brakeCommandResponseStates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_steerCommandResponseStates'] = BaseVehicleState.prototype.get_steerCommandResponseStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_BaseVehicleState_get_steerCommandResponseStates_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_steerCommandResponseStates'] = BaseVehicleState.prototype.set_steerCommandResponseStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_steerCommandResponseStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'steerCommandResponseStates', { get: BaseVehicleState.prototype.get_steerCommandResponseStates, set: BaseVehicleState.prototype.set_steerCommandResponseStates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_actuationStates'] = BaseVehicleState.prototype.get_actuationStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_actuationStates_1(self, arg0), PxVehicleWheelActuationState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_actuationStates'] = BaseVehicleState.prototype.set_actuationStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_actuationStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'actuationStates', { get: BaseVehicleState.prototype.get_actuationStates, set: BaseVehicleState.prototype.set_actuationStates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_roadGeomStates'] = BaseVehicleState.prototype.get_roadGeomStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_roadGeomStates_1(self, arg0), PxVehicleRoadGeometryState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_roadGeomStates'] = BaseVehicleState.prototype.set_roadGeomStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_roadGeomStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'roadGeomStates', { get: BaseVehicleState.prototype.get_roadGeomStates, set: BaseVehicleState.prototype.set_roadGeomStates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_suspensionStates'] = BaseVehicleState.prototype.get_suspensionStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_suspensionStates_1(self, arg0), PxVehicleSuspensionState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_suspensionStates'] = BaseVehicleState.prototype.set_suspensionStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_suspensionStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'suspensionStates', { get: BaseVehicleState.prototype.get_suspensionStates, set: BaseVehicleState.prototype.set_suspensionStates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_suspensionComplianceStates'] = BaseVehicleState.prototype.get_suspensionComplianceStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_suspensionComplianceStates_1(self, arg0), PxVehicleSuspensionComplianceState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_suspensionComplianceStates'] = BaseVehicleState.prototype.set_suspensionComplianceStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_suspensionComplianceStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'suspensionComplianceStates', { get: BaseVehicleState.prototype.get_suspensionComplianceStates, set: BaseVehicleState.prototype.set_suspensionComplianceStates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_suspensionForces'] = BaseVehicleState.prototype.get_suspensionForces = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_suspensionForces_1(self, arg0), PxVehicleSuspensionForce);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_suspensionForces'] = BaseVehicleState.prototype.set_suspensionForces = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_suspensionForces_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'suspensionForces', { get: BaseVehicleState.prototype.get_suspensionForces, set: BaseVehicleState.prototype.set_suspensionForces });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_antiRollTorque'] = BaseVehicleState.prototype.get_antiRollTorque = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_antiRollTorque_0(self), PxVehicleAntiRollTorque);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_antiRollTorque'] = BaseVehicleState.prototype.set_antiRollTorque = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BaseVehicleState_set_antiRollTorque_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'antiRollTorque', { get: BaseVehicleState.prototype.get_antiRollTorque, set: BaseVehicleState.prototype.set_antiRollTorque });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_tireGripStates'] = BaseVehicleState.prototype.get_tireGripStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_tireGripStates_1(self, arg0), PxVehicleTireGripState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_tireGripStates'] = BaseVehicleState.prototype.set_tireGripStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_tireGripStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'tireGripStates', { get: BaseVehicleState.prototype.get_tireGripStates, set: BaseVehicleState.prototype.set_tireGripStates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_tireDirectionStates'] = BaseVehicleState.prototype.get_tireDirectionStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_tireDirectionStates_1(self, arg0), PxVehicleTireDirectionState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_tireDirectionStates'] = BaseVehicleState.prototype.set_tireDirectionStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_tireDirectionStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'tireDirectionStates', { get: BaseVehicleState.prototype.get_tireDirectionStates, set: BaseVehicleState.prototype.set_tireDirectionStates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_tireSpeedStates'] = BaseVehicleState.prototype.get_tireSpeedStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_tireSpeedStates_1(self, arg0), PxVehicleTireSpeedState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_tireSpeedStates'] = BaseVehicleState.prototype.set_tireSpeedStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_tireSpeedStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'tireSpeedStates', { get: BaseVehicleState.prototype.get_tireSpeedStates, set: BaseVehicleState.prototype.set_tireSpeedStates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_tireSlipStates'] = BaseVehicleState.prototype.get_tireSlipStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_tireSlipStates_1(self, arg0), PxVehicleTireSlipState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_tireSlipStates'] = BaseVehicleState.prototype.set_tireSlipStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_tireSlipStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'tireSlipStates', { get: BaseVehicleState.prototype.get_tireSlipStates, set: BaseVehicleState.prototype.set_tireSlipStates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_tireCamberAngleStates'] = BaseVehicleState.prototype.get_tireCamberAngleStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_tireCamberAngleStates_1(self, arg0), PxVehicleTireCamberAngleState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_tireCamberAngleStates'] = BaseVehicleState.prototype.set_tireCamberAngleStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_tireCamberAngleStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'tireCamberAngleStates', { get: BaseVehicleState.prototype.get_tireCamberAngleStates, set: BaseVehicleState.prototype.set_tireCamberAngleStates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_tireStickyStates'] = BaseVehicleState.prototype.get_tireStickyStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_tireStickyStates_1(self, arg0), PxVehicleTireStickyState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_tireStickyStates'] = BaseVehicleState.prototype.set_tireStickyStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_tireStickyStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'tireStickyStates', { get: BaseVehicleState.prototype.get_tireStickyStates, set: BaseVehicleState.prototype.set_tireStickyStates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_tireForces'] = BaseVehicleState.prototype.get_tireForces = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_tireForces_1(self, arg0), PxVehicleTireForce);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_tireForces'] = BaseVehicleState.prototype.set_tireForces = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_tireForces_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'tireForces', { get: BaseVehicleState.prototype.get_tireForces, set: BaseVehicleState.prototype.set_tireForces });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_wheelRigidBody1dStates'] = BaseVehicleState.prototype.get_wheelRigidBody1dStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_wheelRigidBody1dStates_1(self, arg0), PxVehicleWheelRigidBody1dState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_wheelRigidBody1dStates'] = BaseVehicleState.prototype.set_wheelRigidBody1dStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_wheelRigidBody1dStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'wheelRigidBody1dStates', { get: BaseVehicleState.prototype.get_wheelRigidBody1dStates, set: BaseVehicleState.prototype.set_wheelRigidBody1dStates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_wheelLocalPoses'] = BaseVehicleState.prototype.get_wheelLocalPoses = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_wheelLocalPoses_1(self, arg0), PxVehicleWheelLocalPose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_wheelLocalPoses'] = BaseVehicleState.prototype.set_wheelLocalPoses = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_BaseVehicleState_set_wheelLocalPoses_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'wheelLocalPoses', { get: BaseVehicleState.prototype.get_wheelLocalPoses, set: BaseVehicleState.prototype.set_wheelLocalPoses });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['get_rigidBodyState'] = BaseVehicleState.prototype.get_rigidBodyState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_BaseVehicleState_get_rigidBodyState_0(self), PxVehicleRigidBodyState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['set_rigidBodyState'] = BaseVehicleState.prototype.set_rigidBodyState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BaseVehicleState_set_rigidBodyState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BaseVehicleState.prototype, 'rigidBodyState', { get: BaseVehicleState.prototype.get_rigidBodyState, set: BaseVehicleState.prototype.set_rigidBodyState });

/** @suppress {undefinedVars, duplicate} @this{Object} */
BaseVehicleState.prototype['__destroy__'] = BaseVehicleState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_BaseVehicleState___destroy___0(self);
};

// Interface: BoxSupport

/** @suppress {undefinedVars, duplicate} @this{Object} */
function BoxSupport(halfExtents, margin) {
  if (halfExtents && typeof halfExtents === 'object') halfExtents = halfExtents.ptr;
  if (margin && typeof margin === 'object') margin = margin.ptr;
  if (margin === undefined) { this.ptr = _emscripten_bind_BoxSupport_BoxSupport_1(halfExtents); getCache(BoxSupport)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_BoxSupport_BoxSupport_2(halfExtents, margin);
  getCache(BoxSupport)[this.ptr] = this;
};

BoxSupport.prototype = Object.create(Support.prototype);
BoxSupport.prototype.constructor = BoxSupport;
BoxSupport.prototype.__class__ = BoxSupport;
BoxSupport.__cache__ = {};
Module['BoxSupport'] = BoxSupport;
/** @suppress {undefinedVars, duplicate} @this{Object} */
BoxSupport.prototype['getMargin'] = BoxSupport.prototype.getMargin = function() {
  var self = this.ptr;
  return _emscripten_bind_BoxSupport_getMargin_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BoxSupport.prototype['supportLocal'] = BoxSupport.prototype.supportLocal = function(dir) {
  var self = this.ptr;
  if (dir && typeof dir === 'object') dir = dir.ptr;
  return wrapPointer(_emscripten_bind_BoxSupport_supportLocal_1(self, dir), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BoxSupport.prototype['get_halfExtents'] = BoxSupport.prototype.get_halfExtents = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_BoxSupport_get_halfExtents_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BoxSupport.prototype['set_halfExtents'] = BoxSupport.prototype.set_halfExtents = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BoxSupport_set_halfExtents_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BoxSupport.prototype, 'halfExtents', { get: BoxSupport.prototype.get_halfExtents, set: BoxSupport.prototype.set_halfExtents });
/** @suppress {undefinedVars, duplicate} @this{Object} */
BoxSupport.prototype['get_margin'] = BoxSupport.prototype.get_margin = function() {
  var self = this.ptr;
  return _emscripten_bind_BoxSupport_get_margin_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
BoxSupport.prototype['set_margin'] = BoxSupport.prototype.set_margin = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_BoxSupport_set_margin_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(BoxSupport.prototype, 'margin', { get: BoxSupport.prototype.get_margin, set: BoxSupport.prototype.set_margin });

/** @suppress {undefinedVars, duplicate} @this{Object} */
BoxSupport.prototype['__destroy__'] = BoxSupport.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_BoxSupport___destroy___0(self);
};

// Interface: CapsuleSupport

/** @suppress {undefinedVars, duplicate} @this{Object} */
function CapsuleSupport(radius, halfHeight) {
  if (radius && typeof radius === 'object') radius = radius.ptr;
  if (halfHeight && typeof halfHeight === 'object') halfHeight = halfHeight.ptr;
  this.ptr = _emscripten_bind_CapsuleSupport_CapsuleSupport_2(radius, halfHeight);
  getCache(CapsuleSupport)[this.ptr] = this;
};

CapsuleSupport.prototype = Object.create(Support.prototype);
CapsuleSupport.prototype.constructor = CapsuleSupport;
CapsuleSupport.prototype.__class__ = CapsuleSupport;
CapsuleSupport.__cache__ = {};
Module['CapsuleSupport'] = CapsuleSupport;
/** @suppress {undefinedVars, duplicate} @this{Object} */
CapsuleSupport.prototype['getMargin'] = CapsuleSupport.prototype.getMargin = function() {
  var self = this.ptr;
  return _emscripten_bind_CapsuleSupport_getMargin_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
CapsuleSupport.prototype['supportLocal'] = CapsuleSupport.prototype.supportLocal = function(dir) {
  var self = this.ptr;
  if (dir && typeof dir === 'object') dir = dir.ptr;
  return wrapPointer(_emscripten_bind_CapsuleSupport_supportLocal_1(self, dir), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
CapsuleSupport.prototype['get_radius'] = CapsuleSupport.prototype.get_radius = function() {
  var self = this.ptr;
  return _emscripten_bind_CapsuleSupport_get_radius_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
CapsuleSupport.prototype['set_radius'] = CapsuleSupport.prototype.set_radius = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_CapsuleSupport_set_radius_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(CapsuleSupport.prototype, 'radius', { get: CapsuleSupport.prototype.get_radius, set: CapsuleSupport.prototype.set_radius });
/** @suppress {undefinedVars, duplicate} @this{Object} */
CapsuleSupport.prototype['get_halfHeight'] = CapsuleSupport.prototype.get_halfHeight = function() {
  var self = this.ptr;
  return _emscripten_bind_CapsuleSupport_get_halfHeight_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
CapsuleSupport.prototype['set_halfHeight'] = CapsuleSupport.prototype.set_halfHeight = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_CapsuleSupport_set_halfHeight_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(CapsuleSupport.prototype, 'halfHeight', { get: CapsuleSupport.prototype.get_halfHeight, set: CapsuleSupport.prototype.set_halfHeight });

/** @suppress {undefinedVars, duplicate} @this{Object} */
CapsuleSupport.prototype['__destroy__'] = CapsuleSupport.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_CapsuleSupport___destroy___0(self);
};

// Interface: ConvexGeomSupport

/** @suppress {undefinedVars, duplicate} @this{Object} */
function ConvexGeomSupport(geom, margin) {
  if (geom && typeof geom === 'object') geom = geom.ptr;
  if (margin && typeof margin === 'object') margin = margin.ptr;
  if (geom === undefined) { this.ptr = _emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_0(); getCache(ConvexGeomSupport)[this.ptr] = this;return }
  if (margin === undefined) { this.ptr = _emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_1(geom); getCache(ConvexGeomSupport)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_ConvexGeomSupport_ConvexGeomSupport_2(geom, margin);
  getCache(ConvexGeomSupport)[this.ptr] = this;
};

ConvexGeomSupport.prototype = Object.create(Support.prototype);
ConvexGeomSupport.prototype.constructor = ConvexGeomSupport;
ConvexGeomSupport.prototype.__class__ = ConvexGeomSupport;
ConvexGeomSupport.__cache__ = {};
Module['ConvexGeomSupport'] = ConvexGeomSupport;
/** @suppress {undefinedVars, duplicate} @this{Object} */
ConvexGeomSupport.prototype['getMargin'] = ConvexGeomSupport.prototype.getMargin = function() {
  var self = this.ptr;
  return _emscripten_bind_ConvexGeomSupport_getMargin_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
ConvexGeomSupport.prototype['supportLocal'] = ConvexGeomSupport.prototype.supportLocal = function(dir) {
  var self = this.ptr;
  if (dir && typeof dir === 'object') dir = dir.ptr;
  return wrapPointer(_emscripten_bind_ConvexGeomSupport_supportLocal_1(self, dir), PxVec3);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
ConvexGeomSupport.prototype['__destroy__'] = ConvexGeomSupport.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_ConvexGeomSupport___destroy___0(self);
};

// Interface: ConvexMeshSupport

/** @suppress {undefinedVars, duplicate} @this{Object} */
function ConvexMeshSupport(convexMesh, scale, scaleRotation, margin) {
  if (convexMesh && typeof convexMesh === 'object') convexMesh = convexMesh.ptr;
  if (scale && typeof scale === 'object') scale = scale.ptr;
  if (scaleRotation && typeof scaleRotation === 'object') scaleRotation = scaleRotation.ptr;
  if (margin && typeof margin === 'object') margin = margin.ptr;
  if (scale === undefined) { this.ptr = _emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_1(convexMesh); getCache(ConvexMeshSupport)[this.ptr] = this;return }
  if (scaleRotation === undefined) { this.ptr = _emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_2(convexMesh, scale); getCache(ConvexMeshSupport)[this.ptr] = this;return }
  if (margin === undefined) { this.ptr = _emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_3(convexMesh, scale, scaleRotation); getCache(ConvexMeshSupport)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_ConvexMeshSupport_ConvexMeshSupport_4(convexMesh, scale, scaleRotation, margin);
  getCache(ConvexMeshSupport)[this.ptr] = this;
};

ConvexMeshSupport.prototype = Object.create(Support.prototype);
ConvexMeshSupport.prototype.constructor = ConvexMeshSupport;
ConvexMeshSupport.prototype.__class__ = ConvexMeshSupport;
ConvexMeshSupport.__cache__ = {};
Module['ConvexMeshSupport'] = ConvexMeshSupport;
/** @suppress {undefinedVars, duplicate} @this{Object} */
ConvexMeshSupport.prototype['getMargin'] = ConvexMeshSupport.prototype.getMargin = function() {
  var self = this.ptr;
  return _emscripten_bind_ConvexMeshSupport_getMargin_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
ConvexMeshSupport.prototype['supportLocal'] = ConvexMeshSupport.prototype.supportLocal = function(dir) {
  var self = this.ptr;
  if (dir && typeof dir === 'object') dir = dir.ptr;
  return wrapPointer(_emscripten_bind_ConvexMeshSupport_supportLocal_1(self, dir), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
ConvexMeshSupport.prototype['get_scale'] = ConvexMeshSupport.prototype.get_scale = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_ConvexMeshSupport_get_scale_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
ConvexMeshSupport.prototype['set_scale'] = ConvexMeshSupport.prototype.set_scale = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_ConvexMeshSupport_set_scale_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(ConvexMeshSupport.prototype, 'scale', { get: ConvexMeshSupport.prototype.get_scale, set: ConvexMeshSupport.prototype.set_scale });
/** @suppress {undefinedVars, duplicate} @this{Object} */
ConvexMeshSupport.prototype['get_scaleRotation'] = ConvexMeshSupport.prototype.get_scaleRotation = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_ConvexMeshSupport_get_scaleRotation_0(self), PxQuat);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
ConvexMeshSupport.prototype['set_scaleRotation'] = ConvexMeshSupport.prototype.set_scaleRotation = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_ConvexMeshSupport_set_scaleRotation_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(ConvexMeshSupport.prototype, 'scaleRotation', { get: ConvexMeshSupport.prototype.get_scaleRotation, set: ConvexMeshSupport.prototype.set_scaleRotation });
/** @suppress {undefinedVars, duplicate} @this{Object} */
ConvexMeshSupport.prototype['get_margin'] = ConvexMeshSupport.prototype.get_margin = function() {
  var self = this.ptr;
  return _emscripten_bind_ConvexMeshSupport_get_margin_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
ConvexMeshSupport.prototype['set_margin'] = ConvexMeshSupport.prototype.set_margin = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_ConvexMeshSupport_set_margin_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(ConvexMeshSupport.prototype, 'margin', { get: ConvexMeshSupport.prototype.get_margin, set: ConvexMeshSupport.prototype.set_margin });

/** @suppress {undefinedVars, duplicate} @this{Object} */
ConvexMeshSupport.prototype['__destroy__'] = ConvexMeshSupport.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_ConvexMeshSupport___destroy___0(self);
};

// Interface: CustomSupportImpl

/** @suppress {undefinedVars, duplicate} @this{Object} */
function CustomSupportImpl() {
  this.ptr = _emscripten_bind_CustomSupportImpl_CustomSupportImpl_0();
  getCache(CustomSupportImpl)[this.ptr] = this;
};

CustomSupportImpl.prototype = Object.create(CustomSupport.prototype);
CustomSupportImpl.prototype.constructor = CustomSupportImpl;
CustomSupportImpl.prototype.__class__ = CustomSupportImpl;
CustomSupportImpl.__cache__ = {};
Module['CustomSupportImpl'] = CustomSupportImpl;
/** @suppress {undefinedVars, duplicate} @this{Object} */
CustomSupportImpl.prototype['getCustomMargin'] = CustomSupportImpl.prototype.getCustomMargin = function() {
  var self = this.ptr;
  return _emscripten_bind_CustomSupportImpl_getCustomMargin_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
CustomSupportImpl.prototype['getCustomSupportLocal'] = CustomSupportImpl.prototype.getCustomSupportLocal = function(dir, result) {
  var self = this.ptr;
  if (dir && typeof dir === 'object') dir = dir.ptr;
  if (result && typeof result === 'object') result = result.ptr;
  _emscripten_bind_CustomSupportImpl_getCustomSupportLocal_2(self, dir, result);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
CustomSupportImpl.prototype['__destroy__'] = CustomSupportImpl.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_CustomSupportImpl___destroy___0(self);
};

// Interface: DirectDriveVehicle

/** @suppress {undefinedVars, duplicate} @this{Object} */
function DirectDriveVehicle() {
  this.ptr = _emscripten_bind_DirectDriveVehicle_DirectDriveVehicle_0();
  getCache(DirectDriveVehicle)[this.ptr] = this;
};

DirectDriveVehicle.prototype = Object.create(PhysXActorVehicle.prototype);
DirectDriveVehicle.prototype.constructor = DirectDriveVehicle;
DirectDriveVehicle.prototype.__class__ = DirectDriveVehicle;
DirectDriveVehicle.__cache__ = {};
Module['DirectDriveVehicle'] = DirectDriveVehicle;
/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['initialize'] = DirectDriveVehicle.prototype.initialize = function(physics, params, defaultMaterial, addPhysXBeginEndComponents) {
  var self = this.ptr;
  if (physics && typeof physics === 'object') physics = physics.ptr;
  if (params && typeof params === 'object') params = params.ptr;
  if (defaultMaterial && typeof defaultMaterial === 'object') defaultMaterial = defaultMaterial.ptr;
  if (addPhysXBeginEndComponents && typeof addPhysXBeginEndComponents === 'object') addPhysXBeginEndComponents = addPhysXBeginEndComponents.ptr;
  if (addPhysXBeginEndComponents === undefined) { return !!(_emscripten_bind_DirectDriveVehicle_initialize_3(self, physics, params, defaultMaterial)) }
  return !!(_emscripten_bind_DirectDriveVehicle_initialize_4(self, physics, params, defaultMaterial, addPhysXBeginEndComponents));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['initComponentSequence'] = DirectDriveVehicle.prototype.initComponentSequence = function(addPhysXBeginEndComponents) {
  var self = this.ptr;
  if (addPhysXBeginEndComponents && typeof addPhysXBeginEndComponents === 'object') addPhysXBeginEndComponents = addPhysXBeginEndComponents.ptr;
  _emscripten_bind_DirectDriveVehicle_initComponentSequence_1(self, addPhysXBeginEndComponents);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['destroyState'] = DirectDriveVehicle.prototype.destroyState = function() {
  var self = this.ptr;
  _emscripten_bind_DirectDriveVehicle_destroyState_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['step'] = DirectDriveVehicle.prototype.step = function(dt, context) {
  var self = this.ptr;
  if (dt && typeof dt === 'object') dt = dt.ptr;
  if (context && typeof context === 'object') context = context.ptr;
  _emscripten_bind_DirectDriveVehicle_step_2(self, dt, context);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['get_directDriveParams'] = DirectDriveVehicle.prototype.get_directDriveParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_DirectDriveVehicle_get_directDriveParams_0(self), DirectDrivetrainParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['set_directDriveParams'] = DirectDriveVehicle.prototype.set_directDriveParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_DirectDriveVehicle_set_directDriveParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(DirectDriveVehicle.prototype, 'directDriveParams', { get: DirectDriveVehicle.prototype.get_directDriveParams, set: DirectDriveVehicle.prototype.set_directDriveParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['get_directDriveState'] = DirectDriveVehicle.prototype.get_directDriveState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_DirectDriveVehicle_get_directDriveState_0(self), DirectDrivetrainState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['set_directDriveState'] = DirectDriveVehicle.prototype.set_directDriveState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_DirectDriveVehicle_set_directDriveState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(DirectDriveVehicle.prototype, 'directDriveState', { get: DirectDriveVehicle.prototype.get_directDriveState, set: DirectDriveVehicle.prototype.set_directDriveState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['get_transmissionCommandState'] = DirectDriveVehicle.prototype.get_transmissionCommandState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_DirectDriveVehicle_get_transmissionCommandState_0(self), PxVehicleDirectDriveTransmissionCommandState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['set_transmissionCommandState'] = DirectDriveVehicle.prototype.set_transmissionCommandState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_DirectDriveVehicle_set_transmissionCommandState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(DirectDriveVehicle.prototype, 'transmissionCommandState', { get: DirectDriveVehicle.prototype.get_transmissionCommandState, set: DirectDriveVehicle.prototype.set_transmissionCommandState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['get_baseParams'] = DirectDriveVehicle.prototype.get_baseParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_DirectDriveVehicle_get_baseParams_0(self), BaseVehicleParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['set_baseParams'] = DirectDriveVehicle.prototype.set_baseParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_DirectDriveVehicle_set_baseParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(DirectDriveVehicle.prototype, 'baseParams', { get: DirectDriveVehicle.prototype.get_baseParams, set: DirectDriveVehicle.prototype.set_baseParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['get_baseState'] = DirectDriveVehicle.prototype.get_baseState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_DirectDriveVehicle_get_baseState_0(self), BaseVehicleState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['set_baseState'] = DirectDriveVehicle.prototype.set_baseState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_DirectDriveVehicle_set_baseState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(DirectDriveVehicle.prototype, 'baseState', { get: DirectDriveVehicle.prototype.get_baseState, set: DirectDriveVehicle.prototype.set_baseState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['get_componentSequence'] = DirectDriveVehicle.prototype.get_componentSequence = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_DirectDriveVehicle_get_componentSequence_0(self), PxVehicleComponentSequence);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['set_componentSequence'] = DirectDriveVehicle.prototype.set_componentSequence = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_DirectDriveVehicle_set_componentSequence_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(DirectDriveVehicle.prototype, 'componentSequence', { get: DirectDriveVehicle.prototype.get_componentSequence, set: DirectDriveVehicle.prototype.set_componentSequence });
/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['get_componentSequenceSubstepGroupHandle'] = DirectDriveVehicle.prototype.get_componentSequenceSubstepGroupHandle = function() {
  var self = this.ptr;
  return _emscripten_bind_DirectDriveVehicle_get_componentSequenceSubstepGroupHandle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['set_componentSequenceSubstepGroupHandle'] = DirectDriveVehicle.prototype.set_componentSequenceSubstepGroupHandle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_DirectDriveVehicle_set_componentSequenceSubstepGroupHandle_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(DirectDriveVehicle.prototype, 'componentSequenceSubstepGroupHandle', { get: DirectDriveVehicle.prototype.get_componentSequenceSubstepGroupHandle, set: DirectDriveVehicle.prototype.set_componentSequenceSubstepGroupHandle });
/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['get_physXParams'] = DirectDriveVehicle.prototype.get_physXParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_DirectDriveVehicle_get_physXParams_0(self), PhysXIntegrationParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['set_physXParams'] = DirectDriveVehicle.prototype.set_physXParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_DirectDriveVehicle_set_physXParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(DirectDriveVehicle.prototype, 'physXParams', { get: DirectDriveVehicle.prototype.get_physXParams, set: DirectDriveVehicle.prototype.set_physXParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['get_physXState'] = DirectDriveVehicle.prototype.get_physXState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_DirectDriveVehicle_get_physXState_0(self), PhysXIntegrationState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['set_physXState'] = DirectDriveVehicle.prototype.set_physXState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_DirectDriveVehicle_set_physXState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(DirectDriveVehicle.prototype, 'physXState', { get: DirectDriveVehicle.prototype.get_physXState, set: DirectDriveVehicle.prototype.set_physXState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['get_commandState'] = DirectDriveVehicle.prototype.get_commandState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_DirectDriveVehicle_get_commandState_0(self), PxVehicleCommandState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['set_commandState'] = DirectDriveVehicle.prototype.set_commandState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_DirectDriveVehicle_set_commandState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(DirectDriveVehicle.prototype, 'commandState', { get: DirectDriveVehicle.prototype.get_commandState, set: DirectDriveVehicle.prototype.set_commandState });

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDriveVehicle.prototype['__destroy__'] = DirectDriveVehicle.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_DirectDriveVehicle___destroy___0(self);
};

// Interface: DirectDrivetrainParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function DirectDrivetrainParams() {
  this.ptr = _emscripten_bind_DirectDrivetrainParams_DirectDrivetrainParams_0();
  getCache(DirectDrivetrainParams)[this.ptr] = this;
};

DirectDrivetrainParams.prototype = Object.create(WrapperObject.prototype);
DirectDrivetrainParams.prototype.constructor = DirectDrivetrainParams;
DirectDrivetrainParams.prototype.__class__ = DirectDrivetrainParams;
DirectDrivetrainParams.__cache__ = {};
Module['DirectDrivetrainParams'] = DirectDrivetrainParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDrivetrainParams.prototype['transformAndScale'] = DirectDrivetrainParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_DirectDrivetrainParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), DirectDrivetrainParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDrivetrainParams.prototype['isValid'] = DirectDrivetrainParams.prototype.isValid = function(axleDesc) {
  var self = this.ptr;
  if (axleDesc && typeof axleDesc === 'object') axleDesc = axleDesc.ptr;
  return !!(_emscripten_bind_DirectDrivetrainParams_isValid_1(self, axleDesc));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDrivetrainParams.prototype['get_directDriveThrottleResponseParams'] = DirectDrivetrainParams.prototype.get_directDriveThrottleResponseParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_DirectDrivetrainParams_get_directDriveThrottleResponseParams_0(self), PxVehicleDirectDriveThrottleCommandResponseParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDrivetrainParams.prototype['set_directDriveThrottleResponseParams'] = DirectDrivetrainParams.prototype.set_directDriveThrottleResponseParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_DirectDrivetrainParams_set_directDriveThrottleResponseParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(DirectDrivetrainParams.prototype, 'directDriveThrottleResponseParams', { get: DirectDrivetrainParams.prototype.get_directDriveThrottleResponseParams, set: DirectDrivetrainParams.prototype.set_directDriveThrottleResponseParams });

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDrivetrainParams.prototype['__destroy__'] = DirectDrivetrainParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_DirectDrivetrainParams___destroy___0(self);
};

// Interface: DirectDrivetrainState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function DirectDrivetrainState() {
  this.ptr = _emscripten_bind_DirectDrivetrainState_DirectDrivetrainState_0();
  getCache(DirectDrivetrainState)[this.ptr] = this;
};

DirectDrivetrainState.prototype = Object.create(WrapperObject.prototype);
DirectDrivetrainState.prototype.constructor = DirectDrivetrainState;
DirectDrivetrainState.prototype.__class__ = DirectDrivetrainState;
DirectDrivetrainState.__cache__ = {};
Module['DirectDrivetrainState'] = DirectDrivetrainState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDrivetrainState.prototype['setToDefault'] = DirectDrivetrainState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_DirectDrivetrainState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDrivetrainState.prototype['get_directDriveThrottleResponseStates'] = DirectDrivetrainState.prototype.get_directDriveThrottleResponseStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_DirectDrivetrainState_get_directDriveThrottleResponseStates_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDrivetrainState.prototype['set_directDriveThrottleResponseStates'] = DirectDrivetrainState.prototype.set_directDriveThrottleResponseStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_DirectDrivetrainState_set_directDriveThrottleResponseStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(DirectDrivetrainState.prototype, 'directDriveThrottleResponseStates', { get: DirectDrivetrainState.prototype.get_directDriveThrottleResponseStates, set: DirectDrivetrainState.prototype.set_directDriveThrottleResponseStates });

/** @suppress {undefinedVars, duplicate} @this{Object} */
DirectDrivetrainState.prototype['__destroy__'] = DirectDrivetrainState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_DirectDrivetrainState___destroy___0(self);
};

// Interface: EngineDriveVehicle

/** @suppress {undefinedVars, duplicate} @this{Object} */
function EngineDriveVehicle() {
  this.ptr = _emscripten_bind_EngineDriveVehicle_EngineDriveVehicle_0();
  getCache(EngineDriveVehicle)[this.ptr] = this;
};

EngineDriveVehicle.prototype = Object.create(PhysXActorVehicle.prototype);
EngineDriveVehicle.prototype.constructor = EngineDriveVehicle;
EngineDriveVehicle.prototype.__class__ = EngineDriveVehicle;
EngineDriveVehicle.__cache__ = {};
Module['EngineDriveVehicle'] = EngineDriveVehicle;
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['initialize'] = EngineDriveVehicle.prototype.initialize = function(physics, params, defaultMaterial, differentialType, addPhysXBeginEndComponents) {
  var self = this.ptr;
  if (physics && typeof physics === 'object') physics = physics.ptr;
  if (params && typeof params === 'object') params = params.ptr;
  if (defaultMaterial && typeof defaultMaterial === 'object') defaultMaterial = defaultMaterial.ptr;
  if (differentialType && typeof differentialType === 'object') differentialType = differentialType.ptr;
  if (addPhysXBeginEndComponents && typeof addPhysXBeginEndComponents === 'object') addPhysXBeginEndComponents = addPhysXBeginEndComponents.ptr;
  if (addPhysXBeginEndComponents === undefined) { return !!(_emscripten_bind_EngineDriveVehicle_initialize_4(self, physics, params, defaultMaterial, differentialType)) }
  return !!(_emscripten_bind_EngineDriveVehicle_initialize_5(self, physics, params, defaultMaterial, differentialType, addPhysXBeginEndComponents));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['initComponentSequence'] = EngineDriveVehicle.prototype.initComponentSequence = function(addPhysXBeginEndComponents) {
  var self = this.ptr;
  if (addPhysXBeginEndComponents && typeof addPhysXBeginEndComponents === 'object') addPhysXBeginEndComponents = addPhysXBeginEndComponents.ptr;
  _emscripten_bind_EngineDriveVehicle_initComponentSequence_1(self, addPhysXBeginEndComponents);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['destroyState'] = EngineDriveVehicle.prototype.destroyState = function() {
  var self = this.ptr;
  _emscripten_bind_EngineDriveVehicle_destroyState_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['step'] = EngineDriveVehicle.prototype.step = function(dt, context) {
  var self = this.ptr;
  if (dt && typeof dt === 'object') dt = dt.ptr;
  if (context && typeof context === 'object') context = context.ptr;
  _emscripten_bind_EngineDriveVehicle_step_2(self, dt, context);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['get_engineDriveParams'] = EngineDriveVehicle.prototype.get_engineDriveParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDriveVehicle_get_engineDriveParams_0(self), EngineDrivetrainParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['set_engineDriveParams'] = EngineDriveVehicle.prototype.set_engineDriveParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDriveVehicle_set_engineDriveParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDriveVehicle.prototype, 'engineDriveParams', { get: EngineDriveVehicle.prototype.get_engineDriveParams, set: EngineDriveVehicle.prototype.set_engineDriveParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['get_engineDriveState'] = EngineDriveVehicle.prototype.get_engineDriveState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDriveVehicle_get_engineDriveState_0(self), EngineDrivetrainState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['set_engineDriveState'] = EngineDriveVehicle.prototype.set_engineDriveState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDriveVehicle_set_engineDriveState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDriveVehicle.prototype, 'engineDriveState', { get: EngineDriveVehicle.prototype.get_engineDriveState, set: EngineDriveVehicle.prototype.set_engineDriveState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['get_transmissionCommandState'] = EngineDriveVehicle.prototype.get_transmissionCommandState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDriveVehicle_get_transmissionCommandState_0(self), PxVehicleEngineDriveTransmissionCommandState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['set_transmissionCommandState'] = EngineDriveVehicle.prototype.set_transmissionCommandState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDriveVehicle_set_transmissionCommandState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDriveVehicle.prototype, 'transmissionCommandState', { get: EngineDriveVehicle.prototype.get_transmissionCommandState, set: EngineDriveVehicle.prototype.set_transmissionCommandState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['get_tankDriveTransmissionCommandState'] = EngineDriveVehicle.prototype.get_tankDriveTransmissionCommandState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDriveVehicle_get_tankDriveTransmissionCommandState_0(self), PxVehicleTankDriveTransmissionCommandState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['set_tankDriveTransmissionCommandState'] = EngineDriveVehicle.prototype.set_tankDriveTransmissionCommandState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDriveVehicle_set_tankDriveTransmissionCommandState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDriveVehicle.prototype, 'tankDriveTransmissionCommandState', { get: EngineDriveVehicle.prototype.get_tankDriveTransmissionCommandState, set: EngineDriveVehicle.prototype.set_tankDriveTransmissionCommandState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['get_differentialType'] = EngineDriveVehicle.prototype.get_differentialType = function() {
  var self = this.ptr;
  return _emscripten_bind_EngineDriveVehicle_get_differentialType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['set_differentialType'] = EngineDriveVehicle.prototype.set_differentialType = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDriveVehicle_set_differentialType_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDriveVehicle.prototype, 'differentialType', { get: EngineDriveVehicle.prototype.get_differentialType, set: EngineDriveVehicle.prototype.set_differentialType });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['get_baseParams'] = EngineDriveVehicle.prototype.get_baseParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDriveVehicle_get_baseParams_0(self), BaseVehicleParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['set_baseParams'] = EngineDriveVehicle.prototype.set_baseParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDriveVehicle_set_baseParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDriveVehicle.prototype, 'baseParams', { get: EngineDriveVehicle.prototype.get_baseParams, set: EngineDriveVehicle.prototype.set_baseParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['get_baseState'] = EngineDriveVehicle.prototype.get_baseState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDriveVehicle_get_baseState_0(self), BaseVehicleState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['set_baseState'] = EngineDriveVehicle.prototype.set_baseState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDriveVehicle_set_baseState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDriveVehicle.prototype, 'baseState', { get: EngineDriveVehicle.prototype.get_baseState, set: EngineDriveVehicle.prototype.set_baseState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['get_componentSequence'] = EngineDriveVehicle.prototype.get_componentSequence = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDriveVehicle_get_componentSequence_0(self), PxVehicleComponentSequence);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['set_componentSequence'] = EngineDriveVehicle.prototype.set_componentSequence = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDriveVehicle_set_componentSequence_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDriveVehicle.prototype, 'componentSequence', { get: EngineDriveVehicle.prototype.get_componentSequence, set: EngineDriveVehicle.prototype.set_componentSequence });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['get_componentSequenceSubstepGroupHandle'] = EngineDriveVehicle.prototype.get_componentSequenceSubstepGroupHandle = function() {
  var self = this.ptr;
  return _emscripten_bind_EngineDriveVehicle_get_componentSequenceSubstepGroupHandle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['set_componentSequenceSubstepGroupHandle'] = EngineDriveVehicle.prototype.set_componentSequenceSubstepGroupHandle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDriveVehicle_set_componentSequenceSubstepGroupHandle_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDriveVehicle.prototype, 'componentSequenceSubstepGroupHandle', { get: EngineDriveVehicle.prototype.get_componentSequenceSubstepGroupHandle, set: EngineDriveVehicle.prototype.set_componentSequenceSubstepGroupHandle });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['get_physXParams'] = EngineDriveVehicle.prototype.get_physXParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDriveVehicle_get_physXParams_0(self), PhysXIntegrationParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['set_physXParams'] = EngineDriveVehicle.prototype.set_physXParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDriveVehicle_set_physXParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDriveVehicle.prototype, 'physXParams', { get: EngineDriveVehicle.prototype.get_physXParams, set: EngineDriveVehicle.prototype.set_physXParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['get_physXState'] = EngineDriveVehicle.prototype.get_physXState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDriveVehicle_get_physXState_0(self), PhysXIntegrationState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['set_physXState'] = EngineDriveVehicle.prototype.set_physXState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDriveVehicle_set_physXState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDriveVehicle.prototype, 'physXState', { get: EngineDriveVehicle.prototype.get_physXState, set: EngineDriveVehicle.prototype.set_physXState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['get_commandState'] = EngineDriveVehicle.prototype.get_commandState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDriveVehicle_get_commandState_0(self), PxVehicleCommandState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['set_commandState'] = EngineDriveVehicle.prototype.set_commandState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDriveVehicle_set_commandState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDriveVehicle.prototype, 'commandState', { get: EngineDriveVehicle.prototype.get_commandState, set: EngineDriveVehicle.prototype.set_commandState });

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDriveVehicle.prototype['__destroy__'] = EngineDriveVehicle.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_EngineDriveVehicle___destroy___0(self);
};

// Interface: EngineDrivetrainParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function EngineDrivetrainParams() {
  this.ptr = _emscripten_bind_EngineDrivetrainParams_EngineDrivetrainParams_0();
  getCache(EngineDrivetrainParams)[this.ptr] = this;
};

EngineDrivetrainParams.prototype = Object.create(WrapperObject.prototype);
EngineDrivetrainParams.prototype.constructor = EngineDrivetrainParams;
EngineDrivetrainParams.prototype.__class__ = EngineDrivetrainParams;
EngineDrivetrainParams.__cache__ = {};
Module['EngineDrivetrainParams'] = EngineDrivetrainParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['transformAndScale'] = EngineDrivetrainParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), EngineDrivetrainParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['isValid'] = EngineDrivetrainParams.prototype.isValid = function(axleDesc) {
  var self = this.ptr;
  if (axleDesc && typeof axleDesc === 'object') axleDesc = axleDesc.ptr;
  return !!(_emscripten_bind_EngineDrivetrainParams_isValid_1(self, axleDesc));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['get_autoboxParams'] = EngineDrivetrainParams.prototype.get_autoboxParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainParams_get_autoboxParams_0(self), PxVehicleAutoboxParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['set_autoboxParams'] = EngineDrivetrainParams.prototype.set_autoboxParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainParams_set_autoboxParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainParams.prototype, 'autoboxParams', { get: EngineDrivetrainParams.prototype.get_autoboxParams, set: EngineDrivetrainParams.prototype.set_autoboxParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['get_clutchCommandResponseParams'] = EngineDrivetrainParams.prototype.get_clutchCommandResponseParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainParams_get_clutchCommandResponseParams_0(self), PxVehicleClutchCommandResponseParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['set_clutchCommandResponseParams'] = EngineDrivetrainParams.prototype.set_clutchCommandResponseParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainParams_set_clutchCommandResponseParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainParams.prototype, 'clutchCommandResponseParams', { get: EngineDrivetrainParams.prototype.get_clutchCommandResponseParams, set: EngineDrivetrainParams.prototype.set_clutchCommandResponseParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['get_engineParams'] = EngineDrivetrainParams.prototype.get_engineParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainParams_get_engineParams_0(self), PxVehicleEngineParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['set_engineParams'] = EngineDrivetrainParams.prototype.set_engineParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainParams_set_engineParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainParams.prototype, 'engineParams', { get: EngineDrivetrainParams.prototype.get_engineParams, set: EngineDrivetrainParams.prototype.set_engineParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['get_gearBoxParams'] = EngineDrivetrainParams.prototype.get_gearBoxParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainParams_get_gearBoxParams_0(self), PxVehicleGearboxParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['set_gearBoxParams'] = EngineDrivetrainParams.prototype.set_gearBoxParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainParams_set_gearBoxParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainParams.prototype, 'gearBoxParams', { get: EngineDrivetrainParams.prototype.get_gearBoxParams, set: EngineDrivetrainParams.prototype.set_gearBoxParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['get_multiWheelDifferentialParams'] = EngineDrivetrainParams.prototype.get_multiWheelDifferentialParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainParams_get_multiWheelDifferentialParams_0(self), PxVehicleMultiWheelDriveDifferentialParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['set_multiWheelDifferentialParams'] = EngineDrivetrainParams.prototype.set_multiWheelDifferentialParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainParams_set_multiWheelDifferentialParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainParams.prototype, 'multiWheelDifferentialParams', { get: EngineDrivetrainParams.prototype.get_multiWheelDifferentialParams, set: EngineDrivetrainParams.prototype.set_multiWheelDifferentialParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['get_fourWheelDifferentialParams'] = EngineDrivetrainParams.prototype.get_fourWheelDifferentialParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainParams_get_fourWheelDifferentialParams_0(self), PxVehicleFourWheelDriveDifferentialParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['set_fourWheelDifferentialParams'] = EngineDrivetrainParams.prototype.set_fourWheelDifferentialParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainParams_set_fourWheelDifferentialParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainParams.prototype, 'fourWheelDifferentialParams', { get: EngineDrivetrainParams.prototype.get_fourWheelDifferentialParams, set: EngineDrivetrainParams.prototype.set_fourWheelDifferentialParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['get_tankDifferentialParams'] = EngineDrivetrainParams.prototype.get_tankDifferentialParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainParams_get_tankDifferentialParams_0(self), PxVehicleTankDriveDifferentialParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['set_tankDifferentialParams'] = EngineDrivetrainParams.prototype.set_tankDifferentialParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainParams_set_tankDifferentialParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainParams.prototype, 'tankDifferentialParams', { get: EngineDrivetrainParams.prototype.get_tankDifferentialParams, set: EngineDrivetrainParams.prototype.set_tankDifferentialParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['get_clutchParams'] = EngineDrivetrainParams.prototype.get_clutchParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainParams_get_clutchParams_0(self), PxVehicleClutchParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['set_clutchParams'] = EngineDrivetrainParams.prototype.set_clutchParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainParams_set_clutchParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainParams.prototype, 'clutchParams', { get: EngineDrivetrainParams.prototype.get_clutchParams, set: EngineDrivetrainParams.prototype.set_clutchParams });

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainParams.prototype['__destroy__'] = EngineDrivetrainParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_EngineDrivetrainParams___destroy___0(self);
};

// Interface: EngineDrivetrainState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function EngineDrivetrainState() {
  this.ptr = _emscripten_bind_EngineDrivetrainState_EngineDrivetrainState_0();
  getCache(EngineDrivetrainState)[this.ptr] = this;
};

EngineDrivetrainState.prototype = Object.create(WrapperObject.prototype);
EngineDrivetrainState.prototype.constructor = EngineDrivetrainState;
EngineDrivetrainState.prototype.__class__ = EngineDrivetrainState;
EngineDrivetrainState.__cache__ = {};
Module['EngineDrivetrainState'] = EngineDrivetrainState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['setToDefault'] = EngineDrivetrainState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_EngineDrivetrainState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['get_throttleCommandResponseState'] = EngineDrivetrainState.prototype.get_throttleCommandResponseState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainState_get_throttleCommandResponseState_0(self), PxVehicleEngineDriveThrottleCommandResponseState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['set_throttleCommandResponseState'] = EngineDrivetrainState.prototype.set_throttleCommandResponseState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainState_set_throttleCommandResponseState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainState.prototype, 'throttleCommandResponseState', { get: EngineDrivetrainState.prototype.get_throttleCommandResponseState, set: EngineDrivetrainState.prototype.set_throttleCommandResponseState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['get_autoboxState'] = EngineDrivetrainState.prototype.get_autoboxState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainState_get_autoboxState_0(self), PxVehicleAutoboxState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['set_autoboxState'] = EngineDrivetrainState.prototype.set_autoboxState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainState_set_autoboxState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainState.prototype, 'autoboxState', { get: EngineDrivetrainState.prototype.get_autoboxState, set: EngineDrivetrainState.prototype.set_autoboxState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['get_clutchCommandResponseState'] = EngineDrivetrainState.prototype.get_clutchCommandResponseState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainState_get_clutchCommandResponseState_0(self), PxVehicleClutchCommandResponseState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['set_clutchCommandResponseState'] = EngineDrivetrainState.prototype.set_clutchCommandResponseState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainState_set_clutchCommandResponseState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainState.prototype, 'clutchCommandResponseState', { get: EngineDrivetrainState.prototype.get_clutchCommandResponseState, set: EngineDrivetrainState.prototype.set_clutchCommandResponseState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['get_differentialState'] = EngineDrivetrainState.prototype.get_differentialState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainState_get_differentialState_0(self), PxVehicleDifferentialState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['set_differentialState'] = EngineDrivetrainState.prototype.set_differentialState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainState_set_differentialState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainState.prototype, 'differentialState', { get: EngineDrivetrainState.prototype.get_differentialState, set: EngineDrivetrainState.prototype.set_differentialState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['get_wheelConstraintGroupState'] = EngineDrivetrainState.prototype.get_wheelConstraintGroupState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainState_get_wheelConstraintGroupState_0(self), PxVehicleWheelConstraintGroupState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['set_wheelConstraintGroupState'] = EngineDrivetrainState.prototype.set_wheelConstraintGroupState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainState_set_wheelConstraintGroupState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainState.prototype, 'wheelConstraintGroupState', { get: EngineDrivetrainState.prototype.get_wheelConstraintGroupState, set: EngineDrivetrainState.prototype.set_wheelConstraintGroupState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['get_engineState'] = EngineDrivetrainState.prototype.get_engineState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainState_get_engineState_0(self), PxVehicleEngineState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['set_engineState'] = EngineDrivetrainState.prototype.set_engineState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainState_set_engineState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainState.prototype, 'engineState', { get: EngineDrivetrainState.prototype.get_engineState, set: EngineDrivetrainState.prototype.set_engineState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['get_gearboxState'] = EngineDrivetrainState.prototype.get_gearboxState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainState_get_gearboxState_0(self), PxVehicleGearboxState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['set_gearboxState'] = EngineDrivetrainState.prototype.set_gearboxState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainState_set_gearboxState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainState.prototype, 'gearboxState', { get: EngineDrivetrainState.prototype.get_gearboxState, set: EngineDrivetrainState.prototype.set_gearboxState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['get_clutchState'] = EngineDrivetrainState.prototype.get_clutchState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_EngineDrivetrainState_get_clutchState_0(self), PxVehicleClutchSlipState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['set_clutchState'] = EngineDrivetrainState.prototype.set_clutchState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_EngineDrivetrainState_set_clutchState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(EngineDrivetrainState.prototype, 'clutchState', { get: EngineDrivetrainState.prototype.get_clutchState, set: EngineDrivetrainState.prototype.set_clutchState });

/** @suppress {undefinedVars, duplicate} @this{Object} */
EngineDrivetrainState.prototype['__destroy__'] = EngineDrivetrainState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_EngineDrivetrainState___destroy___0(self);
};

// Interface: NativeArrayHelpers

/** @suppress {undefinedVars, duplicate} @this{Object} */
function NativeArrayHelpers() { throw "cannot construct a NativeArrayHelpers, no constructor in IDL" }
NativeArrayHelpers.prototype = Object.create(WrapperObject.prototype);
NativeArrayHelpers.prototype.constructor = NativeArrayHelpers;
NativeArrayHelpers.prototype.__class__ = NativeArrayHelpers;
NativeArrayHelpers.__cache__ = {};
Module['NativeArrayHelpers'] = NativeArrayHelpers;
/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getU8At'] = NativeArrayHelpers.prototype.getU8At = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return _emscripten_bind_NativeArrayHelpers_getU8At_2(base, index);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getU16At'] = NativeArrayHelpers.prototype.getU16At = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return _emscripten_bind_NativeArrayHelpers_getU16At_2(base, index);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getU32At'] = NativeArrayHelpers.prototype.getU32At = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return _emscripten_bind_NativeArrayHelpers_getU32At_2(base, index);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getRealAt'] = NativeArrayHelpers.prototype.getRealAt = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return _emscripten_bind_NativeArrayHelpers_getRealAt_2(base, index);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['setU8At'] = NativeArrayHelpers.prototype.setU8At = function(base, index, value) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_NativeArrayHelpers_setU8At_3(base, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['setU16At'] = NativeArrayHelpers.prototype.setU16At = function(base, index, value) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_NativeArrayHelpers_setU16At_3(base, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['setU32At'] = NativeArrayHelpers.prototype.setU32At = function(base, index, value) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_NativeArrayHelpers_setU32At_3(base, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['setRealAt'] = NativeArrayHelpers.prototype.setRealAt = function(base, index, value) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_NativeArrayHelpers_setRealAt_3(base, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['voidToU8Ptr'] = NativeArrayHelpers.prototype.voidToU8Ptr = function(voidPtr) {
  if (voidPtr && typeof voidPtr === 'object') voidPtr = voidPtr.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_voidToU8Ptr_1(voidPtr), PxU8Ptr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['voidToU16Ptr'] = NativeArrayHelpers.prototype.voidToU16Ptr = function(voidPtr) {
  if (voidPtr && typeof voidPtr === 'object') voidPtr = voidPtr.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_voidToU16Ptr_1(voidPtr), PxU16Ptr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['voidToU32Ptr'] = NativeArrayHelpers.prototype.voidToU32Ptr = function(voidPtr) {
  if (voidPtr && typeof voidPtr === 'object') voidPtr = voidPtr.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_voidToU32Ptr_1(voidPtr), PxU32Ptr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['voidToI32Ptr'] = NativeArrayHelpers.prototype.voidToI32Ptr = function(voidPtr) {
  if (voidPtr && typeof voidPtr === 'object') voidPtr = voidPtr.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_voidToI32Ptr_1(voidPtr), PxI32Ptr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['voidToRealPtr'] = NativeArrayHelpers.prototype.voidToRealPtr = function(voidPtr) {
  if (voidPtr && typeof voidPtr === 'object') voidPtr = voidPtr.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_voidToRealPtr_1(voidPtr), PxRealPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getActorAt'] = NativeArrayHelpers.prototype.getActorAt = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getActorAt_2(base, index), PxActor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getBounds3At'] = NativeArrayHelpers.prototype.getBounds3At = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getBounds3At_2(base, index), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getContactPairAt'] = NativeArrayHelpers.prototype.getContactPairAt = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getContactPairAt_2(base, index), PxContactPair);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getContactPairHeaderAt'] = NativeArrayHelpers.prototype.getContactPairHeaderAt = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getContactPairHeaderAt_2(base, index), PxContactPairHeader);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getControllerAt'] = NativeArrayHelpers.prototype.getControllerAt = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getControllerAt_2(base, index), PxController);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getControllerShapeHitAt'] = NativeArrayHelpers.prototype.getControllerShapeHitAt = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getControllerShapeHitAt_2(base, index), PxControllerShapeHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getControllersHitAt'] = NativeArrayHelpers.prototype.getControllersHitAt = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getControllersHitAt_2(base, index), PxControllersHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getControllerObstacleHitAt'] = NativeArrayHelpers.prototype.getControllerObstacleHitAt = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getControllerObstacleHitAt_2(base, index), PxControllerObstacleHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getDebugPointAt'] = NativeArrayHelpers.prototype.getDebugPointAt = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getDebugPointAt_2(base, index), PxDebugPoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getDebugLineAt'] = NativeArrayHelpers.prototype.getDebugLineAt = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getDebugLineAt_2(base, index), PxDebugLine);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getDebugTriangleAt'] = NativeArrayHelpers.prototype.getDebugTriangleAt = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getDebugTriangleAt_2(base, index), PxDebugTriangle);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getObstacleAt'] = NativeArrayHelpers.prototype.getObstacleAt = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getObstacleAt_2(base, index), PxObstacle);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getShapeAt'] = NativeArrayHelpers.prototype.getShapeAt = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getShapeAt_2(base, index), PxShape);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getTriggerPairAt'] = NativeArrayHelpers.prototype.getTriggerPairAt = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getTriggerPairAt_2(base, index), PxTriggerPair);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['getVec3At'] = NativeArrayHelpers.prototype.getVec3At = function(base, index) {
  if (base && typeof base === 'object') base = base.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_NativeArrayHelpers_getVec3At_2(base, index), PxVec3);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
NativeArrayHelpers.prototype['__destroy__'] = NativeArrayHelpers.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_NativeArrayHelpers___destroy___0(self);
};

// Interface: PassThroughFilterShaderImpl

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PassThroughFilterShaderImpl() {
  this.ptr = _emscripten_bind_PassThroughFilterShaderImpl_PassThroughFilterShaderImpl_0();
  getCache(PassThroughFilterShaderImpl)[this.ptr] = this;
};

PassThroughFilterShaderImpl.prototype = Object.create(PassThroughFilterShader.prototype);
PassThroughFilterShaderImpl.prototype.constructor = PassThroughFilterShaderImpl;
PassThroughFilterShaderImpl.prototype.__class__ = PassThroughFilterShaderImpl;
PassThroughFilterShaderImpl.__cache__ = {};
Module['PassThroughFilterShaderImpl'] = PassThroughFilterShaderImpl;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PassThroughFilterShaderImpl.prototype['filterShader'] = PassThroughFilterShaderImpl.prototype.filterShader = function(attributes0, filterData0w0, filterData0w1, filterData0w2, filterData0w3, attributes1, filterData1w0, filterData1w1, filterData1w2, filterData1w3) {
  var self = this.ptr;
  if (attributes0 && typeof attributes0 === 'object') attributes0 = attributes0.ptr;
  if (filterData0w0 && typeof filterData0w0 === 'object') filterData0w0 = filterData0w0.ptr;
  if (filterData0w1 && typeof filterData0w1 === 'object') filterData0w1 = filterData0w1.ptr;
  if (filterData0w2 && typeof filterData0w2 === 'object') filterData0w2 = filterData0w2.ptr;
  if (filterData0w3 && typeof filterData0w3 === 'object') filterData0w3 = filterData0w3.ptr;
  if (attributes1 && typeof attributes1 === 'object') attributes1 = attributes1.ptr;
  if (filterData1w0 && typeof filterData1w0 === 'object') filterData1w0 = filterData1w0.ptr;
  if (filterData1w1 && typeof filterData1w1 === 'object') filterData1w1 = filterData1w1.ptr;
  if (filterData1w2 && typeof filterData1w2 === 'object') filterData1w2 = filterData1w2.ptr;
  if (filterData1w3 && typeof filterData1w3 === 'object') filterData1w3 = filterData1w3.ptr;
  return _emscripten_bind_PassThroughFilterShaderImpl_filterShader_10(self, attributes0, filterData0w0, filterData0w1, filterData0w2, filterData0w3, attributes1, filterData1w0, filterData1w1, filterData1w2, filterData1w3);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PassThroughFilterShaderImpl.prototype['__destroy__'] = PassThroughFilterShaderImpl.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PassThroughFilterShaderImpl___destroy___0(self);
};

// Interface: PhysXIntegrationParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PhysXIntegrationParams() {
  this.ptr = _emscripten_bind_PhysXIntegrationParams_PhysXIntegrationParams_0();
  getCache(PhysXIntegrationParams)[this.ptr] = this;
};

PhysXIntegrationParams.prototype = Object.create(WrapperObject.prototype);
PhysXIntegrationParams.prototype.constructor = PhysXIntegrationParams;
PhysXIntegrationParams.prototype.__class__ = PhysXIntegrationParams;
PhysXIntegrationParams.__cache__ = {};
Module['PhysXIntegrationParams'] = PhysXIntegrationParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['transformAndScale'] = PhysXIntegrationParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PhysXIntegrationParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['isValid'] = PhysXIntegrationParams.prototype.isValid = function(axleDesc) {
  var self = this.ptr;
  if (axleDesc && typeof axleDesc === 'object') axleDesc = axleDesc.ptr;
  return !!(_emscripten_bind_PhysXIntegrationParams_isValid_1(self, axleDesc));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['create'] = PhysXIntegrationParams.prototype.create = function(axleDesc, roadQueryFilterData, roadQueryFilterCallback, materialFrictions, nbMaterialFrictions, defaultFriction, physxActorCMassLocalPose, actorGeometry, physxActorBoxShapeLocalPose, roadGeometryQueryType) {
  var self = this.ptr;
  if (axleDesc && typeof axleDesc === 'object') axleDesc = axleDesc.ptr;
  if (roadQueryFilterData && typeof roadQueryFilterData === 'object') roadQueryFilterData = roadQueryFilterData.ptr;
  if (roadQueryFilterCallback && typeof roadQueryFilterCallback === 'object') roadQueryFilterCallback = roadQueryFilterCallback.ptr;
  if (materialFrictions && typeof materialFrictions === 'object') materialFrictions = materialFrictions.ptr;
  if (nbMaterialFrictions && typeof nbMaterialFrictions === 'object') nbMaterialFrictions = nbMaterialFrictions.ptr;
  if (defaultFriction && typeof defaultFriction === 'object') defaultFriction = defaultFriction.ptr;
  if (physxActorCMassLocalPose && typeof physxActorCMassLocalPose === 'object') physxActorCMassLocalPose = physxActorCMassLocalPose.ptr;
  if (actorGeometry && typeof actorGeometry === 'object') actorGeometry = actorGeometry.ptr;
  if (physxActorBoxShapeLocalPose && typeof physxActorBoxShapeLocalPose === 'object') physxActorBoxShapeLocalPose = physxActorBoxShapeLocalPose.ptr;
  if (roadGeometryQueryType && typeof roadGeometryQueryType === 'object') roadGeometryQueryType = roadGeometryQueryType.ptr;
  _emscripten_bind_PhysXIntegrationParams_create_10(self, axleDesc, roadQueryFilterData, roadQueryFilterCallback, materialFrictions, nbMaterialFrictions, defaultFriction, physxActorCMassLocalPose, actorGeometry, physxActorBoxShapeLocalPose, roadGeometryQueryType);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['get_physxRoadGeometryQueryParams'] = PhysXIntegrationParams.prototype.get_physxRoadGeometryQueryParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationParams_get_physxRoadGeometryQueryParams_0(self), PxVehiclePhysXRoadGeometryQueryParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['set_physxRoadGeometryQueryParams'] = PhysXIntegrationParams.prototype.set_physxRoadGeometryQueryParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXIntegrationParams_set_physxRoadGeometryQueryParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationParams.prototype, 'physxRoadGeometryQueryParams', { get: PhysXIntegrationParams.prototype.get_physxRoadGeometryQueryParams, set: PhysXIntegrationParams.prototype.set_physxRoadGeometryQueryParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['get_physxMaterialFrictionParams'] = PhysXIntegrationParams.prototype.get_physxMaterialFrictionParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationParams_get_physxMaterialFrictionParams_1(self, arg0), PxVehiclePhysXMaterialFrictionParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['set_physxMaterialFrictionParams'] = PhysXIntegrationParams.prototype.set_physxMaterialFrictionParams = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PhysXIntegrationParams_set_physxMaterialFrictionParams_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationParams.prototype, 'physxMaterialFrictionParams', { get: PhysXIntegrationParams.prototype.get_physxMaterialFrictionParams, set: PhysXIntegrationParams.prototype.set_physxMaterialFrictionParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['get_physxSuspensionLimitConstraintParams'] = PhysXIntegrationParams.prototype.get_physxSuspensionLimitConstraintParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationParams_get_physxSuspensionLimitConstraintParams_1(self, arg0), PxVehiclePhysXSuspensionLimitConstraintParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['set_physxSuspensionLimitConstraintParams'] = PhysXIntegrationParams.prototype.set_physxSuspensionLimitConstraintParams = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PhysXIntegrationParams_set_physxSuspensionLimitConstraintParams_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationParams.prototype, 'physxSuspensionLimitConstraintParams', { get: PhysXIntegrationParams.prototype.get_physxSuspensionLimitConstraintParams, set: PhysXIntegrationParams.prototype.set_physxSuspensionLimitConstraintParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['get_physxActorCMassLocalPose'] = PhysXIntegrationParams.prototype.get_physxActorCMassLocalPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationParams_get_physxActorCMassLocalPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['set_physxActorCMassLocalPose'] = PhysXIntegrationParams.prototype.set_physxActorCMassLocalPose = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXIntegrationParams_set_physxActorCMassLocalPose_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationParams.prototype, 'physxActorCMassLocalPose', { get: PhysXIntegrationParams.prototype.get_physxActorCMassLocalPose, set: PhysXIntegrationParams.prototype.set_physxActorCMassLocalPose });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['get_physxActorGeometry'] = PhysXIntegrationParams.prototype.get_physxActorGeometry = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationParams_get_physxActorGeometry_0(self), PxGeometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['set_physxActorGeometry'] = PhysXIntegrationParams.prototype.set_physxActorGeometry = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXIntegrationParams_set_physxActorGeometry_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationParams.prototype, 'physxActorGeometry', { get: PhysXIntegrationParams.prototype.get_physxActorGeometry, set: PhysXIntegrationParams.prototype.set_physxActorGeometry });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['get_physxActorBoxShapeLocalPose'] = PhysXIntegrationParams.prototype.get_physxActorBoxShapeLocalPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationParams_get_physxActorBoxShapeLocalPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['set_physxActorBoxShapeLocalPose'] = PhysXIntegrationParams.prototype.set_physxActorBoxShapeLocalPose = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXIntegrationParams_set_physxActorBoxShapeLocalPose_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationParams.prototype, 'physxActorBoxShapeLocalPose', { get: PhysXIntegrationParams.prototype.get_physxActorBoxShapeLocalPose, set: PhysXIntegrationParams.prototype.set_physxActorBoxShapeLocalPose });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['get_physxWheelShapeLocalPoses'] = PhysXIntegrationParams.prototype.get_physxWheelShapeLocalPoses = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationParams_get_physxWheelShapeLocalPoses_1(self, arg0), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['set_physxWheelShapeLocalPoses'] = PhysXIntegrationParams.prototype.set_physxWheelShapeLocalPoses = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PhysXIntegrationParams_set_physxWheelShapeLocalPoses_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationParams.prototype, 'physxWheelShapeLocalPoses', { get: PhysXIntegrationParams.prototype.get_physxWheelShapeLocalPoses, set: PhysXIntegrationParams.prototype.set_physxWheelShapeLocalPoses });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['get_physxActorShapeFlags'] = PhysXIntegrationParams.prototype.get_physxActorShapeFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationParams_get_physxActorShapeFlags_0(self), PxShapeFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['set_physxActorShapeFlags'] = PhysXIntegrationParams.prototype.set_physxActorShapeFlags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXIntegrationParams_set_physxActorShapeFlags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationParams.prototype, 'physxActorShapeFlags', { get: PhysXIntegrationParams.prototype.get_physxActorShapeFlags, set: PhysXIntegrationParams.prototype.set_physxActorShapeFlags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['get_physxActorSimulationFilterData'] = PhysXIntegrationParams.prototype.get_physxActorSimulationFilterData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationParams_get_physxActorSimulationFilterData_0(self), PxFilterData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['set_physxActorSimulationFilterData'] = PhysXIntegrationParams.prototype.set_physxActorSimulationFilterData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXIntegrationParams_set_physxActorSimulationFilterData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationParams.prototype, 'physxActorSimulationFilterData', { get: PhysXIntegrationParams.prototype.get_physxActorSimulationFilterData, set: PhysXIntegrationParams.prototype.set_physxActorSimulationFilterData });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['get_physxActorQueryFilterData'] = PhysXIntegrationParams.prototype.get_physxActorQueryFilterData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationParams_get_physxActorQueryFilterData_0(self), PxFilterData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['set_physxActorQueryFilterData'] = PhysXIntegrationParams.prototype.set_physxActorQueryFilterData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXIntegrationParams_set_physxActorQueryFilterData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationParams.prototype, 'physxActorQueryFilterData', { get: PhysXIntegrationParams.prototype.get_physxActorQueryFilterData, set: PhysXIntegrationParams.prototype.set_physxActorQueryFilterData });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['get_physxActorWheelShapeFlags'] = PhysXIntegrationParams.prototype.get_physxActorWheelShapeFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationParams_get_physxActorWheelShapeFlags_0(self), PxShapeFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['set_physxActorWheelShapeFlags'] = PhysXIntegrationParams.prototype.set_physxActorWheelShapeFlags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXIntegrationParams_set_physxActorWheelShapeFlags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationParams.prototype, 'physxActorWheelShapeFlags', { get: PhysXIntegrationParams.prototype.get_physxActorWheelShapeFlags, set: PhysXIntegrationParams.prototype.set_physxActorWheelShapeFlags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['get_physxActorWheelSimulationFilterData'] = PhysXIntegrationParams.prototype.get_physxActorWheelSimulationFilterData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationParams_get_physxActorWheelSimulationFilterData_0(self), PxFilterData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['set_physxActorWheelSimulationFilterData'] = PhysXIntegrationParams.prototype.set_physxActorWheelSimulationFilterData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXIntegrationParams_set_physxActorWheelSimulationFilterData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationParams.prototype, 'physxActorWheelSimulationFilterData', { get: PhysXIntegrationParams.prototype.get_physxActorWheelSimulationFilterData, set: PhysXIntegrationParams.prototype.set_physxActorWheelSimulationFilterData });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['get_physxActorWheelQueryFilterData'] = PhysXIntegrationParams.prototype.get_physxActorWheelQueryFilterData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationParams_get_physxActorWheelQueryFilterData_0(self), PxFilterData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['set_physxActorWheelQueryFilterData'] = PhysXIntegrationParams.prototype.set_physxActorWheelQueryFilterData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXIntegrationParams_set_physxActorWheelQueryFilterData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationParams.prototype, 'physxActorWheelQueryFilterData', { get: PhysXIntegrationParams.prototype.get_physxActorWheelQueryFilterData, set: PhysXIntegrationParams.prototype.set_physxActorWheelQueryFilterData });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationParams.prototype['__destroy__'] = PhysXIntegrationParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PhysXIntegrationParams___destroy___0(self);
};

// Interface: PhysXIntegrationState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PhysXIntegrationState() {
  this.ptr = _emscripten_bind_PhysXIntegrationState_PhysXIntegrationState_0();
  getCache(PhysXIntegrationState)[this.ptr] = this;
};

PhysXIntegrationState.prototype = Object.create(WrapperObject.prototype);
PhysXIntegrationState.prototype.constructor = PhysXIntegrationState;
PhysXIntegrationState.prototype.__class__ = PhysXIntegrationState;
PhysXIntegrationState.__cache__ = {};
Module['PhysXIntegrationState'] = PhysXIntegrationState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationState.prototype['destroyState'] = PhysXIntegrationState.prototype.destroyState = function() {
  var self = this.ptr;
  _emscripten_bind_PhysXIntegrationState_destroyState_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationState.prototype['setToDefault'] = PhysXIntegrationState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PhysXIntegrationState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationState.prototype['create'] = PhysXIntegrationState.prototype.create = function(baseParams, physxParams, physics, params, defaultMaterial) {
  var self = this.ptr;
  if (baseParams && typeof baseParams === 'object') baseParams = baseParams.ptr;
  if (physxParams && typeof physxParams === 'object') physxParams = physxParams.ptr;
  if (physics && typeof physics === 'object') physics = physics.ptr;
  if (params && typeof params === 'object') params = params.ptr;
  if (defaultMaterial && typeof defaultMaterial === 'object') defaultMaterial = defaultMaterial.ptr;
  _emscripten_bind_PhysXIntegrationState_create_5(self, baseParams, physxParams, physics, params, defaultMaterial);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationState.prototype['get_physxActor'] = PhysXIntegrationState.prototype.get_physxActor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationState_get_physxActor_0(self), PxVehiclePhysXActor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationState.prototype['set_physxActor'] = PhysXIntegrationState.prototype.set_physxActor = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXIntegrationState_set_physxActor_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationState.prototype, 'physxActor', { get: PhysXIntegrationState.prototype.get_physxActor, set: PhysXIntegrationState.prototype.set_physxActor });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationState.prototype['get_physxSteerState'] = PhysXIntegrationState.prototype.get_physxSteerState = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationState_get_physxSteerState_0(self), PxVehiclePhysXSteerState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationState.prototype['set_physxSteerState'] = PhysXIntegrationState.prototype.set_physxSteerState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXIntegrationState_set_physxSteerState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationState.prototype, 'physxSteerState', { get: PhysXIntegrationState.prototype.get_physxSteerState, set: PhysXIntegrationState.prototype.set_physxSteerState });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationState.prototype['get_physxConstraints'] = PhysXIntegrationState.prototype.get_physxConstraints = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PhysXIntegrationState_get_physxConstraints_0(self), PxVehiclePhysXConstraints);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationState.prototype['set_physxConstraints'] = PhysXIntegrationState.prototype.set_physxConstraints = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PhysXIntegrationState_set_physxConstraints_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PhysXIntegrationState.prototype, 'physxConstraints', { get: PhysXIntegrationState.prototype.get_physxConstraints, set: PhysXIntegrationState.prototype.set_physxConstraints });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PhysXIntegrationState.prototype['__destroy__'] = PhysXIntegrationState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PhysXIntegrationState___destroy___0(self);
};

// Interface: PxActorFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxActorFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxActorFlags_PxActorFlags_1(flags);
  getCache(PxActorFlags)[this.ptr] = this;
};

PxActorFlags.prototype = Object.create(WrapperObject.prototype);
PxActorFlags.prototype.constructor = PxActorFlags;
PxActorFlags.prototype.__class__ = PxActorFlags;
PxActorFlags.__cache__ = {};
Module['PxActorFlags'] = PxActorFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActorFlags.prototype['isSet'] = PxActorFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxActorFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActorFlags.prototype['raise'] = PxActorFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxActorFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActorFlags.prototype['clear'] = PxActorFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxActorFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActorFlags.prototype['__destroy__'] = PxActorFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxActorFlags___destroy___0(self);
};

// Interface: PxActorPtr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxActorPtr() { throw "cannot construct a PxActorPtr, no constructor in IDL" }
PxActorPtr.prototype = Object.create(WrapperObject.prototype);
PxActorPtr.prototype.constructor = PxActorPtr;
PxActorPtr.prototype.__class__ = PxActorPtr;
PxActorPtr.__cache__ = {};
Module['PxActorPtr'] = PxActorPtr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActorPtr.prototype['__destroy__'] = PxActorPtr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxActorPtr___destroy___0(self);
};

// Interface: PxActorTypeFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxActorTypeFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxActorTypeFlags_PxActorTypeFlags_1(flags);
  getCache(PxActorTypeFlags)[this.ptr] = this;
};

PxActorTypeFlags.prototype = Object.create(WrapperObject.prototype);
PxActorTypeFlags.prototype.constructor = PxActorTypeFlags;
PxActorTypeFlags.prototype.__class__ = PxActorTypeFlags;
PxActorTypeFlags.__cache__ = {};
Module['PxActorTypeFlags'] = PxActorTypeFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActorTypeFlags.prototype['isSet'] = PxActorTypeFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxActorTypeFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActorTypeFlags.prototype['raise'] = PxActorTypeFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxActorTypeFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActorTypeFlags.prototype['clear'] = PxActorTypeFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxActorTypeFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxActorTypeFlags.prototype['__destroy__'] = PxActorTypeFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxActorTypeFlags___destroy___0(self);
};

// Interface: PxAggregate

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxAggregate() { throw "cannot construct a PxAggregate, no constructor in IDL" }
PxAggregate.prototype = Object.create(PxBase.prototype);
PxAggregate.prototype.constructor = PxAggregate;
PxAggregate.prototype.__class__ = PxAggregate;
PxAggregate.__cache__ = {};
Module['PxAggregate'] = PxAggregate;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['addActor'] = PxAggregate.prototype.addActor = function(actor, bvh) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (bvh && typeof bvh === 'object') bvh = bvh.ptr;
  if (bvh === undefined) { return !!(_emscripten_bind_PxAggregate_addActor_1(self, actor)) }
  return !!(_emscripten_bind_PxAggregate_addActor_2(self, actor, bvh));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['removeActor'] = PxAggregate.prototype.removeActor = function(actor) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return !!(_emscripten_bind_PxAggregate_removeActor_1(self, actor));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['addArticulation'] = PxAggregate.prototype.addArticulation = function(articulation) {
  var self = this.ptr;
  if (articulation && typeof articulation === 'object') articulation = articulation.ptr;
  return !!(_emscripten_bind_PxAggregate_addArticulation_1(self, articulation));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['removeArticulation'] = PxAggregate.prototype.removeArticulation = function(articulation) {
  var self = this.ptr;
  if (articulation && typeof articulation === 'object') articulation = articulation.ptr;
  return !!(_emscripten_bind_PxAggregate_removeArticulation_1(self, articulation));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['getNbActors'] = PxAggregate.prototype.getNbActors = function() {
  var self = this.ptr;
  return _emscripten_bind_PxAggregate_getNbActors_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['getMaxNbActors'] = PxAggregate.prototype.getMaxNbActors = function() {
  var self = this.ptr;
  return _emscripten_bind_PxAggregate_getMaxNbActors_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['getMaxNbShapes'] = PxAggregate.prototype.getMaxNbShapes = function() {
  var self = this.ptr;
  return _emscripten_bind_PxAggregate_getMaxNbShapes_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['getScene'] = PxAggregate.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxAggregate_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['getSelfCollision'] = PxAggregate.prototype.getSelfCollision = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxAggregate_getSelfCollision_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['release'] = PxAggregate.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxAggregate_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['getConcreteTypeName'] = PxAggregate.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxAggregate_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['getConcreteType'] = PxAggregate.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxAggregate_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['setBaseFlag'] = PxAggregate.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxAggregate_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['setBaseFlags'] = PxAggregate.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxAggregate_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['getBaseFlags'] = PxAggregate.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxAggregate_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxAggregate.prototype['isReleasable'] = PxAggregate.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxAggregate_isReleasable_0(self));
};


// Interface: PxArray_PxActorPtr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArray_PxActorPtr(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_0(); getCache(PxArray_PxActorPtr)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArray_PxActorPtr_PxArray_PxActorPtr_1(size);
  getCache(PxArray_PxActorPtr)[this.ptr] = this;
};

PxArray_PxActorPtr.prototype = Object.create(WrapperObject.prototype);
PxArray_PxActorPtr.prototype.constructor = PxArray_PxActorPtr;
PxArray_PxActorPtr.prototype.__class__ = PxArray_PxActorPtr;
PxArray_PxActorPtr.__cache__ = {};
Module['PxArray_PxActorPtr'] = PxArray_PxActorPtr;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxActorPtr.prototype['get'] = PxArray_PxActorPtr.prototype.get = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxActorPtr_get_1(self, index), PxActor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxActorPtr.prototype['set'] = PxArray_PxActorPtr.prototype.set = function(index, value) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxActorPtr_set_2(self, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxActorPtr.prototype['begin'] = PxArray_PxActorPtr.prototype.begin = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxActorPtr_begin_0(self), PxActorPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxActorPtr.prototype['size'] = PxArray_PxActorPtr.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArray_PxActorPtr_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxActorPtr.prototype['pushBack'] = PxArray_PxActorPtr.prototype.pushBack = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxActorPtr_pushBack_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxActorPtr.prototype['clear'] = PxArray_PxActorPtr.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxActorPtr_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxActorPtr.prototype['__destroy__'] = PxArray_PxActorPtr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxActorPtr___destroy___0(self);
};

// Interface: PxArray_PxContactPairPoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArray_PxContactPairPoint(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_0(); getCache(PxArray_PxContactPairPoint)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArray_PxContactPairPoint_PxArray_PxContactPairPoint_1(size);
  getCache(PxArray_PxContactPairPoint)[this.ptr] = this;
};

PxArray_PxContactPairPoint.prototype = Object.create(WrapperObject.prototype);
PxArray_PxContactPairPoint.prototype.constructor = PxArray_PxContactPairPoint;
PxArray_PxContactPairPoint.prototype.__class__ = PxArray_PxContactPairPoint;
PxArray_PxContactPairPoint.__cache__ = {};
Module['PxArray_PxContactPairPoint'] = PxArray_PxContactPairPoint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxContactPairPoint.prototype['get'] = PxArray_PxContactPairPoint.prototype.get = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxContactPairPoint_get_1(self, index), PxContactPairPoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxContactPairPoint.prototype['set'] = PxArray_PxContactPairPoint.prototype.set = function(index, value) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxContactPairPoint_set_2(self, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxContactPairPoint.prototype['begin'] = PxArray_PxContactPairPoint.prototype.begin = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxContactPairPoint_begin_0(self), PxContactPairPoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxContactPairPoint.prototype['size'] = PxArray_PxContactPairPoint.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArray_PxContactPairPoint_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxContactPairPoint.prototype['pushBack'] = PxArray_PxContactPairPoint.prototype.pushBack = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxContactPairPoint_pushBack_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxContactPairPoint.prototype['clear'] = PxArray_PxContactPairPoint.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxContactPairPoint_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxContactPairPoint.prototype['__destroy__'] = PxArray_PxContactPairPoint.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxContactPairPoint___destroy___0(self);
};

// Interface: PxArray_PxHeightFieldSample

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArray_PxHeightFieldSample(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_0(); getCache(PxArray_PxHeightFieldSample)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArray_PxHeightFieldSample_PxArray_PxHeightFieldSample_1(size);
  getCache(PxArray_PxHeightFieldSample)[this.ptr] = this;
};

PxArray_PxHeightFieldSample.prototype = Object.create(WrapperObject.prototype);
PxArray_PxHeightFieldSample.prototype.constructor = PxArray_PxHeightFieldSample;
PxArray_PxHeightFieldSample.prototype.__class__ = PxArray_PxHeightFieldSample;
PxArray_PxHeightFieldSample.__cache__ = {};
Module['PxArray_PxHeightFieldSample'] = PxArray_PxHeightFieldSample;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxHeightFieldSample.prototype['get'] = PxArray_PxHeightFieldSample.prototype.get = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxHeightFieldSample_get_1(self, index), PxHeightFieldSample);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxHeightFieldSample.prototype['set'] = PxArray_PxHeightFieldSample.prototype.set = function(index, value) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxHeightFieldSample_set_2(self, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxHeightFieldSample.prototype['begin'] = PxArray_PxHeightFieldSample.prototype.begin = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxHeightFieldSample_begin_0(self), PxHeightFieldSample);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxHeightFieldSample.prototype['size'] = PxArray_PxHeightFieldSample.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArray_PxHeightFieldSample_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxHeightFieldSample.prototype['pushBack'] = PxArray_PxHeightFieldSample.prototype.pushBack = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxHeightFieldSample_pushBack_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxHeightFieldSample.prototype['clear'] = PxArray_PxHeightFieldSample.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxHeightFieldSample_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxHeightFieldSample.prototype['__destroy__'] = PxArray_PxHeightFieldSample.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxHeightFieldSample___destroy___0(self);
};

// Interface: PxArray_PxMaterialConst

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArray_PxMaterialConst(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_0(); getCache(PxArray_PxMaterialConst)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArray_PxMaterialConst_PxArray_PxMaterialConst_1(size);
  getCache(PxArray_PxMaterialConst)[this.ptr] = this;
};

PxArray_PxMaterialConst.prototype = Object.create(WrapperObject.prototype);
PxArray_PxMaterialConst.prototype.constructor = PxArray_PxMaterialConst;
PxArray_PxMaterialConst.prototype.__class__ = PxArray_PxMaterialConst;
PxArray_PxMaterialConst.__cache__ = {};
Module['PxArray_PxMaterialConst'] = PxArray_PxMaterialConst;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxMaterialConst.prototype['get'] = PxArray_PxMaterialConst.prototype.get = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxMaterialConst_get_1(self, index), PxMaterial);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxMaterialConst.prototype['set'] = PxArray_PxMaterialConst.prototype.set = function(index, value) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxMaterialConst_set_2(self, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxMaterialConst.prototype['begin'] = PxArray_PxMaterialConst.prototype.begin = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxMaterialConst_begin_0(self), PxMaterialConstPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxMaterialConst.prototype['size'] = PxArray_PxMaterialConst.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArray_PxMaterialConst_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxMaterialConst.prototype['pushBack'] = PxArray_PxMaterialConst.prototype.pushBack = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxMaterialConst_pushBack_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxMaterialConst.prototype['clear'] = PxArray_PxMaterialConst.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxMaterialConst_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxMaterialConst.prototype['__destroy__'] = PxArray_PxMaterialConst.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxMaterialConst___destroy___0(self);
};

// Interface: PxArray_PxRaycastHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArray_PxRaycastHit(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_0(); getCache(PxArray_PxRaycastHit)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArray_PxRaycastHit_PxArray_PxRaycastHit_1(size);
  getCache(PxArray_PxRaycastHit)[this.ptr] = this;
};

PxArray_PxRaycastHit.prototype = Object.create(WrapperObject.prototype);
PxArray_PxRaycastHit.prototype.constructor = PxArray_PxRaycastHit;
PxArray_PxRaycastHit.prototype.__class__ = PxArray_PxRaycastHit;
PxArray_PxRaycastHit.__cache__ = {};
Module['PxArray_PxRaycastHit'] = PxArray_PxRaycastHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxRaycastHit.prototype['get'] = PxArray_PxRaycastHit.prototype.get = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxRaycastHit_get_1(self, index), PxRaycastHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxRaycastHit.prototype['set'] = PxArray_PxRaycastHit.prototype.set = function(index, value) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxRaycastHit_set_2(self, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxRaycastHit.prototype['begin'] = PxArray_PxRaycastHit.prototype.begin = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxRaycastHit_begin_0(self), PxRaycastHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxRaycastHit.prototype['size'] = PxArray_PxRaycastHit.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArray_PxRaycastHit_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxRaycastHit.prototype['pushBack'] = PxArray_PxRaycastHit.prototype.pushBack = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxRaycastHit_pushBack_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxRaycastHit.prototype['clear'] = PxArray_PxRaycastHit.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxRaycastHit_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxRaycastHit.prototype['__destroy__'] = PxArray_PxRaycastHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxRaycastHit___destroy___0(self);
};

// Interface: PxArray_PxReal

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArray_PxReal(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_PxArray_PxReal_PxArray_PxReal_0(); getCache(PxArray_PxReal)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArray_PxReal_PxArray_PxReal_1(size);
  getCache(PxArray_PxReal)[this.ptr] = this;
};

PxArray_PxReal.prototype = Object.create(WrapperObject.prototype);
PxArray_PxReal.prototype.constructor = PxArray_PxReal;
PxArray_PxReal.prototype.__class__ = PxArray_PxReal;
PxArray_PxReal.__cache__ = {};
Module['PxArray_PxReal'] = PxArray_PxReal;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxReal.prototype['get'] = PxArray_PxReal.prototype.get = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return _emscripten_bind_PxArray_PxReal_get_1(self, index);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxReal.prototype['set'] = PxArray_PxReal.prototype.set = function(index, value) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxReal_set_2(self, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxReal.prototype['begin'] = PxArray_PxReal.prototype.begin = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxReal_begin_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxReal.prototype['size'] = PxArray_PxReal.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArray_PxReal_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxReal.prototype['pushBack'] = PxArray_PxReal.prototype.pushBack = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxReal_pushBack_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxReal.prototype['clear'] = PxArray_PxReal.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxReal_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxReal.prototype['__destroy__'] = PxArray_PxReal.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxReal___destroy___0(self);
};

// Interface: PxArray_PxShapePtr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArray_PxShapePtr(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_0(); getCache(PxArray_PxShapePtr)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArray_PxShapePtr_PxArray_PxShapePtr_1(size);
  getCache(PxArray_PxShapePtr)[this.ptr] = this;
};

PxArray_PxShapePtr.prototype = Object.create(WrapperObject.prototype);
PxArray_PxShapePtr.prototype.constructor = PxArray_PxShapePtr;
PxArray_PxShapePtr.prototype.__class__ = PxArray_PxShapePtr;
PxArray_PxShapePtr.__cache__ = {};
Module['PxArray_PxShapePtr'] = PxArray_PxShapePtr;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxShapePtr.prototype['get'] = PxArray_PxShapePtr.prototype.get = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxShapePtr_get_1(self, index), PxShape);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxShapePtr.prototype['set'] = PxArray_PxShapePtr.prototype.set = function(index, value) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxShapePtr_set_2(self, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxShapePtr.prototype['begin'] = PxArray_PxShapePtr.prototype.begin = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxShapePtr_begin_0(self), PxShapePtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxShapePtr.prototype['size'] = PxArray_PxShapePtr.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArray_PxShapePtr_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxShapePtr.prototype['pushBack'] = PxArray_PxShapePtr.prototype.pushBack = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxShapePtr_pushBack_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxShapePtr.prototype['clear'] = PxArray_PxShapePtr.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxShapePtr_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxShapePtr.prototype['__destroy__'] = PxArray_PxShapePtr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxShapePtr___destroy___0(self);
};

// Interface: PxArray_PxSweepHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArray_PxSweepHit(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_0(); getCache(PxArray_PxSweepHit)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArray_PxSweepHit_PxArray_PxSweepHit_1(size);
  getCache(PxArray_PxSweepHit)[this.ptr] = this;
};

PxArray_PxSweepHit.prototype = Object.create(WrapperObject.prototype);
PxArray_PxSweepHit.prototype.constructor = PxArray_PxSweepHit;
PxArray_PxSweepHit.prototype.__class__ = PxArray_PxSweepHit;
PxArray_PxSweepHit.__cache__ = {};
Module['PxArray_PxSweepHit'] = PxArray_PxSweepHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxSweepHit.prototype['get'] = PxArray_PxSweepHit.prototype.get = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxSweepHit_get_1(self, index), PxSweepHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxSweepHit.prototype['set'] = PxArray_PxSweepHit.prototype.set = function(index, value) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxSweepHit_set_2(self, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxSweepHit.prototype['begin'] = PxArray_PxSweepHit.prototype.begin = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxSweepHit_begin_0(self), PxSweepHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxSweepHit.prototype['size'] = PxArray_PxSweepHit.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArray_PxSweepHit_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxSweepHit.prototype['pushBack'] = PxArray_PxSweepHit.prototype.pushBack = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxSweepHit_pushBack_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxSweepHit.prototype['clear'] = PxArray_PxSweepHit.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxSweepHit_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxSweepHit.prototype['__destroy__'] = PxArray_PxSweepHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxSweepHit___destroy___0(self);
};

// Interface: PxArray_PxU16

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArray_PxU16(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_PxArray_PxU16_PxArray_PxU16_0(); getCache(PxArray_PxU16)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArray_PxU16_PxArray_PxU16_1(size);
  getCache(PxArray_PxU16)[this.ptr] = this;
};

PxArray_PxU16.prototype = Object.create(WrapperObject.prototype);
PxArray_PxU16.prototype.constructor = PxArray_PxU16;
PxArray_PxU16.prototype.__class__ = PxArray_PxU16;
PxArray_PxU16.__cache__ = {};
Module['PxArray_PxU16'] = PxArray_PxU16;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU16.prototype['get'] = PxArray_PxU16.prototype.get = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return _emscripten_bind_PxArray_PxU16_get_1(self, index);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU16.prototype['set'] = PxArray_PxU16.prototype.set = function(index, value) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxU16_set_2(self, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU16.prototype['begin'] = PxArray_PxU16.prototype.begin = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxU16_begin_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU16.prototype['size'] = PxArray_PxU16.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArray_PxU16_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU16.prototype['pushBack'] = PxArray_PxU16.prototype.pushBack = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxU16_pushBack_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU16.prototype['clear'] = PxArray_PxU16.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxU16_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU16.prototype['__destroy__'] = PxArray_PxU16.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxU16___destroy___0(self);
};

// Interface: PxArray_PxU32

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArray_PxU32(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_PxArray_PxU32_PxArray_PxU32_0(); getCache(PxArray_PxU32)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArray_PxU32_PxArray_PxU32_1(size);
  getCache(PxArray_PxU32)[this.ptr] = this;
};

PxArray_PxU32.prototype = Object.create(WrapperObject.prototype);
PxArray_PxU32.prototype.constructor = PxArray_PxU32;
PxArray_PxU32.prototype.__class__ = PxArray_PxU32;
PxArray_PxU32.__cache__ = {};
Module['PxArray_PxU32'] = PxArray_PxU32;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU32.prototype['get'] = PxArray_PxU32.prototype.get = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return _emscripten_bind_PxArray_PxU32_get_1(self, index);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU32.prototype['set'] = PxArray_PxU32.prototype.set = function(index, value) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxU32_set_2(self, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU32.prototype['begin'] = PxArray_PxU32.prototype.begin = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxU32_begin_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU32.prototype['size'] = PxArray_PxU32.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArray_PxU32_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU32.prototype['pushBack'] = PxArray_PxU32.prototype.pushBack = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxU32_pushBack_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU32.prototype['clear'] = PxArray_PxU32.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxU32_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU32.prototype['__destroy__'] = PxArray_PxU32.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxU32___destroy___0(self);
};

// Interface: PxArray_PxU8

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArray_PxU8(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_PxArray_PxU8_PxArray_PxU8_0(); getCache(PxArray_PxU8)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArray_PxU8_PxArray_PxU8_1(size);
  getCache(PxArray_PxU8)[this.ptr] = this;
};

PxArray_PxU8.prototype = Object.create(WrapperObject.prototype);
PxArray_PxU8.prototype.constructor = PxArray_PxU8;
PxArray_PxU8.prototype.__class__ = PxArray_PxU8;
PxArray_PxU8.__cache__ = {};
Module['PxArray_PxU8'] = PxArray_PxU8;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU8.prototype['get'] = PxArray_PxU8.prototype.get = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return _emscripten_bind_PxArray_PxU8_get_1(self, index);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU8.prototype['set'] = PxArray_PxU8.prototype.set = function(index, value) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxU8_set_2(self, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU8.prototype['begin'] = PxArray_PxU8.prototype.begin = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxU8_begin_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU8.prototype['size'] = PxArray_PxU8.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArray_PxU8_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU8.prototype['pushBack'] = PxArray_PxU8.prototype.pushBack = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxU8_pushBack_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU8.prototype['setFromBuffer'] = PxArray_PxU8.prototype.setFromBuffer = function(buffer, size) {
  var self = this.ptr;
  if (buffer && typeof buffer === 'object') buffer = buffer.ptr;
  if (size && typeof size === 'object') size = size.ptr;
  _emscripten_bind_PxArray_PxU8_setFromBuffer_2(self, buffer, size);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU8.prototype['clear'] = PxArray_PxU8.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxU8_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxU8.prototype['__destroy__'] = PxArray_PxU8.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxU8___destroy___0(self);
};

// Interface: PxArray_PxVec3

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArray_PxVec3(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_0(); getCache(PxArray_PxVec3)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArray_PxVec3_PxArray_PxVec3_1(size);
  getCache(PxArray_PxVec3)[this.ptr] = this;
};

PxArray_PxVec3.prototype = Object.create(WrapperObject.prototype);
PxArray_PxVec3.prototype.constructor = PxArray_PxVec3;
PxArray_PxVec3.prototype.__class__ = PxArray_PxVec3;
PxArray_PxVec3.__cache__ = {};
Module['PxArray_PxVec3'] = PxArray_PxVec3;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxVec3.prototype['get'] = PxArray_PxVec3.prototype.get = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxVec3_get_1(self, index), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxVec3.prototype['set'] = PxArray_PxVec3.prototype.set = function(index, value) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxVec3_set_2(self, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxVec3.prototype['begin'] = PxArray_PxVec3.prototype.begin = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxVec3_begin_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxVec3.prototype['size'] = PxArray_PxVec3.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArray_PxVec3_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxVec3.prototype['pushBack'] = PxArray_PxVec3.prototype.pushBack = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxVec3_pushBack_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxVec3.prototype['clear'] = PxArray_PxVec3.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxVec3_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxVec3.prototype['__destroy__'] = PxArray_PxVec3.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxVec3___destroy___0(self);
};

// Interface: PxArray_PxVec4

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArray_PxVec4(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_0(); getCache(PxArray_PxVec4)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArray_PxVec4_PxArray_PxVec4_1(size);
  getCache(PxArray_PxVec4)[this.ptr] = this;
};

PxArray_PxVec4.prototype = Object.create(WrapperObject.prototype);
PxArray_PxVec4.prototype.constructor = PxArray_PxVec4;
PxArray_PxVec4.prototype.__class__ = PxArray_PxVec4;
PxArray_PxVec4.__cache__ = {};
Module['PxArray_PxVec4'] = PxArray_PxVec4;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxVec4.prototype['get'] = PxArray_PxVec4.prototype.get = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxVec4_get_1(self, index), PxVec4);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxVec4.prototype['set'] = PxArray_PxVec4.prototype.set = function(index, value) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxVec4_set_2(self, index, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxVec4.prototype['begin'] = PxArray_PxVec4.prototype.begin = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArray_PxVec4_begin_0(self), PxVec4);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxVec4.prototype['size'] = PxArray_PxVec4.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArray_PxVec4_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxVec4.prototype['pushBack'] = PxArray_PxVec4.prototype.pushBack = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArray_PxVec4_pushBack_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxVec4.prototype['clear'] = PxArray_PxVec4.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxVec4_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArray_PxVec4.prototype['__destroy__'] = PxArray_PxVec4.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArray_PxVec4___destroy___0(self);
};

// Interface: PxArticulationAttachment

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationAttachment() { throw "cannot construct a PxArticulationAttachment, no constructor in IDL" }
PxArticulationAttachment.prototype = Object.create(WrapperObject.prototype);
PxArticulationAttachment.prototype.constructor = PxArticulationAttachment;
PxArticulationAttachment.prototype.__class__ = PxArticulationAttachment;
PxArticulationAttachment.__cache__ = {};
Module['PxArticulationAttachment'] = PxArticulationAttachment;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['setRestLength'] = PxArticulationAttachment.prototype.setRestLength = function(restLength) {
  var self = this.ptr;
  if (restLength && typeof restLength === 'object') restLength = restLength.ptr;
  _emscripten_bind_PxArticulationAttachment_setRestLength_1(self, restLength);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['getRestLength'] = PxArticulationAttachment.prototype.getRestLength = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationAttachment_getRestLength_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['setLimitParameters'] = PxArticulationAttachment.prototype.setLimitParameters = function(parameters) {
  var self = this.ptr;
  if (parameters && typeof parameters === 'object') parameters = parameters.ptr;
  _emscripten_bind_PxArticulationAttachment_setLimitParameters_1(self, parameters);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['getLimitParameters'] = PxArticulationAttachment.prototype.getLimitParameters = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationAttachment_getLimitParameters_0(self), PxArticulationTendonLimit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['setRelativeOffset'] = PxArticulationAttachment.prototype.setRelativeOffset = function(offset) {
  var self = this.ptr;
  if (offset && typeof offset === 'object') offset = offset.ptr;
  _emscripten_bind_PxArticulationAttachment_setRelativeOffset_1(self, offset);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['getRelativeOffset'] = PxArticulationAttachment.prototype.getRelativeOffset = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationAttachment_getRelativeOffset_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['setCoefficient'] = PxArticulationAttachment.prototype.setCoefficient = function(coefficient) {
  var self = this.ptr;
  if (coefficient && typeof coefficient === 'object') coefficient = coefficient.ptr;
  _emscripten_bind_PxArticulationAttachment_setCoefficient_1(self, coefficient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['getCoefficient'] = PxArticulationAttachment.prototype.getCoefficient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationAttachment_getCoefficient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['getLink'] = PxArticulationAttachment.prototype.getLink = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationAttachment_getLink_0(self), PxArticulationLink);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['getParent'] = PxArticulationAttachment.prototype.getParent = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationAttachment_getParent_0(self), PxArticulationAttachment);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['isLeaf'] = PxArticulationAttachment.prototype.isLeaf = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxArticulationAttachment_isLeaf_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['getTendon'] = PxArticulationAttachment.prototype.getTendon = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationAttachment_getTendon_0(self), PxArticulationSpatialTendon);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['release'] = PxArticulationAttachment.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationAttachment_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['get_userData'] = PxArticulationAttachment.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationAttachment_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['set_userData'] = PxArticulationAttachment.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationAttachment_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationAttachment.prototype, 'userData', { get: PxArticulationAttachment.prototype.get_userData, set: PxArticulationAttachment.prototype.set_userData });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationAttachment.prototype['__destroy__'] = PxArticulationAttachment.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationAttachment___destroy___0(self);
};

// Interface: PxArticulationCache

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationCache() { throw "cannot construct a PxArticulationCache, no constructor in IDL" }
PxArticulationCache.prototype = Object.create(WrapperObject.prototype);
PxArticulationCache.prototype.constructor = PxArticulationCache;
PxArticulationCache.prototype.__class__ = PxArticulationCache;
PxArticulationCache.__cache__ = {};
Module['PxArticulationCache'] = PxArticulationCache;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['release'] = PxArticulationCache.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationCache_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_externalForces'] = PxArticulationCache.prototype.get_externalForces = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_externalForces_0(self), PxSpatialForce);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_externalForces'] = PxArticulationCache.prototype.set_externalForces = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_externalForces_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'externalForces', { get: PxArticulationCache.prototype.get_externalForces, set: PxArticulationCache.prototype.set_externalForces });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_denseJacobian'] = PxArticulationCache.prototype.get_denseJacobian = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_denseJacobian_0(self), PxRealPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_denseJacobian'] = PxArticulationCache.prototype.set_denseJacobian = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_denseJacobian_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'denseJacobian', { get: PxArticulationCache.prototype.get_denseJacobian, set: PxArticulationCache.prototype.set_denseJacobian });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_massMatrix'] = PxArticulationCache.prototype.get_massMatrix = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_massMatrix_0(self), PxRealPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_massMatrix'] = PxArticulationCache.prototype.set_massMatrix = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_massMatrix_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'massMatrix', { get: PxArticulationCache.prototype.get_massMatrix, set: PxArticulationCache.prototype.set_massMatrix });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_jointVelocity'] = PxArticulationCache.prototype.get_jointVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_jointVelocity_0(self), PxRealPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_jointVelocity'] = PxArticulationCache.prototype.set_jointVelocity = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_jointVelocity_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'jointVelocity', { get: PxArticulationCache.prototype.get_jointVelocity, set: PxArticulationCache.prototype.set_jointVelocity });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_jointAcceleration'] = PxArticulationCache.prototype.get_jointAcceleration = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_jointAcceleration_0(self), PxRealPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_jointAcceleration'] = PxArticulationCache.prototype.set_jointAcceleration = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_jointAcceleration_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'jointAcceleration', { get: PxArticulationCache.prototype.get_jointAcceleration, set: PxArticulationCache.prototype.set_jointAcceleration });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_jointPosition'] = PxArticulationCache.prototype.get_jointPosition = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_jointPosition_0(self), PxRealPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_jointPosition'] = PxArticulationCache.prototype.set_jointPosition = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_jointPosition_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'jointPosition', { get: PxArticulationCache.prototype.get_jointPosition, set: PxArticulationCache.prototype.set_jointPosition });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_jointForce'] = PxArticulationCache.prototype.get_jointForce = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_jointForce_0(self), PxRealPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_jointForce'] = PxArticulationCache.prototype.set_jointForce = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_jointForce_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'jointForce', { get: PxArticulationCache.prototype.get_jointForce, set: PxArticulationCache.prototype.set_jointForce });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_linkVelocity'] = PxArticulationCache.prototype.get_linkVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_linkVelocity_0(self), PxSpatialVelocity);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_linkVelocity'] = PxArticulationCache.prototype.set_linkVelocity = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_linkVelocity_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'linkVelocity', { get: PxArticulationCache.prototype.get_linkVelocity, set: PxArticulationCache.prototype.set_linkVelocity });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_linkAcceleration'] = PxArticulationCache.prototype.get_linkAcceleration = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_linkAcceleration_0(self), PxSpatialVelocity);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_linkAcceleration'] = PxArticulationCache.prototype.set_linkAcceleration = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_linkAcceleration_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'linkAcceleration', { get: PxArticulationCache.prototype.get_linkAcceleration, set: PxArticulationCache.prototype.set_linkAcceleration });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_linkIncomingJointForce'] = PxArticulationCache.prototype.get_linkIncomingJointForce = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_linkIncomingJointForce_0(self), PxSpatialForce);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_linkIncomingJointForce'] = PxArticulationCache.prototype.set_linkIncomingJointForce = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_linkIncomingJointForce_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'linkIncomingJointForce', { get: PxArticulationCache.prototype.get_linkIncomingJointForce, set: PxArticulationCache.prototype.set_linkIncomingJointForce });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_rootLinkData'] = PxArticulationCache.prototype.get_rootLinkData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_rootLinkData_0(self), PxArticulationRootLinkData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_rootLinkData'] = PxArticulationCache.prototype.set_rootLinkData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_rootLinkData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'rootLinkData', { get: PxArticulationCache.prototype.get_rootLinkData, set: PxArticulationCache.prototype.set_rootLinkData });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_coefficientMatrix'] = PxArticulationCache.prototype.get_coefficientMatrix = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_coefficientMatrix_0(self), PxRealPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_coefficientMatrix'] = PxArticulationCache.prototype.set_coefficientMatrix = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_coefficientMatrix_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'coefficientMatrix', { get: PxArticulationCache.prototype.get_coefficientMatrix, set: PxArticulationCache.prototype.set_coefficientMatrix });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_lambda'] = PxArticulationCache.prototype.get_lambda = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_lambda_0(self), PxRealPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_lambda'] = PxArticulationCache.prototype.set_lambda = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_lambda_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'lambda', { get: PxArticulationCache.prototype.get_lambda, set: PxArticulationCache.prototype.set_lambda });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_scratchMemory'] = PxArticulationCache.prototype.get_scratchMemory = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_scratchMemory_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_scratchMemory'] = PxArticulationCache.prototype.set_scratchMemory = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_scratchMemory_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'scratchMemory', { get: PxArticulationCache.prototype.get_scratchMemory, set: PxArticulationCache.prototype.set_scratchMemory });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_scratchAllocator'] = PxArticulationCache.prototype.get_scratchAllocator = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationCache_get_scratchAllocator_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_scratchAllocator'] = PxArticulationCache.prototype.set_scratchAllocator = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_scratchAllocator_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'scratchAllocator', { get: PxArticulationCache.prototype.get_scratchAllocator, set: PxArticulationCache.prototype.set_scratchAllocator });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['get_version'] = PxArticulationCache.prototype.get_version = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationCache_get_version_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['set_version'] = PxArticulationCache.prototype.set_version = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationCache_set_version_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationCache.prototype, 'version', { get: PxArticulationCache.prototype.get_version, set: PxArticulationCache.prototype.set_version });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCache.prototype['__destroy__'] = PxArticulationCache.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationCache___destroy___0(self);
};

// Interface: PxArticulationCacheFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationCacheFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxArticulationCacheFlags_PxArticulationCacheFlags_1(flags);
  getCache(PxArticulationCacheFlags)[this.ptr] = this;
};

PxArticulationCacheFlags.prototype = Object.create(WrapperObject.prototype);
PxArticulationCacheFlags.prototype.constructor = PxArticulationCacheFlags;
PxArticulationCacheFlags.prototype.__class__ = PxArticulationCacheFlags;
PxArticulationCacheFlags.__cache__ = {};
Module['PxArticulationCacheFlags'] = PxArticulationCacheFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCacheFlags.prototype['isSet'] = PxArticulationCacheFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxArticulationCacheFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCacheFlags.prototype['raise'] = PxArticulationCacheFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxArticulationCacheFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCacheFlags.prototype['clear'] = PxArticulationCacheFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxArticulationCacheFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationCacheFlags.prototype['__destroy__'] = PxArticulationCacheFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationCacheFlags___destroy___0(self);
};

// Interface: PxArticulationDrive

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationDrive(stiffness, damping, maxForce, driveType) {
  if (stiffness && typeof stiffness === 'object') stiffness = stiffness.ptr;
  if (damping && typeof damping === 'object') damping = damping.ptr;
  if (maxForce && typeof maxForce === 'object') maxForce = maxForce.ptr;
  if (driveType && typeof driveType === 'object') driveType = driveType.ptr;
  if (stiffness === undefined) { this.ptr = _emscripten_bind_PxArticulationDrive_PxArticulationDrive_0(); getCache(PxArticulationDrive)[this.ptr] = this;return }
  if (damping === undefined) { this.ptr = _emscripten_bind_PxArticulationDrive_PxArticulationDrive_1(stiffness); getCache(PxArticulationDrive)[this.ptr] = this;return }
  if (maxForce === undefined) { this.ptr = _emscripten_bind_PxArticulationDrive_PxArticulationDrive_2(stiffness, damping); getCache(PxArticulationDrive)[this.ptr] = this;return }
  if (driveType === undefined) { this.ptr = _emscripten_bind_PxArticulationDrive_PxArticulationDrive_3(stiffness, damping, maxForce); getCache(PxArticulationDrive)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArticulationDrive_PxArticulationDrive_4(stiffness, damping, maxForce, driveType);
  getCache(PxArticulationDrive)[this.ptr] = this;
};

PxArticulationDrive.prototype = Object.create(WrapperObject.prototype);
PxArticulationDrive.prototype.constructor = PxArticulationDrive;
PxArticulationDrive.prototype.__class__ = PxArticulationDrive;
PxArticulationDrive.__cache__ = {};
Module['PxArticulationDrive'] = PxArticulationDrive;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationDrive.prototype['get_stiffness'] = PxArticulationDrive.prototype.get_stiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationDrive_get_stiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationDrive.prototype['set_stiffness'] = PxArticulationDrive.prototype.set_stiffness = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationDrive_set_stiffness_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationDrive.prototype, 'stiffness', { get: PxArticulationDrive.prototype.get_stiffness, set: PxArticulationDrive.prototype.set_stiffness });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationDrive.prototype['get_damping'] = PxArticulationDrive.prototype.get_damping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationDrive_get_damping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationDrive.prototype['set_damping'] = PxArticulationDrive.prototype.set_damping = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationDrive_set_damping_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationDrive.prototype, 'damping', { get: PxArticulationDrive.prototype.get_damping, set: PxArticulationDrive.prototype.set_damping });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationDrive.prototype['get_maxForce'] = PxArticulationDrive.prototype.get_maxForce = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationDrive_get_maxForce_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationDrive.prototype['set_maxForce'] = PxArticulationDrive.prototype.set_maxForce = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationDrive_set_maxForce_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationDrive.prototype, 'maxForce', { get: PxArticulationDrive.prototype.get_maxForce, set: PxArticulationDrive.prototype.set_maxForce });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationDrive.prototype['get_driveType'] = PxArticulationDrive.prototype.get_driveType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationDrive_get_driveType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationDrive.prototype['set_driveType'] = PxArticulationDrive.prototype.set_driveType = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationDrive_set_driveType_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationDrive.prototype, 'driveType', { get: PxArticulationDrive.prototype.get_driveType, set: PxArticulationDrive.prototype.set_driveType });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationDrive.prototype['__destroy__'] = PxArticulationDrive.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationDrive___destroy___0(self);
};

// Interface: PxArticulationFixedTendon

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationFixedTendon() { throw "cannot construct a PxArticulationFixedTendon, no constructor in IDL" }
PxArticulationFixedTendon.prototype = Object.create(PxArticulationTendon.prototype);
PxArticulationFixedTendon.prototype.constructor = PxArticulationFixedTendon;
PxArticulationFixedTendon.prototype.__class__ = PxArticulationFixedTendon;
PxArticulationFixedTendon.__cache__ = {};
Module['PxArticulationFixedTendon'] = PxArticulationFixedTendon;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['createTendonJoint'] = PxArticulationFixedTendon.prototype.createTendonJoint = function(parent, axis, coefficient, recipCoefficient, link) {
  var self = this.ptr;
  if (parent && typeof parent === 'object') parent = parent.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  if (coefficient && typeof coefficient === 'object') coefficient = coefficient.ptr;
  if (recipCoefficient && typeof recipCoefficient === 'object') recipCoefficient = recipCoefficient.ptr;
  if (link && typeof link === 'object') link = link.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationFixedTendon_createTendonJoint_5(self, parent, axis, coefficient, recipCoefficient, link), PxArticulationTendonJoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['getNbTendonJoints'] = PxArticulationFixedTendon.prototype.getNbTendonJoints = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationFixedTendon_getNbTendonJoints_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['setRestLength'] = PxArticulationFixedTendon.prototype.setRestLength = function(restLength) {
  var self = this.ptr;
  if (restLength && typeof restLength === 'object') restLength = restLength.ptr;
  _emscripten_bind_PxArticulationFixedTendon_setRestLength_1(self, restLength);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['getRestLength'] = PxArticulationFixedTendon.prototype.getRestLength = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationFixedTendon_getRestLength_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['setLimitParameters'] = PxArticulationFixedTendon.prototype.setLimitParameters = function(parameter) {
  var self = this.ptr;
  if (parameter && typeof parameter === 'object') parameter = parameter.ptr;
  _emscripten_bind_PxArticulationFixedTendon_setLimitParameters_1(self, parameter);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['getLimitParameters'] = PxArticulationFixedTendon.prototype.getLimitParameters = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationFixedTendon_getLimitParameters_0(self), PxArticulationTendonLimit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['setStiffness'] = PxArticulationFixedTendon.prototype.setStiffness = function(stiffness) {
  var self = this.ptr;
  if (stiffness && typeof stiffness === 'object') stiffness = stiffness.ptr;
  _emscripten_bind_PxArticulationFixedTendon_setStiffness_1(self, stiffness);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['getStiffness'] = PxArticulationFixedTendon.prototype.getStiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationFixedTendon_getStiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['setDamping'] = PxArticulationFixedTendon.prototype.setDamping = function(damping) {
  var self = this.ptr;
  if (damping && typeof damping === 'object') damping = damping.ptr;
  _emscripten_bind_PxArticulationFixedTendon_setDamping_1(self, damping);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['getDamping'] = PxArticulationFixedTendon.prototype.getDamping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationFixedTendon_getDamping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['setLimitStiffness'] = PxArticulationFixedTendon.prototype.setLimitStiffness = function(stiffness) {
  var self = this.ptr;
  if (stiffness && typeof stiffness === 'object') stiffness = stiffness.ptr;
  _emscripten_bind_PxArticulationFixedTendon_setLimitStiffness_1(self, stiffness);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['getLimitStiffness'] = PxArticulationFixedTendon.prototype.getLimitStiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationFixedTendon_getLimitStiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['setOffset'] = PxArticulationFixedTendon.prototype.setOffset = function(offset, autowake) {
  var self = this.ptr;
  if (offset && typeof offset === 'object') offset = offset.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxArticulationFixedTendon_setOffset_1(self, offset); return }
  _emscripten_bind_PxArticulationFixedTendon_setOffset_2(self, offset, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['getOffset'] = PxArticulationFixedTendon.prototype.getOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationFixedTendon_getOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['getArticulation'] = PxArticulationFixedTendon.prototype.getArticulation = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationFixedTendon_getArticulation_0(self), PxArticulationReducedCoordinate);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['release'] = PxArticulationFixedTendon.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationFixedTendon_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['getConcreteTypeName'] = PxArticulationFixedTendon.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxArticulationFixedTendon_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['getConcreteType'] = PxArticulationFixedTendon.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationFixedTendon_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['setBaseFlag'] = PxArticulationFixedTendon.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArticulationFixedTendon_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['setBaseFlags'] = PxArticulationFixedTendon.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxArticulationFixedTendon_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['getBaseFlags'] = PxArticulationFixedTendon.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationFixedTendon_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['isReleasable'] = PxArticulationFixedTendon.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxArticulationFixedTendon_isReleasable_0(self));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFixedTendon.prototype['__destroy__'] = PxArticulationFixedTendon.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationFixedTendon___destroy___0(self);
};

// Interface: PxArticulationFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxArticulationFlags_PxArticulationFlags_1(flags);
  getCache(PxArticulationFlags)[this.ptr] = this;
};

PxArticulationFlags.prototype = Object.create(WrapperObject.prototype);
PxArticulationFlags.prototype.constructor = PxArticulationFlags;
PxArticulationFlags.prototype.__class__ = PxArticulationFlags;
PxArticulationFlags.__cache__ = {};
Module['PxArticulationFlags'] = PxArticulationFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFlags.prototype['isSet'] = PxArticulationFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxArticulationFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFlags.prototype['raise'] = PxArticulationFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxArticulationFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFlags.prototype['clear'] = PxArticulationFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxArticulationFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationFlags.prototype['__destroy__'] = PxArticulationFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationFlags___destroy___0(self);
};

// Interface: PxArticulationJointReducedCoordinate

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationJointReducedCoordinate() { throw "cannot construct a PxArticulationJointReducedCoordinate, no constructor in IDL" }
PxArticulationJointReducedCoordinate.prototype = Object.create(PxBase.prototype);
PxArticulationJointReducedCoordinate.prototype.constructor = PxArticulationJointReducedCoordinate;
PxArticulationJointReducedCoordinate.prototype.__class__ = PxArticulationJointReducedCoordinate;
PxArticulationJointReducedCoordinate.__cache__ = {};
Module['PxArticulationJointReducedCoordinate'] = PxArticulationJointReducedCoordinate;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getParentArticulationLink'] = PxArticulationJointReducedCoordinate.prototype.getParentArticulationLink = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationJointReducedCoordinate_getParentArticulationLink_0(self), PxArticulationLink);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setParentPose'] = PxArticulationJointReducedCoordinate.prototype.setParentPose = function(pose) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate_setParentPose_1(self, pose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getParentPose'] = PxArticulationJointReducedCoordinate.prototype.getParentPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationJointReducedCoordinate_getParentPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getChildArticulationLink'] = PxArticulationJointReducedCoordinate.prototype.getChildArticulationLink = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationJointReducedCoordinate_getChildArticulationLink_0(self), PxArticulationLink);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setChildPose'] = PxArticulationJointReducedCoordinate.prototype.setChildPose = function(pose) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate_setChildPose_1(self, pose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getChildPose'] = PxArticulationJointReducedCoordinate.prototype.getChildPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationJointReducedCoordinate_getChildPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setJointType'] = PxArticulationJointReducedCoordinate.prototype.setJointType = function(jointType) {
  var self = this.ptr;
  if (jointType && typeof jointType === 'object') jointType = jointType.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate_setJointType_1(self, jointType);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getJointType'] = PxArticulationJointReducedCoordinate.prototype.getJointType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationJointReducedCoordinate_getJointType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setMotion'] = PxArticulationJointReducedCoordinate.prototype.setMotion = function(axis, motion) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  if (motion && typeof motion === 'object') motion = motion.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate_setMotion_2(self, axis, motion);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getMotion'] = PxArticulationJointReducedCoordinate.prototype.getMotion = function(axis) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  return _emscripten_bind_PxArticulationJointReducedCoordinate_getMotion_1(self, axis);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setLimitParams'] = PxArticulationJointReducedCoordinate.prototype.setLimitParams = function(axis, limit) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  if (limit && typeof limit === 'object') limit = limit.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate_setLimitParams_2(self, axis, limit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getLimitParams'] = PxArticulationJointReducedCoordinate.prototype.getLimitParams = function(axis) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationJointReducedCoordinate_getLimitParams_1(self, axis), PxArticulationLimit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setDriveParams'] = PxArticulationJointReducedCoordinate.prototype.setDriveParams = function(axis, drive) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  if (drive && typeof drive === 'object') drive = drive.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveParams_2(self, axis, drive);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setDriveTarget'] = PxArticulationJointReducedCoordinate.prototype.setDriveTarget = function(axis, target, autowake) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  if (target && typeof target === 'object') target = target.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_2(self, axis, target); return }
  _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveTarget_3(self, axis, target, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getDriveTarget'] = PxArticulationJointReducedCoordinate.prototype.getDriveTarget = function(axis) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  return _emscripten_bind_PxArticulationJointReducedCoordinate_getDriveTarget_1(self, axis);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setDriveVelocity'] = PxArticulationJointReducedCoordinate.prototype.setDriveVelocity = function(axis, targetVel, autowake) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  if (targetVel && typeof targetVel === 'object') targetVel = targetVel.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_2(self, axis, targetVel); return }
  _emscripten_bind_PxArticulationJointReducedCoordinate_setDriveVelocity_3(self, axis, targetVel, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getDriveVelocity'] = PxArticulationJointReducedCoordinate.prototype.getDriveVelocity = function(axis) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  return _emscripten_bind_PxArticulationJointReducedCoordinate_getDriveVelocity_1(self, axis);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setArmature'] = PxArticulationJointReducedCoordinate.prototype.setArmature = function(axis, armature) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  if (armature && typeof armature === 'object') armature = armature.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate_setArmature_2(self, axis, armature);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getArmature'] = PxArticulationJointReducedCoordinate.prototype.getArmature = function(axis) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  return _emscripten_bind_PxArticulationJointReducedCoordinate_getArmature_1(self, axis);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setFrictionCoefficient'] = PxArticulationJointReducedCoordinate.prototype.setFrictionCoefficient = function(coefficient) {
  var self = this.ptr;
  if (coefficient && typeof coefficient === 'object') coefficient = coefficient.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate_setFrictionCoefficient_1(self, coefficient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getFrictionCoefficient'] = PxArticulationJointReducedCoordinate.prototype.getFrictionCoefficient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationJointReducedCoordinate_getFrictionCoefficient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setMaxJointVelocity'] = PxArticulationJointReducedCoordinate.prototype.setMaxJointVelocity = function(maxJointV) {
  var self = this.ptr;
  if (maxJointV && typeof maxJointV === 'object') maxJointV = maxJointV.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate_setMaxJointVelocity_1(self, maxJointV);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getMaxJointVelocity'] = PxArticulationJointReducedCoordinate.prototype.getMaxJointVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationJointReducedCoordinate_getMaxJointVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setJointPosition'] = PxArticulationJointReducedCoordinate.prototype.setJointPosition = function(axis, jointPos) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  if (jointPos && typeof jointPos === 'object') jointPos = jointPos.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate_setJointPosition_2(self, axis, jointPos);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getJointPosition'] = PxArticulationJointReducedCoordinate.prototype.getJointPosition = function(axis) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  return _emscripten_bind_PxArticulationJointReducedCoordinate_getJointPosition_1(self, axis);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setJointVelocity'] = PxArticulationJointReducedCoordinate.prototype.setJointVelocity = function(axis, jointVel) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  if (jointVel && typeof jointVel === 'object') jointVel = jointVel.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate_setJointVelocity_2(self, axis, jointVel);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getJointVelocity'] = PxArticulationJointReducedCoordinate.prototype.getJointVelocity = function(axis) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  return _emscripten_bind_PxArticulationJointReducedCoordinate_getJointVelocity_1(self, axis);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['release'] = PxArticulationJointReducedCoordinate.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getConcreteTypeName'] = PxArticulationJointReducedCoordinate.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getConcreteType'] = PxArticulationJointReducedCoordinate.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationJointReducedCoordinate_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setBaseFlag'] = PxArticulationJointReducedCoordinate.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['setBaseFlags'] = PxArticulationJointReducedCoordinate.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['getBaseFlags'] = PxArticulationJointReducedCoordinate.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationJointReducedCoordinate_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['isReleasable'] = PxArticulationJointReducedCoordinate.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxArticulationJointReducedCoordinate_isReleasable_0(self));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationJointReducedCoordinate.prototype['__destroy__'] = PxArticulationJointReducedCoordinate.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationJointReducedCoordinate___destroy___0(self);
};

// Interface: PxArticulationKinematicFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationKinematicFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxArticulationKinematicFlags_PxArticulationKinematicFlags_1(flags);
  getCache(PxArticulationKinematicFlags)[this.ptr] = this;
};

PxArticulationKinematicFlags.prototype = Object.create(WrapperObject.prototype);
PxArticulationKinematicFlags.prototype.constructor = PxArticulationKinematicFlags;
PxArticulationKinematicFlags.prototype.__class__ = PxArticulationKinematicFlags;
PxArticulationKinematicFlags.__cache__ = {};
Module['PxArticulationKinematicFlags'] = PxArticulationKinematicFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationKinematicFlags.prototype['isSet'] = PxArticulationKinematicFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxArticulationKinematicFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationKinematicFlags.prototype['raise'] = PxArticulationKinematicFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxArticulationKinematicFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationKinematicFlags.prototype['clear'] = PxArticulationKinematicFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxArticulationKinematicFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationKinematicFlags.prototype['__destroy__'] = PxArticulationKinematicFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationKinematicFlags___destroy___0(self);
};

// Interface: PxArticulationLimit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationLimit(low, high) {
  if (low && typeof low === 'object') low = low.ptr;
  if (high && typeof high === 'object') high = high.ptr;
  if (low === undefined) { this.ptr = _emscripten_bind_PxArticulationLimit_PxArticulationLimit_0(); getCache(PxArticulationLimit)[this.ptr] = this;return }
  if (high === undefined) { this.ptr = _emscripten_bind_PxArticulationLimit_PxArticulationLimit_1(low); getCache(PxArticulationLimit)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxArticulationLimit_PxArticulationLimit_2(low, high);
  getCache(PxArticulationLimit)[this.ptr] = this;
};

PxArticulationLimit.prototype = Object.create(WrapperObject.prototype);
PxArticulationLimit.prototype.constructor = PxArticulationLimit;
PxArticulationLimit.prototype.__class__ = PxArticulationLimit;
PxArticulationLimit.__cache__ = {};
Module['PxArticulationLimit'] = PxArticulationLimit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLimit.prototype['get_low'] = PxArticulationLimit.prototype.get_low = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLimit_get_low_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLimit.prototype['set_low'] = PxArticulationLimit.prototype.set_low = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationLimit_set_low_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationLimit.prototype, 'low', { get: PxArticulationLimit.prototype.get_low, set: PxArticulationLimit.prototype.set_low });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLimit.prototype['get_high'] = PxArticulationLimit.prototype.get_high = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLimit_get_high_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLimit.prototype['set_high'] = PxArticulationLimit.prototype.set_high = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationLimit_set_high_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationLimit.prototype, 'high', { get: PxArticulationLimit.prototype.get_high, set: PxArticulationLimit.prototype.set_high });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLimit.prototype['__destroy__'] = PxArticulationLimit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationLimit___destroy___0(self);
};

// Interface: PxArticulationLink

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationLink() { throw "cannot construct a PxArticulationLink, no constructor in IDL" }
PxArticulationLink.prototype = Object.create(PxRigidBody.prototype);
PxArticulationLink.prototype.constructor = PxArticulationLink;
PxArticulationLink.prototype.__class__ = PxArticulationLink;
PxArticulationLink.__cache__ = {};
Module['PxArticulationLink'] = PxArticulationLink;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getArticulation'] = PxArticulationLink.prototype.getArticulation = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationLink_getArticulation_0(self), PxArticulationReducedCoordinate);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getInboundJoint'] = PxArticulationLink.prototype.getInboundJoint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationLink_getInboundJoint_0(self), PxArticulationJointReducedCoordinate);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getInboundJointDof'] = PxArticulationLink.prototype.getInboundJointDof = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getInboundJointDof_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getNbChildren'] = PxArticulationLink.prototype.getNbChildren = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getNbChildren_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getLinkIndex'] = PxArticulationLink.prototype.getLinkIndex = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getLinkIndex_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setCfmScale'] = PxArticulationLink.prototype.setCfmScale = function(cfm) {
  var self = this.ptr;
  if (cfm && typeof cfm === 'object') cfm = cfm.ptr;
  _emscripten_bind_PxArticulationLink_setCfmScale_1(self, cfm);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getCfmScale'] = PxArticulationLink.prototype.getCfmScale = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getCfmScale_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getType'] = PxArticulationLink.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getScene'] = PxArticulationLink.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationLink_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setName'] = PxArticulationLink.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxArticulationLink_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getName'] = PxArticulationLink.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxArticulationLink_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getWorldBounds'] = PxArticulationLink.prototype.getWorldBounds = function(inflation) {
  var self = this.ptr;
  if (inflation && typeof inflation === 'object') inflation = inflation.ptr;
  if (inflation === undefined) { return wrapPointer(_emscripten_bind_PxArticulationLink_getWorldBounds_0(self), PxBounds3) }
  return wrapPointer(_emscripten_bind_PxArticulationLink_getWorldBounds_1(self, inflation), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setActorFlag'] = PxArticulationLink.prototype.setActorFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArticulationLink_setActorFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setActorFlags'] = PxArticulationLink.prototype.setActorFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxArticulationLink_setActorFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getActorFlags'] = PxArticulationLink.prototype.getActorFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationLink_getActorFlags_0(self), PxActorFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setDominanceGroup'] = PxArticulationLink.prototype.setDominanceGroup = function(dominanceGroup) {
  var self = this.ptr;
  if (dominanceGroup && typeof dominanceGroup === 'object') dominanceGroup = dominanceGroup.ptr;
  _emscripten_bind_PxArticulationLink_setDominanceGroup_1(self, dominanceGroup);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getDominanceGroup'] = PxArticulationLink.prototype.getDominanceGroup = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getDominanceGroup_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setOwnerClient'] = PxArticulationLink.prototype.setOwnerClient = function(inClient) {
  var self = this.ptr;
  if (inClient && typeof inClient === 'object') inClient = inClient.ptr;
  _emscripten_bind_PxArticulationLink_setOwnerClient_1(self, inClient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getOwnerClient'] = PxArticulationLink.prototype.getOwnerClient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getOwnerClient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['release'] = PxArticulationLink.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationLink_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getConcreteTypeName'] = PxArticulationLink.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxArticulationLink_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getConcreteType'] = PxArticulationLink.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setBaseFlag'] = PxArticulationLink.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArticulationLink_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setBaseFlags'] = PxArticulationLink.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxArticulationLink_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getBaseFlags'] = PxArticulationLink.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationLink_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['isReleasable'] = PxArticulationLink.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxArticulationLink_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getGlobalPose'] = PxArticulationLink.prototype.getGlobalPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationLink_getGlobalPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setGlobalPose'] = PxArticulationLink.prototype.setGlobalPose = function(pose, autowake) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxArticulationLink_setGlobalPose_1(self, pose); return }
  _emscripten_bind_PxArticulationLink_setGlobalPose_2(self, pose, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['attachShape'] = PxArticulationLink.prototype.attachShape = function(shape) {
  var self = this.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  return !!(_emscripten_bind_PxArticulationLink_attachShape_1(self, shape));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['detachShape'] = PxArticulationLink.prototype.detachShape = function(shape, wakeOnLostTouch) {
  var self = this.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (wakeOnLostTouch && typeof wakeOnLostTouch === 'object') wakeOnLostTouch = wakeOnLostTouch.ptr;
  if (wakeOnLostTouch === undefined) { _emscripten_bind_PxArticulationLink_detachShape_1(self, shape); return }
  _emscripten_bind_PxArticulationLink_detachShape_2(self, shape, wakeOnLostTouch);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getNbShapes'] = PxArticulationLink.prototype.getNbShapes = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getNbShapes_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getShapes'] = PxArticulationLink.prototype.getShapes = function(userBuffer, bufferSize, startIndex) {
  var self = this.ptr;
  if (userBuffer && typeof userBuffer === 'object') userBuffer = userBuffer.ptr;
  if (bufferSize && typeof bufferSize === 'object') bufferSize = bufferSize.ptr;
  if (startIndex && typeof startIndex === 'object') startIndex = startIndex.ptr;
  return _emscripten_bind_PxArticulationLink_getShapes_3(self, userBuffer, bufferSize, startIndex);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getNbConstraints'] = PxArticulationLink.prototype.getNbConstraints = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getNbConstraints_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setCMassLocalPose'] = PxArticulationLink.prototype.setCMassLocalPose = function(pose) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  _emscripten_bind_PxArticulationLink_setCMassLocalPose_1(self, pose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getCMassLocalPose'] = PxArticulationLink.prototype.getCMassLocalPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationLink_getCMassLocalPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setMass'] = PxArticulationLink.prototype.setMass = function(mass) {
  var self = this.ptr;
  if (mass && typeof mass === 'object') mass = mass.ptr;
  _emscripten_bind_PxArticulationLink_setMass_1(self, mass);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getMass'] = PxArticulationLink.prototype.getMass = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getMass_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getInvMass'] = PxArticulationLink.prototype.getInvMass = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getInvMass_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setMassSpaceInertiaTensor'] = PxArticulationLink.prototype.setMassSpaceInertiaTensor = function(m) {
  var self = this.ptr;
  if (m && typeof m === 'object') m = m.ptr;
  _emscripten_bind_PxArticulationLink_setMassSpaceInertiaTensor_1(self, m);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getMassSpaceInertiaTensor'] = PxArticulationLink.prototype.getMassSpaceInertiaTensor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationLink_getMassSpaceInertiaTensor_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getMassSpaceInvInertiaTensor'] = PxArticulationLink.prototype.getMassSpaceInvInertiaTensor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationLink_getMassSpaceInvInertiaTensor_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setLinearDamping'] = PxArticulationLink.prototype.setLinearDamping = function(linDamp) {
  var self = this.ptr;
  if (linDamp && typeof linDamp === 'object') linDamp = linDamp.ptr;
  _emscripten_bind_PxArticulationLink_setLinearDamping_1(self, linDamp);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getLinearDamping'] = PxArticulationLink.prototype.getLinearDamping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getLinearDamping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setAngularDamping'] = PxArticulationLink.prototype.setAngularDamping = function(angDamp) {
  var self = this.ptr;
  if (angDamp && typeof angDamp === 'object') angDamp = angDamp.ptr;
  _emscripten_bind_PxArticulationLink_setAngularDamping_1(self, angDamp);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getAngularDamping'] = PxArticulationLink.prototype.getAngularDamping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getAngularDamping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getLinearVelocity'] = PxArticulationLink.prototype.getLinearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationLink_getLinearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getAngularVelocity'] = PxArticulationLink.prototype.getAngularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationLink_getAngularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setMaxLinearVelocity'] = PxArticulationLink.prototype.setMaxLinearVelocity = function(maxLinVel) {
  var self = this.ptr;
  if (maxLinVel && typeof maxLinVel === 'object') maxLinVel = maxLinVel.ptr;
  _emscripten_bind_PxArticulationLink_setMaxLinearVelocity_1(self, maxLinVel);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getMaxLinearVelocity'] = PxArticulationLink.prototype.getMaxLinearVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getMaxLinearVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setMaxAngularVelocity'] = PxArticulationLink.prototype.setMaxAngularVelocity = function(maxAngVel) {
  var self = this.ptr;
  if (maxAngVel && typeof maxAngVel === 'object') maxAngVel = maxAngVel.ptr;
  _emscripten_bind_PxArticulationLink_setMaxAngularVelocity_1(self, maxAngVel);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getMaxAngularVelocity'] = PxArticulationLink.prototype.getMaxAngularVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getMaxAngularVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['addForce'] = PxArticulationLink.prototype.addForce = function(force, mode, autowake) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (mode === undefined) { _emscripten_bind_PxArticulationLink_addForce_1(self, force); return }
  if (autowake === undefined) { _emscripten_bind_PxArticulationLink_addForce_2(self, force, mode); return }
  _emscripten_bind_PxArticulationLink_addForce_3(self, force, mode, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['addTorque'] = PxArticulationLink.prototype.addTorque = function(torque, mode, autowake) {
  var self = this.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (mode === undefined) { _emscripten_bind_PxArticulationLink_addTorque_1(self, torque); return }
  if (autowake === undefined) { _emscripten_bind_PxArticulationLink_addTorque_2(self, torque, mode); return }
  _emscripten_bind_PxArticulationLink_addTorque_3(self, torque, mode, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['clearForce'] = PxArticulationLink.prototype.clearForce = function(mode) {
  var self = this.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  _emscripten_bind_PxArticulationLink_clearForce_1(self, mode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['clearTorque'] = PxArticulationLink.prototype.clearTorque = function(mode) {
  var self = this.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  _emscripten_bind_PxArticulationLink_clearTorque_1(self, mode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setForceAndTorque'] = PxArticulationLink.prototype.setForceAndTorque = function(force, torque, mode) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  if (mode === undefined) { _emscripten_bind_PxArticulationLink_setForceAndTorque_2(self, force, torque); return }
  _emscripten_bind_PxArticulationLink_setForceAndTorque_3(self, force, torque, mode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setRigidBodyFlag'] = PxArticulationLink.prototype.setRigidBodyFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArticulationLink_setRigidBodyFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setRigidBodyFlags'] = PxArticulationLink.prototype.setRigidBodyFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxArticulationLink_setRigidBodyFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getRigidBodyFlags'] = PxArticulationLink.prototype.getRigidBodyFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationLink_getRigidBodyFlags_0(self), PxRigidBodyFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setMinCCDAdvanceCoefficient'] = PxArticulationLink.prototype.setMinCCDAdvanceCoefficient = function(advanceCoefficient) {
  var self = this.ptr;
  if (advanceCoefficient && typeof advanceCoefficient === 'object') advanceCoefficient = advanceCoefficient.ptr;
  _emscripten_bind_PxArticulationLink_setMinCCDAdvanceCoefficient_1(self, advanceCoefficient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getMinCCDAdvanceCoefficient'] = PxArticulationLink.prototype.getMinCCDAdvanceCoefficient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getMinCCDAdvanceCoefficient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setMaxDepenetrationVelocity'] = PxArticulationLink.prototype.setMaxDepenetrationVelocity = function(biasClamp) {
  var self = this.ptr;
  if (biasClamp && typeof biasClamp === 'object') biasClamp = biasClamp.ptr;
  _emscripten_bind_PxArticulationLink_setMaxDepenetrationVelocity_1(self, biasClamp);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getMaxDepenetrationVelocity'] = PxArticulationLink.prototype.getMaxDepenetrationVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getMaxDepenetrationVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setMaxContactImpulse'] = PxArticulationLink.prototype.setMaxContactImpulse = function(maxImpulse) {
  var self = this.ptr;
  if (maxImpulse && typeof maxImpulse === 'object') maxImpulse = maxImpulse.ptr;
  _emscripten_bind_PxArticulationLink_setMaxContactImpulse_1(self, maxImpulse);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getMaxContactImpulse'] = PxArticulationLink.prototype.getMaxContactImpulse = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getMaxContactImpulse_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['setContactSlopCoefficient'] = PxArticulationLink.prototype.setContactSlopCoefficient = function(slopCoefficient) {
  var self = this.ptr;
  if (slopCoefficient && typeof slopCoefficient === 'object') slopCoefficient = slopCoefficient.ptr;
  _emscripten_bind_PxArticulationLink_setContactSlopCoefficient_1(self, slopCoefficient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['getContactSlopCoefficient'] = PxArticulationLink.prototype.getContactSlopCoefficient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationLink_getContactSlopCoefficient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['get_userData'] = PxArticulationLink.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationLink_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationLink.prototype['set_userData'] = PxArticulationLink.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationLink_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationLink.prototype, 'userData', { get: PxArticulationLink.prototype.get_userData, set: PxArticulationLink.prototype.set_userData });

// Interface: PxArticulationReducedCoordinate

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationReducedCoordinate() { throw "cannot construct a PxArticulationReducedCoordinate, no constructor in IDL" }
PxArticulationReducedCoordinate.prototype = Object.create(PxBase.prototype);
PxArticulationReducedCoordinate.prototype.constructor = PxArticulationReducedCoordinate;
PxArticulationReducedCoordinate.prototype.__class__ = PxArticulationReducedCoordinate;
PxArticulationReducedCoordinate.__cache__ = {};
Module['PxArticulationReducedCoordinate'] = PxArticulationReducedCoordinate;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getScene'] = PxArticulationReducedCoordinate.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['setSolverIterationCounts'] = PxArticulationReducedCoordinate.prototype.setSolverIterationCounts = function(minPositionIters, minVelocityIters) {
  var self = this.ptr;
  if (minPositionIters && typeof minPositionIters === 'object') minPositionIters = minPositionIters.ptr;
  if (minVelocityIters && typeof minVelocityIters === 'object') minVelocityIters = minVelocityIters.ptr;
  if (minVelocityIters === undefined) { _emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_1(self, minPositionIters); return }
  _emscripten_bind_PxArticulationReducedCoordinate_setSolverIterationCounts_2(self, minPositionIters, minVelocityIters);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['isSleeping'] = PxArticulationReducedCoordinate.prototype.isSleeping = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxArticulationReducedCoordinate_isSleeping_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['setSleepThreshold'] = PxArticulationReducedCoordinate.prototype.setSleepThreshold = function(threshold) {
  var self = this.ptr;
  if (threshold && typeof threshold === 'object') threshold = threshold.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_setSleepThreshold_1(self, threshold);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getSleepThreshold'] = PxArticulationReducedCoordinate.prototype.getSleepThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationReducedCoordinate_getSleepThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['setStabilizationThreshold'] = PxArticulationReducedCoordinate.prototype.setStabilizationThreshold = function(threshold) {
  var self = this.ptr;
  if (threshold && typeof threshold === 'object') threshold = threshold.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_setStabilizationThreshold_1(self, threshold);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getStabilizationThreshold'] = PxArticulationReducedCoordinate.prototype.getStabilizationThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationReducedCoordinate_getStabilizationThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['setWakeCounter'] = PxArticulationReducedCoordinate.prototype.setWakeCounter = function(wakeCounterValue) {
  var self = this.ptr;
  if (wakeCounterValue && typeof wakeCounterValue === 'object') wakeCounterValue = wakeCounterValue.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_setWakeCounter_1(self, wakeCounterValue);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getWakeCounter'] = PxArticulationReducedCoordinate.prototype.getWakeCounter = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationReducedCoordinate_getWakeCounter_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['wakeUp'] = PxArticulationReducedCoordinate.prototype.wakeUp = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_wakeUp_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['putToSleep'] = PxArticulationReducedCoordinate.prototype.putToSleep = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_putToSleep_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['createLink'] = PxArticulationReducedCoordinate.prototype.createLink = function(parent, pose) {
  var self = this.ptr;
  if (parent && typeof parent === 'object') parent = parent.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_createLink_2(self, parent, pose), PxArticulationLink);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getNbLinks'] = PxArticulationReducedCoordinate.prototype.getNbLinks = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationReducedCoordinate_getNbLinks_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getNbShapes'] = PxArticulationReducedCoordinate.prototype.getNbShapes = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationReducedCoordinate_getNbShapes_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['setName'] = PxArticulationReducedCoordinate.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxArticulationReducedCoordinate_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getName'] = PxArticulationReducedCoordinate.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxArticulationReducedCoordinate_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getWorldBounds'] = PxArticulationReducedCoordinate.prototype.getWorldBounds = function(inflation) {
  var self = this.ptr;
  if (inflation && typeof inflation === 'object') inflation = inflation.ptr;
  if (inflation === undefined) { return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_0(self), PxBounds3) }
  return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_getWorldBounds_1(self, inflation), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getAggregate'] = PxArticulationReducedCoordinate.prototype.getAggregate = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_getAggregate_0(self), PxAggregate);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['setArticulationFlags'] = PxArticulationReducedCoordinate.prototype.setArticulationFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['setArticulationFlag'] = PxArticulationReducedCoordinate.prototype.setArticulationFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_setArticulationFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getArticulationFlags'] = PxArticulationReducedCoordinate.prototype.getArticulationFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_getArticulationFlags_0(self), PxArticulationFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getDofs'] = PxArticulationReducedCoordinate.prototype.getDofs = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationReducedCoordinate_getDofs_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['createCache'] = PxArticulationReducedCoordinate.prototype.createCache = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_createCache_0(self), PxArticulationCache);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getCacheDataSize'] = PxArticulationReducedCoordinate.prototype.getCacheDataSize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationReducedCoordinate_getCacheDataSize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['zeroCache'] = PxArticulationReducedCoordinate.prototype.zeroCache = function(cache) {
  var self = this.ptr;
  if (cache && typeof cache === 'object') cache = cache.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_zeroCache_1(self, cache);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['applyCache'] = PxArticulationReducedCoordinate.prototype.applyCache = function(cache, flags, autowake) {
  var self = this.ptr;
  if (cache && typeof cache === 'object') cache = cache.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxArticulationReducedCoordinate_applyCache_2(self, cache, flags); return }
  _emscripten_bind_PxArticulationReducedCoordinate_applyCache_3(self, cache, flags, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['copyInternalStateToCache'] = PxArticulationReducedCoordinate.prototype.copyInternalStateToCache = function(cache, flags) {
  var self = this.ptr;
  if (cache && typeof cache === 'object') cache = cache.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_copyInternalStateToCache_2(self, cache, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['commonInit'] = PxArticulationReducedCoordinate.prototype.commonInit = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_commonInit_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['computeGeneralizedGravityForce'] = PxArticulationReducedCoordinate.prototype.computeGeneralizedGravityForce = function(cache) {
  var self = this.ptr;
  if (cache && typeof cache === 'object') cache = cache.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedGravityForce_1(self, cache);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['computeGravityCompensation'] = PxArticulationReducedCoordinate.prototype.computeGravityCompensation = function(cache) {
  var self = this.ptr;
  if (cache && typeof cache === 'object') cache = cache.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_computeGravityCompensation_1(self, cache);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['computeCoriolisAndCentrifugalForce'] = PxArticulationReducedCoordinate.prototype.computeCoriolisAndCentrifugalForce = function(cache) {
  var self = this.ptr;
  if (cache && typeof cache === 'object') cache = cache.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisAndCentrifugalForce_1(self, cache);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['computeCoriolisCompensation'] = PxArticulationReducedCoordinate.prototype.computeCoriolisCompensation = function(cache) {
  var self = this.ptr;
  if (cache && typeof cache === 'object') cache = cache.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_computeCoriolisCompensation_1(self, cache);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['computeGeneralizedExternalForce'] = PxArticulationReducedCoordinate.prototype.computeGeneralizedExternalForce = function(cache) {
  var self = this.ptr;
  if (cache && typeof cache === 'object') cache = cache.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedExternalForce_1(self, cache);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['computeJointAcceleration'] = PxArticulationReducedCoordinate.prototype.computeJointAcceleration = function(cache) {
  var self = this.ptr;
  if (cache && typeof cache === 'object') cache = cache.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_computeJointAcceleration_1(self, cache);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['computeJointForce'] = PxArticulationReducedCoordinate.prototype.computeJointForce = function(cache) {
  var self = this.ptr;
  if (cache && typeof cache === 'object') cache = cache.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_computeJointForce_1(self, cache);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['computeCoefficientMatrix'] = PxArticulationReducedCoordinate.prototype.computeCoefficientMatrix = function(cache) {
  var self = this.ptr;
  if (cache && typeof cache === 'object') cache = cache.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_computeCoefficientMatrix_1(self, cache);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['computeGeneralizedMassMatrix'] = PxArticulationReducedCoordinate.prototype.computeGeneralizedMassMatrix = function(cache) {
  var self = this.ptr;
  if (cache && typeof cache === 'object') cache = cache.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_computeGeneralizedMassMatrix_1(self, cache);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['computeMassMatrix'] = PxArticulationReducedCoordinate.prototype.computeMassMatrix = function(cache) {
  var self = this.ptr;
  if (cache && typeof cache === 'object') cache = cache.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_computeMassMatrix_1(self, cache);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['computeArticulationCOM'] = PxArticulationReducedCoordinate.prototype.computeArticulationCOM = function(rootFrame) {
  var self = this.ptr;
  if (rootFrame && typeof rootFrame === 'object') rootFrame = rootFrame.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_computeArticulationCOM_1(self, rootFrame), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['computeCentroidalMomentumMatrix'] = PxArticulationReducedCoordinate.prototype.computeCentroidalMomentumMatrix = function(cache) {
  var self = this.ptr;
  if (cache && typeof cache === 'object') cache = cache.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_computeCentroidalMomentumMatrix_1(self, cache);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['addLoopJoint'] = PxArticulationReducedCoordinate.prototype.addLoopJoint = function(joint) {
  var self = this.ptr;
  if (joint && typeof joint === 'object') joint = joint.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_addLoopJoint_1(self, joint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['removeLoopJoint'] = PxArticulationReducedCoordinate.prototype.removeLoopJoint = function(joint) {
  var self = this.ptr;
  if (joint && typeof joint === 'object') joint = joint.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_removeLoopJoint_1(self, joint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getNbLoopJoints'] = PxArticulationReducedCoordinate.prototype.getNbLoopJoints = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationReducedCoordinate_getNbLoopJoints_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getCoefficientMatrixSize'] = PxArticulationReducedCoordinate.prototype.getCoefficientMatrixSize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationReducedCoordinate_getCoefficientMatrixSize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['setRootGlobalPose'] = PxArticulationReducedCoordinate.prototype.setRootGlobalPose = function(pose, autowake) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_1(self, pose); return }
  _emscripten_bind_PxArticulationReducedCoordinate_setRootGlobalPose_2(self, pose, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getRootGlobalPose'] = PxArticulationReducedCoordinate.prototype.getRootGlobalPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_getRootGlobalPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['setRootLinearVelocity'] = PxArticulationReducedCoordinate.prototype.setRootLinearVelocity = function(linearVelocity, autowake) {
  var self = this.ptr;
  if (linearVelocity && typeof linearVelocity === 'object') linearVelocity = linearVelocity.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_1(self, linearVelocity); return }
  _emscripten_bind_PxArticulationReducedCoordinate_setRootLinearVelocity_2(self, linearVelocity, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getRootLinearVelocity'] = PxArticulationReducedCoordinate.prototype.getRootLinearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_getRootLinearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['setRootAngularVelocity'] = PxArticulationReducedCoordinate.prototype.setRootAngularVelocity = function(angularVelocity, autowake) {
  var self = this.ptr;
  if (angularVelocity && typeof angularVelocity === 'object') angularVelocity = angularVelocity.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_1(self, angularVelocity); return }
  _emscripten_bind_PxArticulationReducedCoordinate_setRootAngularVelocity_2(self, angularVelocity, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getRootAngularVelocity'] = PxArticulationReducedCoordinate.prototype.getRootAngularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_getRootAngularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getLinkAcceleration'] = PxArticulationReducedCoordinate.prototype.getLinkAcceleration = function(linkId) {
  var self = this.ptr;
  if (linkId && typeof linkId === 'object') linkId = linkId.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_getLinkAcceleration_1(self, linkId), PxSpatialVelocity);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getGPUIndex'] = PxArticulationReducedCoordinate.prototype.getGPUIndex = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationReducedCoordinate_getGPUIndex_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['createSpatialTendon'] = PxArticulationReducedCoordinate.prototype.createSpatialTendon = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_createSpatialTendon_0(self), PxArticulationSpatialTendon);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['createFixedTendon'] = PxArticulationReducedCoordinate.prototype.createFixedTendon = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_createFixedTendon_0(self), PxArticulationFixedTendon);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getNbSpatialTendons'] = PxArticulationReducedCoordinate.prototype.getNbSpatialTendons = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationReducedCoordinate_getNbSpatialTendons_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getNbFixedTendons'] = PxArticulationReducedCoordinate.prototype.getNbFixedTendons = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationReducedCoordinate_getNbFixedTendons_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['updateKinematic'] = PxArticulationReducedCoordinate.prototype.updateKinematic = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_updateKinematic_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['release'] = PxArticulationReducedCoordinate.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getConcreteTypeName'] = PxArticulationReducedCoordinate.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxArticulationReducedCoordinate_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getConcreteType'] = PxArticulationReducedCoordinate.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationReducedCoordinate_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['setBaseFlag'] = PxArticulationReducedCoordinate.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['setBaseFlags'] = PxArticulationReducedCoordinate.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['getBaseFlags'] = PxArticulationReducedCoordinate.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationReducedCoordinate_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['isReleasable'] = PxArticulationReducedCoordinate.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxArticulationReducedCoordinate_isReleasable_0(self));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationReducedCoordinate.prototype['__destroy__'] = PxArticulationReducedCoordinate.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationReducedCoordinate___destroy___0(self);
};

// Interface: PxArticulationRootLinkData

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationRootLinkData() {
  this.ptr = _emscripten_bind_PxArticulationRootLinkData_PxArticulationRootLinkData_0();
  getCache(PxArticulationRootLinkData)[this.ptr] = this;
};

PxArticulationRootLinkData.prototype = Object.create(WrapperObject.prototype);
PxArticulationRootLinkData.prototype.constructor = PxArticulationRootLinkData;
PxArticulationRootLinkData.prototype.__class__ = PxArticulationRootLinkData;
PxArticulationRootLinkData.__cache__ = {};
Module['PxArticulationRootLinkData'] = PxArticulationRootLinkData;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationRootLinkData.prototype['get_transform'] = PxArticulationRootLinkData.prototype.get_transform = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationRootLinkData_get_transform_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationRootLinkData.prototype['set_transform'] = PxArticulationRootLinkData.prototype.set_transform = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationRootLinkData_set_transform_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationRootLinkData.prototype, 'transform', { get: PxArticulationRootLinkData.prototype.get_transform, set: PxArticulationRootLinkData.prototype.set_transform });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationRootLinkData.prototype['get_worldLinVel'] = PxArticulationRootLinkData.prototype.get_worldLinVel = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationRootLinkData_get_worldLinVel_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationRootLinkData.prototype['set_worldLinVel'] = PxArticulationRootLinkData.prototype.set_worldLinVel = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationRootLinkData_set_worldLinVel_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationRootLinkData.prototype, 'worldLinVel', { get: PxArticulationRootLinkData.prototype.get_worldLinVel, set: PxArticulationRootLinkData.prototype.set_worldLinVel });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationRootLinkData.prototype['get_worldAngVel'] = PxArticulationRootLinkData.prototype.get_worldAngVel = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationRootLinkData_get_worldAngVel_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationRootLinkData.prototype['set_worldAngVel'] = PxArticulationRootLinkData.prototype.set_worldAngVel = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationRootLinkData_set_worldAngVel_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationRootLinkData.prototype, 'worldAngVel', { get: PxArticulationRootLinkData.prototype.get_worldAngVel, set: PxArticulationRootLinkData.prototype.set_worldAngVel });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationRootLinkData.prototype['get_worldLinAccel'] = PxArticulationRootLinkData.prototype.get_worldLinAccel = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationRootLinkData_get_worldLinAccel_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationRootLinkData.prototype['set_worldLinAccel'] = PxArticulationRootLinkData.prototype.set_worldLinAccel = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationRootLinkData_set_worldLinAccel_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationRootLinkData.prototype, 'worldLinAccel', { get: PxArticulationRootLinkData.prototype.get_worldLinAccel, set: PxArticulationRootLinkData.prototype.set_worldLinAccel });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationRootLinkData.prototype['get_worldAngAccel'] = PxArticulationRootLinkData.prototype.get_worldAngAccel = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationRootLinkData_get_worldAngAccel_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationRootLinkData.prototype['set_worldAngAccel'] = PxArticulationRootLinkData.prototype.set_worldAngAccel = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationRootLinkData_set_worldAngAccel_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationRootLinkData.prototype, 'worldAngAccel', { get: PxArticulationRootLinkData.prototype.get_worldAngAccel, set: PxArticulationRootLinkData.prototype.set_worldAngAccel });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationRootLinkData.prototype['__destroy__'] = PxArticulationRootLinkData.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationRootLinkData___destroy___0(self);
};

// Interface: PxArticulationSpatialTendon

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationSpatialTendon() { throw "cannot construct a PxArticulationSpatialTendon, no constructor in IDL" }
PxArticulationSpatialTendon.prototype = Object.create(PxArticulationTendon.prototype);
PxArticulationSpatialTendon.prototype.constructor = PxArticulationSpatialTendon;
PxArticulationSpatialTendon.prototype.__class__ = PxArticulationSpatialTendon;
PxArticulationSpatialTendon.__cache__ = {};
Module['PxArticulationSpatialTendon'] = PxArticulationSpatialTendon;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['createAttachment'] = PxArticulationSpatialTendon.prototype.createAttachment = function(parent, coefficient, relativeOffset, link) {
  var self = this.ptr;
  if (parent && typeof parent === 'object') parent = parent.ptr;
  if (coefficient && typeof coefficient === 'object') coefficient = coefficient.ptr;
  if (relativeOffset && typeof relativeOffset === 'object') relativeOffset = relativeOffset.ptr;
  if (link && typeof link === 'object') link = link.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationSpatialTendon_createAttachment_4(self, parent, coefficient, relativeOffset, link), PxArticulationAttachment);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['getNbAttachments'] = PxArticulationSpatialTendon.prototype.getNbAttachments = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationSpatialTendon_getNbAttachments_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['setStiffness'] = PxArticulationSpatialTendon.prototype.setStiffness = function(stiffness) {
  var self = this.ptr;
  if (stiffness && typeof stiffness === 'object') stiffness = stiffness.ptr;
  _emscripten_bind_PxArticulationSpatialTendon_setStiffness_1(self, stiffness);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['getStiffness'] = PxArticulationSpatialTendon.prototype.getStiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationSpatialTendon_getStiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['setDamping'] = PxArticulationSpatialTendon.prototype.setDamping = function(damping) {
  var self = this.ptr;
  if (damping && typeof damping === 'object') damping = damping.ptr;
  _emscripten_bind_PxArticulationSpatialTendon_setDamping_1(self, damping);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['getDamping'] = PxArticulationSpatialTendon.prototype.getDamping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationSpatialTendon_getDamping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['setLimitStiffness'] = PxArticulationSpatialTendon.prototype.setLimitStiffness = function(stiffness) {
  var self = this.ptr;
  if (stiffness && typeof stiffness === 'object') stiffness = stiffness.ptr;
  _emscripten_bind_PxArticulationSpatialTendon_setLimitStiffness_1(self, stiffness);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['getLimitStiffness'] = PxArticulationSpatialTendon.prototype.getLimitStiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationSpatialTendon_getLimitStiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['setOffset'] = PxArticulationSpatialTendon.prototype.setOffset = function(offset, autowake) {
  var self = this.ptr;
  if (offset && typeof offset === 'object') offset = offset.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxArticulationSpatialTendon_setOffset_1(self, offset); return }
  _emscripten_bind_PxArticulationSpatialTendon_setOffset_2(self, offset, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['getOffset'] = PxArticulationSpatialTendon.prototype.getOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationSpatialTendon_getOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['getArticulation'] = PxArticulationSpatialTendon.prototype.getArticulation = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationSpatialTendon_getArticulation_0(self), PxArticulationReducedCoordinate);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['release'] = PxArticulationSpatialTendon.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationSpatialTendon_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['getConcreteTypeName'] = PxArticulationSpatialTendon.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxArticulationSpatialTendon_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['getConcreteType'] = PxArticulationSpatialTendon.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationSpatialTendon_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['setBaseFlag'] = PxArticulationSpatialTendon.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxArticulationSpatialTendon_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['setBaseFlags'] = PxArticulationSpatialTendon.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxArticulationSpatialTendon_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['getBaseFlags'] = PxArticulationSpatialTendon.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationSpatialTendon_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['isReleasable'] = PxArticulationSpatialTendon.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxArticulationSpatialTendon_isReleasable_0(self));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationSpatialTendon.prototype['__destroy__'] = PxArticulationSpatialTendon.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationSpatialTendon___destroy___0(self);
};

// Interface: PxArticulationTendonJoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationTendonJoint() { throw "cannot construct a PxArticulationTendonJoint, no constructor in IDL" }
PxArticulationTendonJoint.prototype = Object.create(WrapperObject.prototype);
PxArticulationTendonJoint.prototype.constructor = PxArticulationTendonJoint;
PxArticulationTendonJoint.prototype.__class__ = PxArticulationTendonJoint;
PxArticulationTendonJoint.__cache__ = {};
Module['PxArticulationTendonJoint'] = PxArticulationTendonJoint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendonJoint.prototype['setCoefficient'] = PxArticulationTendonJoint.prototype.setCoefficient = function(axis, coefficient, recipCoefficient) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  if (coefficient && typeof coefficient === 'object') coefficient = coefficient.ptr;
  if (recipCoefficient && typeof recipCoefficient === 'object') recipCoefficient = recipCoefficient.ptr;
  _emscripten_bind_PxArticulationTendonJoint_setCoefficient_3(self, axis, coefficient, recipCoefficient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendonJoint.prototype['getLink'] = PxArticulationTendonJoint.prototype.getLink = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationTendonJoint_getLink_0(self), PxArticulationLink);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendonJoint.prototype['getParent'] = PxArticulationTendonJoint.prototype.getParent = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationTendonJoint_getParent_0(self), PxArticulationTendonJoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendonJoint.prototype['getTendon'] = PxArticulationTendonJoint.prototype.getTendon = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationTendonJoint_getTendon_0(self), PxArticulationFixedTendon);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendonJoint.prototype['release'] = PxArticulationTendonJoint.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationTendonJoint_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendonJoint.prototype['get_userData'] = PxArticulationTendonJoint.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxArticulationTendonJoint_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendonJoint.prototype['set_userData'] = PxArticulationTendonJoint.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationTendonJoint_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationTendonJoint.prototype, 'userData', { get: PxArticulationTendonJoint.prototype.get_userData, set: PxArticulationTendonJoint.prototype.set_userData });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendonJoint.prototype['__destroy__'] = PxArticulationTendonJoint.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationTendonJoint___destroy___0(self);
};

// Interface: PxArticulationTendonLimit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxArticulationTendonLimit() { throw "cannot construct a PxArticulationTendonLimit, no constructor in IDL" }
PxArticulationTendonLimit.prototype = Object.create(WrapperObject.prototype);
PxArticulationTendonLimit.prototype.constructor = PxArticulationTendonLimit;
PxArticulationTendonLimit.prototype.__class__ = PxArticulationTendonLimit;
PxArticulationTendonLimit.__cache__ = {};
Module['PxArticulationTendonLimit'] = PxArticulationTendonLimit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendonLimit.prototype['get_lowLimit'] = PxArticulationTendonLimit.prototype.get_lowLimit = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationTendonLimit_get_lowLimit_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendonLimit.prototype['set_lowLimit'] = PxArticulationTendonLimit.prototype.set_lowLimit = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationTendonLimit_set_lowLimit_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationTendonLimit.prototype, 'lowLimit', { get: PxArticulationTendonLimit.prototype.get_lowLimit, set: PxArticulationTendonLimit.prototype.set_lowLimit });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendonLimit.prototype['get_highLimit'] = PxArticulationTendonLimit.prototype.get_highLimit = function() {
  var self = this.ptr;
  return _emscripten_bind_PxArticulationTendonLimit_get_highLimit_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendonLimit.prototype['set_highLimit'] = PxArticulationTendonLimit.prototype.set_highLimit = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxArticulationTendonLimit_set_highLimit_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxArticulationTendonLimit.prototype, 'highLimit', { get: PxArticulationTendonLimit.prototype.get_highLimit, set: PxArticulationTendonLimit.prototype.set_highLimit });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxArticulationTendonLimit.prototype['__destroy__'] = PxArticulationTendonLimit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxArticulationTendonLimit___destroy___0(self);
};

// Interface: PxBVH

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBVH() { throw "cannot construct a PxBVH, no constructor in IDL" }
PxBVH.prototype = Object.create(PxBase.prototype);
PxBVH.prototype.constructor = PxBVH;
PxBVH.prototype.__class__ = PxBVH;
PxBVH.__cache__ = {};
Module['PxBVH'] = PxBVH;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH.prototype['release'] = PxBVH.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxBVH_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH.prototype['getConcreteTypeName'] = PxBVH.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxBVH_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH.prototype['getConcreteType'] = PxBVH.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBVH_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH.prototype['setBaseFlag'] = PxBVH.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxBVH_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH.prototype['setBaseFlags'] = PxBVH.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxBVH_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH.prototype['getBaseFlags'] = PxBVH.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBVH_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH.prototype['isReleasable'] = PxBVH.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxBVH_isReleasable_0(self));
};


// Interface: PxBVH33MidphaseDesc

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBVH33MidphaseDesc() { throw "cannot construct a PxBVH33MidphaseDesc, no constructor in IDL" }
PxBVH33MidphaseDesc.prototype = Object.create(WrapperObject.prototype);
PxBVH33MidphaseDesc.prototype.constructor = PxBVH33MidphaseDesc;
PxBVH33MidphaseDesc.prototype.__class__ = PxBVH33MidphaseDesc;
PxBVH33MidphaseDesc.__cache__ = {};
Module['PxBVH33MidphaseDesc'] = PxBVH33MidphaseDesc;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH33MidphaseDesc.prototype['setToDefault'] = PxBVH33MidphaseDesc.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxBVH33MidphaseDesc_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH33MidphaseDesc.prototype['isValid'] = PxBVH33MidphaseDesc.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxBVH33MidphaseDesc_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH33MidphaseDesc.prototype['get_meshSizePerformanceTradeOff'] = PxBVH33MidphaseDesc.prototype.get_meshSizePerformanceTradeOff = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBVH33MidphaseDesc_get_meshSizePerformanceTradeOff_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH33MidphaseDesc.prototype['set_meshSizePerformanceTradeOff'] = PxBVH33MidphaseDesc.prototype.set_meshSizePerformanceTradeOff = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBVH33MidphaseDesc_set_meshSizePerformanceTradeOff_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBVH33MidphaseDesc.prototype, 'meshSizePerformanceTradeOff', { get: PxBVH33MidphaseDesc.prototype.get_meshSizePerformanceTradeOff, set: PxBVH33MidphaseDesc.prototype.set_meshSizePerformanceTradeOff });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH33MidphaseDesc.prototype['get_meshCookingHint'] = PxBVH33MidphaseDesc.prototype.get_meshCookingHint = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBVH33MidphaseDesc_get_meshCookingHint_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH33MidphaseDesc.prototype['set_meshCookingHint'] = PxBVH33MidphaseDesc.prototype.set_meshCookingHint = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBVH33MidphaseDesc_set_meshCookingHint_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBVH33MidphaseDesc.prototype, 'meshCookingHint', { get: PxBVH33MidphaseDesc.prototype.get_meshCookingHint, set: PxBVH33MidphaseDesc.prototype.set_meshCookingHint });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH33MidphaseDesc.prototype['__destroy__'] = PxBVH33MidphaseDesc.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxBVH33MidphaseDesc___destroy___0(self);
};

// Interface: PxBVH34MidphaseDesc

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBVH34MidphaseDesc() { throw "cannot construct a PxBVH34MidphaseDesc, no constructor in IDL" }
PxBVH34MidphaseDesc.prototype = Object.create(WrapperObject.prototype);
PxBVH34MidphaseDesc.prototype.constructor = PxBVH34MidphaseDesc;
PxBVH34MidphaseDesc.prototype.__class__ = PxBVH34MidphaseDesc;
PxBVH34MidphaseDesc.__cache__ = {};
Module['PxBVH34MidphaseDesc'] = PxBVH34MidphaseDesc;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH34MidphaseDesc.prototype['setToDefault'] = PxBVH34MidphaseDesc.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxBVH34MidphaseDesc_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH34MidphaseDesc.prototype['isValid'] = PxBVH34MidphaseDesc.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxBVH34MidphaseDesc_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH34MidphaseDesc.prototype['get_numPrimsPerLeaf'] = PxBVH34MidphaseDesc.prototype.get_numPrimsPerLeaf = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBVH34MidphaseDesc_get_numPrimsPerLeaf_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH34MidphaseDesc.prototype['set_numPrimsPerLeaf'] = PxBVH34MidphaseDesc.prototype.set_numPrimsPerLeaf = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBVH34MidphaseDesc_set_numPrimsPerLeaf_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBVH34MidphaseDesc.prototype, 'numPrimsPerLeaf', { get: PxBVH34MidphaseDesc.prototype.get_numPrimsPerLeaf, set: PxBVH34MidphaseDesc.prototype.set_numPrimsPerLeaf });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBVH34MidphaseDesc.prototype['__destroy__'] = PxBVH34MidphaseDesc.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxBVH34MidphaseDesc___destroy___0(self);
};

// Interface: PxBaseFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBaseFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxBaseFlags_PxBaseFlags_1(flags);
  getCache(PxBaseFlags)[this.ptr] = this;
};

PxBaseFlags.prototype = Object.create(WrapperObject.prototype);
PxBaseFlags.prototype.constructor = PxBaseFlags;
PxBaseFlags.prototype.__class__ = PxBaseFlags;
PxBaseFlags.__cache__ = {};
Module['PxBaseFlags'] = PxBaseFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseFlags.prototype['isSet'] = PxBaseFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxBaseFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseFlags.prototype['raise'] = PxBaseFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxBaseFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseFlags.prototype['clear'] = PxBaseFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxBaseFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseFlags.prototype['__destroy__'] = PxBaseFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxBaseFlags___destroy___0(self);
};

// Interface: PxBaseTask

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBaseTask() { throw "cannot construct a PxBaseTask, no constructor in IDL" }
PxBaseTask.prototype = Object.create(WrapperObject.prototype);
PxBaseTask.prototype.constructor = PxBaseTask;
PxBaseTask.prototype.__class__ = PxBaseTask;
PxBaseTask.__cache__ = {};
Module['PxBaseTask'] = PxBaseTask;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBaseTask.prototype['__destroy__'] = PxBaseTask.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxBaseTask___destroy___0(self);
};

// Interface: PxBoundedData

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBoundedData() {
  this.ptr = _emscripten_bind_PxBoundedData_PxBoundedData_0();
  getCache(PxBoundedData)[this.ptr] = this;
};

PxBoundedData.prototype = Object.create(PxStridedData.prototype);
PxBoundedData.prototype.constructor = PxBoundedData;
PxBoundedData.prototype.__class__ = PxBoundedData;
PxBoundedData.__cache__ = {};
Module['PxBoundedData'] = PxBoundedData;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoundedData.prototype['get_count'] = PxBoundedData.prototype.get_count = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoundedData_get_count_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoundedData.prototype['set_count'] = PxBoundedData.prototype.set_count = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoundedData_set_count_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoundedData.prototype, 'count', { get: PxBoundedData.prototype.get_count, set: PxBoundedData.prototype.set_count });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoundedData.prototype['get_stride'] = PxBoundedData.prototype.get_stride = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoundedData_get_stride_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoundedData.prototype['set_stride'] = PxBoundedData.prototype.set_stride = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoundedData_set_stride_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoundedData.prototype, 'stride', { get: PxBoundedData.prototype.get_stride, set: PxBoundedData.prototype.set_stride });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoundedData.prototype['get_data'] = PxBoundedData.prototype.get_data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoundedData_get_data_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoundedData.prototype['set_data'] = PxBoundedData.prototype.set_data = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoundedData_set_data_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoundedData.prototype, 'data', { get: PxBoundedData.prototype.get_data, set: PxBoundedData.prototype.set_data });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoundedData.prototype['__destroy__'] = PxBoundedData.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxBoundedData___destroy___0(self);
};

// Interface: PxBounds3

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBounds3(minimum, maximum) {
  if (minimum && typeof minimum === 'object') minimum = minimum.ptr;
  if (maximum && typeof maximum === 'object') maximum = maximum.ptr;
  if (minimum === undefined) { this.ptr = _emscripten_bind_PxBounds3_PxBounds3_0(); getCache(PxBounds3)[this.ptr] = this;return }
  if (maximum === undefined) { this.ptr = _emscripten_bind_PxBounds3_PxBounds3_1(minimum); getCache(PxBounds3)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxBounds3_PxBounds3_2(minimum, maximum);
  getCache(PxBounds3)[this.ptr] = this;
};

PxBounds3.prototype = Object.create(WrapperObject.prototype);
PxBounds3.prototype.constructor = PxBounds3;
PxBounds3.prototype.__class__ = PxBounds3;
PxBounds3.__cache__ = {};
Module['PxBounds3'] = PxBounds3;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['setEmpty'] = PxBounds3.prototype.setEmpty = function() {
  var self = this.ptr;
  _emscripten_bind_PxBounds3_setEmpty_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['setMaximal'] = PxBounds3.prototype.setMaximal = function() {
  var self = this.ptr;
  _emscripten_bind_PxBounds3_setMaximal_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['include'] = PxBounds3.prototype.include = function(v) {
  var self = this.ptr;
  if (v && typeof v === 'object') v = v.ptr;
  _emscripten_bind_PxBounds3_include_1(self, v);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['isEmpty'] = PxBounds3.prototype.isEmpty = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxBounds3_isEmpty_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['intersects'] = PxBounds3.prototype.intersects = function(b) {
  var self = this.ptr;
  if (b && typeof b === 'object') b = b.ptr;
  return !!(_emscripten_bind_PxBounds3_intersects_1(self, b));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['intersects1D'] = PxBounds3.prototype.intersects1D = function(b, axis) {
  var self = this.ptr;
  if (b && typeof b === 'object') b = b.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  return !!(_emscripten_bind_PxBounds3_intersects1D_2(self, b, axis));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['contains'] = PxBounds3.prototype.contains = function(v) {
  var self = this.ptr;
  if (v && typeof v === 'object') v = v.ptr;
  return !!(_emscripten_bind_PxBounds3_contains_1(self, v));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['isInside'] = PxBounds3.prototype.isInside = function(box) {
  var self = this.ptr;
  if (box && typeof box === 'object') box = box.ptr;
  return !!(_emscripten_bind_PxBounds3_isInside_1(self, box));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['getCenter'] = PxBounds3.prototype.getCenter = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBounds3_getCenter_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['getDimensions'] = PxBounds3.prototype.getDimensions = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBounds3_getDimensions_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['getExtents'] = PxBounds3.prototype.getExtents = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBounds3_getExtents_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['scaleSafe'] = PxBounds3.prototype.scaleSafe = function(scale) {
  var self = this.ptr;
  if (scale && typeof scale === 'object') scale = scale.ptr;
  _emscripten_bind_PxBounds3_scaleSafe_1(self, scale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['scaleFast'] = PxBounds3.prototype.scaleFast = function(scale) {
  var self = this.ptr;
  if (scale && typeof scale === 'object') scale = scale.ptr;
  _emscripten_bind_PxBounds3_scaleFast_1(self, scale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['fattenSafe'] = PxBounds3.prototype.fattenSafe = function(distance) {
  var self = this.ptr;
  if (distance && typeof distance === 'object') distance = distance.ptr;
  _emscripten_bind_PxBounds3_fattenSafe_1(self, distance);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['fattenFast'] = PxBounds3.prototype.fattenFast = function(distance) {
  var self = this.ptr;
  if (distance && typeof distance === 'object') distance = distance.ptr;
  _emscripten_bind_PxBounds3_fattenFast_1(self, distance);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['isFinite'] = PxBounds3.prototype.isFinite = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxBounds3_isFinite_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['isValid'] = PxBounds3.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxBounds3_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['get_minimum'] = PxBounds3.prototype.get_minimum = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBounds3_get_minimum_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['set_minimum'] = PxBounds3.prototype.set_minimum = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBounds3_set_minimum_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBounds3.prototype, 'minimum', { get: PxBounds3.prototype.get_minimum, set: PxBounds3.prototype.set_minimum });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['get_maximum'] = PxBounds3.prototype.get_maximum = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBounds3_get_maximum_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['set_maximum'] = PxBounds3.prototype.set_maximum = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBounds3_set_maximum_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBounds3.prototype, 'maximum', { get: PxBounds3.prototype.get_maximum, set: PxBounds3.prototype.set_maximum });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBounds3.prototype['__destroy__'] = PxBounds3.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxBounds3___destroy___0(self);
};

// Interface: PxBoxController

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBoxController() { throw "cannot construct a PxBoxController, no constructor in IDL" }
PxBoxController.prototype = Object.create(PxController.prototype);
PxBoxController.prototype.constructor = PxBoxController;
PxBoxController.prototype.__class__ = PxBoxController;
PxBoxController.__cache__ = {};
Module['PxBoxController'] = PxBoxController;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getHalfHeight'] = PxBoxController.prototype.getHalfHeight = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxController_getHalfHeight_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getHalfSideExtent'] = PxBoxController.prototype.getHalfSideExtent = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxController_getHalfSideExtent_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getHalfForwardExtent'] = PxBoxController.prototype.getHalfForwardExtent = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxController_getHalfForwardExtent_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['setHalfHeight'] = PxBoxController.prototype.setHalfHeight = function(halfHeight) {
  var self = this.ptr;
  if (halfHeight && typeof halfHeight === 'object') halfHeight = halfHeight.ptr;
  return !!(_emscripten_bind_PxBoxController_setHalfHeight_1(self, halfHeight));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['setHalfSideExtent'] = PxBoxController.prototype.setHalfSideExtent = function(halfSideExtent) {
  var self = this.ptr;
  if (halfSideExtent && typeof halfSideExtent === 'object') halfSideExtent = halfSideExtent.ptr;
  return !!(_emscripten_bind_PxBoxController_setHalfSideExtent_1(self, halfSideExtent));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['setHalfForwardExtent'] = PxBoxController.prototype.setHalfForwardExtent = function(halfForwardExtent) {
  var self = this.ptr;
  if (halfForwardExtent && typeof halfForwardExtent === 'object') halfForwardExtent = halfForwardExtent.ptr;
  return !!(_emscripten_bind_PxBoxController_setHalfForwardExtent_1(self, halfForwardExtent));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getType'] = PxBoxController.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxController_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['release'] = PxBoxController.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxBoxController_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['move'] = PxBoxController.prototype.move = function(disp, minDist, elapsedTime, filters, obstacles) {
  var self = this.ptr;
  if (disp && typeof disp === 'object') disp = disp.ptr;
  if (minDist && typeof minDist === 'object') minDist = minDist.ptr;
  if (elapsedTime && typeof elapsedTime === 'object') elapsedTime = elapsedTime.ptr;
  if (filters && typeof filters === 'object') filters = filters.ptr;
  if (obstacles && typeof obstacles === 'object') obstacles = obstacles.ptr;
  if (obstacles === undefined) { return wrapPointer(_emscripten_bind_PxBoxController_move_4(self, disp, minDist, elapsedTime, filters), PxControllerCollisionFlags) }
  return wrapPointer(_emscripten_bind_PxBoxController_move_5(self, disp, minDist, elapsedTime, filters, obstacles), PxControllerCollisionFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['setPosition'] = PxBoxController.prototype.setPosition = function(position) {
  var self = this.ptr;
  if (position && typeof position === 'object') position = position.ptr;
  return !!(_emscripten_bind_PxBoxController_setPosition_1(self, position));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getPosition'] = PxBoxController.prototype.getPosition = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxController_getPosition_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['setFootPosition'] = PxBoxController.prototype.setFootPosition = function(position) {
  var self = this.ptr;
  if (position && typeof position === 'object') position = position.ptr;
  return !!(_emscripten_bind_PxBoxController_setFootPosition_1(self, position));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getFootPosition'] = PxBoxController.prototype.getFootPosition = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxController_getFootPosition_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getActor'] = PxBoxController.prototype.getActor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxController_getActor_0(self), PxRigidDynamic);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['setStepOffset'] = PxBoxController.prototype.setStepOffset = function(offset) {
  var self = this.ptr;
  if (offset && typeof offset === 'object') offset = offset.ptr;
  _emscripten_bind_PxBoxController_setStepOffset_1(self, offset);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getStepOffset'] = PxBoxController.prototype.getStepOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxController_getStepOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['setNonWalkableMode'] = PxBoxController.prototype.setNonWalkableMode = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxBoxController_setNonWalkableMode_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getNonWalkableMode'] = PxBoxController.prototype.getNonWalkableMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxController_getNonWalkableMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getContactOffset'] = PxBoxController.prototype.getContactOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxController_getContactOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['setContactOffset'] = PxBoxController.prototype.setContactOffset = function(offset) {
  var self = this.ptr;
  if (offset && typeof offset === 'object') offset = offset.ptr;
  _emscripten_bind_PxBoxController_setContactOffset_1(self, offset);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getUpDirection'] = PxBoxController.prototype.getUpDirection = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxController_getUpDirection_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['setUpDirection'] = PxBoxController.prototype.setUpDirection = function(up) {
  var self = this.ptr;
  if (up && typeof up === 'object') up = up.ptr;
  _emscripten_bind_PxBoxController_setUpDirection_1(self, up);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getSlopeLimit'] = PxBoxController.prototype.getSlopeLimit = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxController_getSlopeLimit_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['setSlopeLimit'] = PxBoxController.prototype.setSlopeLimit = function(slopeLimit) {
  var self = this.ptr;
  if (slopeLimit && typeof slopeLimit === 'object') slopeLimit = slopeLimit.ptr;
  _emscripten_bind_PxBoxController_setSlopeLimit_1(self, slopeLimit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['invalidateCache'] = PxBoxController.prototype.invalidateCache = function() {
  var self = this.ptr;
  _emscripten_bind_PxBoxController_invalidateCache_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getScene'] = PxBoxController.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxController_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getUserData'] = PxBoxController.prototype.getUserData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxController_getUserData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['setUserData'] = PxBoxController.prototype.setUserData = function(userData) {
  var self = this.ptr;
  if (userData && typeof userData === 'object') userData = userData.ptr;
  _emscripten_bind_PxBoxController_setUserData_1(self, userData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getState'] = PxBoxController.prototype.getState = function(state) {
  var self = this.ptr;
  if (state && typeof state === 'object') state = state.ptr;
  _emscripten_bind_PxBoxController_getState_1(self, state);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['getStats'] = PxBoxController.prototype.getStats = function(stats) {
  var self = this.ptr;
  if (stats && typeof stats === 'object') stats = stats.ptr;
  _emscripten_bind_PxBoxController_getStats_1(self, stats);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxController.prototype['resize'] = PxBoxController.prototype.resize = function(height) {
  var self = this.ptr;
  if (height && typeof height === 'object') height = height.ptr;
  _emscripten_bind_PxBoxController_resize_1(self, height);
};


// Interface: PxBoxControllerDesc

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBoxControllerDesc() {
  this.ptr = _emscripten_bind_PxBoxControllerDesc_PxBoxControllerDesc_0();
  getCache(PxBoxControllerDesc)[this.ptr] = this;
};

PxBoxControllerDesc.prototype = Object.create(PxControllerDesc.prototype);
PxBoxControllerDesc.prototype.constructor = PxBoxControllerDesc;
PxBoxControllerDesc.prototype.__class__ = PxBoxControllerDesc;
PxBoxControllerDesc.__cache__ = {};
Module['PxBoxControllerDesc'] = PxBoxControllerDesc;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['setToDefault'] = PxBoxControllerDesc.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxBoxControllerDesc_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['isValid'] = PxBoxControllerDesc.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxBoxControllerDesc_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['getType'] = PxBoxControllerDesc.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxControllerDesc_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_halfHeight'] = PxBoxControllerDesc.prototype.get_halfHeight = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxControllerDesc_get_halfHeight_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_halfHeight'] = PxBoxControllerDesc.prototype.set_halfHeight = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_halfHeight_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'halfHeight', { get: PxBoxControllerDesc.prototype.get_halfHeight, set: PxBoxControllerDesc.prototype.set_halfHeight });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_halfSideExtent'] = PxBoxControllerDesc.prototype.get_halfSideExtent = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxControllerDesc_get_halfSideExtent_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_halfSideExtent'] = PxBoxControllerDesc.prototype.set_halfSideExtent = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_halfSideExtent_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'halfSideExtent', { get: PxBoxControllerDesc.prototype.get_halfSideExtent, set: PxBoxControllerDesc.prototype.set_halfSideExtent });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_halfForwardExtent'] = PxBoxControllerDesc.prototype.get_halfForwardExtent = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxControllerDesc_get_halfForwardExtent_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_halfForwardExtent'] = PxBoxControllerDesc.prototype.set_halfForwardExtent = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_halfForwardExtent_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'halfForwardExtent', { get: PxBoxControllerDesc.prototype.get_halfForwardExtent, set: PxBoxControllerDesc.prototype.set_halfForwardExtent });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_position'] = PxBoxControllerDesc.prototype.get_position = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxControllerDesc_get_position_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_position'] = PxBoxControllerDesc.prototype.set_position = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_position_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'position', { get: PxBoxControllerDesc.prototype.get_position, set: PxBoxControllerDesc.prototype.set_position });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_upDirection'] = PxBoxControllerDesc.prototype.get_upDirection = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxControllerDesc_get_upDirection_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_upDirection'] = PxBoxControllerDesc.prototype.set_upDirection = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_upDirection_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'upDirection', { get: PxBoxControllerDesc.prototype.get_upDirection, set: PxBoxControllerDesc.prototype.set_upDirection });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_slopeLimit'] = PxBoxControllerDesc.prototype.get_slopeLimit = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxControllerDesc_get_slopeLimit_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_slopeLimit'] = PxBoxControllerDesc.prototype.set_slopeLimit = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_slopeLimit_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'slopeLimit', { get: PxBoxControllerDesc.prototype.get_slopeLimit, set: PxBoxControllerDesc.prototype.set_slopeLimit });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_invisibleWallHeight'] = PxBoxControllerDesc.prototype.get_invisibleWallHeight = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxControllerDesc_get_invisibleWallHeight_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_invisibleWallHeight'] = PxBoxControllerDesc.prototype.set_invisibleWallHeight = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_invisibleWallHeight_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'invisibleWallHeight', { get: PxBoxControllerDesc.prototype.get_invisibleWallHeight, set: PxBoxControllerDesc.prototype.set_invisibleWallHeight });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_maxJumpHeight'] = PxBoxControllerDesc.prototype.get_maxJumpHeight = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxControllerDesc_get_maxJumpHeight_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_maxJumpHeight'] = PxBoxControllerDesc.prototype.set_maxJumpHeight = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_maxJumpHeight_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'maxJumpHeight', { get: PxBoxControllerDesc.prototype.get_maxJumpHeight, set: PxBoxControllerDesc.prototype.set_maxJumpHeight });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_contactOffset'] = PxBoxControllerDesc.prototype.get_contactOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxControllerDesc_get_contactOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_contactOffset'] = PxBoxControllerDesc.prototype.set_contactOffset = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_contactOffset_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'contactOffset', { get: PxBoxControllerDesc.prototype.get_contactOffset, set: PxBoxControllerDesc.prototype.set_contactOffset });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_stepOffset'] = PxBoxControllerDesc.prototype.get_stepOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxControllerDesc_get_stepOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_stepOffset'] = PxBoxControllerDesc.prototype.set_stepOffset = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_stepOffset_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'stepOffset', { get: PxBoxControllerDesc.prototype.get_stepOffset, set: PxBoxControllerDesc.prototype.set_stepOffset });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_density'] = PxBoxControllerDesc.prototype.get_density = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxControllerDesc_get_density_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_density'] = PxBoxControllerDesc.prototype.set_density = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_density_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'density', { get: PxBoxControllerDesc.prototype.get_density, set: PxBoxControllerDesc.prototype.set_density });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_scaleCoeff'] = PxBoxControllerDesc.prototype.get_scaleCoeff = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxControllerDesc_get_scaleCoeff_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_scaleCoeff'] = PxBoxControllerDesc.prototype.set_scaleCoeff = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_scaleCoeff_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'scaleCoeff', { get: PxBoxControllerDesc.prototype.get_scaleCoeff, set: PxBoxControllerDesc.prototype.set_scaleCoeff });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_volumeGrowth'] = PxBoxControllerDesc.prototype.get_volumeGrowth = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxControllerDesc_get_volumeGrowth_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_volumeGrowth'] = PxBoxControllerDesc.prototype.set_volumeGrowth = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_volumeGrowth_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'volumeGrowth', { get: PxBoxControllerDesc.prototype.get_volumeGrowth, set: PxBoxControllerDesc.prototype.set_volumeGrowth });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_reportCallback'] = PxBoxControllerDesc.prototype.get_reportCallback = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxControllerDesc_get_reportCallback_0(self), PxUserControllerHitReport);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_reportCallback'] = PxBoxControllerDesc.prototype.set_reportCallback = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_reportCallback_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'reportCallback', { get: PxBoxControllerDesc.prototype.get_reportCallback, set: PxBoxControllerDesc.prototype.set_reportCallback });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_behaviorCallback'] = PxBoxControllerDesc.prototype.get_behaviorCallback = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxControllerDesc_get_behaviorCallback_0(self), PxControllerBehaviorCallback);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_behaviorCallback'] = PxBoxControllerDesc.prototype.set_behaviorCallback = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_behaviorCallback_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'behaviorCallback', { get: PxBoxControllerDesc.prototype.get_behaviorCallback, set: PxBoxControllerDesc.prototype.set_behaviorCallback });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_nonWalkableMode'] = PxBoxControllerDesc.prototype.get_nonWalkableMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxControllerDesc_get_nonWalkableMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_nonWalkableMode'] = PxBoxControllerDesc.prototype.set_nonWalkableMode = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_nonWalkableMode_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'nonWalkableMode', { get: PxBoxControllerDesc.prototype.get_nonWalkableMode, set: PxBoxControllerDesc.prototype.set_nonWalkableMode });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_material'] = PxBoxControllerDesc.prototype.get_material = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxControllerDesc_get_material_0(self), PxMaterial);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_material'] = PxBoxControllerDesc.prototype.set_material = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_material_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'material', { get: PxBoxControllerDesc.prototype.get_material, set: PxBoxControllerDesc.prototype.set_material });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_registerDeletionListener'] = PxBoxControllerDesc.prototype.get_registerDeletionListener = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxBoxControllerDesc_get_registerDeletionListener_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_registerDeletionListener'] = PxBoxControllerDesc.prototype.set_registerDeletionListener = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_registerDeletionListener_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'registerDeletionListener', { get: PxBoxControllerDesc.prototype.get_registerDeletionListener, set: PxBoxControllerDesc.prototype.set_registerDeletionListener });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['get_userData'] = PxBoxControllerDesc.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxControllerDesc_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['set_userData'] = PxBoxControllerDesc.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxControllerDesc_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxControllerDesc.prototype, 'userData', { get: PxBoxControllerDesc.prototype.get_userData, set: PxBoxControllerDesc.prototype.set_userData });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxControllerDesc.prototype['__destroy__'] = PxBoxControllerDesc.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxBoxControllerDesc___destroy___0(self);
};

// Interface: PxBoxGeometry

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBoxGeometry(hx, hy, hz) {
  if (hx && typeof hx === 'object') hx = hx.ptr;
  if (hy && typeof hy === 'object') hy = hy.ptr;
  if (hz && typeof hz === 'object') hz = hz.ptr;
  this.ptr = _emscripten_bind_PxBoxGeometry_PxBoxGeometry_3(hx, hy, hz);
  getCache(PxBoxGeometry)[this.ptr] = this;
};

PxBoxGeometry.prototype = Object.create(PxGeometry.prototype);
PxBoxGeometry.prototype.constructor = PxBoxGeometry;
PxBoxGeometry.prototype.__class__ = PxBoxGeometry;
PxBoxGeometry.__cache__ = {};
Module['PxBoxGeometry'] = PxBoxGeometry;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxGeometry.prototype['getType'] = PxBoxGeometry.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxGeometry_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxGeometry.prototype['get_halfExtents'] = PxBoxGeometry.prototype.get_halfExtents = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxGeometry_get_halfExtents_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxGeometry.prototype['set_halfExtents'] = PxBoxGeometry.prototype.set_halfExtents = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxGeometry_set_halfExtents_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxGeometry.prototype, 'halfExtents', { get: PxBoxGeometry.prototype.get_halfExtents, set: PxBoxGeometry.prototype.set_halfExtents });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxGeometry.prototype['__destroy__'] = PxBoxGeometry.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxBoxGeometry___destroy___0(self);
};

// Interface: PxBoxObstacle

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBoxObstacle() {
  this.ptr = _emscripten_bind_PxBoxObstacle_PxBoxObstacle_0();
  getCache(PxBoxObstacle)[this.ptr] = this;
};

PxBoxObstacle.prototype = Object.create(PxObstacle.prototype);
PxBoxObstacle.prototype.constructor = PxBoxObstacle;
PxBoxObstacle.prototype.__class__ = PxBoxObstacle;
PxBoxObstacle.__cache__ = {};
Module['PxBoxObstacle'] = PxBoxObstacle;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxObstacle.prototype['getType'] = PxBoxObstacle.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBoxObstacle_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxObstacle.prototype['get_mHalfExtents'] = PxBoxObstacle.prototype.get_mHalfExtents = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxObstacle_get_mHalfExtents_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxObstacle.prototype['set_mHalfExtents'] = PxBoxObstacle.prototype.set_mHalfExtents = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxObstacle_set_mHalfExtents_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxObstacle.prototype, 'mHalfExtents', { get: PxBoxObstacle.prototype.get_mHalfExtents, set: PxBoxObstacle.prototype.set_mHalfExtents });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxObstacle.prototype['get_mUserData'] = PxBoxObstacle.prototype.get_mUserData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxObstacle_get_mUserData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxObstacle.prototype['set_mUserData'] = PxBoxObstacle.prototype.set_mUserData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxObstacle_set_mUserData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxObstacle.prototype, 'mUserData', { get: PxBoxObstacle.prototype.get_mUserData, set: PxBoxObstacle.prototype.set_mUserData });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxObstacle.prototype['get_mPos'] = PxBoxObstacle.prototype.get_mPos = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxObstacle_get_mPos_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxObstacle.prototype['set_mPos'] = PxBoxObstacle.prototype.set_mPos = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxObstacle_set_mPos_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxObstacle.prototype, 'mPos', { get: PxBoxObstacle.prototype.get_mPos, set: PxBoxObstacle.prototype.set_mPos });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxObstacle.prototype['get_mRot'] = PxBoxObstacle.prototype.get_mRot = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBoxObstacle_get_mRot_0(self), PxQuat);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxObstacle.prototype['set_mRot'] = PxBoxObstacle.prototype.set_mRot = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBoxObstacle_set_mRot_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBoxObstacle.prototype, 'mRot', { get: PxBoxObstacle.prototype.get_mRot, set: PxBoxObstacle.prototype.set_mRot });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBoxObstacle.prototype['__destroy__'] = PxBoxObstacle.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxBoxObstacle___destroy___0(self);
};

// Interface: PxBroadPhaseCaps

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBroadPhaseCaps() {
  this.ptr = _emscripten_bind_PxBroadPhaseCaps_PxBroadPhaseCaps_0();
  getCache(PxBroadPhaseCaps)[this.ptr] = this;
};

PxBroadPhaseCaps.prototype = Object.create(WrapperObject.prototype);
PxBroadPhaseCaps.prototype.constructor = PxBroadPhaseCaps;
PxBroadPhaseCaps.prototype.__class__ = PxBroadPhaseCaps;
PxBroadPhaseCaps.__cache__ = {};
Module['PxBroadPhaseCaps'] = PxBroadPhaseCaps;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseCaps.prototype['get_mMaxNbRegions'] = PxBroadPhaseCaps.prototype.get_mMaxNbRegions = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBroadPhaseCaps_get_mMaxNbRegions_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseCaps.prototype['set_mMaxNbRegions'] = PxBroadPhaseCaps.prototype.set_mMaxNbRegions = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBroadPhaseCaps_set_mMaxNbRegions_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBroadPhaseCaps.prototype, 'mMaxNbRegions', { get: PxBroadPhaseCaps.prototype.get_mMaxNbRegions, set: PxBroadPhaseCaps.prototype.set_mMaxNbRegions });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseCaps.prototype['__destroy__'] = PxBroadPhaseCaps.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxBroadPhaseCaps___destroy___0(self);
};

// Interface: PxBroadPhaseRegion

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBroadPhaseRegion() {
  this.ptr = _emscripten_bind_PxBroadPhaseRegion_PxBroadPhaseRegion_0();
  getCache(PxBroadPhaseRegion)[this.ptr] = this;
};

PxBroadPhaseRegion.prototype = Object.create(WrapperObject.prototype);
PxBroadPhaseRegion.prototype.constructor = PxBroadPhaseRegion;
PxBroadPhaseRegion.prototype.__class__ = PxBroadPhaseRegion;
PxBroadPhaseRegion.__cache__ = {};
Module['PxBroadPhaseRegion'] = PxBroadPhaseRegion;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegion.prototype['get_mBounds'] = PxBroadPhaseRegion.prototype.get_mBounds = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBroadPhaseRegion_get_mBounds_0(self), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegion.prototype['set_mBounds'] = PxBroadPhaseRegion.prototype.set_mBounds = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBroadPhaseRegion_set_mBounds_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBroadPhaseRegion.prototype, 'mBounds', { get: PxBroadPhaseRegion.prototype.get_mBounds, set: PxBroadPhaseRegion.prototype.set_mBounds });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegion.prototype['get_mUserData'] = PxBroadPhaseRegion.prototype.get_mUserData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBroadPhaseRegion_get_mUserData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegion.prototype['set_mUserData'] = PxBroadPhaseRegion.prototype.set_mUserData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBroadPhaseRegion_set_mUserData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBroadPhaseRegion.prototype, 'mUserData', { get: PxBroadPhaseRegion.prototype.get_mUserData, set: PxBroadPhaseRegion.prototype.set_mUserData });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegion.prototype['__destroy__'] = PxBroadPhaseRegion.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxBroadPhaseRegion___destroy___0(self);
};

// Interface: PxBroadPhaseRegionInfo

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxBroadPhaseRegionInfo() {
  this.ptr = _emscripten_bind_PxBroadPhaseRegionInfo_PxBroadPhaseRegionInfo_0();
  getCache(PxBroadPhaseRegionInfo)[this.ptr] = this;
};

PxBroadPhaseRegionInfo.prototype = Object.create(WrapperObject.prototype);
PxBroadPhaseRegionInfo.prototype.constructor = PxBroadPhaseRegionInfo;
PxBroadPhaseRegionInfo.prototype.__class__ = PxBroadPhaseRegionInfo;
PxBroadPhaseRegionInfo.__cache__ = {};
Module['PxBroadPhaseRegionInfo'] = PxBroadPhaseRegionInfo;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegionInfo.prototype['get_mRegion'] = PxBroadPhaseRegionInfo.prototype.get_mRegion = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxBroadPhaseRegionInfo_get_mRegion_0(self), PxBroadPhaseRegion);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegionInfo.prototype['set_mRegion'] = PxBroadPhaseRegionInfo.prototype.set_mRegion = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBroadPhaseRegionInfo_set_mRegion_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBroadPhaseRegionInfo.prototype, 'mRegion', { get: PxBroadPhaseRegionInfo.prototype.get_mRegion, set: PxBroadPhaseRegionInfo.prototype.set_mRegion });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegionInfo.prototype['get_mNbStaticObjects'] = PxBroadPhaseRegionInfo.prototype.get_mNbStaticObjects = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBroadPhaseRegionInfo_get_mNbStaticObjects_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegionInfo.prototype['set_mNbStaticObjects'] = PxBroadPhaseRegionInfo.prototype.set_mNbStaticObjects = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBroadPhaseRegionInfo_set_mNbStaticObjects_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBroadPhaseRegionInfo.prototype, 'mNbStaticObjects', { get: PxBroadPhaseRegionInfo.prototype.get_mNbStaticObjects, set: PxBroadPhaseRegionInfo.prototype.set_mNbStaticObjects });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegionInfo.prototype['get_mNbDynamicObjects'] = PxBroadPhaseRegionInfo.prototype.get_mNbDynamicObjects = function() {
  var self = this.ptr;
  return _emscripten_bind_PxBroadPhaseRegionInfo_get_mNbDynamicObjects_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegionInfo.prototype['set_mNbDynamicObjects'] = PxBroadPhaseRegionInfo.prototype.set_mNbDynamicObjects = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBroadPhaseRegionInfo_set_mNbDynamicObjects_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBroadPhaseRegionInfo.prototype, 'mNbDynamicObjects', { get: PxBroadPhaseRegionInfo.prototype.get_mNbDynamicObjects, set: PxBroadPhaseRegionInfo.prototype.set_mNbDynamicObjects });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegionInfo.prototype['get_mActive'] = PxBroadPhaseRegionInfo.prototype.get_mActive = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxBroadPhaseRegionInfo_get_mActive_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegionInfo.prototype['set_mActive'] = PxBroadPhaseRegionInfo.prototype.set_mActive = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBroadPhaseRegionInfo_set_mActive_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBroadPhaseRegionInfo.prototype, 'mActive', { get: PxBroadPhaseRegionInfo.prototype.get_mActive, set: PxBroadPhaseRegionInfo.prototype.set_mActive });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegionInfo.prototype['get_mOverlap'] = PxBroadPhaseRegionInfo.prototype.get_mOverlap = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxBroadPhaseRegionInfo_get_mOverlap_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegionInfo.prototype['set_mOverlap'] = PxBroadPhaseRegionInfo.prototype.set_mOverlap = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxBroadPhaseRegionInfo_set_mOverlap_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxBroadPhaseRegionInfo.prototype, 'mOverlap', { get: PxBroadPhaseRegionInfo.prototype.get_mOverlap, set: PxBroadPhaseRegionInfo.prototype.set_mOverlap });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxBroadPhaseRegionInfo.prototype['__destroy__'] = PxBroadPhaseRegionInfo.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxBroadPhaseRegionInfo___destroy___0(self);
};

// Interface: PxCapsuleController

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxCapsuleController() { throw "cannot construct a PxCapsuleController, no constructor in IDL" }
PxCapsuleController.prototype = Object.create(PxController.prototype);
PxCapsuleController.prototype.constructor = PxCapsuleController;
PxCapsuleController.prototype.__class__ = PxCapsuleController;
PxCapsuleController.__cache__ = {};
Module['PxCapsuleController'] = PxCapsuleController;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getRadius'] = PxCapsuleController.prototype.getRadius = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleController_getRadius_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['setRadius'] = PxCapsuleController.prototype.setRadius = function(radius) {
  var self = this.ptr;
  if (radius && typeof radius === 'object') radius = radius.ptr;
  return !!(_emscripten_bind_PxCapsuleController_setRadius_1(self, radius));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getHeight'] = PxCapsuleController.prototype.getHeight = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleController_getHeight_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['setHeight'] = PxCapsuleController.prototype.setHeight = function(height) {
  var self = this.ptr;
  if (height && typeof height === 'object') height = height.ptr;
  return !!(_emscripten_bind_PxCapsuleController_setHeight_1(self, height));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getClimbingMode'] = PxCapsuleController.prototype.getClimbingMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleController_getClimbingMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['setClimbingMode'] = PxCapsuleController.prototype.setClimbingMode = function(mode) {
  var self = this.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  return !!(_emscripten_bind_PxCapsuleController_setClimbingMode_1(self, mode));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getType'] = PxCapsuleController.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleController_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['release'] = PxCapsuleController.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxCapsuleController_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['move'] = PxCapsuleController.prototype.move = function(disp, minDist, elapsedTime, filters, obstacles) {
  var self = this.ptr;
  if (disp && typeof disp === 'object') disp = disp.ptr;
  if (minDist && typeof minDist === 'object') minDist = minDist.ptr;
  if (elapsedTime && typeof elapsedTime === 'object') elapsedTime = elapsedTime.ptr;
  if (filters && typeof filters === 'object') filters = filters.ptr;
  if (obstacles && typeof obstacles === 'object') obstacles = obstacles.ptr;
  if (obstacles === undefined) { return wrapPointer(_emscripten_bind_PxCapsuleController_move_4(self, disp, minDist, elapsedTime, filters), PxControllerCollisionFlags) }
  return wrapPointer(_emscripten_bind_PxCapsuleController_move_5(self, disp, minDist, elapsedTime, filters, obstacles), PxControllerCollisionFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['setPosition'] = PxCapsuleController.prototype.setPosition = function(position) {
  var self = this.ptr;
  if (position && typeof position === 'object') position = position.ptr;
  return !!(_emscripten_bind_PxCapsuleController_setPosition_1(self, position));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getPosition'] = PxCapsuleController.prototype.getPosition = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleController_getPosition_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['setFootPosition'] = PxCapsuleController.prototype.setFootPosition = function(position) {
  var self = this.ptr;
  if (position && typeof position === 'object') position = position.ptr;
  return !!(_emscripten_bind_PxCapsuleController_setFootPosition_1(self, position));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getFootPosition'] = PxCapsuleController.prototype.getFootPosition = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleController_getFootPosition_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getActor'] = PxCapsuleController.prototype.getActor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleController_getActor_0(self), PxRigidDynamic);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['setStepOffset'] = PxCapsuleController.prototype.setStepOffset = function(offset) {
  var self = this.ptr;
  if (offset && typeof offset === 'object') offset = offset.ptr;
  _emscripten_bind_PxCapsuleController_setStepOffset_1(self, offset);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getStepOffset'] = PxCapsuleController.prototype.getStepOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleController_getStepOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['setNonWalkableMode'] = PxCapsuleController.prototype.setNonWalkableMode = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxCapsuleController_setNonWalkableMode_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getNonWalkableMode'] = PxCapsuleController.prototype.getNonWalkableMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleController_getNonWalkableMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getContactOffset'] = PxCapsuleController.prototype.getContactOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleController_getContactOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['setContactOffset'] = PxCapsuleController.prototype.setContactOffset = function(offset) {
  var self = this.ptr;
  if (offset && typeof offset === 'object') offset = offset.ptr;
  _emscripten_bind_PxCapsuleController_setContactOffset_1(self, offset);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getUpDirection'] = PxCapsuleController.prototype.getUpDirection = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleController_getUpDirection_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['setUpDirection'] = PxCapsuleController.prototype.setUpDirection = function(up) {
  var self = this.ptr;
  if (up && typeof up === 'object') up = up.ptr;
  _emscripten_bind_PxCapsuleController_setUpDirection_1(self, up);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getSlopeLimit'] = PxCapsuleController.prototype.getSlopeLimit = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleController_getSlopeLimit_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['setSlopeLimit'] = PxCapsuleController.prototype.setSlopeLimit = function(slopeLimit) {
  var self = this.ptr;
  if (slopeLimit && typeof slopeLimit === 'object') slopeLimit = slopeLimit.ptr;
  _emscripten_bind_PxCapsuleController_setSlopeLimit_1(self, slopeLimit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['invalidateCache'] = PxCapsuleController.prototype.invalidateCache = function() {
  var self = this.ptr;
  _emscripten_bind_PxCapsuleController_invalidateCache_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getScene'] = PxCapsuleController.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleController_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getUserData'] = PxCapsuleController.prototype.getUserData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleController_getUserData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['setUserData'] = PxCapsuleController.prototype.setUserData = function(userData) {
  var self = this.ptr;
  if (userData && typeof userData === 'object') userData = userData.ptr;
  _emscripten_bind_PxCapsuleController_setUserData_1(self, userData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getState'] = PxCapsuleController.prototype.getState = function(state) {
  var self = this.ptr;
  if (state && typeof state === 'object') state = state.ptr;
  _emscripten_bind_PxCapsuleController_getState_1(self, state);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['getStats'] = PxCapsuleController.prototype.getStats = function(stats) {
  var self = this.ptr;
  if (stats && typeof stats === 'object') stats = stats.ptr;
  _emscripten_bind_PxCapsuleController_getStats_1(self, stats);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleController.prototype['resize'] = PxCapsuleController.prototype.resize = function(height) {
  var self = this.ptr;
  if (height && typeof height === 'object') height = height.ptr;
  _emscripten_bind_PxCapsuleController_resize_1(self, height);
};


// Interface: PxCapsuleControllerDesc

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxCapsuleControllerDesc() {
  this.ptr = _emscripten_bind_PxCapsuleControllerDesc_PxCapsuleControllerDesc_0();
  getCache(PxCapsuleControllerDesc)[this.ptr] = this;
};

PxCapsuleControllerDesc.prototype = Object.create(PxControllerDesc.prototype);
PxCapsuleControllerDesc.prototype.constructor = PxCapsuleControllerDesc;
PxCapsuleControllerDesc.prototype.__class__ = PxCapsuleControllerDesc;
PxCapsuleControllerDesc.__cache__ = {};
Module['PxCapsuleControllerDesc'] = PxCapsuleControllerDesc;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['setToDefault'] = PxCapsuleControllerDesc.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['isValid'] = PxCapsuleControllerDesc.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxCapsuleControllerDesc_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['getType'] = PxCapsuleControllerDesc.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleControllerDesc_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_radius'] = PxCapsuleControllerDesc.prototype.get_radius = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleControllerDesc_get_radius_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_radius'] = PxCapsuleControllerDesc.prototype.set_radius = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_radius_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'radius', { get: PxCapsuleControllerDesc.prototype.get_radius, set: PxCapsuleControllerDesc.prototype.set_radius });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_height'] = PxCapsuleControllerDesc.prototype.get_height = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleControllerDesc_get_height_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_height'] = PxCapsuleControllerDesc.prototype.set_height = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_height_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'height', { get: PxCapsuleControllerDesc.prototype.get_height, set: PxCapsuleControllerDesc.prototype.set_height });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_climbingMode'] = PxCapsuleControllerDesc.prototype.get_climbingMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleControllerDesc_get_climbingMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_climbingMode'] = PxCapsuleControllerDesc.prototype.set_climbingMode = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_climbingMode_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'climbingMode', { get: PxCapsuleControllerDesc.prototype.get_climbingMode, set: PxCapsuleControllerDesc.prototype.set_climbingMode });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_position'] = PxCapsuleControllerDesc.prototype.get_position = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleControllerDesc_get_position_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_position'] = PxCapsuleControllerDesc.prototype.set_position = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_position_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'position', { get: PxCapsuleControllerDesc.prototype.get_position, set: PxCapsuleControllerDesc.prototype.set_position });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_upDirection'] = PxCapsuleControllerDesc.prototype.get_upDirection = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleControllerDesc_get_upDirection_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_upDirection'] = PxCapsuleControllerDesc.prototype.set_upDirection = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_upDirection_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'upDirection', { get: PxCapsuleControllerDesc.prototype.get_upDirection, set: PxCapsuleControllerDesc.prototype.set_upDirection });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_slopeLimit'] = PxCapsuleControllerDesc.prototype.get_slopeLimit = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleControllerDesc_get_slopeLimit_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_slopeLimit'] = PxCapsuleControllerDesc.prototype.set_slopeLimit = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_slopeLimit_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'slopeLimit', { get: PxCapsuleControllerDesc.prototype.get_slopeLimit, set: PxCapsuleControllerDesc.prototype.set_slopeLimit });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_invisibleWallHeight'] = PxCapsuleControllerDesc.prototype.get_invisibleWallHeight = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleControllerDesc_get_invisibleWallHeight_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_invisibleWallHeight'] = PxCapsuleControllerDesc.prototype.set_invisibleWallHeight = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_invisibleWallHeight_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'invisibleWallHeight', { get: PxCapsuleControllerDesc.prototype.get_invisibleWallHeight, set: PxCapsuleControllerDesc.prototype.set_invisibleWallHeight });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_maxJumpHeight'] = PxCapsuleControllerDesc.prototype.get_maxJumpHeight = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleControllerDesc_get_maxJumpHeight_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_maxJumpHeight'] = PxCapsuleControllerDesc.prototype.set_maxJumpHeight = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_maxJumpHeight_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'maxJumpHeight', { get: PxCapsuleControllerDesc.prototype.get_maxJumpHeight, set: PxCapsuleControllerDesc.prototype.set_maxJumpHeight });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_contactOffset'] = PxCapsuleControllerDesc.prototype.get_contactOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleControllerDesc_get_contactOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_contactOffset'] = PxCapsuleControllerDesc.prototype.set_contactOffset = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_contactOffset_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'contactOffset', { get: PxCapsuleControllerDesc.prototype.get_contactOffset, set: PxCapsuleControllerDesc.prototype.set_contactOffset });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_stepOffset'] = PxCapsuleControllerDesc.prototype.get_stepOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleControllerDesc_get_stepOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_stepOffset'] = PxCapsuleControllerDesc.prototype.set_stepOffset = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_stepOffset_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'stepOffset', { get: PxCapsuleControllerDesc.prototype.get_stepOffset, set: PxCapsuleControllerDesc.prototype.set_stepOffset });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_density'] = PxCapsuleControllerDesc.prototype.get_density = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleControllerDesc_get_density_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_density'] = PxCapsuleControllerDesc.prototype.set_density = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_density_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'density', { get: PxCapsuleControllerDesc.prototype.get_density, set: PxCapsuleControllerDesc.prototype.set_density });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_scaleCoeff'] = PxCapsuleControllerDesc.prototype.get_scaleCoeff = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleControllerDesc_get_scaleCoeff_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_scaleCoeff'] = PxCapsuleControllerDesc.prototype.set_scaleCoeff = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_scaleCoeff_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'scaleCoeff', { get: PxCapsuleControllerDesc.prototype.get_scaleCoeff, set: PxCapsuleControllerDesc.prototype.set_scaleCoeff });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_volumeGrowth'] = PxCapsuleControllerDesc.prototype.get_volumeGrowth = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleControllerDesc_get_volumeGrowth_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_volumeGrowth'] = PxCapsuleControllerDesc.prototype.set_volumeGrowth = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_volumeGrowth_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'volumeGrowth', { get: PxCapsuleControllerDesc.prototype.get_volumeGrowth, set: PxCapsuleControllerDesc.prototype.set_volumeGrowth });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_reportCallback'] = PxCapsuleControllerDesc.prototype.get_reportCallback = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleControllerDesc_get_reportCallback_0(self), PxUserControllerHitReport);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_reportCallback'] = PxCapsuleControllerDesc.prototype.set_reportCallback = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_reportCallback_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'reportCallback', { get: PxCapsuleControllerDesc.prototype.get_reportCallback, set: PxCapsuleControllerDesc.prototype.set_reportCallback });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_behaviorCallback'] = PxCapsuleControllerDesc.prototype.get_behaviorCallback = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleControllerDesc_get_behaviorCallback_0(self), PxControllerBehaviorCallback);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_behaviorCallback'] = PxCapsuleControllerDesc.prototype.set_behaviorCallback = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_behaviorCallback_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'behaviorCallback', { get: PxCapsuleControllerDesc.prototype.get_behaviorCallback, set: PxCapsuleControllerDesc.prototype.set_behaviorCallback });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_nonWalkableMode'] = PxCapsuleControllerDesc.prototype.get_nonWalkableMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleControllerDesc_get_nonWalkableMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_nonWalkableMode'] = PxCapsuleControllerDesc.prototype.set_nonWalkableMode = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_nonWalkableMode_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'nonWalkableMode', { get: PxCapsuleControllerDesc.prototype.get_nonWalkableMode, set: PxCapsuleControllerDesc.prototype.set_nonWalkableMode });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_material'] = PxCapsuleControllerDesc.prototype.get_material = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleControllerDesc_get_material_0(self), PxMaterial);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_material'] = PxCapsuleControllerDesc.prototype.set_material = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_material_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'material', { get: PxCapsuleControllerDesc.prototype.get_material, set: PxCapsuleControllerDesc.prototype.set_material });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_registerDeletionListener'] = PxCapsuleControllerDesc.prototype.get_registerDeletionListener = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxCapsuleControllerDesc_get_registerDeletionListener_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_registerDeletionListener'] = PxCapsuleControllerDesc.prototype.set_registerDeletionListener = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_registerDeletionListener_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'registerDeletionListener', { get: PxCapsuleControllerDesc.prototype.get_registerDeletionListener, set: PxCapsuleControllerDesc.prototype.set_registerDeletionListener });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['get_userData'] = PxCapsuleControllerDesc.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleControllerDesc_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['set_userData'] = PxCapsuleControllerDesc.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleControllerDesc_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleControllerDesc.prototype, 'userData', { get: PxCapsuleControllerDesc.prototype.get_userData, set: PxCapsuleControllerDesc.prototype.set_userData });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleControllerDesc.prototype['__destroy__'] = PxCapsuleControllerDesc.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxCapsuleControllerDesc___destroy___0(self);
};

// Interface: PxCapsuleGeometry

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxCapsuleGeometry(radius, halfHeight) {
  if (radius && typeof radius === 'object') radius = radius.ptr;
  if (halfHeight && typeof halfHeight === 'object') halfHeight = halfHeight.ptr;
  this.ptr = _emscripten_bind_PxCapsuleGeometry_PxCapsuleGeometry_2(radius, halfHeight);
  getCache(PxCapsuleGeometry)[this.ptr] = this;
};

PxCapsuleGeometry.prototype = Object.create(PxGeometry.prototype);
PxCapsuleGeometry.prototype.constructor = PxCapsuleGeometry;
PxCapsuleGeometry.prototype.__class__ = PxCapsuleGeometry;
PxCapsuleGeometry.__cache__ = {};
Module['PxCapsuleGeometry'] = PxCapsuleGeometry;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleGeometry.prototype['getType'] = PxCapsuleGeometry.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleGeometry_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleGeometry.prototype['get_radius'] = PxCapsuleGeometry.prototype.get_radius = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleGeometry_get_radius_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleGeometry.prototype['set_radius'] = PxCapsuleGeometry.prototype.set_radius = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleGeometry_set_radius_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleGeometry.prototype, 'radius', { get: PxCapsuleGeometry.prototype.get_radius, set: PxCapsuleGeometry.prototype.set_radius });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleGeometry.prototype['get_halfHeight'] = PxCapsuleGeometry.prototype.get_halfHeight = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleGeometry_get_halfHeight_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleGeometry.prototype['set_halfHeight'] = PxCapsuleGeometry.prototype.set_halfHeight = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleGeometry_set_halfHeight_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleGeometry.prototype, 'halfHeight', { get: PxCapsuleGeometry.prototype.get_halfHeight, set: PxCapsuleGeometry.prototype.set_halfHeight });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleGeometry.prototype['__destroy__'] = PxCapsuleGeometry.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxCapsuleGeometry___destroy___0(self);
};

// Interface: PxCapsuleObstacle

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxCapsuleObstacle() {
  this.ptr = _emscripten_bind_PxCapsuleObstacle_PxCapsuleObstacle_0();
  getCache(PxCapsuleObstacle)[this.ptr] = this;
};

PxCapsuleObstacle.prototype = Object.create(PxObstacle.prototype);
PxCapsuleObstacle.prototype.constructor = PxCapsuleObstacle;
PxCapsuleObstacle.prototype.__class__ = PxCapsuleObstacle;
PxCapsuleObstacle.__cache__ = {};
Module['PxCapsuleObstacle'] = PxCapsuleObstacle;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleObstacle.prototype['getType'] = PxCapsuleObstacle.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleObstacle_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleObstacle.prototype['get_mHalfHeight'] = PxCapsuleObstacle.prototype.get_mHalfHeight = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleObstacle_get_mHalfHeight_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleObstacle.prototype['set_mHalfHeight'] = PxCapsuleObstacle.prototype.set_mHalfHeight = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleObstacle_set_mHalfHeight_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleObstacle.prototype, 'mHalfHeight', { get: PxCapsuleObstacle.prototype.get_mHalfHeight, set: PxCapsuleObstacle.prototype.set_mHalfHeight });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleObstacle.prototype['get_mRadius'] = PxCapsuleObstacle.prototype.get_mRadius = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCapsuleObstacle_get_mRadius_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleObstacle.prototype['set_mRadius'] = PxCapsuleObstacle.prototype.set_mRadius = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleObstacle_set_mRadius_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleObstacle.prototype, 'mRadius', { get: PxCapsuleObstacle.prototype.get_mRadius, set: PxCapsuleObstacle.prototype.set_mRadius });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleObstacle.prototype['get_mUserData'] = PxCapsuleObstacle.prototype.get_mUserData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleObstacle_get_mUserData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleObstacle.prototype['set_mUserData'] = PxCapsuleObstacle.prototype.set_mUserData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleObstacle_set_mUserData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleObstacle.prototype, 'mUserData', { get: PxCapsuleObstacle.prototype.get_mUserData, set: PxCapsuleObstacle.prototype.set_mUserData });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleObstacle.prototype['get_mPos'] = PxCapsuleObstacle.prototype.get_mPos = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleObstacle_get_mPos_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleObstacle.prototype['set_mPos'] = PxCapsuleObstacle.prototype.set_mPos = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleObstacle_set_mPos_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleObstacle.prototype, 'mPos', { get: PxCapsuleObstacle.prototype.get_mPos, set: PxCapsuleObstacle.prototype.set_mPos });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleObstacle.prototype['get_mRot'] = PxCapsuleObstacle.prototype.get_mRot = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCapsuleObstacle_get_mRot_0(self), PxQuat);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleObstacle.prototype['set_mRot'] = PxCapsuleObstacle.prototype.set_mRot = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCapsuleObstacle_set_mRot_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCapsuleObstacle.prototype, 'mRot', { get: PxCapsuleObstacle.prototype.get_mRot, set: PxCapsuleObstacle.prototype.set_mRot });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCapsuleObstacle.prototype['__destroy__'] = PxCapsuleObstacle.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxCapsuleObstacle___destroy___0(self);
};

// Interface: PxCollection

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxCollection() { throw "cannot construct a PxCollection, no constructor in IDL" }
PxCollection.prototype = Object.create(WrapperObject.prototype);
PxCollection.prototype.constructor = PxCollection;
PxCollection.prototype.__class__ = PxCollection;
PxCollection.__cache__ = {};
Module['PxCollection'] = PxCollection;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollection.prototype['add'] = PxCollection.prototype.add = function(obj, id) {
  var self = this.ptr;
  if (obj && typeof obj === 'object') obj = obj.ptr;
  if (id && typeof id === 'object') id = id.ptr;
  if (id === undefined) { _emscripten_bind_PxCollection_add_1(self, obj); return }
  _emscripten_bind_PxCollection_add_2(self, obj, id);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollection.prototype['remove'] = PxCollection.prototype.remove = function(obj) {
  var self = this.ptr;
  if (obj && typeof obj === 'object') obj = obj.ptr;
  _emscripten_bind_PxCollection_remove_1(self, obj);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollection.prototype['contains'] = PxCollection.prototype.contains = function(obj) {
  var self = this.ptr;
  if (obj && typeof obj === 'object') obj = obj.ptr;
  return !!(_emscripten_bind_PxCollection_contains_1(self, obj));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollection.prototype['addId'] = PxCollection.prototype.addId = function(obj, id) {
  var self = this.ptr;
  if (obj && typeof obj === 'object') obj = obj.ptr;
  if (id && typeof id === 'object') id = id.ptr;
  _emscripten_bind_PxCollection_addId_2(self, obj, id);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollection.prototype['removeId'] = PxCollection.prototype.removeId = function(id) {
  var self = this.ptr;
  if (id && typeof id === 'object') id = id.ptr;
  _emscripten_bind_PxCollection_removeId_1(self, id);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollection.prototype['getNbObjects'] = PxCollection.prototype.getNbObjects = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCollection_getNbObjects_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollection.prototype['getObject'] = PxCollection.prototype.getObject = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxCollection_getObject_1(self, index), PxBase);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollection.prototype['find'] = PxCollection.prototype.find = function(id) {
  var self = this.ptr;
  if (id && typeof id === 'object') id = id.ptr;
  return wrapPointer(_emscripten_bind_PxCollection_find_1(self, id), PxBase);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollection.prototype['getNbIds'] = PxCollection.prototype.getNbIds = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCollection_getNbIds_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollection.prototype['getId'] = PxCollection.prototype.getId = function(obj) {
  var self = this.ptr;
  if (obj && typeof obj === 'object') obj = obj.ptr;
  return _emscripten_bind_PxCollection_getId_1(self, obj);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollection.prototype['release'] = PxCollection.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxCollection_release_0(self);
};


// Interface: PxCollectionExt

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxCollectionExt() { throw "cannot construct a PxCollectionExt, no constructor in IDL" }
PxCollectionExt.prototype = Object.create(WrapperObject.prototype);
PxCollectionExt.prototype.constructor = PxCollectionExt;
PxCollectionExt.prototype.__class__ = PxCollectionExt;
PxCollectionExt.__cache__ = {};
Module['PxCollectionExt'] = PxCollectionExt;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollectionExt.prototype['releaseObjects'] = PxCollectionExt.prototype.releaseObjects = function(collection, releaseExclusiveShapes) {
  if (collection && typeof collection === 'object') collection = collection.ptr;
  if (releaseExclusiveShapes && typeof releaseExclusiveShapes === 'object') releaseExclusiveShapes = releaseExclusiveShapes.ptr;
  if (releaseExclusiveShapes === undefined) { _emscripten_bind_PxCollectionExt_releaseObjects_1(collection); return }
  _emscripten_bind_PxCollectionExt_releaseObjects_2(collection, releaseExclusiveShapes);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollectionExt.prototype['remove'] = PxCollectionExt.prototype.remove = function(collection, concreteType, to) {
  if (collection && typeof collection === 'object') collection = collection.ptr;
  if (concreteType && typeof concreteType === 'object') concreteType = concreteType.ptr;
  if (to && typeof to === 'object') to = to.ptr;
  if (to === undefined) { _emscripten_bind_PxCollectionExt_remove_2(collection, concreteType); return }
  _emscripten_bind_PxCollectionExt_remove_3(collection, concreteType, to);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollectionExt.prototype['createCollection'] = PxCollectionExt.prototype.createCollection = function(scene) {
  if (scene && typeof scene === 'object') scene = scene.ptr;
  return wrapPointer(_emscripten_bind_PxCollectionExt_createCollection_1(scene), PxCollection);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCollectionExt.prototype['__destroy__'] = PxCollectionExt.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxCollectionExt___destroy___0(self);
};

// Interface: PxConstraint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConstraint() { throw "cannot construct a PxConstraint, no constructor in IDL" }
PxConstraint.prototype = Object.create(PxBase.prototype);
PxConstraint.prototype.constructor = PxConstraint;
PxConstraint.prototype.__class__ = PxConstraint;
PxConstraint.__cache__ = {};
Module['PxConstraint'] = PxConstraint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['getScene'] = PxConstraint.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConstraint_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['setActors'] = PxConstraint.prototype.setActors = function(actor0, actor1) {
  var self = this.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  _emscripten_bind_PxConstraint_setActors_2(self, actor0, actor1);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['markDirty'] = PxConstraint.prototype.markDirty = function() {
  var self = this.ptr;
  _emscripten_bind_PxConstraint_markDirty_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['setFlags'] = PxConstraint.prototype.setFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxConstraint_setFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['getFlags'] = PxConstraint.prototype.getFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConstraint_getFlags_0(self), PxConstraintFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['setFlag'] = PxConstraint.prototype.setFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxConstraint_setFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['getForce'] = PxConstraint.prototype.getForce = function(linear, angular) {
  var self = this.ptr;
  if (linear && typeof linear === 'object') linear = linear.ptr;
  if (angular && typeof angular === 'object') angular = angular.ptr;
  _emscripten_bind_PxConstraint_getForce_2(self, linear, angular);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['isValid'] = PxConstraint.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxConstraint_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['setBreakForce'] = PxConstraint.prototype.setBreakForce = function(linear, angular) {
  var self = this.ptr;
  if (linear && typeof linear === 'object') linear = linear.ptr;
  if (angular && typeof angular === 'object') angular = angular.ptr;
  _emscripten_bind_PxConstraint_setBreakForce_2(self, linear, angular);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['setMinResponseThreshold'] = PxConstraint.prototype.setMinResponseThreshold = function(threshold) {
  var self = this.ptr;
  if (threshold && typeof threshold === 'object') threshold = threshold.ptr;
  _emscripten_bind_PxConstraint_setMinResponseThreshold_1(self, threshold);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['getMinResponseThreshold'] = PxConstraint.prototype.getMinResponseThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConstraint_getMinResponseThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['release'] = PxConstraint.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxConstraint_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['getConcreteTypeName'] = PxConstraint.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxConstraint_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['getConcreteType'] = PxConstraint.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConstraint_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['setBaseFlag'] = PxConstraint.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxConstraint_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['setBaseFlags'] = PxConstraint.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxConstraint_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['getBaseFlags'] = PxConstraint.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConstraint_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraint.prototype['isReleasable'] = PxConstraint.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxConstraint_isReleasable_0(self));
};


// Interface: PxConstraintFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConstraintFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxConstraintFlags_PxConstraintFlags_1(flags);
  getCache(PxConstraintFlags)[this.ptr] = this;
};

PxConstraintFlags.prototype = Object.create(WrapperObject.prototype);
PxConstraintFlags.prototype.constructor = PxConstraintFlags;
PxConstraintFlags.prototype.__class__ = PxConstraintFlags;
PxConstraintFlags.__cache__ = {};
Module['PxConstraintFlags'] = PxConstraintFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintFlags.prototype['isSet'] = PxConstraintFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxConstraintFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintFlags.prototype['raise'] = PxConstraintFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxConstraintFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintFlags.prototype['clear'] = PxConstraintFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxConstraintFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintFlags.prototype['__destroy__'] = PxConstraintFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConstraintFlags___destroy___0(self);
};

// Interface: PxConstraintInfo

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConstraintInfo() { throw "cannot construct a PxConstraintInfo, no constructor in IDL" }
PxConstraintInfo.prototype = Object.create(WrapperObject.prototype);
PxConstraintInfo.prototype.constructor = PxConstraintInfo;
PxConstraintInfo.prototype.__class__ = PxConstraintInfo;
PxConstraintInfo.__cache__ = {};
Module['PxConstraintInfo'] = PxConstraintInfo;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintInfo.prototype['get_constraint'] = PxConstraintInfo.prototype.get_constraint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConstraintInfo_get_constraint_0(self), PxConstraint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintInfo.prototype['set_constraint'] = PxConstraintInfo.prototype.set_constraint = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConstraintInfo_set_constraint_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConstraintInfo.prototype, 'constraint', { get: PxConstraintInfo.prototype.get_constraint, set: PxConstraintInfo.prototype.set_constraint });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintInfo.prototype['get_externalReference'] = PxConstraintInfo.prototype.get_externalReference = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConstraintInfo_get_externalReference_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintInfo.prototype['set_externalReference'] = PxConstraintInfo.prototype.set_externalReference = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConstraintInfo_set_externalReference_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConstraintInfo.prototype, 'externalReference', { get: PxConstraintInfo.prototype.get_externalReference, set: PxConstraintInfo.prototype.set_externalReference });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintInfo.prototype['get_type'] = PxConstraintInfo.prototype.get_type = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConstraintInfo_get_type_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintInfo.prototype['set_type'] = PxConstraintInfo.prototype.set_type = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConstraintInfo_set_type_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConstraintInfo.prototype, 'type', { get: PxConstraintInfo.prototype.get_type, set: PxConstraintInfo.prototype.set_type });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintInfo.prototype['__destroy__'] = PxConstraintInfo.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConstraintInfo___destroy___0(self);
};

// Interface: PxConstraintSolverPrep

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConstraintSolverPrep() { throw "cannot construct a PxConstraintSolverPrep, no constructor in IDL" }
PxConstraintSolverPrep.prototype = Object.create(WrapperObject.prototype);
PxConstraintSolverPrep.prototype.constructor = PxConstraintSolverPrep;
PxConstraintSolverPrep.prototype.__class__ = PxConstraintSolverPrep;
PxConstraintSolverPrep.__cache__ = {};
Module['PxConstraintSolverPrep'] = PxConstraintSolverPrep;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConstraintSolverPrep.prototype['__destroy__'] = PxConstraintSolverPrep.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConstraintSolverPrep___destroy___0(self);
};

// Interface: PxContactBuffer

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxContactBuffer() { throw "cannot construct a PxContactBuffer, no constructor in IDL" }
PxContactBuffer.prototype = Object.create(WrapperObject.prototype);
PxContactBuffer.prototype.constructor = PxContactBuffer;
PxContactBuffer.prototype.__class__ = PxContactBuffer;
PxContactBuffer.__cache__ = {};
Module['PxContactBuffer'] = PxContactBuffer;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactBuffer.prototype['reset'] = PxContactBuffer.prototype.reset = function() {
  var self = this.ptr;
  _emscripten_bind_PxContactBuffer_reset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactBuffer.prototype['contact'] = PxContactBuffer.prototype.contact = function(worldPoint, worldNormalIn, separation, faceIndex1) {
  var self = this.ptr;
  if (worldPoint && typeof worldPoint === 'object') worldPoint = worldPoint.ptr;
  if (worldNormalIn && typeof worldNormalIn === 'object') worldNormalIn = worldNormalIn.ptr;
  if (separation && typeof separation === 'object') separation = separation.ptr;
  if (faceIndex1 && typeof faceIndex1 === 'object') faceIndex1 = faceIndex1.ptr;
  if (worldNormalIn === undefined) { return !!(_emscripten_bind_PxContactBuffer_contact_1(self, worldPoint)) }
  if (separation === undefined) { return !!(_emscripten_bind_PxContactBuffer_contact_2(self, worldPoint, worldNormalIn)) }
  if (faceIndex1 === undefined) { return !!(_emscripten_bind_PxContactBuffer_contact_3(self, worldPoint, worldNormalIn, separation)) }
  return !!(_emscripten_bind_PxContactBuffer_contact_4(self, worldPoint, worldNormalIn, separation, faceIndex1));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactBuffer.prototype['get_contacts'] = PxContactBuffer.prototype.get_contacts = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PxContactBuffer_get_contacts_1(self, arg0), PxContactPoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactBuffer.prototype['set_contacts'] = PxContactBuffer.prototype.set_contacts = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxContactBuffer_set_contacts_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactBuffer.prototype, 'contacts', { get: PxContactBuffer.prototype.get_contacts, set: PxContactBuffer.prototype.set_contacts });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactBuffer.prototype['get_count'] = PxContactBuffer.prototype.get_count = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactBuffer_get_count_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactBuffer.prototype['set_count'] = PxContactBuffer.prototype.set_count = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactBuffer_set_count_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactBuffer.prototype, 'count', { get: PxContactBuffer.prototype.get_count, set: PxContactBuffer.prototype.set_count });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactBuffer.prototype['get_pad'] = PxContactBuffer.prototype.get_pad = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactBuffer_get_pad_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactBuffer.prototype['set_pad'] = PxContactBuffer.prototype.set_pad = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactBuffer_set_pad_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactBuffer.prototype, 'pad', { get: PxContactBuffer.prototype.get_pad, set: PxContactBuffer.prototype.set_pad });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactBuffer.prototype['get_MAX_CONTACTS'] = PxContactBuffer.prototype.get_MAX_CONTACTS = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactBuffer_get_MAX_CONTACTS_0(self);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactBuffer.prototype, 'MAX_CONTACTS', { get: PxContactBuffer.prototype.get_MAX_CONTACTS });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactBuffer.prototype['__destroy__'] = PxContactBuffer.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxContactBuffer___destroy___0(self);
};

// Interface: PxContactPair

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxContactPair() { throw "cannot construct a PxContactPair, no constructor in IDL" }
PxContactPair.prototype = Object.create(WrapperObject.prototype);
PxContactPair.prototype.constructor = PxContactPair;
PxContactPair.prototype.__class__ = PxContactPair;
PxContactPair.__cache__ = {};
Module['PxContactPair'] = PxContactPair;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPair.prototype['extractContacts'] = PxContactPair.prototype.extractContacts = function(userBuffer, bufferSize) {
  var self = this.ptr;
  if (userBuffer && typeof userBuffer === 'object') userBuffer = userBuffer.ptr;
  if (bufferSize && typeof bufferSize === 'object') bufferSize = bufferSize.ptr;
  return _emscripten_bind_PxContactPair_extractContacts_2(self, userBuffer, bufferSize);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPair.prototype['get_shapes'] = PxContactPair.prototype.get_shapes = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PxContactPair_get_shapes_1(self, arg0), PxShape);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPair.prototype['set_shapes'] = PxContactPair.prototype.set_shapes = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxContactPair_set_shapes_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPair.prototype, 'shapes', { get: PxContactPair.prototype.get_shapes, set: PxContactPair.prototype.set_shapes });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPair.prototype['get_contactCount'] = PxContactPair.prototype.get_contactCount = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactPair_get_contactCount_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPair.prototype['set_contactCount'] = PxContactPair.prototype.set_contactCount = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPair_set_contactCount_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPair.prototype, 'contactCount', { get: PxContactPair.prototype.get_contactCount, set: PxContactPair.prototype.set_contactCount });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPair.prototype['get_patchCount'] = PxContactPair.prototype.get_patchCount = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactPair_get_patchCount_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPair.prototype['set_patchCount'] = PxContactPair.prototype.set_patchCount = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPair_set_patchCount_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPair.prototype, 'patchCount', { get: PxContactPair.prototype.get_patchCount, set: PxContactPair.prototype.set_patchCount });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPair.prototype['get_flags'] = PxContactPair.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxContactPair_get_flags_0(self), PxContactPairFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPair.prototype['set_flags'] = PxContactPair.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPair_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPair.prototype, 'flags', { get: PxContactPair.prototype.get_flags, set: PxContactPair.prototype.set_flags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPair.prototype['get_events'] = PxContactPair.prototype.get_events = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxContactPair_get_events_0(self), PxPairFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPair.prototype['set_events'] = PxContactPair.prototype.set_events = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPair_set_events_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPair.prototype, 'events', { get: PxContactPair.prototype.get_events, set: PxContactPair.prototype.set_events });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPair.prototype['__destroy__'] = PxContactPair.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxContactPair___destroy___0(self);
};

// Interface: PxContactPairFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxContactPairFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxContactPairFlags_PxContactPairFlags_1(flags);
  getCache(PxContactPairFlags)[this.ptr] = this;
};

PxContactPairFlags.prototype = Object.create(WrapperObject.prototype);
PxContactPairFlags.prototype.constructor = PxContactPairFlags;
PxContactPairFlags.prototype.__class__ = PxContactPairFlags;
PxContactPairFlags.__cache__ = {};
Module['PxContactPairFlags'] = PxContactPairFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairFlags.prototype['isSet'] = PxContactPairFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxContactPairFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairFlags.prototype['raise'] = PxContactPairFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxContactPairFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairFlags.prototype['clear'] = PxContactPairFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxContactPairFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairFlags.prototype['__destroy__'] = PxContactPairFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxContactPairFlags___destroy___0(self);
};

// Interface: PxContactPairHeader

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxContactPairHeader() { throw "cannot construct a PxContactPairHeader, no constructor in IDL" }
PxContactPairHeader.prototype = Object.create(WrapperObject.prototype);
PxContactPairHeader.prototype.constructor = PxContactPairHeader;
PxContactPairHeader.prototype.__class__ = PxContactPairHeader;
PxContactPairHeader.__cache__ = {};
Module['PxContactPairHeader'] = PxContactPairHeader;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairHeader.prototype['get_actors'] = PxContactPairHeader.prototype.get_actors = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PxContactPairHeader_get_actors_1(self, arg0), PxActor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairHeader.prototype['set_actors'] = PxContactPairHeader.prototype.set_actors = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxContactPairHeader_set_actors_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPairHeader.prototype, 'actors', { get: PxContactPairHeader.prototype.get_actors, set: PxContactPairHeader.prototype.set_actors });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairHeader.prototype['get_flags'] = PxContactPairHeader.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxContactPairHeader_get_flags_0(self), PxContactPairHeaderFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairHeader.prototype['set_flags'] = PxContactPairHeader.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPairHeader_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPairHeader.prototype, 'flags', { get: PxContactPairHeader.prototype.get_flags, set: PxContactPairHeader.prototype.set_flags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairHeader.prototype['get_pairs'] = PxContactPairHeader.prototype.get_pairs = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxContactPairHeader_get_pairs_0(self), PxContactPair);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairHeader.prototype['set_pairs'] = PxContactPairHeader.prototype.set_pairs = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPairHeader_set_pairs_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPairHeader.prototype, 'pairs', { get: PxContactPairHeader.prototype.get_pairs, set: PxContactPairHeader.prototype.set_pairs });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairHeader.prototype['get_nbPairs'] = PxContactPairHeader.prototype.get_nbPairs = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactPairHeader_get_nbPairs_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairHeader.prototype['set_nbPairs'] = PxContactPairHeader.prototype.set_nbPairs = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPairHeader_set_nbPairs_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPairHeader.prototype, 'nbPairs', { get: PxContactPairHeader.prototype.get_nbPairs, set: PxContactPairHeader.prototype.set_nbPairs });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairHeader.prototype['__destroy__'] = PxContactPairHeader.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxContactPairHeader___destroy___0(self);
};

// Interface: PxContactPairHeaderFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxContactPairHeaderFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxContactPairHeaderFlags_PxContactPairHeaderFlags_1(flags);
  getCache(PxContactPairHeaderFlags)[this.ptr] = this;
};

PxContactPairHeaderFlags.prototype = Object.create(WrapperObject.prototype);
PxContactPairHeaderFlags.prototype.constructor = PxContactPairHeaderFlags;
PxContactPairHeaderFlags.prototype.__class__ = PxContactPairHeaderFlags;
PxContactPairHeaderFlags.__cache__ = {};
Module['PxContactPairHeaderFlags'] = PxContactPairHeaderFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairHeaderFlags.prototype['isSet'] = PxContactPairHeaderFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxContactPairHeaderFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairHeaderFlags.prototype['raise'] = PxContactPairHeaderFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxContactPairHeaderFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairHeaderFlags.prototype['clear'] = PxContactPairHeaderFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxContactPairHeaderFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairHeaderFlags.prototype['__destroy__'] = PxContactPairHeaderFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxContactPairHeaderFlags___destroy___0(self);
};

// Interface: PxContactPairPoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxContactPairPoint() { throw "cannot construct a PxContactPairPoint, no constructor in IDL" }
PxContactPairPoint.prototype = Object.create(WrapperObject.prototype);
PxContactPairPoint.prototype.constructor = PxContactPairPoint;
PxContactPairPoint.prototype.__class__ = PxContactPairPoint;
PxContactPairPoint.__cache__ = {};
Module['PxContactPairPoint'] = PxContactPairPoint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairPoint.prototype['get_position'] = PxContactPairPoint.prototype.get_position = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxContactPairPoint_get_position_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairPoint.prototype['set_position'] = PxContactPairPoint.prototype.set_position = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPairPoint_set_position_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPairPoint.prototype, 'position', { get: PxContactPairPoint.prototype.get_position, set: PxContactPairPoint.prototype.set_position });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairPoint.prototype['get_separation'] = PxContactPairPoint.prototype.get_separation = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactPairPoint_get_separation_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairPoint.prototype['set_separation'] = PxContactPairPoint.prototype.set_separation = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPairPoint_set_separation_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPairPoint.prototype, 'separation', { get: PxContactPairPoint.prototype.get_separation, set: PxContactPairPoint.prototype.set_separation });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairPoint.prototype['get_normal'] = PxContactPairPoint.prototype.get_normal = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxContactPairPoint_get_normal_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairPoint.prototype['set_normal'] = PxContactPairPoint.prototype.set_normal = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPairPoint_set_normal_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPairPoint.prototype, 'normal', { get: PxContactPairPoint.prototype.get_normal, set: PxContactPairPoint.prototype.set_normal });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairPoint.prototype['get_internalFaceIndex0'] = PxContactPairPoint.prototype.get_internalFaceIndex0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactPairPoint_get_internalFaceIndex0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairPoint.prototype['set_internalFaceIndex0'] = PxContactPairPoint.prototype.set_internalFaceIndex0 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPairPoint_set_internalFaceIndex0_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPairPoint.prototype, 'internalFaceIndex0', { get: PxContactPairPoint.prototype.get_internalFaceIndex0, set: PxContactPairPoint.prototype.set_internalFaceIndex0 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairPoint.prototype['get_impulse'] = PxContactPairPoint.prototype.get_impulse = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxContactPairPoint_get_impulse_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairPoint.prototype['set_impulse'] = PxContactPairPoint.prototype.set_impulse = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPairPoint_set_impulse_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPairPoint.prototype, 'impulse', { get: PxContactPairPoint.prototype.get_impulse, set: PxContactPairPoint.prototype.set_impulse });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairPoint.prototype['get_internalFaceIndex1'] = PxContactPairPoint.prototype.get_internalFaceIndex1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactPairPoint_get_internalFaceIndex1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairPoint.prototype['set_internalFaceIndex1'] = PxContactPairPoint.prototype.set_internalFaceIndex1 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPairPoint_set_internalFaceIndex1_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPairPoint.prototype, 'internalFaceIndex1', { get: PxContactPairPoint.prototype.get_internalFaceIndex1, set: PxContactPairPoint.prototype.set_internalFaceIndex1 });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPairPoint.prototype['__destroy__'] = PxContactPairPoint.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxContactPairPoint___destroy___0(self);
};

// Interface: PxContactPoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxContactPoint() {
  this.ptr = _emscripten_bind_PxContactPoint_PxContactPoint_0();
  getCache(PxContactPoint)[this.ptr] = this;
};

PxContactPoint.prototype = Object.create(WrapperObject.prototype);
PxContactPoint.prototype.constructor = PxContactPoint;
PxContactPoint.prototype.__class__ = PxContactPoint;
PxContactPoint.__cache__ = {};
Module['PxContactPoint'] = PxContactPoint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['get_normal'] = PxContactPoint.prototype.get_normal = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxContactPoint_get_normal_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['set_normal'] = PxContactPoint.prototype.set_normal = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPoint_set_normal_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPoint.prototype, 'normal', { get: PxContactPoint.prototype.get_normal, set: PxContactPoint.prototype.set_normal });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['get_point'] = PxContactPoint.prototype.get_point = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxContactPoint_get_point_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['set_point'] = PxContactPoint.prototype.set_point = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPoint_set_point_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPoint.prototype, 'point', { get: PxContactPoint.prototype.get_point, set: PxContactPoint.prototype.set_point });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['get_targetVel'] = PxContactPoint.prototype.get_targetVel = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxContactPoint_get_targetVel_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['set_targetVel'] = PxContactPoint.prototype.set_targetVel = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPoint_set_targetVel_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPoint.prototype, 'targetVel', { get: PxContactPoint.prototype.get_targetVel, set: PxContactPoint.prototype.set_targetVel });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['get_separation'] = PxContactPoint.prototype.get_separation = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactPoint_get_separation_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['set_separation'] = PxContactPoint.prototype.set_separation = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPoint_set_separation_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPoint.prototype, 'separation', { get: PxContactPoint.prototype.get_separation, set: PxContactPoint.prototype.set_separation });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['get_maxImpulse'] = PxContactPoint.prototype.get_maxImpulse = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactPoint_get_maxImpulse_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['set_maxImpulse'] = PxContactPoint.prototype.set_maxImpulse = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPoint_set_maxImpulse_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPoint.prototype, 'maxImpulse', { get: PxContactPoint.prototype.get_maxImpulse, set: PxContactPoint.prototype.set_maxImpulse });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['get_staticFriction'] = PxContactPoint.prototype.get_staticFriction = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactPoint_get_staticFriction_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['set_staticFriction'] = PxContactPoint.prototype.set_staticFriction = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPoint_set_staticFriction_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPoint.prototype, 'staticFriction', { get: PxContactPoint.prototype.get_staticFriction, set: PxContactPoint.prototype.set_staticFriction });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['get_materialFlags'] = PxContactPoint.prototype.get_materialFlags = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactPoint_get_materialFlags_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['set_materialFlags'] = PxContactPoint.prototype.set_materialFlags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPoint_set_materialFlags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPoint.prototype, 'materialFlags', { get: PxContactPoint.prototype.get_materialFlags, set: PxContactPoint.prototype.set_materialFlags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['get_internalFaceIndex1'] = PxContactPoint.prototype.get_internalFaceIndex1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactPoint_get_internalFaceIndex1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['set_internalFaceIndex1'] = PxContactPoint.prototype.set_internalFaceIndex1 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPoint_set_internalFaceIndex1_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPoint.prototype, 'internalFaceIndex1', { get: PxContactPoint.prototype.get_internalFaceIndex1, set: PxContactPoint.prototype.set_internalFaceIndex1 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['get_dynamicFriction'] = PxContactPoint.prototype.get_dynamicFriction = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactPoint_get_dynamicFriction_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['set_dynamicFriction'] = PxContactPoint.prototype.set_dynamicFriction = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPoint_set_dynamicFriction_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPoint.prototype, 'dynamicFriction', { get: PxContactPoint.prototype.get_dynamicFriction, set: PxContactPoint.prototype.set_dynamicFriction });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['get_restitution'] = PxContactPoint.prototype.get_restitution = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactPoint_get_restitution_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['set_restitution'] = PxContactPoint.prototype.set_restitution = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPoint_set_restitution_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPoint.prototype, 'restitution', { get: PxContactPoint.prototype.get_restitution, set: PxContactPoint.prototype.set_restitution });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['get_damping'] = PxContactPoint.prototype.get_damping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxContactPoint_get_damping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['set_damping'] = PxContactPoint.prototype.set_damping = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxContactPoint_set_damping_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxContactPoint.prototype, 'damping', { get: PxContactPoint.prototype.get_damping, set: PxContactPoint.prototype.set_damping });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxContactPoint.prototype['__destroy__'] = PxContactPoint.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxContactPoint___destroy___0(self);
};

// Interface: PxControllerBehaviorCallbackImpl

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllerBehaviorCallbackImpl() {
  this.ptr = _emscripten_bind_PxControllerBehaviorCallbackImpl_PxControllerBehaviorCallbackImpl_0();
  getCache(PxControllerBehaviorCallbackImpl)[this.ptr] = this;
};

PxControllerBehaviorCallbackImpl.prototype = Object.create(SimpleControllerBehaviorCallback.prototype);
PxControllerBehaviorCallbackImpl.prototype.constructor = PxControllerBehaviorCallbackImpl;
PxControllerBehaviorCallbackImpl.prototype.__class__ = PxControllerBehaviorCallbackImpl;
PxControllerBehaviorCallbackImpl.__cache__ = {};
Module['PxControllerBehaviorCallbackImpl'] = PxControllerBehaviorCallbackImpl;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerBehaviorCallbackImpl.prototype['getShapeBehaviorFlags'] = PxControllerBehaviorCallbackImpl.prototype.getShapeBehaviorFlags = function(shape, actor) {
  var self = this.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return _emscripten_bind_PxControllerBehaviorCallbackImpl_getShapeBehaviorFlags_2(self, shape, actor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerBehaviorCallbackImpl.prototype['getControllerBehaviorFlags'] = PxControllerBehaviorCallbackImpl.prototype.getControllerBehaviorFlags = function(controller) {
  var self = this.ptr;
  if (controller && typeof controller === 'object') controller = controller.ptr;
  return _emscripten_bind_PxControllerBehaviorCallbackImpl_getControllerBehaviorFlags_1(self, controller);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerBehaviorCallbackImpl.prototype['getObstacleBehaviorFlags'] = PxControllerBehaviorCallbackImpl.prototype.getObstacleBehaviorFlags = function(obstacle) {
  var self = this.ptr;
  if (obstacle && typeof obstacle === 'object') obstacle = obstacle.ptr;
  return _emscripten_bind_PxControllerBehaviorCallbackImpl_getObstacleBehaviorFlags_1(self, obstacle);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerBehaviorCallbackImpl.prototype['__destroy__'] = PxControllerBehaviorCallbackImpl.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxControllerBehaviorCallbackImpl___destroy___0(self);
};

// Interface: PxControllerBehaviorFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllerBehaviorFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxControllerBehaviorFlags_PxControllerBehaviorFlags_1(flags);
  getCache(PxControllerBehaviorFlags)[this.ptr] = this;
};

PxControllerBehaviorFlags.prototype = Object.create(WrapperObject.prototype);
PxControllerBehaviorFlags.prototype.constructor = PxControllerBehaviorFlags;
PxControllerBehaviorFlags.prototype.__class__ = PxControllerBehaviorFlags;
PxControllerBehaviorFlags.__cache__ = {};
Module['PxControllerBehaviorFlags'] = PxControllerBehaviorFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerBehaviorFlags.prototype['isSet'] = PxControllerBehaviorFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxControllerBehaviorFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerBehaviorFlags.prototype['raise'] = PxControllerBehaviorFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxControllerBehaviorFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerBehaviorFlags.prototype['clear'] = PxControllerBehaviorFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxControllerBehaviorFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerBehaviorFlags.prototype['__destroy__'] = PxControllerBehaviorFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxControllerBehaviorFlags___destroy___0(self);
};

// Interface: PxControllerCollisionFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllerCollisionFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxControllerCollisionFlags_PxControllerCollisionFlags_1(flags);
  getCache(PxControllerCollisionFlags)[this.ptr] = this;
};

PxControllerCollisionFlags.prototype = Object.create(WrapperObject.prototype);
PxControllerCollisionFlags.prototype.constructor = PxControllerCollisionFlags;
PxControllerCollisionFlags.prototype.__class__ = PxControllerCollisionFlags;
PxControllerCollisionFlags.__cache__ = {};
Module['PxControllerCollisionFlags'] = PxControllerCollisionFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerCollisionFlags.prototype['isSet'] = PxControllerCollisionFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxControllerCollisionFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerCollisionFlags.prototype['raise'] = PxControllerCollisionFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxControllerCollisionFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerCollisionFlags.prototype['clear'] = PxControllerCollisionFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxControllerCollisionFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerCollisionFlags.prototype['__destroy__'] = PxControllerCollisionFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxControllerCollisionFlags___destroy___0(self);
};

// Interface: PxControllerFilterCallbackImpl

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllerFilterCallbackImpl() {
  this.ptr = _emscripten_bind_PxControllerFilterCallbackImpl_PxControllerFilterCallbackImpl_0();
  getCache(PxControllerFilterCallbackImpl)[this.ptr] = this;
};

PxControllerFilterCallbackImpl.prototype = Object.create(PxControllerFilterCallback.prototype);
PxControllerFilterCallbackImpl.prototype.constructor = PxControllerFilterCallbackImpl;
PxControllerFilterCallbackImpl.prototype.__class__ = PxControllerFilterCallbackImpl;
PxControllerFilterCallbackImpl.__cache__ = {};
Module['PxControllerFilterCallbackImpl'] = PxControllerFilterCallbackImpl;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerFilterCallbackImpl.prototype['filter'] = PxControllerFilterCallbackImpl.prototype.filter = function(a, b) {
  var self = this.ptr;
  if (a && typeof a === 'object') a = a.ptr;
  if (b && typeof b === 'object') b = b.ptr;
  return !!(_emscripten_bind_PxControllerFilterCallbackImpl_filter_2(self, a, b));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerFilterCallbackImpl.prototype['__destroy__'] = PxControllerFilterCallbackImpl.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxControllerFilterCallbackImpl___destroy___0(self);
};

// Interface: PxControllerFilters

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllerFilters(filterData) {
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  if (filterData === undefined) { this.ptr = _emscripten_bind_PxControllerFilters_PxControllerFilters_0(); getCache(PxControllerFilters)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxControllerFilters_PxControllerFilters_1(filterData);
  getCache(PxControllerFilters)[this.ptr] = this;
};

PxControllerFilters.prototype = Object.create(WrapperObject.prototype);
PxControllerFilters.prototype.constructor = PxControllerFilters;
PxControllerFilters.prototype.__class__ = PxControllerFilters;
PxControllerFilters.__cache__ = {};
Module['PxControllerFilters'] = PxControllerFilters;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerFilters.prototype['get_mFilterData'] = PxControllerFilters.prototype.get_mFilterData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerFilters_get_mFilterData_0(self), PxFilterData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerFilters.prototype['set_mFilterData'] = PxControllerFilters.prototype.set_mFilterData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerFilters_set_mFilterData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerFilters.prototype, 'mFilterData', { get: PxControllerFilters.prototype.get_mFilterData, set: PxControllerFilters.prototype.set_mFilterData });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerFilters.prototype['get_mFilterCallback'] = PxControllerFilters.prototype.get_mFilterCallback = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerFilters_get_mFilterCallback_0(self), PxQueryFilterCallback);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerFilters.prototype['set_mFilterCallback'] = PxControllerFilters.prototype.set_mFilterCallback = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerFilters_set_mFilterCallback_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerFilters.prototype, 'mFilterCallback', { get: PxControllerFilters.prototype.get_mFilterCallback, set: PxControllerFilters.prototype.set_mFilterCallback });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerFilters.prototype['get_mFilterFlags'] = PxControllerFilters.prototype.get_mFilterFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerFilters_get_mFilterFlags_0(self), PxQueryFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerFilters.prototype['set_mFilterFlags'] = PxControllerFilters.prototype.set_mFilterFlags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerFilters_set_mFilterFlags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerFilters.prototype, 'mFilterFlags', { get: PxControllerFilters.prototype.get_mFilterFlags, set: PxControllerFilters.prototype.set_mFilterFlags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerFilters.prototype['get_mCCTFilterCallback'] = PxControllerFilters.prototype.get_mCCTFilterCallback = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerFilters_get_mCCTFilterCallback_0(self), PxControllerFilterCallback);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerFilters.prototype['set_mCCTFilterCallback'] = PxControllerFilters.prototype.set_mCCTFilterCallback = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerFilters_set_mCCTFilterCallback_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerFilters.prototype, 'mCCTFilterCallback', { get: PxControllerFilters.prototype.get_mCCTFilterCallback, set: PxControllerFilters.prototype.set_mCCTFilterCallback });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerFilters.prototype['__destroy__'] = PxControllerFilters.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxControllerFilters___destroy___0(self);
};

// Interface: PxControllerManager

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllerManager() { throw "cannot construct a PxControllerManager, no constructor in IDL" }
PxControllerManager.prototype = Object.create(WrapperObject.prototype);
PxControllerManager.prototype.constructor = PxControllerManager;
PxControllerManager.prototype.__class__ = PxControllerManager;
PxControllerManager.__cache__ = {};
Module['PxControllerManager'] = PxControllerManager;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['release'] = PxControllerManager.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxControllerManager_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['getScene'] = PxControllerManager.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerManager_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['getNbControllers'] = PxControllerManager.prototype.getNbControllers = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerManager_getNbControllers_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['getController'] = PxControllerManager.prototype.getController = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxControllerManager_getController_1(self, index), PxController);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['createController'] = PxControllerManager.prototype.createController = function(desc) {
  var self = this.ptr;
  if (desc && typeof desc === 'object') desc = desc.ptr;
  return wrapPointer(_emscripten_bind_PxControllerManager_createController_1(self, desc), PxController);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['purgeControllers'] = PxControllerManager.prototype.purgeControllers = function() {
  var self = this.ptr;
  _emscripten_bind_PxControllerManager_purgeControllers_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['getNbObstacleContexts'] = PxControllerManager.prototype.getNbObstacleContexts = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerManager_getNbObstacleContexts_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['getObstacleContext'] = PxControllerManager.prototype.getObstacleContext = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxControllerManager_getObstacleContext_1(self, index), PxObstacleContext);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['createObstacleContext'] = PxControllerManager.prototype.createObstacleContext = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerManager_createObstacleContext_0(self), PxObstacleContext);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['computeInteractions'] = PxControllerManager.prototype.computeInteractions = function(elapsedTime) {
  var self = this.ptr;
  if (elapsedTime && typeof elapsedTime === 'object') elapsedTime = elapsedTime.ptr;
  _emscripten_bind_PxControllerManager_computeInteractions_1(self, elapsedTime);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['setTessellation'] = PxControllerManager.prototype.setTessellation = function(flag, maxEdgeLength) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (maxEdgeLength && typeof maxEdgeLength === 'object') maxEdgeLength = maxEdgeLength.ptr;
  _emscripten_bind_PxControllerManager_setTessellation_2(self, flag, maxEdgeLength);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['setOverlapRecoveryModule'] = PxControllerManager.prototype.setOverlapRecoveryModule = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxControllerManager_setOverlapRecoveryModule_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['setPreciseSweeps'] = PxControllerManager.prototype.setPreciseSweeps = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxControllerManager_setPreciseSweeps_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['setPreventVerticalSlidingAgainstCeiling'] = PxControllerManager.prototype.setPreventVerticalSlidingAgainstCeiling = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxControllerManager_setPreventVerticalSlidingAgainstCeiling_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerManager.prototype['shiftOrigin'] = PxControllerManager.prototype.shiftOrigin = function(shift) {
  var self = this.ptr;
  if (shift && typeof shift === 'object') shift = shift.ptr;
  _emscripten_bind_PxControllerManager_shiftOrigin_1(self, shift);
};


// Interface: PxControllerObstacleHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllerObstacleHit() { throw "cannot construct a PxControllerObstacleHit, no constructor in IDL" }
PxControllerObstacleHit.prototype = Object.create(PxControllerHit.prototype);
PxControllerObstacleHit.prototype.constructor = PxControllerObstacleHit;
PxControllerObstacleHit.prototype.__class__ = PxControllerObstacleHit;
PxControllerObstacleHit.__cache__ = {};
Module['PxControllerObstacleHit'] = PxControllerObstacleHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerObstacleHit.prototype['get_userData'] = PxControllerObstacleHit.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerObstacleHit_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerObstacleHit.prototype['set_userData'] = PxControllerObstacleHit.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerObstacleHit_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerObstacleHit.prototype, 'userData', { get: PxControllerObstacleHit.prototype.get_userData, set: PxControllerObstacleHit.prototype.set_userData });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerObstacleHit.prototype['get_controller'] = PxControllerObstacleHit.prototype.get_controller = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerObstacleHit_get_controller_0(self), PxController);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerObstacleHit.prototype['set_controller'] = PxControllerObstacleHit.prototype.set_controller = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerObstacleHit_set_controller_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerObstacleHit.prototype, 'controller', { get: PxControllerObstacleHit.prototype.get_controller, set: PxControllerObstacleHit.prototype.set_controller });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerObstacleHit.prototype['get_worldPos'] = PxControllerObstacleHit.prototype.get_worldPos = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerObstacleHit_get_worldPos_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerObstacleHit.prototype['set_worldPos'] = PxControllerObstacleHit.prototype.set_worldPos = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerObstacleHit_set_worldPos_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerObstacleHit.prototype, 'worldPos', { get: PxControllerObstacleHit.prototype.get_worldPos, set: PxControllerObstacleHit.prototype.set_worldPos });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerObstacleHit.prototype['get_worldNormal'] = PxControllerObstacleHit.prototype.get_worldNormal = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerObstacleHit_get_worldNormal_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerObstacleHit.prototype['set_worldNormal'] = PxControllerObstacleHit.prototype.set_worldNormal = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerObstacleHit_set_worldNormal_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerObstacleHit.prototype, 'worldNormal', { get: PxControllerObstacleHit.prototype.get_worldNormal, set: PxControllerObstacleHit.prototype.set_worldNormal });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerObstacleHit.prototype['get_dir'] = PxControllerObstacleHit.prototype.get_dir = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerObstacleHit_get_dir_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerObstacleHit.prototype['set_dir'] = PxControllerObstacleHit.prototype.set_dir = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerObstacleHit_set_dir_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerObstacleHit.prototype, 'dir', { get: PxControllerObstacleHit.prototype.get_dir, set: PxControllerObstacleHit.prototype.set_dir });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerObstacleHit.prototype['get_length'] = PxControllerObstacleHit.prototype.get_length = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerObstacleHit_get_length_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerObstacleHit.prototype['set_length'] = PxControllerObstacleHit.prototype.set_length = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerObstacleHit_set_length_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerObstacleHit.prototype, 'length', { get: PxControllerObstacleHit.prototype.get_length, set: PxControllerObstacleHit.prototype.set_length });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerObstacleHit.prototype['__destroy__'] = PxControllerObstacleHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxControllerObstacleHit___destroy___0(self);
};

// Interface: PxControllerShapeHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllerShapeHit() { throw "cannot construct a PxControllerShapeHit, no constructor in IDL" }
PxControllerShapeHit.prototype = Object.create(PxControllerHit.prototype);
PxControllerShapeHit.prototype.constructor = PxControllerShapeHit;
PxControllerShapeHit.prototype.__class__ = PxControllerShapeHit;
PxControllerShapeHit.__cache__ = {};
Module['PxControllerShapeHit'] = PxControllerShapeHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['get_shape'] = PxControllerShapeHit.prototype.get_shape = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerShapeHit_get_shape_0(self), PxShape);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['set_shape'] = PxControllerShapeHit.prototype.set_shape = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerShapeHit_set_shape_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerShapeHit.prototype, 'shape', { get: PxControllerShapeHit.prototype.get_shape, set: PxControllerShapeHit.prototype.set_shape });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['get_actor'] = PxControllerShapeHit.prototype.get_actor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerShapeHit_get_actor_0(self), PxRigidActor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['set_actor'] = PxControllerShapeHit.prototype.set_actor = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerShapeHit_set_actor_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerShapeHit.prototype, 'actor', { get: PxControllerShapeHit.prototype.get_actor, set: PxControllerShapeHit.prototype.set_actor });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['get_triangleIndex'] = PxControllerShapeHit.prototype.get_triangleIndex = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerShapeHit_get_triangleIndex_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['set_triangleIndex'] = PxControllerShapeHit.prototype.set_triangleIndex = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerShapeHit_set_triangleIndex_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerShapeHit.prototype, 'triangleIndex', { get: PxControllerShapeHit.prototype.get_triangleIndex, set: PxControllerShapeHit.prototype.set_triangleIndex });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['get_controller'] = PxControllerShapeHit.prototype.get_controller = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerShapeHit_get_controller_0(self), PxController);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['set_controller'] = PxControllerShapeHit.prototype.set_controller = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerShapeHit_set_controller_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerShapeHit.prototype, 'controller', { get: PxControllerShapeHit.prototype.get_controller, set: PxControllerShapeHit.prototype.set_controller });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['get_worldPos'] = PxControllerShapeHit.prototype.get_worldPos = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerShapeHit_get_worldPos_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['set_worldPos'] = PxControllerShapeHit.prototype.set_worldPos = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerShapeHit_set_worldPos_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerShapeHit.prototype, 'worldPos', { get: PxControllerShapeHit.prototype.get_worldPos, set: PxControllerShapeHit.prototype.set_worldPos });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['get_worldNormal'] = PxControllerShapeHit.prototype.get_worldNormal = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerShapeHit_get_worldNormal_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['set_worldNormal'] = PxControllerShapeHit.prototype.set_worldNormal = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerShapeHit_set_worldNormal_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerShapeHit.prototype, 'worldNormal', { get: PxControllerShapeHit.prototype.get_worldNormal, set: PxControllerShapeHit.prototype.set_worldNormal });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['get_dir'] = PxControllerShapeHit.prototype.get_dir = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerShapeHit_get_dir_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['set_dir'] = PxControllerShapeHit.prototype.set_dir = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerShapeHit_set_dir_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerShapeHit.prototype, 'dir', { get: PxControllerShapeHit.prototype.get_dir, set: PxControllerShapeHit.prototype.set_dir });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['get_length'] = PxControllerShapeHit.prototype.get_length = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerShapeHit_get_length_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['set_length'] = PxControllerShapeHit.prototype.set_length = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerShapeHit_set_length_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerShapeHit.prototype, 'length', { get: PxControllerShapeHit.prototype.get_length, set: PxControllerShapeHit.prototype.set_length });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerShapeHit.prototype['__destroy__'] = PxControllerShapeHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxControllerShapeHit___destroy___0(self);
};

// Interface: PxControllerState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllerState() {
  this.ptr = _emscripten_bind_PxControllerState_PxControllerState_0();
  getCache(PxControllerState)[this.ptr] = this;
};

PxControllerState.prototype = Object.create(WrapperObject.prototype);
PxControllerState.prototype.constructor = PxControllerState;
PxControllerState.prototype.__class__ = PxControllerState;
PxControllerState.__cache__ = {};
Module['PxControllerState'] = PxControllerState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['get_deltaXP'] = PxControllerState.prototype.get_deltaXP = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerState_get_deltaXP_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['set_deltaXP'] = PxControllerState.prototype.set_deltaXP = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerState_set_deltaXP_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerState.prototype, 'deltaXP', { get: PxControllerState.prototype.get_deltaXP, set: PxControllerState.prototype.set_deltaXP });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['get_touchedShape'] = PxControllerState.prototype.get_touchedShape = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerState_get_touchedShape_0(self), PxShape);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['set_touchedShape'] = PxControllerState.prototype.set_touchedShape = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerState_set_touchedShape_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerState.prototype, 'touchedShape', { get: PxControllerState.prototype.get_touchedShape, set: PxControllerState.prototype.set_touchedShape });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['get_touchedActor'] = PxControllerState.prototype.get_touchedActor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllerState_get_touchedActor_0(self), PxRigidActor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['set_touchedActor'] = PxControllerState.prototype.set_touchedActor = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerState_set_touchedActor_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerState.prototype, 'touchedActor', { get: PxControllerState.prototype.get_touchedActor, set: PxControllerState.prototype.set_touchedActor });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['get_touchedObstacleHandle'] = PxControllerState.prototype.get_touchedObstacleHandle = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerState_get_touchedObstacleHandle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['set_touchedObstacleHandle'] = PxControllerState.prototype.set_touchedObstacleHandle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerState_set_touchedObstacleHandle_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerState.prototype, 'touchedObstacleHandle', { get: PxControllerState.prototype.get_touchedObstacleHandle, set: PxControllerState.prototype.set_touchedObstacleHandle });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['get_collisionFlags'] = PxControllerState.prototype.get_collisionFlags = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerState_get_collisionFlags_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['set_collisionFlags'] = PxControllerState.prototype.set_collisionFlags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerState_set_collisionFlags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerState.prototype, 'collisionFlags', { get: PxControllerState.prototype.get_collisionFlags, set: PxControllerState.prototype.set_collisionFlags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['get_standOnAnotherCCT'] = PxControllerState.prototype.get_standOnAnotherCCT = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxControllerState_get_standOnAnotherCCT_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['set_standOnAnotherCCT'] = PxControllerState.prototype.set_standOnAnotherCCT = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerState_set_standOnAnotherCCT_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerState.prototype, 'standOnAnotherCCT', { get: PxControllerState.prototype.get_standOnAnotherCCT, set: PxControllerState.prototype.set_standOnAnotherCCT });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['get_standOnObstacle'] = PxControllerState.prototype.get_standOnObstacle = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxControllerState_get_standOnObstacle_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['set_standOnObstacle'] = PxControllerState.prototype.set_standOnObstacle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerState_set_standOnObstacle_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerState.prototype, 'standOnObstacle', { get: PxControllerState.prototype.get_standOnObstacle, set: PxControllerState.prototype.set_standOnObstacle });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['get_isMovingUp'] = PxControllerState.prototype.get_isMovingUp = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxControllerState_get_isMovingUp_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['set_isMovingUp'] = PxControllerState.prototype.set_isMovingUp = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerState_set_isMovingUp_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerState.prototype, 'isMovingUp', { get: PxControllerState.prototype.get_isMovingUp, set: PxControllerState.prototype.set_isMovingUp });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerState.prototype['__destroy__'] = PxControllerState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxControllerState___destroy___0(self);
};

// Interface: PxControllerStats

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllerStats() { throw "cannot construct a PxControllerStats, no constructor in IDL" }
PxControllerStats.prototype = Object.create(WrapperObject.prototype);
PxControllerStats.prototype.constructor = PxControllerStats;
PxControllerStats.prototype.__class__ = PxControllerStats;
PxControllerStats.__cache__ = {};
Module['PxControllerStats'] = PxControllerStats;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerStats.prototype['get_nbIterations'] = PxControllerStats.prototype.get_nbIterations = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerStats_get_nbIterations_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerStats.prototype['set_nbIterations'] = PxControllerStats.prototype.set_nbIterations = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerStats_set_nbIterations_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerStats.prototype, 'nbIterations', { get: PxControllerStats.prototype.get_nbIterations, set: PxControllerStats.prototype.set_nbIterations });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerStats.prototype['get_nbFullUpdates'] = PxControllerStats.prototype.get_nbFullUpdates = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerStats_get_nbFullUpdates_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerStats.prototype['set_nbFullUpdates'] = PxControllerStats.prototype.set_nbFullUpdates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerStats_set_nbFullUpdates_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerStats.prototype, 'nbFullUpdates', { get: PxControllerStats.prototype.get_nbFullUpdates, set: PxControllerStats.prototype.set_nbFullUpdates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerStats.prototype['get_nbPartialUpdates'] = PxControllerStats.prototype.get_nbPartialUpdates = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerStats_get_nbPartialUpdates_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerStats.prototype['set_nbPartialUpdates'] = PxControllerStats.prototype.set_nbPartialUpdates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerStats_set_nbPartialUpdates_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerStats.prototype, 'nbPartialUpdates', { get: PxControllerStats.prototype.get_nbPartialUpdates, set: PxControllerStats.prototype.set_nbPartialUpdates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerStats.prototype['get_nbTessellation'] = PxControllerStats.prototype.get_nbTessellation = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllerStats_get_nbTessellation_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerStats.prototype['set_nbTessellation'] = PxControllerStats.prototype.set_nbTessellation = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllerStats_set_nbTessellation_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllerStats.prototype, 'nbTessellation', { get: PxControllerStats.prototype.get_nbTessellation, set: PxControllerStats.prototype.set_nbTessellation });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllerStats.prototype['__destroy__'] = PxControllerStats.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxControllerStats___destroy___0(self);
};

// Interface: PxControllersHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxControllersHit() { throw "cannot construct a PxControllersHit, no constructor in IDL" }
PxControllersHit.prototype = Object.create(PxControllerHit.prototype);
PxControllersHit.prototype.constructor = PxControllersHit;
PxControllersHit.prototype.__class__ = PxControllersHit;
PxControllersHit.__cache__ = {};
Module['PxControllersHit'] = PxControllersHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllersHit.prototype['get_other'] = PxControllersHit.prototype.get_other = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllersHit_get_other_0(self), PxController);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllersHit.prototype['set_other'] = PxControllersHit.prototype.set_other = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllersHit_set_other_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllersHit.prototype, 'other', { get: PxControllersHit.prototype.get_other, set: PxControllersHit.prototype.set_other });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllersHit.prototype['get_controller'] = PxControllersHit.prototype.get_controller = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllersHit_get_controller_0(self), PxController);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllersHit.prototype['set_controller'] = PxControllersHit.prototype.set_controller = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllersHit_set_controller_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllersHit.prototype, 'controller', { get: PxControllersHit.prototype.get_controller, set: PxControllersHit.prototype.set_controller });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllersHit.prototype['get_worldPos'] = PxControllersHit.prototype.get_worldPos = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllersHit_get_worldPos_0(self), PxExtendedVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllersHit.prototype['set_worldPos'] = PxControllersHit.prototype.set_worldPos = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllersHit_set_worldPos_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllersHit.prototype, 'worldPos', { get: PxControllersHit.prototype.get_worldPos, set: PxControllersHit.prototype.set_worldPos });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllersHit.prototype['get_worldNormal'] = PxControllersHit.prototype.get_worldNormal = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllersHit_get_worldNormal_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllersHit.prototype['set_worldNormal'] = PxControllersHit.prototype.set_worldNormal = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllersHit_set_worldNormal_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllersHit.prototype, 'worldNormal', { get: PxControllersHit.prototype.get_worldNormal, set: PxControllersHit.prototype.set_worldNormal });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllersHit.prototype['get_dir'] = PxControllersHit.prototype.get_dir = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxControllersHit_get_dir_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllersHit.prototype['set_dir'] = PxControllersHit.prototype.set_dir = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllersHit_set_dir_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllersHit.prototype, 'dir', { get: PxControllersHit.prototype.get_dir, set: PxControllersHit.prototype.set_dir });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllersHit.prototype['get_length'] = PxControllersHit.prototype.get_length = function() {
  var self = this.ptr;
  return _emscripten_bind_PxControllersHit_get_length_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllersHit.prototype['set_length'] = PxControllersHit.prototype.set_length = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxControllersHit_set_length_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxControllersHit.prototype, 'length', { get: PxControllersHit.prototype.get_length, set: PxControllersHit.prototype.set_length });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxControllersHit.prototype['__destroy__'] = PxControllersHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxControllersHit___destroy___0(self);
};

// Interface: PxConvexCoreBox

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConvexCoreBox(eX, eY, eZ) {
  if (eX && typeof eX === 'object') eX = eX.ptr;
  if (eY && typeof eY === 'object') eY = eY.ptr;
  if (eZ && typeof eZ === 'object') eZ = eZ.ptr;
  this.ptr = _emscripten_bind_PxConvexCoreBox_PxConvexCoreBox_3(eX, eY, eZ);
  getCache(PxConvexCoreBox)[this.ptr] = this;
};

PxConvexCoreBox.prototype = Object.create(WrapperObject.prototype);
PxConvexCoreBox.prototype.constructor = PxConvexCoreBox;
PxConvexCoreBox.prototype.__class__ = PxConvexCoreBox;
PxConvexCoreBox.__cache__ = {};
Module['PxConvexCoreBox'] = PxConvexCoreBox;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreBox.prototype['get_extents'] = PxConvexCoreBox.prototype.get_extents = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConvexCoreBox_get_extents_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreBox.prototype['set_extents'] = PxConvexCoreBox.prototype.set_extents = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConvexCoreBox_set_extents_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConvexCoreBox.prototype, 'extents', { get: PxConvexCoreBox.prototype.get_extents, set: PxConvexCoreBox.prototype.set_extents });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreBox.prototype['__destroy__'] = PxConvexCoreBox.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConvexCoreBox___destroy___0(self);
};

// Interface: PxConvexCoreCone

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConvexCoreCone(height, radius) {
  if (height && typeof height === 'object') height = height.ptr;
  if (radius && typeof radius === 'object') radius = radius.ptr;
  this.ptr = _emscripten_bind_PxConvexCoreCone_PxConvexCoreCone_2(height, radius);
  getCache(PxConvexCoreCone)[this.ptr] = this;
};

PxConvexCoreCone.prototype = Object.create(WrapperObject.prototype);
PxConvexCoreCone.prototype.constructor = PxConvexCoreCone;
PxConvexCoreCone.prototype.__class__ = PxConvexCoreCone;
PxConvexCoreCone.__cache__ = {};
Module['PxConvexCoreCone'] = PxConvexCoreCone;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreCone.prototype['get_height'] = PxConvexCoreCone.prototype.get_height = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConvexCoreCone_get_height_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreCone.prototype['set_height'] = PxConvexCoreCone.prototype.set_height = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConvexCoreCone_set_height_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConvexCoreCone.prototype, 'height', { get: PxConvexCoreCone.prototype.get_height, set: PxConvexCoreCone.prototype.set_height });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreCone.prototype['get_radius'] = PxConvexCoreCone.prototype.get_radius = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConvexCoreCone_get_radius_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreCone.prototype['set_radius'] = PxConvexCoreCone.prototype.set_radius = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConvexCoreCone_set_radius_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConvexCoreCone.prototype, 'radius', { get: PxConvexCoreCone.prototype.get_radius, set: PxConvexCoreCone.prototype.set_radius });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreCone.prototype['__destroy__'] = PxConvexCoreCone.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConvexCoreCone___destroy___0(self);
};

// Interface: PxConvexCoreCylinder

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConvexCoreCylinder(height, radius) {
  if (height && typeof height === 'object') height = height.ptr;
  if (radius && typeof radius === 'object') radius = radius.ptr;
  this.ptr = _emscripten_bind_PxConvexCoreCylinder_PxConvexCoreCylinder_2(height, radius);
  getCache(PxConvexCoreCylinder)[this.ptr] = this;
};

PxConvexCoreCylinder.prototype = Object.create(WrapperObject.prototype);
PxConvexCoreCylinder.prototype.constructor = PxConvexCoreCylinder;
PxConvexCoreCylinder.prototype.__class__ = PxConvexCoreCylinder;
PxConvexCoreCylinder.__cache__ = {};
Module['PxConvexCoreCylinder'] = PxConvexCoreCylinder;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreCylinder.prototype['get_height'] = PxConvexCoreCylinder.prototype.get_height = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConvexCoreCylinder_get_height_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreCylinder.prototype['set_height'] = PxConvexCoreCylinder.prototype.set_height = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConvexCoreCylinder_set_height_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConvexCoreCylinder.prototype, 'height', { get: PxConvexCoreCylinder.prototype.get_height, set: PxConvexCoreCylinder.prototype.set_height });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreCylinder.prototype['get_radius'] = PxConvexCoreCylinder.prototype.get_radius = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConvexCoreCylinder_get_radius_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreCylinder.prototype['set_radius'] = PxConvexCoreCylinder.prototype.set_radius = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConvexCoreCylinder_set_radius_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConvexCoreCylinder.prototype, 'radius', { get: PxConvexCoreCylinder.prototype.get_radius, set: PxConvexCoreCylinder.prototype.set_radius });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreCylinder.prototype['__destroy__'] = PxConvexCoreCylinder.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConvexCoreCylinder___destroy___0(self);
};

// Interface: PxConvexCoreEllipsoid

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConvexCoreEllipsoid(rX, rY, rZ) {
  if (rX && typeof rX === 'object') rX = rX.ptr;
  if (rY && typeof rY === 'object') rY = rY.ptr;
  if (rZ && typeof rZ === 'object') rZ = rZ.ptr;
  this.ptr = _emscripten_bind_PxConvexCoreEllipsoid_PxConvexCoreEllipsoid_3(rX, rY, rZ);
  getCache(PxConvexCoreEllipsoid)[this.ptr] = this;
};

PxConvexCoreEllipsoid.prototype = Object.create(WrapperObject.prototype);
PxConvexCoreEllipsoid.prototype.constructor = PxConvexCoreEllipsoid;
PxConvexCoreEllipsoid.prototype.__class__ = PxConvexCoreEllipsoid;
PxConvexCoreEllipsoid.__cache__ = {};
Module['PxConvexCoreEllipsoid'] = PxConvexCoreEllipsoid;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreEllipsoid.prototype['get_radii'] = PxConvexCoreEllipsoid.prototype.get_radii = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConvexCoreEllipsoid_get_radii_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreEllipsoid.prototype['set_radii'] = PxConvexCoreEllipsoid.prototype.set_radii = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConvexCoreEllipsoid_set_radii_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConvexCoreEllipsoid.prototype, 'radii', { get: PxConvexCoreEllipsoid.prototype.get_radii, set: PxConvexCoreEllipsoid.prototype.set_radii });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreEllipsoid.prototype['__destroy__'] = PxConvexCoreEllipsoid.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConvexCoreEllipsoid___destroy___0(self);
};

// Interface: PxConvexCoreGeometry

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConvexCoreGeometry() { throw "cannot construct a PxConvexCoreGeometry, no constructor in IDL" }
PxConvexCoreGeometry.prototype = Object.create(PxGeometry.prototype);
PxConvexCoreGeometry.prototype.constructor = PxConvexCoreGeometry;
PxConvexCoreGeometry.prototype.__class__ = PxConvexCoreGeometry;
PxConvexCoreGeometry.__cache__ = {};
Module['PxConvexCoreGeometry'] = PxConvexCoreGeometry;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreGeometry.prototype['getCoreType'] = PxConvexCoreGeometry.prototype.getCoreType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConvexCoreGeometry_getCoreType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreGeometry.prototype['getCoreData'] = PxConvexCoreGeometry.prototype.getCoreData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConvexCoreGeometry_getCoreData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreGeometry.prototype['getMargin'] = PxConvexCoreGeometry.prototype.getMargin = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConvexCoreGeometry_getMargin_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreGeometry.prototype['isValid'] = PxConvexCoreGeometry.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxConvexCoreGeometry_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreGeometry.prototype['getType'] = PxConvexCoreGeometry.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConvexCoreGeometry_getType_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreGeometry.prototype['__destroy__'] = PxConvexCoreGeometry.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConvexCoreGeometry___destroy___0(self);
};

// Interface: PxConvexCoreGeometryFactory

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConvexCoreGeometryFactory() { throw "cannot construct a PxConvexCoreGeometryFactory, no constructor in IDL" }
PxConvexCoreGeometryFactory.prototype = Object.create(WrapperObject.prototype);
PxConvexCoreGeometryFactory.prototype.constructor = PxConvexCoreGeometryFactory;
PxConvexCoreGeometryFactory.prototype.__class__ = PxConvexCoreGeometryFactory;
PxConvexCoreGeometryFactory.__cache__ = {};
Module['PxConvexCoreGeometryFactory'] = PxConvexCoreGeometryFactory;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreGeometryFactory.prototype['createFromBox'] = PxConvexCoreGeometryFactory.prototype.createFromBox = function(box, margin) {
  if (box && typeof box === 'object') box = box.ptr;
  if (margin && typeof margin === 'object') margin = margin.ptr;
  return wrapPointer(_emscripten_bind_PxConvexCoreGeometryFactory_createFromBox_2(box, margin), PxConvexCoreGeometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreGeometryFactory.prototype['createFromCone'] = PxConvexCoreGeometryFactory.prototype.createFromCone = function(cone, margin) {
  if (cone && typeof cone === 'object') cone = cone.ptr;
  if (margin && typeof margin === 'object') margin = margin.ptr;
  return wrapPointer(_emscripten_bind_PxConvexCoreGeometryFactory_createFromCone_2(cone, margin), PxConvexCoreGeometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreGeometryFactory.prototype['createFromCylinder'] = PxConvexCoreGeometryFactory.prototype.createFromCylinder = function(cylinder, margin) {
  if (cylinder && typeof cylinder === 'object') cylinder = cylinder.ptr;
  if (margin && typeof margin === 'object') margin = margin.ptr;
  return wrapPointer(_emscripten_bind_PxConvexCoreGeometryFactory_createFromCylinder_2(cylinder, margin), PxConvexCoreGeometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreGeometryFactory.prototype['createFromEllipsoid'] = PxConvexCoreGeometryFactory.prototype.createFromEllipsoid = function(ellipsoid, margin) {
  if (ellipsoid && typeof ellipsoid === 'object') ellipsoid = ellipsoid.ptr;
  if (margin && typeof margin === 'object') margin = margin.ptr;
  return wrapPointer(_emscripten_bind_PxConvexCoreGeometryFactory_createFromEllipsoid_2(ellipsoid, margin), PxConvexCoreGeometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreGeometryFactory.prototype['createFromPoint'] = PxConvexCoreGeometryFactory.prototype.createFromPoint = function(point, margin) {
  if (point && typeof point === 'object') point = point.ptr;
  if (margin && typeof margin === 'object') margin = margin.ptr;
  return wrapPointer(_emscripten_bind_PxConvexCoreGeometryFactory_createFromPoint_2(point, margin), PxConvexCoreGeometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreGeometryFactory.prototype['createFromSegment'] = PxConvexCoreGeometryFactory.prototype.createFromSegment = function(segment, margin) {
  if (segment && typeof segment === 'object') segment = segment.ptr;
  if (margin && typeof margin === 'object') margin = margin.ptr;
  return wrapPointer(_emscripten_bind_PxConvexCoreGeometryFactory_createFromSegment_2(segment, margin), PxConvexCoreGeometry);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreGeometryFactory.prototype['__destroy__'] = PxConvexCoreGeometryFactory.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConvexCoreGeometryFactory___destroy___0(self);
};

// Interface: PxConvexCorePoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConvexCorePoint() {
  this.ptr = _emscripten_bind_PxConvexCorePoint_PxConvexCorePoint_0();
  getCache(PxConvexCorePoint)[this.ptr] = this;
};

PxConvexCorePoint.prototype = Object.create(WrapperObject.prototype);
PxConvexCorePoint.prototype.constructor = PxConvexCorePoint;
PxConvexCorePoint.prototype.__class__ = PxConvexCorePoint;
PxConvexCorePoint.__cache__ = {};
Module['PxConvexCorePoint'] = PxConvexCorePoint;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCorePoint.prototype['__destroy__'] = PxConvexCorePoint.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConvexCorePoint___destroy___0(self);
};

// Interface: PxConvexCoreSegment

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConvexCoreSegment(length) {
  if (length && typeof length === 'object') length = length.ptr;
  this.ptr = _emscripten_bind_PxConvexCoreSegment_PxConvexCoreSegment_1(length);
  getCache(PxConvexCoreSegment)[this.ptr] = this;
};

PxConvexCoreSegment.prototype = Object.create(WrapperObject.prototype);
PxConvexCoreSegment.prototype.constructor = PxConvexCoreSegment;
PxConvexCoreSegment.prototype.__class__ = PxConvexCoreSegment;
PxConvexCoreSegment.__cache__ = {};
Module['PxConvexCoreSegment'] = PxConvexCoreSegment;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreSegment.prototype['get_length'] = PxConvexCoreSegment.prototype.get_length = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConvexCoreSegment_get_length_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreSegment.prototype['set_length'] = PxConvexCoreSegment.prototype.set_length = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConvexCoreSegment_set_length_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConvexCoreSegment.prototype, 'length', { get: PxConvexCoreSegment.prototype.get_length, set: PxConvexCoreSegment.prototype.set_length });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexCoreSegment.prototype['__destroy__'] = PxConvexCoreSegment.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConvexCoreSegment___destroy___0(self);
};

// Interface: PxConvexFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConvexFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxConvexFlags_PxConvexFlags_1(flags);
  getCache(PxConvexFlags)[this.ptr] = this;
};

PxConvexFlags.prototype = Object.create(WrapperObject.prototype);
PxConvexFlags.prototype.constructor = PxConvexFlags;
PxConvexFlags.prototype.__class__ = PxConvexFlags;
PxConvexFlags.__cache__ = {};
Module['PxConvexFlags'] = PxConvexFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexFlags.prototype['isSet'] = PxConvexFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxConvexFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexFlags.prototype['raise'] = PxConvexFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxConvexFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexFlags.prototype['clear'] = PxConvexFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxConvexFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexFlags.prototype['__destroy__'] = PxConvexFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConvexFlags___destroy___0(self);
};

// Interface: PxConvexMesh

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConvexMesh() { throw "cannot construct a PxConvexMesh, no constructor in IDL" }
PxConvexMesh.prototype = Object.create(PxRefCounted.prototype);
PxConvexMesh.prototype.constructor = PxConvexMesh;
PxConvexMesh.prototype.__class__ = PxConvexMesh;
PxConvexMesh.__cache__ = {};
Module['PxConvexMesh'] = PxConvexMesh;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['getNbVertices'] = PxConvexMesh.prototype.getNbVertices = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConvexMesh_getNbVertices_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['getVertices'] = PxConvexMesh.prototype.getVertices = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConvexMesh_getVertices_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['getIndexBuffer'] = PxConvexMesh.prototype.getIndexBuffer = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConvexMesh_getIndexBuffer_0(self), PxU8ConstPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['getNbPolygons'] = PxConvexMesh.prototype.getNbPolygons = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConvexMesh_getNbPolygons_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['getPolygonData'] = PxConvexMesh.prototype.getPolygonData = function(index, data) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (data && typeof data === 'object') data = data.ptr;
  return !!(_emscripten_bind_PxConvexMesh_getPolygonData_2(self, index, data));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['getLocalBounds'] = PxConvexMesh.prototype.getLocalBounds = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConvexMesh_getLocalBounds_0(self), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['isGpuCompatible'] = PxConvexMesh.prototype.isGpuCompatible = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxConvexMesh_isGpuCompatible_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['release'] = PxConvexMesh.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxConvexMesh_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['getConcreteTypeName'] = PxConvexMesh.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxConvexMesh_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['getConcreteType'] = PxConvexMesh.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConvexMesh_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['setBaseFlag'] = PxConvexMesh.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxConvexMesh_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['setBaseFlags'] = PxConvexMesh.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxConvexMesh_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['getBaseFlags'] = PxConvexMesh.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConvexMesh_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['isReleasable'] = PxConvexMesh.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxConvexMesh_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['getReferenceCount'] = PxConvexMesh.prototype.getReferenceCount = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConvexMesh_getReferenceCount_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMesh.prototype['acquireReference'] = PxConvexMesh.prototype.acquireReference = function() {
  var self = this.ptr;
  _emscripten_bind_PxConvexMesh_acquireReference_0(self);
};


// Interface: PxConvexMeshDesc

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConvexMeshDesc() {
  this.ptr = _emscripten_bind_PxConvexMeshDesc_PxConvexMeshDesc_0();
  getCache(PxConvexMeshDesc)[this.ptr] = this;
};

PxConvexMeshDesc.prototype = Object.create(WrapperObject.prototype);
PxConvexMeshDesc.prototype.constructor = PxConvexMeshDesc;
PxConvexMeshDesc.prototype.__class__ = PxConvexMeshDesc;
PxConvexMeshDesc.__cache__ = {};
Module['PxConvexMeshDesc'] = PxConvexMeshDesc;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshDesc.prototype['get_points'] = PxConvexMeshDesc.prototype.get_points = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConvexMeshDesc_get_points_0(self), PxBoundedData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshDesc.prototype['set_points'] = PxConvexMeshDesc.prototype.set_points = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConvexMeshDesc_set_points_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConvexMeshDesc.prototype, 'points', { get: PxConvexMeshDesc.prototype.get_points, set: PxConvexMeshDesc.prototype.set_points });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshDesc.prototype['get_flags'] = PxConvexMeshDesc.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConvexMeshDesc_get_flags_0(self), PxConvexFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshDesc.prototype['set_flags'] = PxConvexMeshDesc.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConvexMeshDesc_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConvexMeshDesc.prototype, 'flags', { get: PxConvexMeshDesc.prototype.get_flags, set: PxConvexMeshDesc.prototype.set_flags });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshDesc.prototype['__destroy__'] = PxConvexMeshDesc.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConvexMeshDesc___destroy___0(self);
};

// Interface: PxConvexMeshGeometry

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConvexMeshGeometry(mesh, scaling, flags) {
  if (mesh && typeof mesh === 'object') mesh = mesh.ptr;
  if (scaling && typeof scaling === 'object') scaling = scaling.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  if (scaling === undefined) { this.ptr = _emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_1(mesh); getCache(PxConvexMeshGeometry)[this.ptr] = this;return }
  if (flags === undefined) { this.ptr = _emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_2(mesh, scaling); getCache(PxConvexMeshGeometry)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxConvexMeshGeometry_PxConvexMeshGeometry_3(mesh, scaling, flags);
  getCache(PxConvexMeshGeometry)[this.ptr] = this;
};

PxConvexMeshGeometry.prototype = Object.create(PxGeometry.prototype);
PxConvexMeshGeometry.prototype.constructor = PxConvexMeshGeometry;
PxConvexMeshGeometry.prototype.__class__ = PxConvexMeshGeometry;
PxConvexMeshGeometry.__cache__ = {};
Module['PxConvexMeshGeometry'] = PxConvexMeshGeometry;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshGeometry.prototype['getType'] = PxConvexMeshGeometry.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxConvexMeshGeometry_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshGeometry.prototype['get_scale'] = PxConvexMeshGeometry.prototype.get_scale = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConvexMeshGeometry_get_scale_0(self), PxMeshScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshGeometry.prototype['set_scale'] = PxConvexMeshGeometry.prototype.set_scale = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConvexMeshGeometry_set_scale_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConvexMeshGeometry.prototype, 'scale', { get: PxConvexMeshGeometry.prototype.get_scale, set: PxConvexMeshGeometry.prototype.set_scale });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshGeometry.prototype['get_convexMesh'] = PxConvexMeshGeometry.prototype.get_convexMesh = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConvexMeshGeometry_get_convexMesh_0(self), PxConvexMesh);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshGeometry.prototype['set_convexMesh'] = PxConvexMeshGeometry.prototype.set_convexMesh = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConvexMeshGeometry_set_convexMesh_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConvexMeshGeometry.prototype, 'convexMesh', { get: PxConvexMeshGeometry.prototype.get_convexMesh, set: PxConvexMeshGeometry.prototype.set_convexMesh });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshGeometry.prototype['get_meshFlags'] = PxConvexMeshGeometry.prototype.get_meshFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxConvexMeshGeometry_get_meshFlags_0(self), PxConvexMeshGeometryFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshGeometry.prototype['set_meshFlags'] = PxConvexMeshGeometry.prototype.set_meshFlags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxConvexMeshGeometry_set_meshFlags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxConvexMeshGeometry.prototype, 'meshFlags', { get: PxConvexMeshGeometry.prototype.get_meshFlags, set: PxConvexMeshGeometry.prototype.set_meshFlags });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshGeometry.prototype['__destroy__'] = PxConvexMeshGeometry.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConvexMeshGeometry___destroy___0(self);
};

// Interface: PxConvexMeshGeometryFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxConvexMeshGeometryFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxConvexMeshGeometryFlags_PxConvexMeshGeometryFlags_1(flags);
  getCache(PxConvexMeshGeometryFlags)[this.ptr] = this;
};

PxConvexMeshGeometryFlags.prototype = Object.create(WrapperObject.prototype);
PxConvexMeshGeometryFlags.prototype.constructor = PxConvexMeshGeometryFlags;
PxConvexMeshGeometryFlags.prototype.__class__ = PxConvexMeshGeometryFlags;
PxConvexMeshGeometryFlags.__cache__ = {};
Module['PxConvexMeshGeometryFlags'] = PxConvexMeshGeometryFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshGeometryFlags.prototype['isSet'] = PxConvexMeshGeometryFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxConvexMeshGeometryFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshGeometryFlags.prototype['raise'] = PxConvexMeshGeometryFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxConvexMeshGeometryFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshGeometryFlags.prototype['clear'] = PxConvexMeshGeometryFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxConvexMeshGeometryFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxConvexMeshGeometryFlags.prototype['__destroy__'] = PxConvexMeshGeometryFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxConvexMeshGeometryFlags___destroy___0(self);
};

// Interface: PxCookingParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxCookingParams(sc) {
  if (sc && typeof sc === 'object') sc = sc.ptr;
  this.ptr = _emscripten_bind_PxCookingParams_PxCookingParams_1(sc);
  getCache(PxCookingParams)[this.ptr] = this;
};

PxCookingParams.prototype = Object.create(WrapperObject.prototype);
PxCookingParams.prototype.constructor = PxCookingParams;
PxCookingParams.prototype.__class__ = PxCookingParams;
PxCookingParams.__cache__ = {};
Module['PxCookingParams'] = PxCookingParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['get_areaTestEpsilon'] = PxCookingParams.prototype.get_areaTestEpsilon = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCookingParams_get_areaTestEpsilon_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['set_areaTestEpsilon'] = PxCookingParams.prototype.set_areaTestEpsilon = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCookingParams_set_areaTestEpsilon_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCookingParams.prototype, 'areaTestEpsilon', { get: PxCookingParams.prototype.get_areaTestEpsilon, set: PxCookingParams.prototype.set_areaTestEpsilon });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['get_planeTolerance'] = PxCookingParams.prototype.get_planeTolerance = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCookingParams_get_planeTolerance_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['set_planeTolerance'] = PxCookingParams.prototype.set_planeTolerance = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCookingParams_set_planeTolerance_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCookingParams.prototype, 'planeTolerance', { get: PxCookingParams.prototype.get_planeTolerance, set: PxCookingParams.prototype.set_planeTolerance });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['get_convexMeshCookingType'] = PxCookingParams.prototype.get_convexMeshCookingType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCookingParams_get_convexMeshCookingType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['set_convexMeshCookingType'] = PxCookingParams.prototype.set_convexMeshCookingType = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCookingParams_set_convexMeshCookingType_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCookingParams.prototype, 'convexMeshCookingType', { get: PxCookingParams.prototype.get_convexMeshCookingType, set: PxCookingParams.prototype.set_convexMeshCookingType });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['get_suppressTriangleMeshRemapTable'] = PxCookingParams.prototype.get_suppressTriangleMeshRemapTable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxCookingParams_get_suppressTriangleMeshRemapTable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['set_suppressTriangleMeshRemapTable'] = PxCookingParams.prototype.set_suppressTriangleMeshRemapTable = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCookingParams_set_suppressTriangleMeshRemapTable_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCookingParams.prototype, 'suppressTriangleMeshRemapTable', { get: PxCookingParams.prototype.get_suppressTriangleMeshRemapTable, set: PxCookingParams.prototype.set_suppressTriangleMeshRemapTable });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['get_buildTriangleAdjacencies'] = PxCookingParams.prototype.get_buildTriangleAdjacencies = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxCookingParams_get_buildTriangleAdjacencies_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['set_buildTriangleAdjacencies'] = PxCookingParams.prototype.set_buildTriangleAdjacencies = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCookingParams_set_buildTriangleAdjacencies_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCookingParams.prototype, 'buildTriangleAdjacencies', { get: PxCookingParams.prototype.get_buildTriangleAdjacencies, set: PxCookingParams.prototype.set_buildTriangleAdjacencies });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['get_buildGPUData'] = PxCookingParams.prototype.get_buildGPUData = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxCookingParams_get_buildGPUData_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['set_buildGPUData'] = PxCookingParams.prototype.set_buildGPUData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCookingParams_set_buildGPUData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCookingParams.prototype, 'buildGPUData', { get: PxCookingParams.prototype.get_buildGPUData, set: PxCookingParams.prototype.set_buildGPUData });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['get_scale'] = PxCookingParams.prototype.get_scale = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCookingParams_get_scale_0(self), PxTolerancesScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['set_scale'] = PxCookingParams.prototype.set_scale = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCookingParams_set_scale_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCookingParams.prototype, 'scale', { get: PxCookingParams.prototype.get_scale, set: PxCookingParams.prototype.set_scale });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['get_meshPreprocessParams'] = PxCookingParams.prototype.get_meshPreprocessParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCookingParams_get_meshPreprocessParams_0(self), PxMeshPreprocessingFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['set_meshPreprocessParams'] = PxCookingParams.prototype.set_meshPreprocessParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCookingParams_set_meshPreprocessParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCookingParams.prototype, 'meshPreprocessParams', { get: PxCookingParams.prototype.get_meshPreprocessParams, set: PxCookingParams.prototype.set_meshPreprocessParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['get_meshWeldTolerance'] = PxCookingParams.prototype.get_meshWeldTolerance = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCookingParams_get_meshWeldTolerance_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['set_meshWeldTolerance'] = PxCookingParams.prototype.set_meshWeldTolerance = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCookingParams_set_meshWeldTolerance_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCookingParams.prototype, 'meshWeldTolerance', { get: PxCookingParams.prototype.get_meshWeldTolerance, set: PxCookingParams.prototype.set_meshWeldTolerance });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['get_midphaseDesc'] = PxCookingParams.prototype.get_midphaseDesc = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxCookingParams_get_midphaseDesc_0(self), PxMidphaseDesc);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['set_midphaseDesc'] = PxCookingParams.prototype.set_midphaseDesc = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCookingParams_set_midphaseDesc_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCookingParams.prototype, 'midphaseDesc', { get: PxCookingParams.prototype.get_midphaseDesc, set: PxCookingParams.prototype.set_midphaseDesc });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['get_gaussMapLimit'] = PxCookingParams.prototype.get_gaussMapLimit = function() {
  var self = this.ptr;
  return _emscripten_bind_PxCookingParams_get_gaussMapLimit_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['set_gaussMapLimit'] = PxCookingParams.prototype.set_gaussMapLimit = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxCookingParams_set_gaussMapLimit_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxCookingParams.prototype, 'gaussMapLimit', { get: PxCookingParams.prototype.get_gaussMapLimit, set: PxCookingParams.prototype.set_gaussMapLimit });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxCookingParams.prototype['__destroy__'] = PxCookingParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxCookingParams___destroy___0(self);
};

// Interface: PxD6Joint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxD6Joint() { throw "cannot construct a PxD6Joint, no constructor in IDL" }
PxD6Joint.prototype = Object.create(PxJoint.prototype);
PxD6Joint.prototype.constructor = PxD6Joint;
PxD6Joint.prototype.__class__ = PxD6Joint;
PxD6Joint.__cache__ = {};
Module['PxD6Joint'] = PxD6Joint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setMotion'] = PxD6Joint.prototype.setMotion = function(axis, type) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  if (type && typeof type === 'object') type = type.ptr;
  _emscripten_bind_PxD6Joint_setMotion_2(self, axis, type);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getMotion'] = PxD6Joint.prototype.getMotion = function(axis) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  return _emscripten_bind_PxD6Joint_getMotion_1(self, axis);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getTwistAngle'] = PxD6Joint.prototype.getTwistAngle = function() {
  var self = this.ptr;
  return _emscripten_bind_PxD6Joint_getTwistAngle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getSwingYAngle'] = PxD6Joint.prototype.getSwingYAngle = function() {
  var self = this.ptr;
  return _emscripten_bind_PxD6Joint_getSwingYAngle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getSwingZAngle'] = PxD6Joint.prototype.getSwingZAngle = function() {
  var self = this.ptr;
  return _emscripten_bind_PxD6Joint_getSwingZAngle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setDistanceLimit'] = PxD6Joint.prototype.setDistanceLimit = function(limit) {
  var self = this.ptr;
  if (limit && typeof limit === 'object') limit = limit.ptr;
  _emscripten_bind_PxD6Joint_setDistanceLimit_1(self, limit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setLinearLimit'] = PxD6Joint.prototype.setLinearLimit = function(axis, limit) {
  var self = this.ptr;
  if (axis && typeof axis === 'object') axis = axis.ptr;
  if (limit && typeof limit === 'object') limit = limit.ptr;
  _emscripten_bind_PxD6Joint_setLinearLimit_2(self, axis, limit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setTwistLimit'] = PxD6Joint.prototype.setTwistLimit = function(limit) {
  var self = this.ptr;
  if (limit && typeof limit === 'object') limit = limit.ptr;
  _emscripten_bind_PxD6Joint_setTwistLimit_1(self, limit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setSwingLimit'] = PxD6Joint.prototype.setSwingLimit = function(limit) {
  var self = this.ptr;
  if (limit && typeof limit === 'object') limit = limit.ptr;
  _emscripten_bind_PxD6Joint_setSwingLimit_1(self, limit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setPyramidSwingLimit'] = PxD6Joint.prototype.setPyramidSwingLimit = function(limit) {
  var self = this.ptr;
  if (limit && typeof limit === 'object') limit = limit.ptr;
  _emscripten_bind_PxD6Joint_setPyramidSwingLimit_1(self, limit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setDrive'] = PxD6Joint.prototype.setDrive = function(index, drive) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  if (drive && typeof drive === 'object') drive = drive.ptr;
  _emscripten_bind_PxD6Joint_setDrive_2(self, index, drive);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getDrive'] = PxD6Joint.prototype.getDrive = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxD6Joint_getDrive_1(self, index), PxD6JointDrive);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setDrivePosition'] = PxD6Joint.prototype.setDrivePosition = function(pose, autowake) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxD6Joint_setDrivePosition_1(self, pose); return }
  _emscripten_bind_PxD6Joint_setDrivePosition_2(self, pose, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getDrivePosition'] = PxD6Joint.prototype.getDrivePosition = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxD6Joint_getDrivePosition_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setDriveVelocity'] = PxD6Joint.prototype.setDriveVelocity = function(linear, angular) {
  var self = this.ptr;
  if (linear && typeof linear === 'object') linear = linear.ptr;
  if (angular && typeof angular === 'object') angular = angular.ptr;
  _emscripten_bind_PxD6Joint_setDriveVelocity_2(self, linear, angular);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getDriveVelocity'] = PxD6Joint.prototype.getDriveVelocity = function(linear, angular) {
  var self = this.ptr;
  if (linear && typeof linear === 'object') linear = linear.ptr;
  if (angular && typeof angular === 'object') angular = angular.ptr;
  _emscripten_bind_PxD6Joint_getDriveVelocity_2(self, linear, angular);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setAngularDriveConfig'] = PxD6Joint.prototype.setAngularDriveConfig = function(config) {
  var self = this.ptr;
  if (config && typeof config === 'object') config = config.ptr;
  _emscripten_bind_PxD6Joint_setAngularDriveConfig_1(self, config);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getAngularDriveConfig'] = PxD6Joint.prototype.getAngularDriveConfig = function() {
  var self = this.ptr;
  return _emscripten_bind_PxD6Joint_getAngularDriveConfig_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['release'] = PxD6Joint.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxD6Joint_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getConcreteTypeName'] = PxD6Joint.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxD6Joint_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getConcreteType'] = PxD6Joint.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxD6Joint_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setBaseFlag'] = PxD6Joint.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxD6Joint_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setBaseFlags'] = PxD6Joint.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxD6Joint_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getBaseFlags'] = PxD6Joint.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxD6Joint_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['isReleasable'] = PxD6Joint.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxD6Joint_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setActors'] = PxD6Joint.prototype.setActors = function(actor0, actor1) {
  var self = this.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  _emscripten_bind_PxD6Joint_setActors_2(self, actor0, actor1);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setLocalPose'] = PxD6Joint.prototype.setLocalPose = function(actor, localPose) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (localPose && typeof localPose === 'object') localPose = localPose.ptr;
  _emscripten_bind_PxD6Joint_setLocalPose_2(self, actor, localPose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getLocalPose'] = PxD6Joint.prototype.getLocalPose = function(actor) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return wrapPointer(_emscripten_bind_PxD6Joint_getLocalPose_1(self, actor), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getRelativeTransform'] = PxD6Joint.prototype.getRelativeTransform = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxD6Joint_getRelativeTransform_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getRelativeLinearVelocity'] = PxD6Joint.prototype.getRelativeLinearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxD6Joint_getRelativeLinearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getRelativeAngularVelocity'] = PxD6Joint.prototype.getRelativeAngularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxD6Joint_getRelativeAngularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setBreakForce'] = PxD6Joint.prototype.setBreakForce = function(force, torque) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  _emscripten_bind_PxD6Joint_setBreakForce_2(self, force, torque);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setConstraintFlags'] = PxD6Joint.prototype.setConstraintFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxD6Joint_setConstraintFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setConstraintFlag'] = PxD6Joint.prototype.setConstraintFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxD6Joint_setConstraintFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getConstraintFlags'] = PxD6Joint.prototype.getConstraintFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxD6Joint_getConstraintFlags_0(self), PxConstraintFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setInvMassScale0'] = PxD6Joint.prototype.setInvMassScale0 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxD6Joint_setInvMassScale0_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getInvMassScale0'] = PxD6Joint.prototype.getInvMassScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxD6Joint_getInvMassScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setInvMassScale1'] = PxD6Joint.prototype.setInvMassScale1 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxD6Joint_setInvMassScale1_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getInvMassScale1'] = PxD6Joint.prototype.getInvMassScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxD6Joint_getInvMassScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setInvInertiaScale0'] = PxD6Joint.prototype.setInvInertiaScale0 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxD6Joint_setInvInertiaScale0_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getInvInertiaScale0'] = PxD6Joint.prototype.getInvInertiaScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxD6Joint_getInvInertiaScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setInvInertiaScale1'] = PxD6Joint.prototype.setInvInertiaScale1 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxD6Joint_setInvInertiaScale1_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getInvInertiaScale1'] = PxD6Joint.prototype.getInvInertiaScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxD6Joint_getInvInertiaScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getConstraint'] = PxD6Joint.prototype.getConstraint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxD6Joint_getConstraint_0(self), PxConstraint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['setName'] = PxD6Joint.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxD6Joint_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getName'] = PxD6Joint.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxD6Joint_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['getScene'] = PxD6Joint.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxD6Joint_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['get_userData'] = PxD6Joint.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxD6Joint_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['set_userData'] = PxD6Joint.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxD6Joint_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxD6Joint.prototype, 'userData', { get: PxD6Joint.prototype.get_userData, set: PxD6Joint.prototype.set_userData });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6Joint.prototype['__destroy__'] = PxD6Joint.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxD6Joint___destroy___0(self);
};

// Interface: PxD6JointDrive

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxD6JointDrive(driveStiffness, driveDamping, driveForceLimit, isAcceleration) {
  if (driveStiffness && typeof driveStiffness === 'object') driveStiffness = driveStiffness.ptr;
  if (driveDamping && typeof driveDamping === 'object') driveDamping = driveDamping.ptr;
  if (driveForceLimit && typeof driveForceLimit === 'object') driveForceLimit = driveForceLimit.ptr;
  if (isAcceleration && typeof isAcceleration === 'object') isAcceleration = isAcceleration.ptr;
  if (driveStiffness === undefined) { this.ptr = _emscripten_bind_PxD6JointDrive_PxD6JointDrive_0(); getCache(PxD6JointDrive)[this.ptr] = this;return }
  if (driveDamping === undefined) { this.ptr = _emscripten_bind_PxD6JointDrive_PxD6JointDrive_1(driveStiffness); getCache(PxD6JointDrive)[this.ptr] = this;return }
  if (driveForceLimit === undefined) { this.ptr = _emscripten_bind_PxD6JointDrive_PxD6JointDrive_2(driveStiffness, driveDamping); getCache(PxD6JointDrive)[this.ptr] = this;return }
  if (isAcceleration === undefined) { this.ptr = _emscripten_bind_PxD6JointDrive_PxD6JointDrive_3(driveStiffness, driveDamping, driveForceLimit); getCache(PxD6JointDrive)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxD6JointDrive_PxD6JointDrive_4(driveStiffness, driveDamping, driveForceLimit, isAcceleration);
  getCache(PxD6JointDrive)[this.ptr] = this;
};

PxD6JointDrive.prototype = Object.create(PxSpring.prototype);
PxD6JointDrive.prototype.constructor = PxD6JointDrive;
PxD6JointDrive.prototype.__class__ = PxD6JointDrive;
PxD6JointDrive.__cache__ = {};
Module['PxD6JointDrive'] = PxD6JointDrive;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6JointDrive.prototype['get_forceLimit'] = PxD6JointDrive.prototype.get_forceLimit = function() {
  var self = this.ptr;
  return _emscripten_bind_PxD6JointDrive_get_forceLimit_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6JointDrive.prototype['set_forceLimit'] = PxD6JointDrive.prototype.set_forceLimit = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxD6JointDrive_set_forceLimit_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxD6JointDrive.prototype, 'forceLimit', { get: PxD6JointDrive.prototype.get_forceLimit, set: PxD6JointDrive.prototype.set_forceLimit });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6JointDrive.prototype['get_flags'] = PxD6JointDrive.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxD6JointDrive_get_flags_0(self), PxD6JointDriveFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6JointDrive.prototype['set_flags'] = PxD6JointDrive.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxD6JointDrive_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxD6JointDrive.prototype, 'flags', { get: PxD6JointDrive.prototype.get_flags, set: PxD6JointDrive.prototype.set_flags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6JointDrive.prototype['get_stiffness'] = PxD6JointDrive.prototype.get_stiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxD6JointDrive_get_stiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6JointDrive.prototype['set_stiffness'] = PxD6JointDrive.prototype.set_stiffness = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxD6JointDrive_set_stiffness_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxD6JointDrive.prototype, 'stiffness', { get: PxD6JointDrive.prototype.get_stiffness, set: PxD6JointDrive.prototype.set_stiffness });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6JointDrive.prototype['get_damping'] = PxD6JointDrive.prototype.get_damping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxD6JointDrive_get_damping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6JointDrive.prototype['set_damping'] = PxD6JointDrive.prototype.set_damping = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxD6JointDrive_set_damping_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxD6JointDrive.prototype, 'damping', { get: PxD6JointDrive.prototype.get_damping, set: PxD6JointDrive.prototype.set_damping });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6JointDrive.prototype['__destroy__'] = PxD6JointDrive.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxD6JointDrive___destroy___0(self);
};

// Interface: PxD6JointDriveFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxD6JointDriveFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxD6JointDriveFlags_PxD6JointDriveFlags_1(flags);
  getCache(PxD6JointDriveFlags)[this.ptr] = this;
};

PxD6JointDriveFlags.prototype = Object.create(WrapperObject.prototype);
PxD6JointDriveFlags.prototype.constructor = PxD6JointDriveFlags;
PxD6JointDriveFlags.prototype.__class__ = PxD6JointDriveFlags;
PxD6JointDriveFlags.__cache__ = {};
Module['PxD6JointDriveFlags'] = PxD6JointDriveFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6JointDriveFlags.prototype['isSet'] = PxD6JointDriveFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxD6JointDriveFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6JointDriveFlags.prototype['raise'] = PxD6JointDriveFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxD6JointDriveFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6JointDriveFlags.prototype['clear'] = PxD6JointDriveFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxD6JointDriveFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxD6JointDriveFlags.prototype['__destroy__'] = PxD6JointDriveFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxD6JointDriveFlags___destroy___0(self);
};

// Interface: PxDebugLine

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxDebugLine() { throw "cannot construct a PxDebugLine, no constructor in IDL" }
PxDebugLine.prototype = Object.create(WrapperObject.prototype);
PxDebugLine.prototype.constructor = PxDebugLine;
PxDebugLine.prototype.__class__ = PxDebugLine;
PxDebugLine.__cache__ = {};
Module['PxDebugLine'] = PxDebugLine;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugLine.prototype['get_pos0'] = PxDebugLine.prototype.get_pos0 = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDebugLine_get_pos0_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugLine.prototype['set_pos0'] = PxDebugLine.prototype.set_pos0 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDebugLine_set_pos0_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDebugLine.prototype, 'pos0', { get: PxDebugLine.prototype.get_pos0, set: PxDebugLine.prototype.set_pos0 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugLine.prototype['get_color0'] = PxDebugLine.prototype.get_color0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDebugLine_get_color0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugLine.prototype['set_color0'] = PxDebugLine.prototype.set_color0 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDebugLine_set_color0_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDebugLine.prototype, 'color0', { get: PxDebugLine.prototype.get_color0, set: PxDebugLine.prototype.set_color0 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugLine.prototype['get_pos1'] = PxDebugLine.prototype.get_pos1 = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDebugLine_get_pos1_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugLine.prototype['set_pos1'] = PxDebugLine.prototype.set_pos1 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDebugLine_set_pos1_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDebugLine.prototype, 'pos1', { get: PxDebugLine.prototype.get_pos1, set: PxDebugLine.prototype.set_pos1 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugLine.prototype['get_color1'] = PxDebugLine.prototype.get_color1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDebugLine_get_color1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugLine.prototype['set_color1'] = PxDebugLine.prototype.set_color1 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDebugLine_set_color1_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDebugLine.prototype, 'color1', { get: PxDebugLine.prototype.get_color1, set: PxDebugLine.prototype.set_color1 });

// Interface: PxDebugPoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxDebugPoint() { throw "cannot construct a PxDebugPoint, no constructor in IDL" }
PxDebugPoint.prototype = Object.create(WrapperObject.prototype);
PxDebugPoint.prototype.constructor = PxDebugPoint;
PxDebugPoint.prototype.__class__ = PxDebugPoint;
PxDebugPoint.__cache__ = {};
Module['PxDebugPoint'] = PxDebugPoint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugPoint.prototype['get_pos'] = PxDebugPoint.prototype.get_pos = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDebugPoint_get_pos_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugPoint.prototype['set_pos'] = PxDebugPoint.prototype.set_pos = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDebugPoint_set_pos_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDebugPoint.prototype, 'pos', { get: PxDebugPoint.prototype.get_pos, set: PxDebugPoint.prototype.set_pos });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugPoint.prototype['get_color'] = PxDebugPoint.prototype.get_color = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDebugPoint_get_color_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugPoint.prototype['set_color'] = PxDebugPoint.prototype.set_color = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDebugPoint_set_color_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDebugPoint.prototype, 'color', { get: PxDebugPoint.prototype.get_color, set: PxDebugPoint.prototype.set_color });

// Interface: PxDebugTriangle

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxDebugTriangle() { throw "cannot construct a PxDebugTriangle, no constructor in IDL" }
PxDebugTriangle.prototype = Object.create(WrapperObject.prototype);
PxDebugTriangle.prototype.constructor = PxDebugTriangle;
PxDebugTriangle.prototype.__class__ = PxDebugTriangle;
PxDebugTriangle.__cache__ = {};
Module['PxDebugTriangle'] = PxDebugTriangle;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugTriangle.prototype['get_pos0'] = PxDebugTriangle.prototype.get_pos0 = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDebugTriangle_get_pos0_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugTriangle.prototype['set_pos0'] = PxDebugTriangle.prototype.set_pos0 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDebugTriangle_set_pos0_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDebugTriangle.prototype, 'pos0', { get: PxDebugTriangle.prototype.get_pos0, set: PxDebugTriangle.prototype.set_pos0 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugTriangle.prototype['get_color0'] = PxDebugTriangle.prototype.get_color0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDebugTriangle_get_color0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugTriangle.prototype['set_color0'] = PxDebugTriangle.prototype.set_color0 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDebugTriangle_set_color0_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDebugTriangle.prototype, 'color0', { get: PxDebugTriangle.prototype.get_color0, set: PxDebugTriangle.prototype.set_color0 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugTriangle.prototype['get_pos1'] = PxDebugTriangle.prototype.get_pos1 = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDebugTriangle_get_pos1_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugTriangle.prototype['set_pos1'] = PxDebugTriangle.prototype.set_pos1 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDebugTriangle_set_pos1_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDebugTriangle.prototype, 'pos1', { get: PxDebugTriangle.prototype.get_pos1, set: PxDebugTriangle.prototype.set_pos1 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugTriangle.prototype['get_color1'] = PxDebugTriangle.prototype.get_color1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDebugTriangle_get_color1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugTriangle.prototype['set_color1'] = PxDebugTriangle.prototype.set_color1 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDebugTriangle_set_color1_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDebugTriangle.prototype, 'color1', { get: PxDebugTriangle.prototype.get_color1, set: PxDebugTriangle.prototype.set_color1 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugTriangle.prototype['get_pos2'] = PxDebugTriangle.prototype.get_pos2 = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDebugTriangle_get_pos2_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugTriangle.prototype['set_pos2'] = PxDebugTriangle.prototype.set_pos2 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDebugTriangle_set_pos2_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDebugTriangle.prototype, 'pos2', { get: PxDebugTriangle.prototype.get_pos2, set: PxDebugTriangle.prototype.set_pos2 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugTriangle.prototype['get_color2'] = PxDebugTriangle.prototype.get_color2 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDebugTriangle_get_color2_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDebugTriangle.prototype['set_color2'] = PxDebugTriangle.prototype.set_color2 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDebugTriangle_set_color2_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDebugTriangle.prototype, 'color2', { get: PxDebugTriangle.prototype.get_color2, set: PxDebugTriangle.prototype.set_color2 });

// Interface: PxDefaultAllocator

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxDefaultAllocator() {
  this.ptr = _emscripten_bind_PxDefaultAllocator_PxDefaultAllocator_0();
  getCache(PxDefaultAllocator)[this.ptr] = this;
};

PxDefaultAllocator.prototype = Object.create(WrapperObject.prototype);
PxDefaultAllocator.prototype.constructor = PxDefaultAllocator;
PxDefaultAllocator.prototype.__class__ = PxDefaultAllocator;
PxDefaultAllocator.__cache__ = {};
Module['PxDefaultAllocator'] = PxDefaultAllocator;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDefaultAllocator.prototype['__destroy__'] = PxDefaultAllocator.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxDefaultAllocator___destroy___0(self);
};

// Interface: PxDefaultCpuDispatcher

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxDefaultCpuDispatcher() { throw "cannot construct a PxDefaultCpuDispatcher, no constructor in IDL" }
PxDefaultCpuDispatcher.prototype = Object.create(PxCpuDispatcher.prototype);
PxDefaultCpuDispatcher.prototype.constructor = PxDefaultCpuDispatcher;
PxDefaultCpuDispatcher.prototype.__class__ = PxDefaultCpuDispatcher;
PxDefaultCpuDispatcher.__cache__ = {};
Module['PxDefaultCpuDispatcher'] = PxDefaultCpuDispatcher;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDefaultCpuDispatcher.prototype['__destroy__'] = PxDefaultCpuDispatcher.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxDefaultCpuDispatcher___destroy___0(self);
};

// Interface: PxDefaultErrorCallback

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxDefaultErrorCallback() {
  this.ptr = _emscripten_bind_PxDefaultErrorCallback_PxDefaultErrorCallback_0();
  getCache(PxDefaultErrorCallback)[this.ptr] = this;
};

PxDefaultErrorCallback.prototype = Object.create(PxErrorCallback.prototype);
PxDefaultErrorCallback.prototype.constructor = PxDefaultErrorCallback;
PxDefaultErrorCallback.prototype.__class__ = PxDefaultErrorCallback;
PxDefaultErrorCallback.__cache__ = {};
Module['PxDefaultErrorCallback'] = PxDefaultErrorCallback;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDefaultErrorCallback.prototype['reportError'] = PxDefaultErrorCallback.prototype.reportError = function(code, message, file, line) {
  var self = this.ptr;
  ensureCache.prepare();
  if (code && typeof code === 'object') code = code.ptr;
  if (message && typeof message === 'object') message = message.ptr;
  else message = ensureString(message);
  if (file && typeof file === 'object') file = file.ptr;
  else file = ensureString(file);
  if (line && typeof line === 'object') line = line.ptr;
  _emscripten_bind_PxDefaultErrorCallback_reportError_4(self, code, message, file, line);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDefaultErrorCallback.prototype['__destroy__'] = PxDefaultErrorCallback.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxDefaultErrorCallback___destroy___0(self);
};

// Interface: PxDefaultMemoryInputData

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxDefaultMemoryInputData(data, length) {
  if (data && typeof data === 'object') data = data.ptr;
  if (length && typeof length === 'object') length = length.ptr;
  this.ptr = _emscripten_bind_PxDefaultMemoryInputData_PxDefaultMemoryInputData_2(data, length);
  getCache(PxDefaultMemoryInputData)[this.ptr] = this;
};

PxDefaultMemoryInputData.prototype = Object.create(PxInputData.prototype);
PxDefaultMemoryInputData.prototype.constructor = PxDefaultMemoryInputData;
PxDefaultMemoryInputData.prototype.__class__ = PxDefaultMemoryInputData;
PxDefaultMemoryInputData.__cache__ = {};
Module['PxDefaultMemoryInputData'] = PxDefaultMemoryInputData;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDefaultMemoryInputData.prototype['read'] = PxDefaultMemoryInputData.prototype.read = function(dest, count) {
  var self = this.ptr;
  if (dest && typeof dest === 'object') dest = dest.ptr;
  if (count && typeof count === 'object') count = count.ptr;
  return _emscripten_bind_PxDefaultMemoryInputData_read_2(self, dest, count);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDefaultMemoryInputData.prototype['getLength'] = PxDefaultMemoryInputData.prototype.getLength = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDefaultMemoryInputData_getLength_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDefaultMemoryInputData.prototype['seek'] = PxDefaultMemoryInputData.prototype.seek = function(pos) {
  var self = this.ptr;
  if (pos && typeof pos === 'object') pos = pos.ptr;
  _emscripten_bind_PxDefaultMemoryInputData_seek_1(self, pos);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDefaultMemoryInputData.prototype['tell'] = PxDefaultMemoryInputData.prototype.tell = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDefaultMemoryInputData_tell_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDefaultMemoryInputData.prototype['__destroy__'] = PxDefaultMemoryInputData.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxDefaultMemoryInputData___destroy___0(self);
};

// Interface: PxDefaultMemoryOutputStream

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxDefaultMemoryOutputStream() {
  this.ptr = _emscripten_bind_PxDefaultMemoryOutputStream_PxDefaultMemoryOutputStream_0();
  getCache(PxDefaultMemoryOutputStream)[this.ptr] = this;
};

PxDefaultMemoryOutputStream.prototype = Object.create(PxOutputStream.prototype);
PxDefaultMemoryOutputStream.prototype.constructor = PxDefaultMemoryOutputStream;
PxDefaultMemoryOutputStream.prototype.__class__ = PxDefaultMemoryOutputStream;
PxDefaultMemoryOutputStream.__cache__ = {};
Module['PxDefaultMemoryOutputStream'] = PxDefaultMemoryOutputStream;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDefaultMemoryOutputStream.prototype['write'] = PxDefaultMemoryOutputStream.prototype.write = function(src, count) {
  var self = this.ptr;
  if (src && typeof src === 'object') src = src.ptr;
  if (count && typeof count === 'object') count = count.ptr;
  _emscripten_bind_PxDefaultMemoryOutputStream_write_2(self, src, count);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDefaultMemoryOutputStream.prototype['getSize'] = PxDefaultMemoryOutputStream.prototype.getSize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDefaultMemoryOutputStream_getSize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDefaultMemoryOutputStream.prototype['getData'] = PxDefaultMemoryOutputStream.prototype.getData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDefaultMemoryOutputStream_getData_0(self), VoidPtr);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDefaultMemoryOutputStream.prototype['__destroy__'] = PxDefaultMemoryOutputStream.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxDefaultMemoryOutputStream___destroy___0(self);
};

// Interface: PxDim3

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxDim3() {
  this.ptr = _emscripten_bind_PxDim3_PxDim3_0();
  getCache(PxDim3)[this.ptr] = this;
};

PxDim3.prototype = Object.create(WrapperObject.prototype);
PxDim3.prototype.constructor = PxDim3;
PxDim3.prototype.__class__ = PxDim3;
PxDim3.__cache__ = {};
Module['PxDim3'] = PxDim3;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDim3.prototype['get_x'] = PxDim3.prototype.get_x = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDim3_get_x_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDim3.prototype['set_x'] = PxDim3.prototype.set_x = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDim3_set_x_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDim3.prototype, 'x', { get: PxDim3.prototype.get_x, set: PxDim3.prototype.set_x });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDim3.prototype['get_y'] = PxDim3.prototype.get_y = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDim3_get_y_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDim3.prototype['set_y'] = PxDim3.prototype.set_y = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDim3_set_y_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDim3.prototype, 'y', { get: PxDim3.prototype.get_y, set: PxDim3.prototype.set_y });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDim3.prototype['get_z'] = PxDim3.prototype.get_z = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDim3_get_z_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDim3.prototype['set_z'] = PxDim3.prototype.set_z = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDim3_set_z_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDim3.prototype, 'z', { get: PxDim3.prototype.get_z, set: PxDim3.prototype.set_z });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDim3.prototype['__destroy__'] = PxDim3.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxDim3___destroy___0(self);
};

// Interface: PxDistanceJoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxDistanceJoint() { throw "cannot construct a PxDistanceJoint, no constructor in IDL" }
PxDistanceJoint.prototype = Object.create(PxJoint.prototype);
PxDistanceJoint.prototype.constructor = PxDistanceJoint;
PxDistanceJoint.prototype.__class__ = PxDistanceJoint;
PxDistanceJoint.__cache__ = {};
Module['PxDistanceJoint'] = PxDistanceJoint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getDistance'] = PxDistanceJoint.prototype.getDistance = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDistanceJoint_getDistance_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setMinDistance'] = PxDistanceJoint.prototype.setMinDistance = function(distance) {
  var self = this.ptr;
  if (distance && typeof distance === 'object') distance = distance.ptr;
  _emscripten_bind_PxDistanceJoint_setMinDistance_1(self, distance);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getMinDistance'] = PxDistanceJoint.prototype.getMinDistance = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDistanceJoint_getMinDistance_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setMaxDistance'] = PxDistanceJoint.prototype.setMaxDistance = function(distance) {
  var self = this.ptr;
  if (distance && typeof distance === 'object') distance = distance.ptr;
  _emscripten_bind_PxDistanceJoint_setMaxDistance_1(self, distance);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getMaxDistance'] = PxDistanceJoint.prototype.getMaxDistance = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDistanceJoint_getMaxDistance_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setTolerance'] = PxDistanceJoint.prototype.setTolerance = function(tolerance) {
  var self = this.ptr;
  if (tolerance && typeof tolerance === 'object') tolerance = tolerance.ptr;
  _emscripten_bind_PxDistanceJoint_setTolerance_1(self, tolerance);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getTolerance'] = PxDistanceJoint.prototype.getTolerance = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDistanceJoint_getTolerance_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setStiffness'] = PxDistanceJoint.prototype.setStiffness = function(stiffness) {
  var self = this.ptr;
  if (stiffness && typeof stiffness === 'object') stiffness = stiffness.ptr;
  _emscripten_bind_PxDistanceJoint_setStiffness_1(self, stiffness);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getStiffness'] = PxDistanceJoint.prototype.getStiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDistanceJoint_getStiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setDamping'] = PxDistanceJoint.prototype.setDamping = function(damping) {
  var self = this.ptr;
  if (damping && typeof damping === 'object') damping = damping.ptr;
  _emscripten_bind_PxDistanceJoint_setDamping_1(self, damping);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getDamping'] = PxDistanceJoint.prototype.getDamping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDistanceJoint_getDamping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setDistanceJointFlags'] = PxDistanceJoint.prototype.setDistanceJointFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxDistanceJoint_setDistanceJointFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setDistanceJointFlag'] = PxDistanceJoint.prototype.setDistanceJointFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxDistanceJoint_setDistanceJointFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getDistanceJointFlags'] = PxDistanceJoint.prototype.getDistanceJointFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDistanceJoint_getDistanceJointFlags_0(self), PxDistanceJointFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['release'] = PxDistanceJoint.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxDistanceJoint_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getConcreteTypeName'] = PxDistanceJoint.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxDistanceJoint_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getConcreteType'] = PxDistanceJoint.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDistanceJoint_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setBaseFlag'] = PxDistanceJoint.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxDistanceJoint_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setBaseFlags'] = PxDistanceJoint.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxDistanceJoint_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getBaseFlags'] = PxDistanceJoint.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDistanceJoint_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['isReleasable'] = PxDistanceJoint.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxDistanceJoint_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setActors'] = PxDistanceJoint.prototype.setActors = function(actor0, actor1) {
  var self = this.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  _emscripten_bind_PxDistanceJoint_setActors_2(self, actor0, actor1);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setLocalPose'] = PxDistanceJoint.prototype.setLocalPose = function(actor, localPose) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (localPose && typeof localPose === 'object') localPose = localPose.ptr;
  _emscripten_bind_PxDistanceJoint_setLocalPose_2(self, actor, localPose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getLocalPose'] = PxDistanceJoint.prototype.getLocalPose = function(actor) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return wrapPointer(_emscripten_bind_PxDistanceJoint_getLocalPose_1(self, actor), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getRelativeTransform'] = PxDistanceJoint.prototype.getRelativeTransform = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDistanceJoint_getRelativeTransform_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getRelativeLinearVelocity'] = PxDistanceJoint.prototype.getRelativeLinearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDistanceJoint_getRelativeLinearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getRelativeAngularVelocity'] = PxDistanceJoint.prototype.getRelativeAngularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDistanceJoint_getRelativeAngularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setBreakForce'] = PxDistanceJoint.prototype.setBreakForce = function(force, torque) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  _emscripten_bind_PxDistanceJoint_setBreakForce_2(self, force, torque);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setConstraintFlags'] = PxDistanceJoint.prototype.setConstraintFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxDistanceJoint_setConstraintFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setConstraintFlag'] = PxDistanceJoint.prototype.setConstraintFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxDistanceJoint_setConstraintFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getConstraintFlags'] = PxDistanceJoint.prototype.getConstraintFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDistanceJoint_getConstraintFlags_0(self), PxConstraintFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setInvMassScale0'] = PxDistanceJoint.prototype.setInvMassScale0 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxDistanceJoint_setInvMassScale0_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getInvMassScale0'] = PxDistanceJoint.prototype.getInvMassScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDistanceJoint_getInvMassScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setInvMassScale1'] = PxDistanceJoint.prototype.setInvMassScale1 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxDistanceJoint_setInvMassScale1_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getInvMassScale1'] = PxDistanceJoint.prototype.getInvMassScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDistanceJoint_getInvMassScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setInvInertiaScale0'] = PxDistanceJoint.prototype.setInvInertiaScale0 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxDistanceJoint_setInvInertiaScale0_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getInvInertiaScale0'] = PxDistanceJoint.prototype.getInvInertiaScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDistanceJoint_getInvInertiaScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setInvInertiaScale1'] = PxDistanceJoint.prototype.setInvInertiaScale1 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxDistanceJoint_setInvInertiaScale1_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getInvInertiaScale1'] = PxDistanceJoint.prototype.getInvInertiaScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDistanceJoint_getInvInertiaScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getConstraint'] = PxDistanceJoint.prototype.getConstraint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDistanceJoint_getConstraint_0(self), PxConstraint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['setName'] = PxDistanceJoint.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxDistanceJoint_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getName'] = PxDistanceJoint.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxDistanceJoint_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['getScene'] = PxDistanceJoint.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDistanceJoint_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['get_userData'] = PxDistanceJoint.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxDistanceJoint_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['set_userData'] = PxDistanceJoint.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDistanceJoint_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDistanceJoint.prototype, 'userData', { get: PxDistanceJoint.prototype.get_userData, set: PxDistanceJoint.prototype.set_userData });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJoint.prototype['__destroy__'] = PxDistanceJoint.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxDistanceJoint___destroy___0(self);
};

// Interface: PxDistanceJointFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxDistanceJointFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxDistanceJointFlags_PxDistanceJointFlags_1(flags);
  getCache(PxDistanceJointFlags)[this.ptr] = this;
};

PxDistanceJointFlags.prototype = Object.create(WrapperObject.prototype);
PxDistanceJointFlags.prototype.constructor = PxDistanceJointFlags;
PxDistanceJointFlags.prototype.__class__ = PxDistanceJointFlags;
PxDistanceJointFlags.__cache__ = {};
Module['PxDistanceJointFlags'] = PxDistanceJointFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJointFlags.prototype['isSet'] = PxDistanceJointFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxDistanceJointFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJointFlags.prototype['raise'] = PxDistanceJointFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxDistanceJointFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJointFlags.prototype['clear'] = PxDistanceJointFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxDistanceJointFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDistanceJointFlags.prototype['__destroy__'] = PxDistanceJointFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxDistanceJointFlags___destroy___0(self);
};

// Interface: PxDominanceGroupPair

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxDominanceGroupPair(a, b) {
  if (a && typeof a === 'object') a = a.ptr;
  if (b && typeof b === 'object') b = b.ptr;
  this.ptr = _emscripten_bind_PxDominanceGroupPair_PxDominanceGroupPair_2(a, b);
  getCache(PxDominanceGroupPair)[this.ptr] = this;
};

PxDominanceGroupPair.prototype = Object.create(WrapperObject.prototype);
PxDominanceGroupPair.prototype.constructor = PxDominanceGroupPair;
PxDominanceGroupPair.prototype.__class__ = PxDominanceGroupPair;
PxDominanceGroupPair.__cache__ = {};
Module['PxDominanceGroupPair'] = PxDominanceGroupPair;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDominanceGroupPair.prototype['get_dominance0'] = PxDominanceGroupPair.prototype.get_dominance0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDominanceGroupPair_get_dominance0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDominanceGroupPair.prototype['set_dominance0'] = PxDominanceGroupPair.prototype.set_dominance0 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDominanceGroupPair_set_dominance0_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDominanceGroupPair.prototype, 'dominance0', { get: PxDominanceGroupPair.prototype.get_dominance0, set: PxDominanceGroupPair.prototype.set_dominance0 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDominanceGroupPair.prototype['get_dominance1'] = PxDominanceGroupPair.prototype.get_dominance1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxDominanceGroupPair_get_dominance1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDominanceGroupPair.prototype['set_dominance1'] = PxDominanceGroupPair.prototype.set_dominance1 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxDominanceGroupPair_set_dominance1_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxDominanceGroupPair.prototype, 'dominance1', { get: PxDominanceGroupPair.prototype.get_dominance1, set: PxDominanceGroupPair.prototype.set_dominance1 });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxDominanceGroupPair.prototype['__destroy__'] = PxDominanceGroupPair.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxDominanceGroupPair___destroy___0(self);
};

// Interface: PxErrorCallbackImpl

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxErrorCallbackImpl() {
  this.ptr = _emscripten_bind_PxErrorCallbackImpl_PxErrorCallbackImpl_0();
  getCache(PxErrorCallbackImpl)[this.ptr] = this;
};

PxErrorCallbackImpl.prototype = Object.create(PxErrorCallback.prototype);
PxErrorCallbackImpl.prototype.constructor = PxErrorCallbackImpl;
PxErrorCallbackImpl.prototype.__class__ = PxErrorCallbackImpl;
PxErrorCallbackImpl.__cache__ = {};
Module['PxErrorCallbackImpl'] = PxErrorCallbackImpl;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxErrorCallbackImpl.prototype['reportError'] = PxErrorCallbackImpl.prototype.reportError = function(code, message, file, line) {
  var self = this.ptr;
  ensureCache.prepare();
  if (code && typeof code === 'object') code = code.ptr;
  if (message && typeof message === 'object') message = message.ptr;
  else message = ensureString(message);
  if (file && typeof file === 'object') file = file.ptr;
  else file = ensureString(file);
  if (line && typeof line === 'object') line = line.ptr;
  _emscripten_bind_PxErrorCallbackImpl_reportError_4(self, code, message, file, line);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxErrorCallbackImpl.prototype['__destroy__'] = PxErrorCallbackImpl.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxErrorCallbackImpl___destroy___0(self);
};

// Interface: PxExtendedVec3

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxExtendedVec3(x, y, z) {
  if (x && typeof x === 'object') x = x.ptr;
  if (y && typeof y === 'object') y = y.ptr;
  if (z && typeof z === 'object') z = z.ptr;
  if (x === undefined) { this.ptr = _emscripten_bind_PxExtendedVec3_PxExtendedVec3_0(); getCache(PxExtendedVec3)[this.ptr] = this;return }
  if (y === undefined) { this.ptr = _emscripten_bind_PxExtendedVec3_PxExtendedVec3_1(x); getCache(PxExtendedVec3)[this.ptr] = this;return }
  if (z === undefined) { this.ptr = _emscripten_bind_PxExtendedVec3_PxExtendedVec3_2(x, y); getCache(PxExtendedVec3)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxExtendedVec3_PxExtendedVec3_3(x, y, z);
  getCache(PxExtendedVec3)[this.ptr] = this;
};

PxExtendedVec3.prototype = Object.create(WrapperObject.prototype);
PxExtendedVec3.prototype.constructor = PxExtendedVec3;
PxExtendedVec3.prototype.__class__ = PxExtendedVec3;
PxExtendedVec3.__cache__ = {};
Module['PxExtendedVec3'] = PxExtendedVec3;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxExtendedVec3.prototype['get_x'] = PxExtendedVec3.prototype.get_x = function() {
  var self = this.ptr;
  return _emscripten_bind_PxExtendedVec3_get_x_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxExtendedVec3.prototype['set_x'] = PxExtendedVec3.prototype.set_x = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxExtendedVec3_set_x_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxExtendedVec3.prototype, 'x', { get: PxExtendedVec3.prototype.get_x, set: PxExtendedVec3.prototype.set_x });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxExtendedVec3.prototype['get_y'] = PxExtendedVec3.prototype.get_y = function() {
  var self = this.ptr;
  return _emscripten_bind_PxExtendedVec3_get_y_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxExtendedVec3.prototype['set_y'] = PxExtendedVec3.prototype.set_y = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxExtendedVec3_set_y_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxExtendedVec3.prototype, 'y', { get: PxExtendedVec3.prototype.get_y, set: PxExtendedVec3.prototype.set_y });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxExtendedVec3.prototype['get_z'] = PxExtendedVec3.prototype.get_z = function() {
  var self = this.ptr;
  return _emscripten_bind_PxExtendedVec3_get_z_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxExtendedVec3.prototype['set_z'] = PxExtendedVec3.prototype.set_z = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxExtendedVec3_set_z_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxExtendedVec3.prototype, 'z', { get: PxExtendedVec3.prototype.get_z, set: PxExtendedVec3.prototype.set_z });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxExtendedVec3.prototype['__destroy__'] = PxExtendedVec3.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxExtendedVec3___destroy___0(self);
};

// Interface: PxExtensionTopLevelFunctions

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxExtensionTopLevelFunctions() { throw "cannot construct a PxExtensionTopLevelFunctions, no constructor in IDL" }
PxExtensionTopLevelFunctions.prototype = Object.create(WrapperObject.prototype);
PxExtensionTopLevelFunctions.prototype.constructor = PxExtensionTopLevelFunctions;
PxExtensionTopLevelFunctions.prototype.__class__ = PxExtensionTopLevelFunctions;
PxExtensionTopLevelFunctions.__cache__ = {};
Module['PxExtensionTopLevelFunctions'] = PxExtensionTopLevelFunctions;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxExtensionTopLevelFunctions.prototype['CreatePlane'] = PxExtensionTopLevelFunctions.prototype.CreatePlane = function(sdk, plane, material, filterData) {
  if (sdk && typeof sdk === 'object') sdk = sdk.ptr;
  if (plane && typeof plane === 'object') plane = plane.ptr;
  if (material && typeof material === 'object') material = material.ptr;
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  return wrapPointer(_emscripten_bind_PxExtensionTopLevelFunctions_CreatePlane_4(sdk, plane, material, filterData), PxRigidStatic);
};


// Interface: PxFilterData

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxFilterData(w0, w1, w2, w3) {
  if (w0 && typeof w0 === 'object') w0 = w0.ptr;
  if (w1 && typeof w1 === 'object') w1 = w1.ptr;
  if (w2 && typeof w2 === 'object') w2 = w2.ptr;
  if (w3 && typeof w3 === 'object') w3 = w3.ptr;
  if (w0 === undefined) { this.ptr = _emscripten_bind_PxFilterData_PxFilterData_0(); getCache(PxFilterData)[this.ptr] = this;return }
  if (w1 === undefined) { this.ptr = _emscripten_bind_PxFilterData_PxFilterData_1(w0); getCache(PxFilterData)[this.ptr] = this;return }
  if (w2 === undefined) { this.ptr = _emscripten_bind_PxFilterData_PxFilterData_2(w0, w1); getCache(PxFilterData)[this.ptr] = this;return }
  if (w3 === undefined) { this.ptr = _emscripten_bind_PxFilterData_PxFilterData_3(w0, w1, w2); getCache(PxFilterData)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxFilterData_PxFilterData_4(w0, w1, w2, w3);
  getCache(PxFilterData)[this.ptr] = this;
};

PxFilterData.prototype = Object.create(WrapperObject.prototype);
PxFilterData.prototype.constructor = PxFilterData;
PxFilterData.prototype.__class__ = PxFilterData;
PxFilterData.__cache__ = {};
Module['PxFilterData'] = PxFilterData;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFilterData.prototype['get_word0'] = PxFilterData.prototype.get_word0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxFilterData_get_word0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFilterData.prototype['set_word0'] = PxFilterData.prototype.set_word0 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxFilterData_set_word0_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxFilterData.prototype, 'word0', { get: PxFilterData.prototype.get_word0, set: PxFilterData.prototype.set_word0 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFilterData.prototype['get_word1'] = PxFilterData.prototype.get_word1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxFilterData_get_word1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFilterData.prototype['set_word1'] = PxFilterData.prototype.set_word1 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxFilterData_set_word1_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxFilterData.prototype, 'word1', { get: PxFilterData.prototype.get_word1, set: PxFilterData.prototype.set_word1 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFilterData.prototype['get_word2'] = PxFilterData.prototype.get_word2 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxFilterData_get_word2_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFilterData.prototype['set_word2'] = PxFilterData.prototype.set_word2 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxFilterData_set_word2_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxFilterData.prototype, 'word2', { get: PxFilterData.prototype.get_word2, set: PxFilterData.prototype.set_word2 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFilterData.prototype['get_word3'] = PxFilterData.prototype.get_word3 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxFilterData_get_word3_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFilterData.prototype['set_word3'] = PxFilterData.prototype.set_word3 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxFilterData_set_word3_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxFilterData.prototype, 'word3', { get: PxFilterData.prototype.get_word3, set: PxFilterData.prototype.set_word3 });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFilterData.prototype['__destroy__'] = PxFilterData.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxFilterData___destroy___0(self);
};

// Interface: PxFixedJoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxFixedJoint() { throw "cannot construct a PxFixedJoint, no constructor in IDL" }
PxFixedJoint.prototype = Object.create(PxJoint.prototype);
PxFixedJoint.prototype.constructor = PxFixedJoint;
PxFixedJoint.prototype.__class__ = PxFixedJoint;
PxFixedJoint.__cache__ = {};
Module['PxFixedJoint'] = PxFixedJoint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['release'] = PxFixedJoint.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxFixedJoint_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getConcreteTypeName'] = PxFixedJoint.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxFixedJoint_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getConcreteType'] = PxFixedJoint.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxFixedJoint_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['setBaseFlag'] = PxFixedJoint.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxFixedJoint_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['setBaseFlags'] = PxFixedJoint.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxFixedJoint_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getBaseFlags'] = PxFixedJoint.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxFixedJoint_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['isReleasable'] = PxFixedJoint.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxFixedJoint_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['setActors'] = PxFixedJoint.prototype.setActors = function(actor0, actor1) {
  var self = this.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  _emscripten_bind_PxFixedJoint_setActors_2(self, actor0, actor1);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['setLocalPose'] = PxFixedJoint.prototype.setLocalPose = function(actor, localPose) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (localPose && typeof localPose === 'object') localPose = localPose.ptr;
  _emscripten_bind_PxFixedJoint_setLocalPose_2(self, actor, localPose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getLocalPose'] = PxFixedJoint.prototype.getLocalPose = function(actor) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return wrapPointer(_emscripten_bind_PxFixedJoint_getLocalPose_1(self, actor), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getRelativeTransform'] = PxFixedJoint.prototype.getRelativeTransform = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxFixedJoint_getRelativeTransform_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getRelativeLinearVelocity'] = PxFixedJoint.prototype.getRelativeLinearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxFixedJoint_getRelativeLinearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getRelativeAngularVelocity'] = PxFixedJoint.prototype.getRelativeAngularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxFixedJoint_getRelativeAngularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['setBreakForce'] = PxFixedJoint.prototype.setBreakForce = function(force, torque) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  _emscripten_bind_PxFixedJoint_setBreakForce_2(self, force, torque);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['setConstraintFlags'] = PxFixedJoint.prototype.setConstraintFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxFixedJoint_setConstraintFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['setConstraintFlag'] = PxFixedJoint.prototype.setConstraintFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxFixedJoint_setConstraintFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getConstraintFlags'] = PxFixedJoint.prototype.getConstraintFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxFixedJoint_getConstraintFlags_0(self), PxConstraintFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['setInvMassScale0'] = PxFixedJoint.prototype.setInvMassScale0 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxFixedJoint_setInvMassScale0_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getInvMassScale0'] = PxFixedJoint.prototype.getInvMassScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxFixedJoint_getInvMassScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['setInvMassScale1'] = PxFixedJoint.prototype.setInvMassScale1 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxFixedJoint_setInvMassScale1_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getInvMassScale1'] = PxFixedJoint.prototype.getInvMassScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxFixedJoint_getInvMassScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['setInvInertiaScale0'] = PxFixedJoint.prototype.setInvInertiaScale0 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxFixedJoint_setInvInertiaScale0_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getInvInertiaScale0'] = PxFixedJoint.prototype.getInvInertiaScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxFixedJoint_getInvInertiaScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['setInvInertiaScale1'] = PxFixedJoint.prototype.setInvInertiaScale1 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxFixedJoint_setInvInertiaScale1_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getInvInertiaScale1'] = PxFixedJoint.prototype.getInvInertiaScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxFixedJoint_getInvInertiaScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getConstraint'] = PxFixedJoint.prototype.getConstraint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxFixedJoint_getConstraint_0(self), PxConstraint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['setName'] = PxFixedJoint.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxFixedJoint_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getName'] = PxFixedJoint.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxFixedJoint_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['getScene'] = PxFixedJoint.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxFixedJoint_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['get_userData'] = PxFixedJoint.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxFixedJoint_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['set_userData'] = PxFixedJoint.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxFixedJoint_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxFixedJoint.prototype, 'userData', { get: PxFixedJoint.prototype.get_userData, set: PxFixedJoint.prototype.set_userData });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFixedJoint.prototype['__destroy__'] = PxFixedJoint.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxFixedJoint___destroy___0(self);
};

// Interface: PxFoundation

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxFoundation() { throw "cannot construct a PxFoundation, no constructor in IDL" }
PxFoundation.prototype = Object.create(WrapperObject.prototype);
PxFoundation.prototype.constructor = PxFoundation;
PxFoundation.prototype.__class__ = PxFoundation;
PxFoundation.__cache__ = {};
Module['PxFoundation'] = PxFoundation;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxFoundation.prototype['release'] = PxFoundation.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxFoundation_release_0(self);
};


// Interface: PxGearJoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxGearJoint() { throw "cannot construct a PxGearJoint, no constructor in IDL" }
PxGearJoint.prototype = Object.create(PxJoint.prototype);
PxGearJoint.prototype.constructor = PxGearJoint;
PxGearJoint.prototype.__class__ = PxGearJoint;
PxGearJoint.__cache__ = {};
Module['PxGearJoint'] = PxGearJoint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['setHinges'] = PxGearJoint.prototype.setHinges = function(hinge0, hinge1) {
  var self = this.ptr;
  if (hinge0 && typeof hinge0 === 'object') hinge0 = hinge0.ptr;
  if (hinge1 && typeof hinge1 === 'object') hinge1 = hinge1.ptr;
  return !!(_emscripten_bind_PxGearJoint_setHinges_2(self, hinge0, hinge1));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['setGearRatio'] = PxGearJoint.prototype.setGearRatio = function(ratio) {
  var self = this.ptr;
  if (ratio && typeof ratio === 'object') ratio = ratio.ptr;
  _emscripten_bind_PxGearJoint_setGearRatio_1(self, ratio);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getGearRatio'] = PxGearJoint.prototype.getGearRatio = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGearJoint_getGearRatio_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['release'] = PxGearJoint.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxGearJoint_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getConcreteTypeName'] = PxGearJoint.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxGearJoint_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getConcreteType'] = PxGearJoint.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGearJoint_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['setBaseFlag'] = PxGearJoint.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxGearJoint_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['setBaseFlags'] = PxGearJoint.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxGearJoint_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getBaseFlags'] = PxGearJoint.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGearJoint_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['isReleasable'] = PxGearJoint.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxGearJoint_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['setActors'] = PxGearJoint.prototype.setActors = function(actor0, actor1) {
  var self = this.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  _emscripten_bind_PxGearJoint_setActors_2(self, actor0, actor1);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['setLocalPose'] = PxGearJoint.prototype.setLocalPose = function(actor, localPose) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (localPose && typeof localPose === 'object') localPose = localPose.ptr;
  _emscripten_bind_PxGearJoint_setLocalPose_2(self, actor, localPose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getLocalPose'] = PxGearJoint.prototype.getLocalPose = function(actor) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return wrapPointer(_emscripten_bind_PxGearJoint_getLocalPose_1(self, actor), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getRelativeTransform'] = PxGearJoint.prototype.getRelativeTransform = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGearJoint_getRelativeTransform_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getRelativeLinearVelocity'] = PxGearJoint.prototype.getRelativeLinearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGearJoint_getRelativeLinearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getRelativeAngularVelocity'] = PxGearJoint.prototype.getRelativeAngularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGearJoint_getRelativeAngularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['setBreakForce'] = PxGearJoint.prototype.setBreakForce = function(force, torque) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  _emscripten_bind_PxGearJoint_setBreakForce_2(self, force, torque);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['setConstraintFlags'] = PxGearJoint.prototype.setConstraintFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxGearJoint_setConstraintFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['setConstraintFlag'] = PxGearJoint.prototype.setConstraintFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxGearJoint_setConstraintFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getConstraintFlags'] = PxGearJoint.prototype.getConstraintFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGearJoint_getConstraintFlags_0(self), PxConstraintFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['setInvMassScale0'] = PxGearJoint.prototype.setInvMassScale0 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxGearJoint_setInvMassScale0_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getInvMassScale0'] = PxGearJoint.prototype.getInvMassScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGearJoint_getInvMassScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['setInvMassScale1'] = PxGearJoint.prototype.setInvMassScale1 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxGearJoint_setInvMassScale1_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getInvMassScale1'] = PxGearJoint.prototype.getInvMassScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGearJoint_getInvMassScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['setInvInertiaScale0'] = PxGearJoint.prototype.setInvInertiaScale0 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxGearJoint_setInvInertiaScale0_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getInvInertiaScale0'] = PxGearJoint.prototype.getInvInertiaScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGearJoint_getInvInertiaScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['setInvInertiaScale1'] = PxGearJoint.prototype.setInvInertiaScale1 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxGearJoint_setInvInertiaScale1_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getInvInertiaScale1'] = PxGearJoint.prototype.getInvInertiaScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGearJoint_getInvInertiaScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getConstraint'] = PxGearJoint.prototype.getConstraint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGearJoint_getConstraint_0(self), PxConstraint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['setName'] = PxGearJoint.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxGearJoint_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getName'] = PxGearJoint.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxGearJoint_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['getScene'] = PxGearJoint.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGearJoint_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['get_userData'] = PxGearJoint.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGearJoint_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['set_userData'] = PxGearJoint.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGearJoint_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGearJoint.prototype, 'userData', { get: PxGearJoint.prototype.get_userData, set: PxGearJoint.prototype.set_userData });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGearJoint.prototype['__destroy__'] = PxGearJoint.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxGearJoint___destroy___0(self);
};

// Interface: PxGeometryHolder

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxGeometryHolder(geometry) {
  if (geometry && typeof geometry === 'object') geometry = geometry.ptr;
  if (geometry === undefined) { this.ptr = _emscripten_bind_PxGeometryHolder_PxGeometryHolder_0(); getCache(PxGeometryHolder)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxGeometryHolder_PxGeometryHolder_1(geometry);
  getCache(PxGeometryHolder)[this.ptr] = this;
};

PxGeometryHolder.prototype = Object.create(WrapperObject.prototype);
PxGeometryHolder.prototype.constructor = PxGeometryHolder;
PxGeometryHolder.prototype.__class__ = PxGeometryHolder;
PxGeometryHolder.__cache__ = {};
Module['PxGeometryHolder'] = PxGeometryHolder;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryHolder.prototype['getType'] = PxGeometryHolder.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGeometryHolder_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryHolder.prototype['sphere'] = PxGeometryHolder.prototype.sphere = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGeometryHolder_sphere_0(self), PxSphereGeometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryHolder.prototype['plane'] = PxGeometryHolder.prototype.plane = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGeometryHolder_plane_0(self), PxPlaneGeometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryHolder.prototype['capsule'] = PxGeometryHolder.prototype.capsule = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGeometryHolder_capsule_0(self), PxCapsuleGeometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryHolder.prototype['box'] = PxGeometryHolder.prototype.box = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGeometryHolder_box_0(self), PxBoxGeometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryHolder.prototype['convexMesh'] = PxGeometryHolder.prototype.convexMesh = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGeometryHolder_convexMesh_0(self), PxConvexMeshGeometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryHolder.prototype['triangleMesh'] = PxGeometryHolder.prototype.triangleMesh = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGeometryHolder_triangleMesh_0(self), PxTriangleMeshGeometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryHolder.prototype['heightField'] = PxGeometryHolder.prototype.heightField = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGeometryHolder_heightField_0(self), PxHeightFieldGeometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryHolder.prototype['storeAny'] = PxGeometryHolder.prototype.storeAny = function(geometry) {
  var self = this.ptr;
  if (geometry && typeof geometry === 'object') geometry = geometry.ptr;
  _emscripten_bind_PxGeometryHolder_storeAny_1(self, geometry);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryHolder.prototype['__destroy__'] = PxGeometryHolder.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxGeometryHolder___destroy___0(self);
};

// Interface: PxGeometryQuery

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxGeometryQuery() { throw "cannot construct a PxGeometryQuery, no constructor in IDL" }
PxGeometryQuery.prototype = Object.create(WrapperObject.prototype);
PxGeometryQuery.prototype.constructor = PxGeometryQuery;
PxGeometryQuery.prototype.__class__ = PxGeometryQuery;
PxGeometryQuery.__cache__ = {};
Module['PxGeometryQuery'] = PxGeometryQuery;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryQuery.prototype['sweep'] = PxGeometryQuery.prototype.sweep = function(unitDir, maxDist, geom0, pose0, geom1, pose1, sweepHit, hitFlags, inflation) {
  if (unitDir && typeof unitDir === 'object') unitDir = unitDir.ptr;
  if (maxDist && typeof maxDist === 'object') maxDist = maxDist.ptr;
  if (geom0 && typeof geom0 === 'object') geom0 = geom0.ptr;
  if (pose0 && typeof pose0 === 'object') pose0 = pose0.ptr;
  if (geom1 && typeof geom1 === 'object') geom1 = geom1.ptr;
  if (pose1 && typeof pose1 === 'object') pose1 = pose1.ptr;
  if (sweepHit && typeof sweepHit === 'object') sweepHit = sweepHit.ptr;
  if (hitFlags && typeof hitFlags === 'object') hitFlags = hitFlags.ptr;
  if (inflation && typeof inflation === 'object') inflation = inflation.ptr;
  if (hitFlags === undefined) { return !!(_emscripten_bind_PxGeometryQuery_sweep_7(unitDir, maxDist, geom0, pose0, geom1, pose1, sweepHit)) }
  if (inflation === undefined) { return !!(_emscripten_bind_PxGeometryQuery_sweep_8(unitDir, maxDist, geom0, pose0, geom1, pose1, sweepHit, hitFlags)) }
  return !!(_emscripten_bind_PxGeometryQuery_sweep_9(unitDir, maxDist, geom0, pose0, geom1, pose1, sweepHit, hitFlags, inflation));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryQuery.prototype['overlap'] = PxGeometryQuery.prototype.overlap = function(geom0, pose0, geom1, pose1) {
  if (geom0 && typeof geom0 === 'object') geom0 = geom0.ptr;
  if (pose0 && typeof pose0 === 'object') pose0 = pose0.ptr;
  if (geom1 && typeof geom1 === 'object') geom1 = geom1.ptr;
  if (pose1 && typeof pose1 === 'object') pose1 = pose1.ptr;
  return !!(_emscripten_bind_PxGeometryQuery_overlap_4(geom0, pose0, geom1, pose1));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryQuery.prototype['raycast'] = PxGeometryQuery.prototype.raycast = function(origin, unitDir, geom, pose, maxDist, hitFlags, maxHits, rayHits) {
  if (origin && typeof origin === 'object') origin = origin.ptr;
  if (unitDir && typeof unitDir === 'object') unitDir = unitDir.ptr;
  if (geom && typeof geom === 'object') geom = geom.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (maxDist && typeof maxDist === 'object') maxDist = maxDist.ptr;
  if (hitFlags && typeof hitFlags === 'object') hitFlags = hitFlags.ptr;
  if (maxHits && typeof maxHits === 'object') maxHits = maxHits.ptr;
  if (rayHits && typeof rayHits === 'object') rayHits = rayHits.ptr;
  return _emscripten_bind_PxGeometryQuery_raycast_8(origin, unitDir, geom, pose, maxDist, hitFlags, maxHits, rayHits);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryQuery.prototype['pointDistance'] = PxGeometryQuery.prototype.pointDistance = function(point, geom, pose, closestPoint) {
  if (point && typeof point === 'object') point = point.ptr;
  if (geom && typeof geom === 'object') geom = geom.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (closestPoint && typeof closestPoint === 'object') closestPoint = closestPoint.ptr;
  if (closestPoint === undefined) { return _emscripten_bind_PxGeometryQuery_pointDistance_3(point, geom, pose) }
  return _emscripten_bind_PxGeometryQuery_pointDistance_4(point, geom, pose, closestPoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryQuery.prototype['computeGeomBounds'] = PxGeometryQuery.prototype.computeGeomBounds = function(bounds, geom, pose, inflation) {
  if (bounds && typeof bounds === 'object') bounds = bounds.ptr;
  if (geom && typeof geom === 'object') geom = geom.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (inflation && typeof inflation === 'object') inflation = inflation.ptr;
  if (inflation === undefined) { _emscripten_bind_PxGeometryQuery_computeGeomBounds_3(bounds, geom, pose); return }
  _emscripten_bind_PxGeometryQuery_computeGeomBounds_4(bounds, geom, pose, inflation);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryQuery.prototype['isValid'] = PxGeometryQuery.prototype.isValid = function(geom) {
  if (geom && typeof geom === 'object') geom = geom.ptr;
  return !!(_emscripten_bind_PxGeometryQuery_isValid_1(geom));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGeometryQuery.prototype['__destroy__'] = PxGeometryQuery.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxGeometryQuery___destroy___0(self);
};

// Interface: PxGjkQuery

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxGjkQuery() { throw "cannot construct a PxGjkQuery, no constructor in IDL" }
PxGjkQuery.prototype = Object.create(WrapperObject.prototype);
PxGjkQuery.prototype.constructor = PxGjkQuery;
PxGjkQuery.prototype.__class__ = PxGjkQuery;
PxGjkQuery.__cache__ = {};
Module['PxGjkQuery'] = PxGjkQuery;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQuery.prototype['proximityInfo'] = PxGjkQuery.prototype.proximityInfo = function(a, b, poseA, poseB, contactDistance, toleranceLength, result) {
  if (a && typeof a === 'object') a = a.ptr;
  if (b && typeof b === 'object') b = b.ptr;
  if (poseA && typeof poseA === 'object') poseA = poseA.ptr;
  if (poseB && typeof poseB === 'object') poseB = poseB.ptr;
  if (contactDistance && typeof contactDistance === 'object') contactDistance = contactDistance.ptr;
  if (toleranceLength && typeof toleranceLength === 'object') toleranceLength = toleranceLength.ptr;
  if (result && typeof result === 'object') result = result.ptr;
  return !!(_emscripten_bind_PxGjkQuery_proximityInfo_7(a, b, poseA, poseB, contactDistance, toleranceLength, result));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQuery.prototype['raycast'] = PxGjkQuery.prototype.raycast = function(shape, pose, rayStart, unitDir, maxDist, result) {
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (rayStart && typeof rayStart === 'object') rayStart = rayStart.ptr;
  if (unitDir && typeof unitDir === 'object') unitDir = unitDir.ptr;
  if (maxDist && typeof maxDist === 'object') maxDist = maxDist.ptr;
  if (result && typeof result === 'object') result = result.ptr;
  return !!(_emscripten_bind_PxGjkQuery_raycast_6(shape, pose, rayStart, unitDir, maxDist, result));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQuery.prototype['overlap'] = PxGjkQuery.prototype.overlap = function(a, b, poseA, poseB) {
  if (a && typeof a === 'object') a = a.ptr;
  if (b && typeof b === 'object') b = b.ptr;
  if (poseA && typeof poseA === 'object') poseA = poseA.ptr;
  if (poseB && typeof poseB === 'object') poseB = poseB.ptr;
  return !!(_emscripten_bind_PxGjkQuery_overlap_4(a, b, poseA, poseB));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQuery.prototype['sweep'] = PxGjkQuery.prototype.sweep = function(a, b, poseA, poseB, unitDir, maxDist, result) {
  if (a && typeof a === 'object') a = a.ptr;
  if (b && typeof b === 'object') b = b.ptr;
  if (poseA && typeof poseA === 'object') poseA = poseA.ptr;
  if (poseB && typeof poseB === 'object') poseB = poseB.ptr;
  if (unitDir && typeof unitDir === 'object') unitDir = unitDir.ptr;
  if (maxDist && typeof maxDist === 'object') maxDist = maxDist.ptr;
  if (result && typeof result === 'object') result = result.ptr;
  return !!(_emscripten_bind_PxGjkQuery_sweep_7(a, b, poseA, poseB, unitDir, maxDist, result));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQuery.prototype['__destroy__'] = PxGjkQuery.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxGjkQuery___destroy___0(self);
};

// Interface: PxGjkQueryExt

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxGjkQueryExt() { throw "cannot construct a PxGjkQueryExt, no constructor in IDL" }
PxGjkQueryExt.prototype = Object.create(WrapperObject.prototype);
PxGjkQueryExt.prototype.constructor = PxGjkQueryExt;
PxGjkQueryExt.prototype.__class__ = PxGjkQueryExt;
PxGjkQueryExt.__cache__ = {};
Module['PxGjkQueryExt'] = PxGjkQueryExt;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryExt.prototype['generateContacts'] = PxGjkQueryExt.prototype.generateContacts = function(a, b, poseA, poseB, contactDistance, toleranceLength, contactBuffer) {
  if (a && typeof a === 'object') a = a.ptr;
  if (b && typeof b === 'object') b = b.ptr;
  if (poseA && typeof poseA === 'object') poseA = poseA.ptr;
  if (poseB && typeof poseB === 'object') poseB = poseB.ptr;
  if (contactDistance && typeof contactDistance === 'object') contactDistance = contactDistance.ptr;
  if (toleranceLength && typeof toleranceLength === 'object') toleranceLength = toleranceLength.ptr;
  if (contactBuffer && typeof contactBuffer === 'object') contactBuffer = contactBuffer.ptr;
  return !!(_emscripten_bind_PxGjkQueryExt_generateContacts_7(a, b, poseA, poseB, contactDistance, toleranceLength, contactBuffer));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryExt.prototype['__destroy__'] = PxGjkQueryExt.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxGjkQueryExt___destroy___0(self);
};

// Interface: PxGjkQueryProximityInfoResult

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxGjkQueryProximityInfoResult() {
  this.ptr = _emscripten_bind_PxGjkQueryProximityInfoResult_PxGjkQueryProximityInfoResult_0();
  getCache(PxGjkQueryProximityInfoResult)[this.ptr] = this;
};

PxGjkQueryProximityInfoResult.prototype = Object.create(WrapperObject.prototype);
PxGjkQueryProximityInfoResult.prototype.constructor = PxGjkQueryProximityInfoResult;
PxGjkQueryProximityInfoResult.prototype.__class__ = PxGjkQueryProximityInfoResult;
PxGjkQueryProximityInfoResult.__cache__ = {};
Module['PxGjkQueryProximityInfoResult'] = PxGjkQueryProximityInfoResult;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryProximityInfoResult.prototype['get_success'] = PxGjkQueryProximityInfoResult.prototype.get_success = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxGjkQueryProximityInfoResult_get_success_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryProximityInfoResult.prototype['set_success'] = PxGjkQueryProximityInfoResult.prototype.set_success = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGjkQueryProximityInfoResult_set_success_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGjkQueryProximityInfoResult.prototype, 'success', { get: PxGjkQueryProximityInfoResult.prototype.get_success, set: PxGjkQueryProximityInfoResult.prototype.set_success });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryProximityInfoResult.prototype['get_pointA'] = PxGjkQueryProximityInfoResult.prototype.get_pointA = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGjkQueryProximityInfoResult_get_pointA_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryProximityInfoResult.prototype['set_pointA'] = PxGjkQueryProximityInfoResult.prototype.set_pointA = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGjkQueryProximityInfoResult_set_pointA_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGjkQueryProximityInfoResult.prototype, 'pointA', { get: PxGjkQueryProximityInfoResult.prototype.get_pointA, set: PxGjkQueryProximityInfoResult.prototype.set_pointA });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryProximityInfoResult.prototype['get_pointB'] = PxGjkQueryProximityInfoResult.prototype.get_pointB = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGjkQueryProximityInfoResult_get_pointB_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryProximityInfoResult.prototype['set_pointB'] = PxGjkQueryProximityInfoResult.prototype.set_pointB = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGjkQueryProximityInfoResult_set_pointB_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGjkQueryProximityInfoResult.prototype, 'pointB', { get: PxGjkQueryProximityInfoResult.prototype.get_pointB, set: PxGjkQueryProximityInfoResult.prototype.set_pointB });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryProximityInfoResult.prototype['get_separatingAxis'] = PxGjkQueryProximityInfoResult.prototype.get_separatingAxis = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGjkQueryProximityInfoResult_get_separatingAxis_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryProximityInfoResult.prototype['set_separatingAxis'] = PxGjkQueryProximityInfoResult.prototype.set_separatingAxis = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGjkQueryProximityInfoResult_set_separatingAxis_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGjkQueryProximityInfoResult.prototype, 'separatingAxis', { get: PxGjkQueryProximityInfoResult.prototype.get_separatingAxis, set: PxGjkQueryProximityInfoResult.prototype.set_separatingAxis });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryProximityInfoResult.prototype['get_separation'] = PxGjkQueryProximityInfoResult.prototype.get_separation = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGjkQueryProximityInfoResult_get_separation_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryProximityInfoResult.prototype['set_separation'] = PxGjkQueryProximityInfoResult.prototype.set_separation = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGjkQueryProximityInfoResult_set_separation_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGjkQueryProximityInfoResult.prototype, 'separation', { get: PxGjkQueryProximityInfoResult.prototype.get_separation, set: PxGjkQueryProximityInfoResult.prototype.set_separation });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryProximityInfoResult.prototype['__destroy__'] = PxGjkQueryProximityInfoResult.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxGjkQueryProximityInfoResult___destroy___0(self);
};

// Interface: PxGjkQueryRaycastResult

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxGjkQueryRaycastResult() {
  this.ptr = _emscripten_bind_PxGjkQueryRaycastResult_PxGjkQueryRaycastResult_0();
  getCache(PxGjkQueryRaycastResult)[this.ptr] = this;
};

PxGjkQueryRaycastResult.prototype = Object.create(WrapperObject.prototype);
PxGjkQueryRaycastResult.prototype.constructor = PxGjkQueryRaycastResult;
PxGjkQueryRaycastResult.prototype.__class__ = PxGjkQueryRaycastResult;
PxGjkQueryRaycastResult.__cache__ = {};
Module['PxGjkQueryRaycastResult'] = PxGjkQueryRaycastResult;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryRaycastResult.prototype['get_success'] = PxGjkQueryRaycastResult.prototype.get_success = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxGjkQueryRaycastResult_get_success_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryRaycastResult.prototype['set_success'] = PxGjkQueryRaycastResult.prototype.set_success = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGjkQueryRaycastResult_set_success_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGjkQueryRaycastResult.prototype, 'success', { get: PxGjkQueryRaycastResult.prototype.get_success, set: PxGjkQueryRaycastResult.prototype.set_success });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryRaycastResult.prototype['get_t'] = PxGjkQueryRaycastResult.prototype.get_t = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGjkQueryRaycastResult_get_t_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryRaycastResult.prototype['set_t'] = PxGjkQueryRaycastResult.prototype.set_t = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGjkQueryRaycastResult_set_t_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGjkQueryRaycastResult.prototype, 't', { get: PxGjkQueryRaycastResult.prototype.get_t, set: PxGjkQueryRaycastResult.prototype.set_t });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryRaycastResult.prototype['get_n'] = PxGjkQueryRaycastResult.prototype.get_n = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGjkQueryRaycastResult_get_n_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryRaycastResult.prototype['set_n'] = PxGjkQueryRaycastResult.prototype.set_n = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGjkQueryRaycastResult_set_n_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGjkQueryRaycastResult.prototype, 'n', { get: PxGjkQueryRaycastResult.prototype.get_n, set: PxGjkQueryRaycastResult.prototype.set_n });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryRaycastResult.prototype['get_p'] = PxGjkQueryRaycastResult.prototype.get_p = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGjkQueryRaycastResult_get_p_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryRaycastResult.prototype['set_p'] = PxGjkQueryRaycastResult.prototype.set_p = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGjkQueryRaycastResult_set_p_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGjkQueryRaycastResult.prototype, 'p', { get: PxGjkQueryRaycastResult.prototype.get_p, set: PxGjkQueryRaycastResult.prototype.set_p });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQueryRaycastResult.prototype['__destroy__'] = PxGjkQueryRaycastResult.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxGjkQueryRaycastResult___destroy___0(self);
};

// Interface: PxGjkQuerySweepResult

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxGjkQuerySweepResult() {
  this.ptr = _emscripten_bind_PxGjkQuerySweepResult_PxGjkQuerySweepResult_0();
  getCache(PxGjkQuerySweepResult)[this.ptr] = this;
};

PxGjkQuerySweepResult.prototype = Object.create(WrapperObject.prototype);
PxGjkQuerySweepResult.prototype.constructor = PxGjkQuerySweepResult;
PxGjkQuerySweepResult.prototype.__class__ = PxGjkQuerySweepResult;
PxGjkQuerySweepResult.__cache__ = {};
Module['PxGjkQuerySweepResult'] = PxGjkQuerySweepResult;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQuerySweepResult.prototype['get_success'] = PxGjkQuerySweepResult.prototype.get_success = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxGjkQuerySweepResult_get_success_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQuerySweepResult.prototype['set_success'] = PxGjkQuerySweepResult.prototype.set_success = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGjkQuerySweepResult_set_success_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGjkQuerySweepResult.prototype, 'success', { get: PxGjkQuerySweepResult.prototype.get_success, set: PxGjkQuerySweepResult.prototype.set_success });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQuerySweepResult.prototype['get_t'] = PxGjkQuerySweepResult.prototype.get_t = function() {
  var self = this.ptr;
  return _emscripten_bind_PxGjkQuerySweepResult_get_t_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQuerySweepResult.prototype['set_t'] = PxGjkQuerySweepResult.prototype.set_t = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGjkQuerySweepResult_set_t_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGjkQuerySweepResult.prototype, 't', { get: PxGjkQuerySweepResult.prototype.get_t, set: PxGjkQuerySweepResult.prototype.set_t });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQuerySweepResult.prototype['get_n'] = PxGjkQuerySweepResult.prototype.get_n = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGjkQuerySweepResult_get_n_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQuerySweepResult.prototype['set_n'] = PxGjkQuerySweepResult.prototype.set_n = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGjkQuerySweepResult_set_n_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGjkQuerySweepResult.prototype, 'n', { get: PxGjkQuerySweepResult.prototype.get_n, set: PxGjkQuerySweepResult.prototype.set_n });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQuerySweepResult.prototype['get_p'] = PxGjkQuerySweepResult.prototype.get_p = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxGjkQuerySweepResult_get_p_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQuerySweepResult.prototype['set_p'] = PxGjkQuerySweepResult.prototype.set_p = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxGjkQuerySweepResult_set_p_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxGjkQuerySweepResult.prototype, 'p', { get: PxGjkQuerySweepResult.prototype.get_p, set: PxGjkQuerySweepResult.prototype.set_p });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxGjkQuerySweepResult.prototype['__destroy__'] = PxGjkQuerySweepResult.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxGjkQuerySweepResult___destroy___0(self);
};

// Interface: PxHeightField

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxHeightField() { throw "cannot construct a PxHeightField, no constructor in IDL" }
PxHeightField.prototype = Object.create(PxRefCounted.prototype);
PxHeightField.prototype.constructor = PxHeightField;
PxHeightField.prototype.__class__ = PxHeightField;
PxHeightField.__cache__ = {};
Module['PxHeightField'] = PxHeightField;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['saveCells'] = PxHeightField.prototype.saveCells = function(destBuffer, destBufferSize) {
  var self = this.ptr;
  if (destBuffer && typeof destBuffer === 'object') destBuffer = destBuffer.ptr;
  if (destBufferSize && typeof destBufferSize === 'object') destBufferSize = destBufferSize.ptr;
  return _emscripten_bind_PxHeightField_saveCells_2(self, destBuffer, destBufferSize);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['modifySamples'] = PxHeightField.prototype.modifySamples = function(startCol, startRow, subfieldDesc, shrinkBounds) {
  var self = this.ptr;
  if (startCol && typeof startCol === 'object') startCol = startCol.ptr;
  if (startRow && typeof startRow === 'object') startRow = startRow.ptr;
  if (subfieldDesc && typeof subfieldDesc === 'object') subfieldDesc = subfieldDesc.ptr;
  if (shrinkBounds && typeof shrinkBounds === 'object') shrinkBounds = shrinkBounds.ptr;
  if (shrinkBounds === undefined) { return !!(_emscripten_bind_PxHeightField_modifySamples_3(self, startCol, startRow, subfieldDesc)) }
  return !!(_emscripten_bind_PxHeightField_modifySamples_4(self, startCol, startRow, subfieldDesc, shrinkBounds));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getNbRows'] = PxHeightField.prototype.getNbRows = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightField_getNbRows_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getNbColumns'] = PxHeightField.prototype.getNbColumns = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightField_getNbColumns_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getFormat'] = PxHeightField.prototype.getFormat = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightField_getFormat_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getSampleStride'] = PxHeightField.prototype.getSampleStride = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightField_getSampleStride_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getConvexEdgeThreshold'] = PxHeightField.prototype.getConvexEdgeThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightField_getConvexEdgeThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getFlags'] = PxHeightField.prototype.getFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxHeightField_getFlags_0(self), PxHeightFieldFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getHeight'] = PxHeightField.prototype.getHeight = function(x, z) {
  var self = this.ptr;
  if (x && typeof x === 'object') x = x.ptr;
  if (z && typeof z === 'object') z = z.ptr;
  return _emscripten_bind_PxHeightField_getHeight_2(self, x, z);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getTriangleMaterialIndex'] = PxHeightField.prototype.getTriangleMaterialIndex = function(triangleIndex) {
  var self = this.ptr;
  if (triangleIndex && typeof triangleIndex === 'object') triangleIndex = triangleIndex.ptr;
  return _emscripten_bind_PxHeightField_getTriangleMaterialIndex_1(self, triangleIndex);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getTriangleNormal'] = PxHeightField.prototype.getTriangleNormal = function(triangleIndex) {
  var self = this.ptr;
  if (triangleIndex && typeof triangleIndex === 'object') triangleIndex = triangleIndex.ptr;
  return wrapPointer(_emscripten_bind_PxHeightField_getTriangleNormal_1(self, triangleIndex), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getSample'] = PxHeightField.prototype.getSample = function(row, column) {
  var self = this.ptr;
  if (row && typeof row === 'object') row = row.ptr;
  if (column && typeof column === 'object') column = column.ptr;
  return wrapPointer(_emscripten_bind_PxHeightField_getSample_2(self, row, column), PxHeightFieldSample);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getTimestamp'] = PxHeightField.prototype.getTimestamp = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightField_getTimestamp_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['release'] = PxHeightField.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxHeightField_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getConcreteTypeName'] = PxHeightField.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxHeightField_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getConcreteType'] = PxHeightField.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightField_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['setBaseFlag'] = PxHeightField.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxHeightField_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['setBaseFlags'] = PxHeightField.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxHeightField_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getBaseFlags'] = PxHeightField.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxHeightField_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['isReleasable'] = PxHeightField.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxHeightField_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['getReferenceCount'] = PxHeightField.prototype.getReferenceCount = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightField_getReferenceCount_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightField.prototype['acquireReference'] = PxHeightField.prototype.acquireReference = function() {
  var self = this.ptr;
  _emscripten_bind_PxHeightField_acquireReference_0(self);
};


// Interface: PxHeightFieldDesc

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxHeightFieldDesc() {
  this.ptr = _emscripten_bind_PxHeightFieldDesc_PxHeightFieldDesc_0();
  getCache(PxHeightFieldDesc)[this.ptr] = this;
};

PxHeightFieldDesc.prototype = Object.create(WrapperObject.prototype);
PxHeightFieldDesc.prototype.constructor = PxHeightFieldDesc;
PxHeightFieldDesc.prototype.__class__ = PxHeightFieldDesc;
PxHeightFieldDesc.__cache__ = {};
Module['PxHeightFieldDesc'] = PxHeightFieldDesc;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['setToDefault'] = PxHeightFieldDesc.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxHeightFieldDesc_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['isValid'] = PxHeightFieldDesc.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxHeightFieldDesc_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['get_nbRows'] = PxHeightFieldDesc.prototype.get_nbRows = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightFieldDesc_get_nbRows_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['set_nbRows'] = PxHeightFieldDesc.prototype.set_nbRows = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHeightFieldDesc_set_nbRows_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHeightFieldDesc.prototype, 'nbRows', { get: PxHeightFieldDesc.prototype.get_nbRows, set: PxHeightFieldDesc.prototype.set_nbRows });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['get_nbColumns'] = PxHeightFieldDesc.prototype.get_nbColumns = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightFieldDesc_get_nbColumns_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['set_nbColumns'] = PxHeightFieldDesc.prototype.set_nbColumns = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHeightFieldDesc_set_nbColumns_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHeightFieldDesc.prototype, 'nbColumns', { get: PxHeightFieldDesc.prototype.get_nbColumns, set: PxHeightFieldDesc.prototype.set_nbColumns });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['get_format'] = PxHeightFieldDesc.prototype.get_format = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightFieldDesc_get_format_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['set_format'] = PxHeightFieldDesc.prototype.set_format = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHeightFieldDesc_set_format_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHeightFieldDesc.prototype, 'format', { get: PxHeightFieldDesc.prototype.get_format, set: PxHeightFieldDesc.prototype.set_format });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['get_samples'] = PxHeightFieldDesc.prototype.get_samples = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxHeightFieldDesc_get_samples_0(self), PxStridedData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['set_samples'] = PxHeightFieldDesc.prototype.set_samples = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHeightFieldDesc_set_samples_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHeightFieldDesc.prototype, 'samples', { get: PxHeightFieldDesc.prototype.get_samples, set: PxHeightFieldDesc.prototype.set_samples });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['get_convexEdgeThreshold'] = PxHeightFieldDesc.prototype.get_convexEdgeThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightFieldDesc_get_convexEdgeThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['set_convexEdgeThreshold'] = PxHeightFieldDesc.prototype.set_convexEdgeThreshold = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHeightFieldDesc_set_convexEdgeThreshold_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHeightFieldDesc.prototype, 'convexEdgeThreshold', { get: PxHeightFieldDesc.prototype.get_convexEdgeThreshold, set: PxHeightFieldDesc.prototype.set_convexEdgeThreshold });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['get_flags'] = PxHeightFieldDesc.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxHeightFieldDesc_get_flags_0(self), PxHeightFieldFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['set_flags'] = PxHeightFieldDesc.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHeightFieldDesc_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHeightFieldDesc.prototype, 'flags', { get: PxHeightFieldDesc.prototype.get_flags, set: PxHeightFieldDesc.prototype.set_flags });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldDesc.prototype['__destroy__'] = PxHeightFieldDesc.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxHeightFieldDesc___destroy___0(self);
};

// Interface: PxHeightFieldFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxHeightFieldFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxHeightFieldFlags_PxHeightFieldFlags_1(flags);
  getCache(PxHeightFieldFlags)[this.ptr] = this;
};

PxHeightFieldFlags.prototype = Object.create(WrapperObject.prototype);
PxHeightFieldFlags.prototype.constructor = PxHeightFieldFlags;
PxHeightFieldFlags.prototype.__class__ = PxHeightFieldFlags;
PxHeightFieldFlags.__cache__ = {};
Module['PxHeightFieldFlags'] = PxHeightFieldFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldFlags.prototype['isSet'] = PxHeightFieldFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxHeightFieldFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldFlags.prototype['raise'] = PxHeightFieldFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxHeightFieldFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldFlags.prototype['clear'] = PxHeightFieldFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxHeightFieldFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldFlags.prototype['__destroy__'] = PxHeightFieldFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxHeightFieldFlags___destroy___0(self);
};

// Interface: PxHeightFieldGeometry

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxHeightFieldGeometry(hf, flags, heightScale, rowScale, columnScale) {
  if (hf && typeof hf === 'object') hf = hf.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  if (heightScale && typeof heightScale === 'object') heightScale = heightScale.ptr;
  if (rowScale && typeof rowScale === 'object') rowScale = rowScale.ptr;
  if (columnScale && typeof columnScale === 'object') columnScale = columnScale.ptr;
  if (hf === undefined) { this.ptr = _emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_0(); getCache(PxHeightFieldGeometry)[this.ptr] = this;return }
  if (flags === undefined) { this.ptr = _emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_1(hf); getCache(PxHeightFieldGeometry)[this.ptr] = this;return }
  if (heightScale === undefined) { this.ptr = _emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_2(hf, flags); getCache(PxHeightFieldGeometry)[this.ptr] = this;return }
  if (rowScale === undefined) { this.ptr = _emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_3(hf, flags, heightScale); getCache(PxHeightFieldGeometry)[this.ptr] = this;return }
  if (columnScale === undefined) { this.ptr = _emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_4(hf, flags, heightScale, rowScale); getCache(PxHeightFieldGeometry)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxHeightFieldGeometry_PxHeightFieldGeometry_5(hf, flags, heightScale, rowScale, columnScale);
  getCache(PxHeightFieldGeometry)[this.ptr] = this;
};

PxHeightFieldGeometry.prototype = Object.create(PxGeometry.prototype);
PxHeightFieldGeometry.prototype.constructor = PxHeightFieldGeometry;
PxHeightFieldGeometry.prototype.__class__ = PxHeightFieldGeometry;
PxHeightFieldGeometry.__cache__ = {};
Module['PxHeightFieldGeometry'] = PxHeightFieldGeometry;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldGeometry.prototype['isValid'] = PxHeightFieldGeometry.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxHeightFieldGeometry_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldGeometry.prototype['getType'] = PxHeightFieldGeometry.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightFieldGeometry_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldGeometry.prototype['get_heightField'] = PxHeightFieldGeometry.prototype.get_heightField = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxHeightFieldGeometry_get_heightField_0(self), PxHeightField);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldGeometry.prototype['set_heightField'] = PxHeightFieldGeometry.prototype.set_heightField = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHeightFieldGeometry_set_heightField_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHeightFieldGeometry.prototype, 'heightField', { get: PxHeightFieldGeometry.prototype.get_heightField, set: PxHeightFieldGeometry.prototype.set_heightField });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldGeometry.prototype['get_heightScale'] = PxHeightFieldGeometry.prototype.get_heightScale = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightFieldGeometry_get_heightScale_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldGeometry.prototype['set_heightScale'] = PxHeightFieldGeometry.prototype.set_heightScale = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHeightFieldGeometry_set_heightScale_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHeightFieldGeometry.prototype, 'heightScale', { get: PxHeightFieldGeometry.prototype.get_heightScale, set: PxHeightFieldGeometry.prototype.set_heightScale });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldGeometry.prototype['get_rowScale'] = PxHeightFieldGeometry.prototype.get_rowScale = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightFieldGeometry_get_rowScale_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldGeometry.prototype['set_rowScale'] = PxHeightFieldGeometry.prototype.set_rowScale = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHeightFieldGeometry_set_rowScale_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHeightFieldGeometry.prototype, 'rowScale', { get: PxHeightFieldGeometry.prototype.get_rowScale, set: PxHeightFieldGeometry.prototype.set_rowScale });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldGeometry.prototype['get_columnScale'] = PxHeightFieldGeometry.prototype.get_columnScale = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightFieldGeometry_get_columnScale_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldGeometry.prototype['set_columnScale'] = PxHeightFieldGeometry.prototype.set_columnScale = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHeightFieldGeometry_set_columnScale_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHeightFieldGeometry.prototype, 'columnScale', { get: PxHeightFieldGeometry.prototype.get_columnScale, set: PxHeightFieldGeometry.prototype.set_columnScale });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldGeometry.prototype['get_heightFieldFlags'] = PxHeightFieldGeometry.prototype.get_heightFieldFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxHeightFieldGeometry_get_heightFieldFlags_0(self), PxMeshGeometryFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldGeometry.prototype['set_heightFieldFlags'] = PxHeightFieldGeometry.prototype.set_heightFieldFlags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHeightFieldGeometry_set_heightFieldFlags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHeightFieldGeometry.prototype, 'heightFieldFlags', { get: PxHeightFieldGeometry.prototype.get_heightFieldFlags, set: PxHeightFieldGeometry.prototype.set_heightFieldFlags });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldGeometry.prototype['__destroy__'] = PxHeightFieldGeometry.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxHeightFieldGeometry___destroy___0(self);
};

// Interface: PxHeightFieldSample

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxHeightFieldSample() {
  this.ptr = _emscripten_bind_PxHeightFieldSample_PxHeightFieldSample_0();
  getCache(PxHeightFieldSample)[this.ptr] = this;
};

PxHeightFieldSample.prototype = Object.create(WrapperObject.prototype);
PxHeightFieldSample.prototype.constructor = PxHeightFieldSample;
PxHeightFieldSample.prototype.__class__ = PxHeightFieldSample;
PxHeightFieldSample.__cache__ = {};
Module['PxHeightFieldSample'] = PxHeightFieldSample;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldSample.prototype['tessFlag'] = PxHeightFieldSample.prototype.tessFlag = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightFieldSample_tessFlag_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldSample.prototype['clearTessFlag'] = PxHeightFieldSample.prototype.clearTessFlag = function() {
  var self = this.ptr;
  _emscripten_bind_PxHeightFieldSample_clearTessFlag_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldSample.prototype['setTessFlag'] = PxHeightFieldSample.prototype.setTessFlag = function() {
  var self = this.ptr;
  _emscripten_bind_PxHeightFieldSample_setTessFlag_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldSample.prototype['get_height'] = PxHeightFieldSample.prototype.get_height = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightFieldSample_get_height_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldSample.prototype['set_height'] = PxHeightFieldSample.prototype.set_height = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHeightFieldSample_set_height_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHeightFieldSample.prototype, 'height', { get: PxHeightFieldSample.prototype.get_height, set: PxHeightFieldSample.prototype.set_height });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldSample.prototype['get_materialIndex0'] = PxHeightFieldSample.prototype.get_materialIndex0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightFieldSample_get_materialIndex0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldSample.prototype['set_materialIndex0'] = PxHeightFieldSample.prototype.set_materialIndex0 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHeightFieldSample_set_materialIndex0_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHeightFieldSample.prototype, 'materialIndex0', { get: PxHeightFieldSample.prototype.get_materialIndex0, set: PxHeightFieldSample.prototype.set_materialIndex0 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldSample.prototype['get_materialIndex1'] = PxHeightFieldSample.prototype.get_materialIndex1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHeightFieldSample_get_materialIndex1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldSample.prototype['set_materialIndex1'] = PxHeightFieldSample.prototype.set_materialIndex1 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHeightFieldSample_set_materialIndex1_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHeightFieldSample.prototype, 'materialIndex1', { get: PxHeightFieldSample.prototype.get_materialIndex1, set: PxHeightFieldSample.prototype.set_materialIndex1 });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHeightFieldSample.prototype['__destroy__'] = PxHeightFieldSample.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxHeightFieldSample___destroy___0(self);
};

// Interface: PxHitFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxHitFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxHitFlags_PxHitFlags_1(flags);
  getCache(PxHitFlags)[this.ptr] = this;
};

PxHitFlags.prototype = Object.create(WrapperObject.prototype);
PxHitFlags.prototype.constructor = PxHitFlags;
PxHitFlags.prototype.__class__ = PxHitFlags;
PxHitFlags.__cache__ = {};
Module['PxHitFlags'] = PxHitFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHitFlags.prototype['isSet'] = PxHitFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxHitFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHitFlags.prototype['raise'] = PxHitFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxHitFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHitFlags.prototype['clear'] = PxHitFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxHitFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHitFlags.prototype['__destroy__'] = PxHitFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxHitFlags___destroy___0(self);
};

// Interface: PxHullPolygon

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxHullPolygon() {
  this.ptr = _emscripten_bind_PxHullPolygon_PxHullPolygon_0();
  getCache(PxHullPolygon)[this.ptr] = this;
};

PxHullPolygon.prototype = Object.create(WrapperObject.prototype);
PxHullPolygon.prototype.constructor = PxHullPolygon;
PxHullPolygon.prototype.__class__ = PxHullPolygon;
PxHullPolygon.__cache__ = {};
Module['PxHullPolygon'] = PxHullPolygon;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHullPolygon.prototype['get_mPlane'] = PxHullPolygon.prototype.get_mPlane = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxHullPolygon_get_mPlane_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHullPolygon.prototype['set_mPlane'] = PxHullPolygon.prototype.set_mPlane = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxHullPolygon_set_mPlane_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHullPolygon.prototype, 'mPlane', { get: PxHullPolygon.prototype.get_mPlane, set: PxHullPolygon.prototype.set_mPlane });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHullPolygon.prototype['get_mNbVerts'] = PxHullPolygon.prototype.get_mNbVerts = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHullPolygon_get_mNbVerts_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHullPolygon.prototype['set_mNbVerts'] = PxHullPolygon.prototype.set_mNbVerts = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHullPolygon_set_mNbVerts_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHullPolygon.prototype, 'mNbVerts', { get: PxHullPolygon.prototype.get_mNbVerts, set: PxHullPolygon.prototype.set_mNbVerts });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHullPolygon.prototype['get_mIndexBase'] = PxHullPolygon.prototype.get_mIndexBase = function() {
  var self = this.ptr;
  return _emscripten_bind_PxHullPolygon_get_mIndexBase_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHullPolygon.prototype['set_mIndexBase'] = PxHullPolygon.prototype.set_mIndexBase = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxHullPolygon_set_mIndexBase_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxHullPolygon.prototype, 'mIndexBase', { get: PxHullPolygon.prototype.get_mIndexBase, set: PxHullPolygon.prototype.set_mIndexBase });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxHullPolygon.prototype['__destroy__'] = PxHullPolygon.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxHullPolygon___destroy___0(self);
};

// Interface: PxI32Ptr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxI32Ptr() { throw "cannot construct a PxI32Ptr, no constructor in IDL" }
PxI32Ptr.prototype = Object.create(PxI32ConstPtr.prototype);
PxI32Ptr.prototype.constructor = PxI32Ptr;
PxI32Ptr.prototype.__class__ = PxI32Ptr;
PxI32Ptr.__cache__ = {};
Module['PxI32Ptr'] = PxI32Ptr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxI32Ptr.prototype['__destroy__'] = PxI32Ptr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxI32Ptr___destroy___0(self);
};

// Interface: PxInsertionCallback

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxInsertionCallback() { throw "cannot construct a PxInsertionCallback, no constructor in IDL" }
PxInsertionCallback.prototype = Object.create(WrapperObject.prototype);
PxInsertionCallback.prototype.constructor = PxInsertionCallback;
PxInsertionCallback.prototype.__class__ = PxInsertionCallback;
PxInsertionCallback.__cache__ = {};
Module['PxInsertionCallback'] = PxInsertionCallback;

// Interface: PxJointAngularLimitPair

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxJointAngularLimitPair(lowerLimit, upperLimit, spring) {
  if (lowerLimit && typeof lowerLimit === 'object') lowerLimit = lowerLimit.ptr;
  if (upperLimit && typeof upperLimit === 'object') upperLimit = upperLimit.ptr;
  if (spring && typeof spring === 'object') spring = spring.ptr;
  if (spring === undefined) { this.ptr = _emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_2(lowerLimit, upperLimit); getCache(PxJointAngularLimitPair)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxJointAngularLimitPair_PxJointAngularLimitPair_3(lowerLimit, upperLimit, spring);
  getCache(PxJointAngularLimitPair)[this.ptr] = this;
};

PxJointAngularLimitPair.prototype = Object.create(PxJointLimitParameters.prototype);
PxJointAngularLimitPair.prototype.constructor = PxJointAngularLimitPair;
PxJointAngularLimitPair.prototype.__class__ = PxJointAngularLimitPair;
PxJointAngularLimitPair.__cache__ = {};
Module['PxJointAngularLimitPair'] = PxJointAngularLimitPair;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['isValid'] = PxJointAngularLimitPair.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxJointAngularLimitPair_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['isSoft'] = PxJointAngularLimitPair.prototype.isSoft = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxJointAngularLimitPair_isSoft_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['get_upper'] = PxJointAngularLimitPair.prototype.get_upper = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointAngularLimitPair_get_upper_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['set_upper'] = PxJointAngularLimitPair.prototype.set_upper = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointAngularLimitPair_set_upper_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointAngularLimitPair.prototype, 'upper', { get: PxJointAngularLimitPair.prototype.get_upper, set: PxJointAngularLimitPair.prototype.set_upper });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['get_lower'] = PxJointAngularLimitPair.prototype.get_lower = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointAngularLimitPair_get_lower_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['set_lower'] = PxJointAngularLimitPair.prototype.set_lower = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointAngularLimitPair_set_lower_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointAngularLimitPair.prototype, 'lower', { get: PxJointAngularLimitPair.prototype.get_lower, set: PxJointAngularLimitPair.prototype.set_lower });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['get_restitution'] = PxJointAngularLimitPair.prototype.get_restitution = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointAngularLimitPair_get_restitution_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['set_restitution'] = PxJointAngularLimitPair.prototype.set_restitution = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointAngularLimitPair_set_restitution_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointAngularLimitPair.prototype, 'restitution', { get: PxJointAngularLimitPair.prototype.get_restitution, set: PxJointAngularLimitPair.prototype.set_restitution });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['get_bounceThreshold'] = PxJointAngularLimitPair.prototype.get_bounceThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointAngularLimitPair_get_bounceThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['set_bounceThreshold'] = PxJointAngularLimitPair.prototype.set_bounceThreshold = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointAngularLimitPair_set_bounceThreshold_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointAngularLimitPair.prototype, 'bounceThreshold', { get: PxJointAngularLimitPair.prototype.get_bounceThreshold, set: PxJointAngularLimitPair.prototype.set_bounceThreshold });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['get_stiffness'] = PxJointAngularLimitPair.prototype.get_stiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointAngularLimitPair_get_stiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['set_stiffness'] = PxJointAngularLimitPair.prototype.set_stiffness = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointAngularLimitPair_set_stiffness_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointAngularLimitPair.prototype, 'stiffness', { get: PxJointAngularLimitPair.prototype.get_stiffness, set: PxJointAngularLimitPair.prototype.set_stiffness });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['get_damping'] = PxJointAngularLimitPair.prototype.get_damping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointAngularLimitPair_get_damping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['set_damping'] = PxJointAngularLimitPair.prototype.set_damping = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointAngularLimitPair_set_damping_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointAngularLimitPair.prototype, 'damping', { get: PxJointAngularLimitPair.prototype.get_damping, set: PxJointAngularLimitPair.prototype.set_damping });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointAngularLimitPair.prototype['__destroy__'] = PxJointAngularLimitPair.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxJointAngularLimitPair___destroy___0(self);
};

// Interface: PxJointLimitCone

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxJointLimitCone(yLimitAngle, zLimitAngle, spring) {
  if (yLimitAngle && typeof yLimitAngle === 'object') yLimitAngle = yLimitAngle.ptr;
  if (zLimitAngle && typeof zLimitAngle === 'object') zLimitAngle = zLimitAngle.ptr;
  if (spring && typeof spring === 'object') spring = spring.ptr;
  if (spring === undefined) { this.ptr = _emscripten_bind_PxJointLimitCone_PxJointLimitCone_2(yLimitAngle, zLimitAngle); getCache(PxJointLimitCone)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxJointLimitCone_PxJointLimitCone_3(yLimitAngle, zLimitAngle, spring);
  getCache(PxJointLimitCone)[this.ptr] = this;
};

PxJointLimitCone.prototype = Object.create(PxJointLimitParameters.prototype);
PxJointLimitCone.prototype.constructor = PxJointLimitCone;
PxJointLimitCone.prototype.__class__ = PxJointLimitCone;
PxJointLimitCone.__cache__ = {};
Module['PxJointLimitCone'] = PxJointLimitCone;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['isValid'] = PxJointLimitCone.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxJointLimitCone_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['isSoft'] = PxJointLimitCone.prototype.isSoft = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxJointLimitCone_isSoft_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['get_yAngle'] = PxJointLimitCone.prototype.get_yAngle = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitCone_get_yAngle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['set_yAngle'] = PxJointLimitCone.prototype.set_yAngle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitCone_set_yAngle_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitCone.prototype, 'yAngle', { get: PxJointLimitCone.prototype.get_yAngle, set: PxJointLimitCone.prototype.set_yAngle });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['get_zAngle'] = PxJointLimitCone.prototype.get_zAngle = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitCone_get_zAngle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['set_zAngle'] = PxJointLimitCone.prototype.set_zAngle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitCone_set_zAngle_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitCone.prototype, 'zAngle', { get: PxJointLimitCone.prototype.get_zAngle, set: PxJointLimitCone.prototype.set_zAngle });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['get_restitution'] = PxJointLimitCone.prototype.get_restitution = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitCone_get_restitution_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['set_restitution'] = PxJointLimitCone.prototype.set_restitution = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitCone_set_restitution_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitCone.prototype, 'restitution', { get: PxJointLimitCone.prototype.get_restitution, set: PxJointLimitCone.prototype.set_restitution });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['get_bounceThreshold'] = PxJointLimitCone.prototype.get_bounceThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitCone_get_bounceThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['set_bounceThreshold'] = PxJointLimitCone.prototype.set_bounceThreshold = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitCone_set_bounceThreshold_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitCone.prototype, 'bounceThreshold', { get: PxJointLimitCone.prototype.get_bounceThreshold, set: PxJointLimitCone.prototype.set_bounceThreshold });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['get_stiffness'] = PxJointLimitCone.prototype.get_stiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitCone_get_stiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['set_stiffness'] = PxJointLimitCone.prototype.set_stiffness = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitCone_set_stiffness_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitCone.prototype, 'stiffness', { get: PxJointLimitCone.prototype.get_stiffness, set: PxJointLimitCone.prototype.set_stiffness });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['get_damping'] = PxJointLimitCone.prototype.get_damping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitCone_get_damping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['set_damping'] = PxJointLimitCone.prototype.set_damping = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitCone_set_damping_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitCone.prototype, 'damping', { get: PxJointLimitCone.prototype.get_damping, set: PxJointLimitCone.prototype.set_damping });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitCone.prototype['__destroy__'] = PxJointLimitCone.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxJointLimitCone___destroy___0(self);
};

// Interface: PxJointLimitPyramid

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxJointLimitPyramid(yLimitAngleMin, yLimitAngleMax, zLimitAngleMin, zLimitAngleMax, spring) {
  if (yLimitAngleMin && typeof yLimitAngleMin === 'object') yLimitAngleMin = yLimitAngleMin.ptr;
  if (yLimitAngleMax && typeof yLimitAngleMax === 'object') yLimitAngleMax = yLimitAngleMax.ptr;
  if (zLimitAngleMin && typeof zLimitAngleMin === 'object') zLimitAngleMin = zLimitAngleMin.ptr;
  if (zLimitAngleMax && typeof zLimitAngleMax === 'object') zLimitAngleMax = zLimitAngleMax.ptr;
  if (spring && typeof spring === 'object') spring = spring.ptr;
  if (spring === undefined) { this.ptr = _emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_4(yLimitAngleMin, yLimitAngleMax, zLimitAngleMin, zLimitAngleMax); getCache(PxJointLimitPyramid)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxJointLimitPyramid_PxJointLimitPyramid_5(yLimitAngleMin, yLimitAngleMax, zLimitAngleMin, zLimitAngleMax, spring);
  getCache(PxJointLimitPyramid)[this.ptr] = this;
};

PxJointLimitPyramid.prototype = Object.create(PxJointLimitParameters.prototype);
PxJointLimitPyramid.prototype.constructor = PxJointLimitPyramid;
PxJointLimitPyramid.prototype.__class__ = PxJointLimitPyramid;
PxJointLimitPyramid.__cache__ = {};
Module['PxJointLimitPyramid'] = PxJointLimitPyramid;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['isValid'] = PxJointLimitPyramid.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxJointLimitPyramid_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['isSoft'] = PxJointLimitPyramid.prototype.isSoft = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxJointLimitPyramid_isSoft_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['get_yAngleMin'] = PxJointLimitPyramid.prototype.get_yAngleMin = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitPyramid_get_yAngleMin_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['set_yAngleMin'] = PxJointLimitPyramid.prototype.set_yAngleMin = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitPyramid_set_yAngleMin_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitPyramid.prototype, 'yAngleMin', { get: PxJointLimitPyramid.prototype.get_yAngleMin, set: PxJointLimitPyramid.prototype.set_yAngleMin });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['get_yAngleMax'] = PxJointLimitPyramid.prototype.get_yAngleMax = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitPyramid_get_yAngleMax_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['set_yAngleMax'] = PxJointLimitPyramid.prototype.set_yAngleMax = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitPyramid_set_yAngleMax_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitPyramid.prototype, 'yAngleMax', { get: PxJointLimitPyramid.prototype.get_yAngleMax, set: PxJointLimitPyramid.prototype.set_yAngleMax });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['get_zAngleMin'] = PxJointLimitPyramid.prototype.get_zAngleMin = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitPyramid_get_zAngleMin_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['set_zAngleMin'] = PxJointLimitPyramid.prototype.set_zAngleMin = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitPyramid_set_zAngleMin_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitPyramid.prototype, 'zAngleMin', { get: PxJointLimitPyramid.prototype.get_zAngleMin, set: PxJointLimitPyramid.prototype.set_zAngleMin });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['get_zAngleMax'] = PxJointLimitPyramid.prototype.get_zAngleMax = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitPyramid_get_zAngleMax_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['set_zAngleMax'] = PxJointLimitPyramid.prototype.set_zAngleMax = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitPyramid_set_zAngleMax_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitPyramid.prototype, 'zAngleMax', { get: PxJointLimitPyramid.prototype.get_zAngleMax, set: PxJointLimitPyramid.prototype.set_zAngleMax });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['get_restitution'] = PxJointLimitPyramid.prototype.get_restitution = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitPyramid_get_restitution_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['set_restitution'] = PxJointLimitPyramid.prototype.set_restitution = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitPyramid_set_restitution_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitPyramid.prototype, 'restitution', { get: PxJointLimitPyramid.prototype.get_restitution, set: PxJointLimitPyramid.prototype.set_restitution });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['get_bounceThreshold'] = PxJointLimitPyramid.prototype.get_bounceThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitPyramid_get_bounceThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['set_bounceThreshold'] = PxJointLimitPyramid.prototype.set_bounceThreshold = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitPyramid_set_bounceThreshold_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitPyramid.prototype, 'bounceThreshold', { get: PxJointLimitPyramid.prototype.get_bounceThreshold, set: PxJointLimitPyramid.prototype.set_bounceThreshold });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['get_stiffness'] = PxJointLimitPyramid.prototype.get_stiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitPyramid_get_stiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['set_stiffness'] = PxJointLimitPyramid.prototype.set_stiffness = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitPyramid_set_stiffness_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitPyramid.prototype, 'stiffness', { get: PxJointLimitPyramid.prototype.get_stiffness, set: PxJointLimitPyramid.prototype.set_stiffness });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['get_damping'] = PxJointLimitPyramid.prototype.get_damping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLimitPyramid_get_damping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['set_damping'] = PxJointLimitPyramid.prototype.set_damping = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLimitPyramid_set_damping_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLimitPyramid.prototype, 'damping', { get: PxJointLimitPyramid.prototype.get_damping, set: PxJointLimitPyramid.prototype.set_damping });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLimitPyramid.prototype['__destroy__'] = PxJointLimitPyramid.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxJointLimitPyramid___destroy___0(self);
};

// Interface: PxJointLinearLimit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxJointLinearLimit(extent, spring) {
  if (extent && typeof extent === 'object') extent = extent.ptr;
  if (spring && typeof spring === 'object') spring = spring.ptr;
  this.ptr = _emscripten_bind_PxJointLinearLimit_PxJointLinearLimit_2(extent, spring);
  getCache(PxJointLinearLimit)[this.ptr] = this;
};

PxJointLinearLimit.prototype = Object.create(PxJointLimitParameters.prototype);
PxJointLinearLimit.prototype.constructor = PxJointLinearLimit;
PxJointLinearLimit.prototype.__class__ = PxJointLinearLimit;
PxJointLinearLimit.__cache__ = {};
Module['PxJointLinearLimit'] = PxJointLinearLimit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimit.prototype['isValid'] = PxJointLinearLimit.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxJointLinearLimit_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimit.prototype['isSoft'] = PxJointLinearLimit.prototype.isSoft = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxJointLinearLimit_isSoft_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimit.prototype['get_value'] = PxJointLinearLimit.prototype.get_value = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLinearLimit_get_value_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimit.prototype['set_value'] = PxJointLinearLimit.prototype.set_value = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLinearLimit_set_value_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLinearLimit.prototype, 'value', { get: PxJointLinearLimit.prototype.get_value, set: PxJointLinearLimit.prototype.set_value });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimit.prototype['get_restitution'] = PxJointLinearLimit.prototype.get_restitution = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLinearLimit_get_restitution_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimit.prototype['set_restitution'] = PxJointLinearLimit.prototype.set_restitution = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLinearLimit_set_restitution_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLinearLimit.prototype, 'restitution', { get: PxJointLinearLimit.prototype.get_restitution, set: PxJointLinearLimit.prototype.set_restitution });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimit.prototype['get_bounceThreshold'] = PxJointLinearLimit.prototype.get_bounceThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLinearLimit_get_bounceThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimit.prototype['set_bounceThreshold'] = PxJointLinearLimit.prototype.set_bounceThreshold = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLinearLimit_set_bounceThreshold_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLinearLimit.prototype, 'bounceThreshold', { get: PxJointLinearLimit.prototype.get_bounceThreshold, set: PxJointLinearLimit.prototype.set_bounceThreshold });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimit.prototype['get_stiffness'] = PxJointLinearLimit.prototype.get_stiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLinearLimit_get_stiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimit.prototype['set_stiffness'] = PxJointLinearLimit.prototype.set_stiffness = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLinearLimit_set_stiffness_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLinearLimit.prototype, 'stiffness', { get: PxJointLinearLimit.prototype.get_stiffness, set: PxJointLinearLimit.prototype.set_stiffness });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimit.prototype['get_damping'] = PxJointLinearLimit.prototype.get_damping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLinearLimit_get_damping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimit.prototype['set_damping'] = PxJointLinearLimit.prototype.set_damping = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLinearLimit_set_damping_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLinearLimit.prototype, 'damping', { get: PxJointLinearLimit.prototype.get_damping, set: PxJointLinearLimit.prototype.set_damping });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimit.prototype['__destroy__'] = PxJointLinearLimit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxJointLinearLimit___destroy___0(self);
};

// Interface: PxJointLinearLimitPair

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxJointLinearLimitPair(lowerLimit, upperLimit, spring) {
  if (lowerLimit && typeof lowerLimit === 'object') lowerLimit = lowerLimit.ptr;
  if (upperLimit && typeof upperLimit === 'object') upperLimit = upperLimit.ptr;
  if (spring && typeof spring === 'object') spring = spring.ptr;
  this.ptr = _emscripten_bind_PxJointLinearLimitPair_PxJointLinearLimitPair_3(lowerLimit, upperLimit, spring);
  getCache(PxJointLinearLimitPair)[this.ptr] = this;
};

PxJointLinearLimitPair.prototype = Object.create(PxJointLimitParameters.prototype);
PxJointLinearLimitPair.prototype.constructor = PxJointLinearLimitPair;
PxJointLinearLimitPair.prototype.__class__ = PxJointLinearLimitPair;
PxJointLinearLimitPair.__cache__ = {};
Module['PxJointLinearLimitPair'] = PxJointLinearLimitPair;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['isValid'] = PxJointLinearLimitPair.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxJointLinearLimitPair_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['isSoft'] = PxJointLinearLimitPair.prototype.isSoft = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxJointLinearLimitPair_isSoft_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['get_upper'] = PxJointLinearLimitPair.prototype.get_upper = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLinearLimitPair_get_upper_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['set_upper'] = PxJointLinearLimitPair.prototype.set_upper = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLinearLimitPair_set_upper_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLinearLimitPair.prototype, 'upper', { get: PxJointLinearLimitPair.prototype.get_upper, set: PxJointLinearLimitPair.prototype.set_upper });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['get_lower'] = PxJointLinearLimitPair.prototype.get_lower = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLinearLimitPair_get_lower_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['set_lower'] = PxJointLinearLimitPair.prototype.set_lower = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLinearLimitPair_set_lower_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLinearLimitPair.prototype, 'lower', { get: PxJointLinearLimitPair.prototype.get_lower, set: PxJointLinearLimitPair.prototype.set_lower });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['get_restitution'] = PxJointLinearLimitPair.prototype.get_restitution = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLinearLimitPair_get_restitution_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['set_restitution'] = PxJointLinearLimitPair.prototype.set_restitution = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLinearLimitPair_set_restitution_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLinearLimitPair.prototype, 'restitution', { get: PxJointLinearLimitPair.prototype.get_restitution, set: PxJointLinearLimitPair.prototype.set_restitution });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['get_bounceThreshold'] = PxJointLinearLimitPair.prototype.get_bounceThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLinearLimitPair_get_bounceThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['set_bounceThreshold'] = PxJointLinearLimitPair.prototype.set_bounceThreshold = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLinearLimitPair_set_bounceThreshold_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLinearLimitPair.prototype, 'bounceThreshold', { get: PxJointLinearLimitPair.prototype.get_bounceThreshold, set: PxJointLinearLimitPair.prototype.set_bounceThreshold });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['get_stiffness'] = PxJointLinearLimitPair.prototype.get_stiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLinearLimitPair_get_stiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['set_stiffness'] = PxJointLinearLimitPair.prototype.set_stiffness = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLinearLimitPair_set_stiffness_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLinearLimitPair.prototype, 'stiffness', { get: PxJointLinearLimitPair.prototype.get_stiffness, set: PxJointLinearLimitPair.prototype.set_stiffness });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['get_damping'] = PxJointLinearLimitPair.prototype.get_damping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxJointLinearLimitPair_get_damping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['set_damping'] = PxJointLinearLimitPair.prototype.set_damping = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxJointLinearLimitPair_set_damping_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxJointLinearLimitPair.prototype, 'damping', { get: PxJointLinearLimitPair.prototype.get_damping, set: PxJointLinearLimitPair.prototype.set_damping });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxJointLinearLimitPair.prototype['__destroy__'] = PxJointLinearLimitPair.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxJointLinearLimitPair___destroy___0(self);
};

// Interface: PxMassProperties

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxMassProperties(m, inertiaT, com) {
  if (m && typeof m === 'object') m = m.ptr;
  if (inertiaT && typeof inertiaT === 'object') inertiaT = inertiaT.ptr;
  if (com && typeof com === 'object') com = com.ptr;
  if (m === undefined) { this.ptr = _emscripten_bind_PxMassProperties_PxMassProperties_0(); getCache(PxMassProperties)[this.ptr] = this;return }
  if (inertiaT === undefined) { this.ptr = _emscripten_bind_PxMassProperties_PxMassProperties_1(m); getCache(PxMassProperties)[this.ptr] = this;return }
  if (com === undefined) { this.ptr = _emscripten_bind_PxMassProperties_PxMassProperties_2(m, inertiaT); getCache(PxMassProperties)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxMassProperties_PxMassProperties_3(m, inertiaT, com);
  getCache(PxMassProperties)[this.ptr] = this;
};

PxMassProperties.prototype = Object.create(WrapperObject.prototype);
PxMassProperties.prototype.constructor = PxMassProperties;
PxMassProperties.prototype.__class__ = PxMassProperties;
PxMassProperties.__cache__ = {};
Module['PxMassProperties'] = PxMassProperties;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMassProperties.prototype['translate'] = PxMassProperties.prototype.translate = function(t) {
  var self = this.ptr;
  if (t && typeof t === 'object') t = t.ptr;
  _emscripten_bind_PxMassProperties_translate_1(self, t);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMassProperties.prototype['getMassSpaceInertia'] = PxMassProperties.prototype.getMassSpaceInertia = function(inertia, massFrame) {
  if (inertia && typeof inertia === 'object') inertia = inertia.ptr;
  if (massFrame && typeof massFrame === 'object') massFrame = massFrame.ptr;
  return wrapPointer(_emscripten_bind_PxMassProperties_getMassSpaceInertia_2(inertia, massFrame), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMassProperties.prototype['translateInertia'] = PxMassProperties.prototype.translateInertia = function(inertia, mass, t) {
  if (inertia && typeof inertia === 'object') inertia = inertia.ptr;
  if (mass && typeof mass === 'object') mass = mass.ptr;
  if (t && typeof t === 'object') t = t.ptr;
  return wrapPointer(_emscripten_bind_PxMassProperties_translateInertia_3(inertia, mass, t), PxMat33);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMassProperties.prototype['rotateInertia'] = PxMassProperties.prototype.rotateInertia = function(inertia, q) {
  if (inertia && typeof inertia === 'object') inertia = inertia.ptr;
  if (q && typeof q === 'object') q = q.ptr;
  return wrapPointer(_emscripten_bind_PxMassProperties_rotateInertia_2(inertia, q), PxMat33);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMassProperties.prototype['scaleInertia'] = PxMassProperties.prototype.scaleInertia = function(inertia, scaleRotation, scale) {
  if (inertia && typeof inertia === 'object') inertia = inertia.ptr;
  if (scaleRotation && typeof scaleRotation === 'object') scaleRotation = scaleRotation.ptr;
  if (scale && typeof scale === 'object') scale = scale.ptr;
  return wrapPointer(_emscripten_bind_PxMassProperties_scaleInertia_3(inertia, scaleRotation, scale), PxMat33);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMassProperties.prototype['sum'] = PxMassProperties.prototype.sum = function(props, transforms, count) {
  if (props && typeof props === 'object') props = props.ptr;
  if (transforms && typeof transforms === 'object') transforms = transforms.ptr;
  if (count && typeof count === 'object') count = count.ptr;
  return wrapPointer(_emscripten_bind_PxMassProperties_sum_3(props, transforms, count), PxMassProperties);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMassProperties.prototype['get_inertiaTensor'] = PxMassProperties.prototype.get_inertiaTensor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxMassProperties_get_inertiaTensor_0(self), PxMat33);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMassProperties.prototype['set_inertiaTensor'] = PxMassProperties.prototype.set_inertiaTensor = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxMassProperties_set_inertiaTensor_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxMassProperties.prototype, 'inertiaTensor', { get: PxMassProperties.prototype.get_inertiaTensor, set: PxMassProperties.prototype.set_inertiaTensor });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMassProperties.prototype['get_centerOfMass'] = PxMassProperties.prototype.get_centerOfMass = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxMassProperties_get_centerOfMass_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMassProperties.prototype['set_centerOfMass'] = PxMassProperties.prototype.set_centerOfMass = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxMassProperties_set_centerOfMass_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxMassProperties.prototype, 'centerOfMass', { get: PxMassProperties.prototype.get_centerOfMass, set: PxMassProperties.prototype.set_centerOfMass });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMassProperties.prototype['get_mass'] = PxMassProperties.prototype.get_mass = function() {
  var self = this.ptr;
  return _emscripten_bind_PxMassProperties_get_mass_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMassProperties.prototype['set_mass'] = PxMassProperties.prototype.set_mass = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxMassProperties_set_mass_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxMassProperties.prototype, 'mass', { get: PxMassProperties.prototype.get_mass, set: PxMassProperties.prototype.set_mass });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMassProperties.prototype['__destroy__'] = PxMassProperties.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxMassProperties___destroy___0(self);
};

// Interface: PxMat33

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxMat33(col0, col1, col2) {
  if (col0 && typeof col0 === 'object') col0 = col0.ptr;
  if (col1 && typeof col1 === 'object') col1 = col1.ptr;
  if (col2 && typeof col2 === 'object') col2 = col2.ptr;
  if (col0 === undefined) { this.ptr = _emscripten_bind_PxMat33_PxMat33_0(); getCache(PxMat33)[this.ptr] = this;return }
  if (col1 === undefined) { this.ptr = _emscripten_bind_PxMat33_PxMat33_1(col0); getCache(PxMat33)[this.ptr] = this;return }
  if (col2 === undefined) { this.ptr = _emscripten_bind_PxMat33_PxMat33_2(col0, col1); getCache(PxMat33)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxMat33_PxMat33_3(col0, col1, col2);
  getCache(PxMat33)[this.ptr] = this;
};

PxMat33.prototype = Object.create(WrapperObject.prototype);
PxMat33.prototype.constructor = PxMat33;
PxMat33.prototype.__class__ = PxMat33;
PxMat33.__cache__ = {};
Module['PxMat33'] = PxMat33;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMat33.prototype['getTranspose'] = PxMat33.prototype.getTranspose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxMat33_getTranspose_0(self), PxMat33);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMat33.prototype['getInverse'] = PxMat33.prototype.getInverse = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxMat33_getInverse_0(self), PxMat33);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMat33.prototype['getDeterminant'] = PxMat33.prototype.getDeterminant = function() {
  var self = this.ptr;
  return _emscripten_bind_PxMat33_getDeterminant_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMat33.prototype['transform'] = PxMat33.prototype.transform = function(other) {
  var self = this.ptr;
  if (other && typeof other === 'object') other = other.ptr;
  return wrapPointer(_emscripten_bind_PxMat33_transform_1(self, other), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMat33.prototype['transformTranspose'] = PxMat33.prototype.transformTranspose = function(other) {
  var self = this.ptr;
  if (other && typeof other === 'object') other = other.ptr;
  return wrapPointer(_emscripten_bind_PxMat33_transformTranspose_1(self, other), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMat33.prototype['get_column0'] = PxMat33.prototype.get_column0 = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxMat33_get_column0_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMat33.prototype['set_column0'] = PxMat33.prototype.set_column0 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxMat33_set_column0_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxMat33.prototype, 'column0', { get: PxMat33.prototype.get_column0, set: PxMat33.prototype.set_column0 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMat33.prototype['get_column1'] = PxMat33.prototype.get_column1 = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxMat33_get_column1_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMat33.prototype['set_column1'] = PxMat33.prototype.set_column1 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxMat33_set_column1_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxMat33.prototype, 'column1', { get: PxMat33.prototype.get_column1, set: PxMat33.prototype.set_column1 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMat33.prototype['get_column2'] = PxMat33.prototype.get_column2 = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxMat33_get_column2_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMat33.prototype['set_column2'] = PxMat33.prototype.set_column2 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxMat33_set_column2_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxMat33.prototype, 'column2', { get: PxMat33.prototype.get_column2, set: PxMat33.prototype.set_column2 });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMat33.prototype['__destroy__'] = PxMat33.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxMat33___destroy___0(self);
};

// Interface: PxMaterial

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxMaterial() { throw "cannot construct a PxMaterial, no constructor in IDL" }
PxMaterial.prototype = Object.create(PxBaseMaterial.prototype);
PxMaterial.prototype.constructor = PxMaterial;
PxMaterial.prototype.__class__ = PxMaterial;
PxMaterial.__cache__ = {};
Module['PxMaterial'] = PxMaterial;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['setDynamicFriction'] = PxMaterial.prototype.setDynamicFriction = function(coef) {
  var self = this.ptr;
  if (coef && typeof coef === 'object') coef = coef.ptr;
  _emscripten_bind_PxMaterial_setDynamicFriction_1(self, coef);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['getDynamicFriction'] = PxMaterial.prototype.getDynamicFriction = function() {
  var self = this.ptr;
  return _emscripten_bind_PxMaterial_getDynamicFriction_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['setStaticFriction'] = PxMaterial.prototype.setStaticFriction = function(coef) {
  var self = this.ptr;
  if (coef && typeof coef === 'object') coef = coef.ptr;
  _emscripten_bind_PxMaterial_setStaticFriction_1(self, coef);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['getStaticFriction'] = PxMaterial.prototype.getStaticFriction = function() {
  var self = this.ptr;
  return _emscripten_bind_PxMaterial_getStaticFriction_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['setRestitution'] = PxMaterial.prototype.setRestitution = function(coef) {
  var self = this.ptr;
  if (coef && typeof coef === 'object') coef = coef.ptr;
  _emscripten_bind_PxMaterial_setRestitution_1(self, coef);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['getRestitution'] = PxMaterial.prototype.getRestitution = function() {
  var self = this.ptr;
  return _emscripten_bind_PxMaterial_getRestitution_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['setFlag'] = PxMaterial.prototype.setFlag = function(flag, b) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (b && typeof b === 'object') b = b.ptr;
  _emscripten_bind_PxMaterial_setFlag_2(self, flag, b);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['setFlags'] = PxMaterial.prototype.setFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxMaterial_setFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['getFlags'] = PxMaterial.prototype.getFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxMaterial_getFlags_0(self), PxMaterialFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['setFrictionCombineMode'] = PxMaterial.prototype.setFrictionCombineMode = function(combMode) {
  var self = this.ptr;
  if (combMode && typeof combMode === 'object') combMode = combMode.ptr;
  _emscripten_bind_PxMaterial_setFrictionCombineMode_1(self, combMode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['getFrictionCombineMode'] = PxMaterial.prototype.getFrictionCombineMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxMaterial_getFrictionCombineMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['setRestitutionCombineMode'] = PxMaterial.prototype.setRestitutionCombineMode = function(combMode) {
  var self = this.ptr;
  if (combMode && typeof combMode === 'object') combMode = combMode.ptr;
  _emscripten_bind_PxMaterial_setRestitutionCombineMode_1(self, combMode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['getRestitutionCombineMode'] = PxMaterial.prototype.getRestitutionCombineMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxMaterial_getRestitutionCombineMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['release'] = PxMaterial.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxMaterial_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['getConcreteTypeName'] = PxMaterial.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxMaterial_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['getConcreteType'] = PxMaterial.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxMaterial_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['setBaseFlag'] = PxMaterial.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxMaterial_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['setBaseFlags'] = PxMaterial.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxMaterial_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['getBaseFlags'] = PxMaterial.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxMaterial_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['isReleasable'] = PxMaterial.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxMaterial_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['getReferenceCount'] = PxMaterial.prototype.getReferenceCount = function() {
  var self = this.ptr;
  return _emscripten_bind_PxMaterial_getReferenceCount_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['acquireReference'] = PxMaterial.prototype.acquireReference = function() {
  var self = this.ptr;
  _emscripten_bind_PxMaterial_acquireReference_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['get_userData'] = PxMaterial.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxMaterial_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterial.prototype['set_userData'] = PxMaterial.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxMaterial_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxMaterial.prototype, 'userData', { get: PxMaterial.prototype.get_userData, set: PxMaterial.prototype.set_userData });

// Interface: PxMaterialConstPtr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxMaterialConstPtr() { throw "cannot construct a PxMaterialConstPtr, no constructor in IDL" }
PxMaterialConstPtr.prototype = Object.create(WrapperObject.prototype);
PxMaterialConstPtr.prototype.constructor = PxMaterialConstPtr;
PxMaterialConstPtr.prototype.__class__ = PxMaterialConstPtr;
PxMaterialConstPtr.__cache__ = {};
Module['PxMaterialConstPtr'] = PxMaterialConstPtr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterialConstPtr.prototype['__destroy__'] = PxMaterialConstPtr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxMaterialConstPtr___destroy___0(self);
};

// Interface: PxMaterialFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxMaterialFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxMaterialFlags_PxMaterialFlags_1(flags);
  getCache(PxMaterialFlags)[this.ptr] = this;
};

PxMaterialFlags.prototype = Object.create(WrapperObject.prototype);
PxMaterialFlags.prototype.constructor = PxMaterialFlags;
PxMaterialFlags.prototype.__class__ = PxMaterialFlags;
PxMaterialFlags.__cache__ = {};
Module['PxMaterialFlags'] = PxMaterialFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterialFlags.prototype['isSet'] = PxMaterialFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxMaterialFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterialFlags.prototype['raise'] = PxMaterialFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxMaterialFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterialFlags.prototype['clear'] = PxMaterialFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxMaterialFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterialFlags.prototype['__destroy__'] = PxMaterialFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxMaterialFlags___destroy___0(self);
};

// Interface: PxMaterialPtr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxMaterialPtr() { throw "cannot construct a PxMaterialPtr, no constructor in IDL" }
PxMaterialPtr.prototype = Object.create(WrapperObject.prototype);
PxMaterialPtr.prototype.constructor = PxMaterialPtr;
PxMaterialPtr.prototype.__class__ = PxMaterialPtr;
PxMaterialPtr.__cache__ = {};
Module['PxMaterialPtr'] = PxMaterialPtr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMaterialPtr.prototype['__destroy__'] = PxMaterialPtr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxMaterialPtr___destroy___0(self);
};

// Interface: PxMeshFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxMeshFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxMeshFlags_PxMeshFlags_1(flags);
  getCache(PxMeshFlags)[this.ptr] = this;
};

PxMeshFlags.prototype = Object.create(WrapperObject.prototype);
PxMeshFlags.prototype.constructor = PxMeshFlags;
PxMeshFlags.prototype.__class__ = PxMeshFlags;
PxMeshFlags.__cache__ = {};
Module['PxMeshFlags'] = PxMeshFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshFlags.prototype['isSet'] = PxMeshFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxMeshFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshFlags.prototype['raise'] = PxMeshFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxMeshFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshFlags.prototype['clear'] = PxMeshFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxMeshFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshFlags.prototype['__destroy__'] = PxMeshFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxMeshFlags___destroy___0(self);
};

// Interface: PxMeshGeometryFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxMeshGeometryFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxMeshGeometryFlags_PxMeshGeometryFlags_1(flags);
  getCache(PxMeshGeometryFlags)[this.ptr] = this;
};

PxMeshGeometryFlags.prototype = Object.create(WrapperObject.prototype);
PxMeshGeometryFlags.prototype.constructor = PxMeshGeometryFlags;
PxMeshGeometryFlags.prototype.__class__ = PxMeshGeometryFlags;
PxMeshGeometryFlags.__cache__ = {};
Module['PxMeshGeometryFlags'] = PxMeshGeometryFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshGeometryFlags.prototype['isSet'] = PxMeshGeometryFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxMeshGeometryFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshGeometryFlags.prototype['raise'] = PxMeshGeometryFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxMeshGeometryFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshGeometryFlags.prototype['clear'] = PxMeshGeometryFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxMeshGeometryFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshGeometryFlags.prototype['__destroy__'] = PxMeshGeometryFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxMeshGeometryFlags___destroy___0(self);
};

// Interface: PxMeshOverlapUtil

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxMeshOverlapUtil() {
  this.ptr = _emscripten_bind_PxMeshOverlapUtil_PxMeshOverlapUtil_0();
  getCache(PxMeshOverlapUtil)[this.ptr] = this;
};

PxMeshOverlapUtil.prototype = Object.create(WrapperObject.prototype);
PxMeshOverlapUtil.prototype.constructor = PxMeshOverlapUtil;
PxMeshOverlapUtil.prototype.__class__ = PxMeshOverlapUtil;
PxMeshOverlapUtil.__cache__ = {};
Module['PxMeshOverlapUtil'] = PxMeshOverlapUtil;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshOverlapUtil.prototype['findOverlap'] = PxMeshOverlapUtil.prototype.findOverlap = function(geom, geomPose, meshGeom, meshPose) {
  var self = this.ptr;
  if (geom && typeof geom === 'object') geom = geom.ptr;
  if (geomPose && typeof geomPose === 'object') geomPose = geomPose.ptr;
  if (meshGeom && typeof meshGeom === 'object') meshGeom = meshGeom.ptr;
  if (meshPose && typeof meshPose === 'object') meshPose = meshPose.ptr;
  return _emscripten_bind_PxMeshOverlapUtil_findOverlap_4(self, geom, geomPose, meshGeom, meshPose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshOverlapUtil.prototype['getResults'] = PxMeshOverlapUtil.prototype.getResults = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxMeshOverlapUtil_getResults_0(self), PxU32ConstPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshOverlapUtil.prototype['getNbResults'] = PxMeshOverlapUtil.prototype.getNbResults = function() {
  var self = this.ptr;
  return _emscripten_bind_PxMeshOverlapUtil_getNbResults_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshOverlapUtil.prototype['__destroy__'] = PxMeshOverlapUtil.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxMeshOverlapUtil___destroy___0(self);
};

// Interface: PxMeshPreprocessingFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxMeshPreprocessingFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxMeshPreprocessingFlags_PxMeshPreprocessingFlags_1(flags);
  getCache(PxMeshPreprocessingFlags)[this.ptr] = this;
};

PxMeshPreprocessingFlags.prototype = Object.create(WrapperObject.prototype);
PxMeshPreprocessingFlags.prototype.constructor = PxMeshPreprocessingFlags;
PxMeshPreprocessingFlags.prototype.__class__ = PxMeshPreprocessingFlags;
PxMeshPreprocessingFlags.__cache__ = {};
Module['PxMeshPreprocessingFlags'] = PxMeshPreprocessingFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshPreprocessingFlags.prototype['isSet'] = PxMeshPreprocessingFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxMeshPreprocessingFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshPreprocessingFlags.prototype['raise'] = PxMeshPreprocessingFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxMeshPreprocessingFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshPreprocessingFlags.prototype['clear'] = PxMeshPreprocessingFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxMeshPreprocessingFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshPreprocessingFlags.prototype['__destroy__'] = PxMeshPreprocessingFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxMeshPreprocessingFlags___destroy___0(self);
};

// Interface: PxMeshScale

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxMeshScale(s, r) {
  if (s && typeof s === 'object') s = s.ptr;
  if (r && typeof r === 'object') r = r.ptr;
  if (s === undefined) { this.ptr = _emscripten_bind_PxMeshScale_PxMeshScale_0(); getCache(PxMeshScale)[this.ptr] = this;return }
  if (r === undefined) { this.ptr = _emscripten_bind_PxMeshScale_PxMeshScale_1(s); getCache(PxMeshScale)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxMeshScale_PxMeshScale_2(s, r);
  getCache(PxMeshScale)[this.ptr] = this;
};

PxMeshScale.prototype = Object.create(WrapperObject.prototype);
PxMeshScale.prototype.constructor = PxMeshScale;
PxMeshScale.prototype.__class__ = PxMeshScale;
PxMeshScale.__cache__ = {};
Module['PxMeshScale'] = PxMeshScale;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMeshScale.prototype['__destroy__'] = PxMeshScale.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxMeshScale___destroy___0(self);
};

// Interface: PxMidphaseDesc

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxMidphaseDesc() {
  this.ptr = _emscripten_bind_PxMidphaseDesc_PxMidphaseDesc_0();
  getCache(PxMidphaseDesc)[this.ptr] = this;
};

PxMidphaseDesc.prototype = Object.create(WrapperObject.prototype);
PxMidphaseDesc.prototype.constructor = PxMidphaseDesc;
PxMidphaseDesc.prototype.__class__ = PxMidphaseDesc;
PxMidphaseDesc.__cache__ = {};
Module['PxMidphaseDesc'] = PxMidphaseDesc;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMidphaseDesc.prototype['getType'] = PxMidphaseDesc.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxMidphaseDesc_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMidphaseDesc.prototype['setToDefault'] = PxMidphaseDesc.prototype.setToDefault = function(type) {
  var self = this.ptr;
  if (type && typeof type === 'object') type = type.ptr;
  _emscripten_bind_PxMidphaseDesc_setToDefault_1(self, type);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMidphaseDesc.prototype['isValid'] = PxMidphaseDesc.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxMidphaseDesc_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMidphaseDesc.prototype['get_mBVH33Desc'] = PxMidphaseDesc.prototype.get_mBVH33Desc = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxMidphaseDesc_get_mBVH33Desc_0(self), PxBVH33MidphaseDesc);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMidphaseDesc.prototype['set_mBVH33Desc'] = PxMidphaseDesc.prototype.set_mBVH33Desc = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxMidphaseDesc_set_mBVH33Desc_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxMidphaseDesc.prototype, 'mBVH33Desc', { get: PxMidphaseDesc.prototype.get_mBVH33Desc, set: PxMidphaseDesc.prototype.set_mBVH33Desc });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMidphaseDesc.prototype['get_mBVH34Desc'] = PxMidphaseDesc.prototype.get_mBVH34Desc = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxMidphaseDesc_get_mBVH34Desc_0(self), PxBVH34MidphaseDesc);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMidphaseDesc.prototype['set_mBVH34Desc'] = PxMidphaseDesc.prototype.set_mBVH34Desc = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxMidphaseDesc_set_mBVH34Desc_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxMidphaseDesc.prototype, 'mBVH34Desc', { get: PxMidphaseDesc.prototype.get_mBVH34Desc, set: PxMidphaseDesc.prototype.set_mBVH34Desc });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxMidphaseDesc.prototype['__destroy__'] = PxMidphaseDesc.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxMidphaseDesc___destroy___0(self);
};

// Interface: PxObstacleContext

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxObstacleContext() { throw "cannot construct a PxObstacleContext, no constructor in IDL" }
PxObstacleContext.prototype = Object.create(WrapperObject.prototype);
PxObstacleContext.prototype.constructor = PxObstacleContext;
PxObstacleContext.prototype.__class__ = PxObstacleContext;
PxObstacleContext.__cache__ = {};
Module['PxObstacleContext'] = PxObstacleContext;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacleContext.prototype['release'] = PxObstacleContext.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxObstacleContext_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacleContext.prototype['getControllerManager'] = PxObstacleContext.prototype.getControllerManager = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxObstacleContext_getControllerManager_0(self), PxControllerManager);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacleContext.prototype['addObstacle'] = PxObstacleContext.prototype.addObstacle = function(obstacle) {
  var self = this.ptr;
  if (obstacle && typeof obstacle === 'object') obstacle = obstacle.ptr;
  return _emscripten_bind_PxObstacleContext_addObstacle_1(self, obstacle);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacleContext.prototype['removeObstacle'] = PxObstacleContext.prototype.removeObstacle = function(handle) {
  var self = this.ptr;
  if (handle && typeof handle === 'object') handle = handle.ptr;
  return !!(_emscripten_bind_PxObstacleContext_removeObstacle_1(self, handle));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacleContext.prototype['updateObstacle'] = PxObstacleContext.prototype.updateObstacle = function(handle, obstacle) {
  var self = this.ptr;
  if (handle && typeof handle === 'object') handle = handle.ptr;
  if (obstacle && typeof obstacle === 'object') obstacle = obstacle.ptr;
  return !!(_emscripten_bind_PxObstacleContext_updateObstacle_2(self, handle, obstacle));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacleContext.prototype['getNbObstacles'] = PxObstacleContext.prototype.getNbObstacles = function() {
  var self = this.ptr;
  return _emscripten_bind_PxObstacleContext_getNbObstacles_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacleContext.prototype['getObstacle'] = PxObstacleContext.prototype.getObstacle = function(i) {
  var self = this.ptr;
  if (i && typeof i === 'object') i = i.ptr;
  return wrapPointer(_emscripten_bind_PxObstacleContext_getObstacle_1(self, i), PxObstacle);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacleContext.prototype['getObstacleByHandle'] = PxObstacleContext.prototype.getObstacleByHandle = function(handle) {
  var self = this.ptr;
  if (handle && typeof handle === 'object') handle = handle.ptr;
  return wrapPointer(_emscripten_bind_PxObstacleContext_getObstacleByHandle_1(self, handle), PxObstacle);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxObstacleContext.prototype['__destroy__'] = PxObstacleContext.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxObstacleContext___destroy___0(self);
};

// Interface: PxOmniPvd

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxOmniPvd() { throw "cannot construct a PxOmniPvd, no constructor in IDL" }
PxOmniPvd.prototype = Object.create(WrapperObject.prototype);
PxOmniPvd.prototype.constructor = PxOmniPvd;
PxOmniPvd.prototype.__class__ = PxOmniPvd;
PxOmniPvd.__cache__ = {};
Module['PxOmniPvd'] = PxOmniPvd;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOmniPvd.prototype['startSampling'] = PxOmniPvd.prototype.startSampling = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxOmniPvd_startSampling_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOmniPvd.prototype['release'] = PxOmniPvd.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxOmniPvd_release_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOmniPvd.prototype['__destroy__'] = PxOmniPvd.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxOmniPvd___destroy___0(self);
};

// Interface: PxOverlapBuffer10

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxOverlapBuffer10() {
  this.ptr = _emscripten_bind_PxOverlapBuffer10_PxOverlapBuffer10_0();
  getCache(PxOverlapBuffer10)[this.ptr] = this;
};

PxOverlapBuffer10.prototype = Object.create(PxOverlapCallback.prototype);
PxOverlapBuffer10.prototype.constructor = PxOverlapBuffer10;
PxOverlapBuffer10.prototype.__class__ = PxOverlapBuffer10;
PxOverlapBuffer10.__cache__ = {};
Module['PxOverlapBuffer10'] = PxOverlapBuffer10;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapBuffer10.prototype['getNbAnyHits'] = PxOverlapBuffer10.prototype.getNbAnyHits = function() {
  var self = this.ptr;
  return _emscripten_bind_PxOverlapBuffer10_getNbAnyHits_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapBuffer10.prototype['getAnyHit'] = PxOverlapBuffer10.prototype.getAnyHit = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxOverlapBuffer10_getAnyHit_1(self, index), PxOverlapHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapBuffer10.prototype['getNbTouches'] = PxOverlapBuffer10.prototype.getNbTouches = function() {
  var self = this.ptr;
  return _emscripten_bind_PxOverlapBuffer10_getNbTouches_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapBuffer10.prototype['getTouches'] = PxOverlapBuffer10.prototype.getTouches = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxOverlapBuffer10_getTouches_0(self), PxOverlapHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapBuffer10.prototype['getTouch'] = PxOverlapBuffer10.prototype.getTouch = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxOverlapBuffer10_getTouch_1(self, index), PxOverlapHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapBuffer10.prototype['getMaxNbTouches'] = PxOverlapBuffer10.prototype.getMaxNbTouches = function() {
  var self = this.ptr;
  return _emscripten_bind_PxOverlapBuffer10_getMaxNbTouches_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapBuffer10.prototype['hasAnyHits'] = PxOverlapBuffer10.prototype.hasAnyHits = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxOverlapBuffer10_hasAnyHits_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapBuffer10.prototype['get_block'] = PxOverlapBuffer10.prototype.get_block = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxOverlapBuffer10_get_block_0(self), PxOverlapHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapBuffer10.prototype['set_block'] = PxOverlapBuffer10.prototype.set_block = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxOverlapBuffer10_set_block_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxOverlapBuffer10.prototype, 'block', { get: PxOverlapBuffer10.prototype.get_block, set: PxOverlapBuffer10.prototype.set_block });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapBuffer10.prototype['get_hasBlock'] = PxOverlapBuffer10.prototype.get_hasBlock = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxOverlapBuffer10_get_hasBlock_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapBuffer10.prototype['set_hasBlock'] = PxOverlapBuffer10.prototype.set_hasBlock = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxOverlapBuffer10_set_hasBlock_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxOverlapBuffer10.prototype, 'hasBlock', { get: PxOverlapBuffer10.prototype.get_hasBlock, set: PxOverlapBuffer10.prototype.set_hasBlock });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapBuffer10.prototype['__destroy__'] = PxOverlapBuffer10.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxOverlapBuffer10___destroy___0(self);
};

// Interface: PxOverlapHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxOverlapHit() { throw "cannot construct a PxOverlapHit, no constructor in IDL" }
PxOverlapHit.prototype = Object.create(PxQueryHit.prototype);
PxOverlapHit.prototype.constructor = PxOverlapHit;
PxOverlapHit.prototype.__class__ = PxOverlapHit;
PxOverlapHit.__cache__ = {};
Module['PxOverlapHit'] = PxOverlapHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapHit.prototype['get_actor'] = PxOverlapHit.prototype.get_actor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxOverlapHit_get_actor_0(self), PxRigidActor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapHit.prototype['set_actor'] = PxOverlapHit.prototype.set_actor = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxOverlapHit_set_actor_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxOverlapHit.prototype, 'actor', { get: PxOverlapHit.prototype.get_actor, set: PxOverlapHit.prototype.set_actor });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapHit.prototype['get_shape'] = PxOverlapHit.prototype.get_shape = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxOverlapHit_get_shape_0(self), PxShape);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapHit.prototype['set_shape'] = PxOverlapHit.prototype.set_shape = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxOverlapHit_set_shape_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxOverlapHit.prototype, 'shape', { get: PxOverlapHit.prototype.get_shape, set: PxOverlapHit.prototype.set_shape });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapHit.prototype['get_faceIndex'] = PxOverlapHit.prototype.get_faceIndex = function() {
  var self = this.ptr;
  return _emscripten_bind_PxOverlapHit_get_faceIndex_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapHit.prototype['set_faceIndex'] = PxOverlapHit.prototype.set_faceIndex = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxOverlapHit_set_faceIndex_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxOverlapHit.prototype, 'faceIndex', { get: PxOverlapHit.prototype.get_faceIndex, set: PxOverlapHit.prototype.set_faceIndex });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapHit.prototype['__destroy__'] = PxOverlapHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxOverlapHit___destroy___0(self);
};

// Interface: PxOverlapResult

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxOverlapResult() {
  this.ptr = _emscripten_bind_PxOverlapResult_PxOverlapResult_0();
  getCache(PxOverlapResult)[this.ptr] = this;
};

PxOverlapResult.prototype = Object.create(PxOverlapCallback.prototype);
PxOverlapResult.prototype.constructor = PxOverlapResult;
PxOverlapResult.prototype.__class__ = PxOverlapResult;
PxOverlapResult.__cache__ = {};
Module['PxOverlapResult'] = PxOverlapResult;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapResult.prototype['getNbAnyHits'] = PxOverlapResult.prototype.getNbAnyHits = function() {
  var self = this.ptr;
  return _emscripten_bind_PxOverlapResult_getNbAnyHits_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapResult.prototype['getAnyHit'] = PxOverlapResult.prototype.getAnyHit = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxOverlapResult_getAnyHit_1(self, index), PxOverlapHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapResult.prototype['getNbTouches'] = PxOverlapResult.prototype.getNbTouches = function() {
  var self = this.ptr;
  return _emscripten_bind_PxOverlapResult_getNbTouches_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapResult.prototype['getTouch'] = PxOverlapResult.prototype.getTouch = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxOverlapResult_getTouch_1(self, index), PxOverlapHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapResult.prototype['clear'] = PxOverlapResult.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxOverlapResult_clear_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapResult.prototype['hasAnyHits'] = PxOverlapResult.prototype.hasAnyHits = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxOverlapResult_hasAnyHits_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapResult.prototype['get_block'] = PxOverlapResult.prototype.get_block = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxOverlapResult_get_block_0(self), PxOverlapHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapResult.prototype['set_block'] = PxOverlapResult.prototype.set_block = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxOverlapResult_set_block_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxOverlapResult.prototype, 'block', { get: PxOverlapResult.prototype.get_block, set: PxOverlapResult.prototype.set_block });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapResult.prototype['get_hasBlock'] = PxOverlapResult.prototype.get_hasBlock = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxOverlapResult_get_hasBlock_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapResult.prototype['set_hasBlock'] = PxOverlapResult.prototype.set_hasBlock = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxOverlapResult_set_hasBlock_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxOverlapResult.prototype, 'hasBlock', { get: PxOverlapResult.prototype.get_hasBlock, set: PxOverlapResult.prototype.set_hasBlock });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxOverlapResult.prototype['__destroy__'] = PxOverlapResult.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxOverlapResult___destroy___0(self);
};

// Interface: PxPairFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxPairFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxPairFlags_PxPairFlags_1(flags);
  getCache(PxPairFlags)[this.ptr] = this;
};

PxPairFlags.prototype = Object.create(WrapperObject.prototype);
PxPairFlags.prototype.constructor = PxPairFlags;
PxPairFlags.prototype.__class__ = PxPairFlags;
PxPairFlags.__cache__ = {};
Module['PxPairFlags'] = PxPairFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPairFlags.prototype['isSet'] = PxPairFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxPairFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPairFlags.prototype['raise'] = PxPairFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxPairFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPairFlags.prototype['clear'] = PxPairFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxPairFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPairFlags.prototype['__destroy__'] = PxPairFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxPairFlags___destroy___0(self);
};

// Interface: PxPhysics

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxPhysics() { throw "cannot construct a PxPhysics, no constructor in IDL" }
PxPhysics.prototype = Object.create(WrapperObject.prototype);
PxPhysics.prototype.constructor = PxPhysics;
PxPhysics.prototype.__class__ = PxPhysics;
PxPhysics.__cache__ = {};
Module['PxPhysics'] = PxPhysics;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['release'] = PxPhysics.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxPhysics_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['getFoundation'] = PxPhysics.prototype.getFoundation = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPhysics_getFoundation_0(self), PxFoundation);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['createAggregate'] = PxPhysics.prototype.createAggregate = function(maxActor, maxShape, enableSelfCollision) {
  var self = this.ptr;
  if (maxActor && typeof maxActor === 'object') maxActor = maxActor.ptr;
  if (maxShape && typeof maxShape === 'object') maxShape = maxShape.ptr;
  if (enableSelfCollision && typeof enableSelfCollision === 'object') enableSelfCollision = enableSelfCollision.ptr;
  return wrapPointer(_emscripten_bind_PxPhysics_createAggregate_3(self, maxActor, maxShape, enableSelfCollision), PxAggregate);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['getTolerancesScale'] = PxPhysics.prototype.getTolerancesScale = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPhysics_getTolerancesScale_0(self), PxTolerancesScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['createScene'] = PxPhysics.prototype.createScene = function(sceneDesc) {
  var self = this.ptr;
  if (sceneDesc && typeof sceneDesc === 'object') sceneDesc = sceneDesc.ptr;
  return wrapPointer(_emscripten_bind_PxPhysics_createScene_1(self, sceneDesc), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['createRigidStatic'] = PxPhysics.prototype.createRigidStatic = function(pose) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  return wrapPointer(_emscripten_bind_PxPhysics_createRigidStatic_1(self, pose), PxRigidStatic);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['createRigidDynamic'] = PxPhysics.prototype.createRigidDynamic = function(pose) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  return wrapPointer(_emscripten_bind_PxPhysics_createRigidDynamic_1(self, pose), PxRigidDynamic);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['createShape'] = PxPhysics.prototype.createShape = function(geometry, material, isExclusive, shapeFlags) {
  var self = this.ptr;
  if (geometry && typeof geometry === 'object') geometry = geometry.ptr;
  if (material && typeof material === 'object') material = material.ptr;
  if (isExclusive && typeof isExclusive === 'object') isExclusive = isExclusive.ptr;
  if (shapeFlags && typeof shapeFlags === 'object') shapeFlags = shapeFlags.ptr;
  if (isExclusive === undefined) { return wrapPointer(_emscripten_bind_PxPhysics_createShape_2(self, geometry, material), PxShape) }
  if (shapeFlags === undefined) { return wrapPointer(_emscripten_bind_PxPhysics_createShape_3(self, geometry, material, isExclusive), PxShape) }
  return wrapPointer(_emscripten_bind_PxPhysics_createShape_4(self, geometry, material, isExclusive, shapeFlags), PxShape);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['createTriangleMesh'] = PxPhysics.prototype.createTriangleMesh = function(stream) {
  var self = this.ptr;
  if (stream && typeof stream === 'object') stream = stream.ptr;
  return wrapPointer(_emscripten_bind_PxPhysics_createTriangleMesh_1(self, stream), PxTriangleMesh);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['createConvexMesh'] = PxPhysics.prototype.createConvexMesh = function(stream) {
  var self = this.ptr;
  if (stream && typeof stream === 'object') stream = stream.ptr;
  return wrapPointer(_emscripten_bind_PxPhysics_createConvexMesh_1(self, stream), PxConvexMesh);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['getNbShapes'] = PxPhysics.prototype.getNbShapes = function() {
  var self = this.ptr;
  return _emscripten_bind_PxPhysics_getNbShapes_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['createArticulationReducedCoordinate'] = PxPhysics.prototype.createArticulationReducedCoordinate = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPhysics_createArticulationReducedCoordinate_0(self), PxArticulationReducedCoordinate);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['createMaterial'] = PxPhysics.prototype.createMaterial = function(staticFriction, dynamicFriction, restitution) {
  var self = this.ptr;
  if (staticFriction && typeof staticFriction === 'object') staticFriction = staticFriction.ptr;
  if (dynamicFriction && typeof dynamicFriction === 'object') dynamicFriction = dynamicFriction.ptr;
  if (restitution && typeof restitution === 'object') restitution = restitution.ptr;
  return wrapPointer(_emscripten_bind_PxPhysics_createMaterial_3(self, staticFriction, dynamicFriction, restitution), PxMaterial);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['getPhysicsInsertionCallback'] = PxPhysics.prototype.getPhysicsInsertionCallback = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPhysics_getPhysicsInsertionCallback_0(self), PxInsertionCallback);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPhysics.prototype['__destroy__'] = PxPhysics.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxPhysics___destroy___0(self);
};

// Interface: PxPlane

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxPlane(nx, ny, nz, distance) {
  if (nx && typeof nx === 'object') nx = nx.ptr;
  if (ny && typeof ny === 'object') ny = ny.ptr;
  if (nz && typeof nz === 'object') nz = nz.ptr;
  if (distance && typeof distance === 'object') distance = distance.ptr;
  if (nx === undefined) { this.ptr = _emscripten_bind_PxPlane_PxPlane_0(); getCache(PxPlane)[this.ptr] = this;return }
  if (ny === undefined) { this.ptr = _emscripten_bind_PxPlane_PxPlane_1(nx); getCache(PxPlane)[this.ptr] = this;return }
  if (nz === undefined) { this.ptr = _emscripten_bind_PxPlane_PxPlane_2(nx, ny); getCache(PxPlane)[this.ptr] = this;return }
  if (distance === undefined) { this.ptr = _emscripten_bind_PxPlane_PxPlane_3(nx, ny, nz); getCache(PxPlane)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxPlane_PxPlane_4(nx, ny, nz, distance);
  getCache(PxPlane)[this.ptr] = this;
};

PxPlane.prototype = Object.create(WrapperObject.prototype);
PxPlane.prototype.constructor = PxPlane;
PxPlane.prototype.__class__ = PxPlane;
PxPlane.__cache__ = {};
Module['PxPlane'] = PxPlane;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPlane.prototype['distance'] = PxPlane.prototype.distance = function(p) {
  var self = this.ptr;
  if (p && typeof p === 'object') p = p.ptr;
  return _emscripten_bind_PxPlane_distance_1(self, p);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPlane.prototype['contains'] = PxPlane.prototype.contains = function(p) {
  var self = this.ptr;
  if (p && typeof p === 'object') p = p.ptr;
  return !!(_emscripten_bind_PxPlane_contains_1(self, p));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPlane.prototype['project'] = PxPlane.prototype.project = function(p) {
  var self = this.ptr;
  if (p && typeof p === 'object') p = p.ptr;
  return wrapPointer(_emscripten_bind_PxPlane_project_1(self, p), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPlane.prototype['pointInPlane'] = PxPlane.prototype.pointInPlane = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPlane_pointInPlane_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPlane.prototype['normalize'] = PxPlane.prototype.normalize = function() {
  var self = this.ptr;
  _emscripten_bind_PxPlane_normalize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPlane.prototype['transform'] = PxPlane.prototype.transform = function(pose) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  return wrapPointer(_emscripten_bind_PxPlane_transform_1(self, pose), PxPlane);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPlane.prototype['inverseTransform'] = PxPlane.prototype.inverseTransform = function(pose) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  return wrapPointer(_emscripten_bind_PxPlane_inverseTransform_1(self, pose), PxPlane);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPlane.prototype['get_n'] = PxPlane.prototype.get_n = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPlane_get_n_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPlane.prototype['set_n'] = PxPlane.prototype.set_n = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxPlane_set_n_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxPlane.prototype, 'n', { get: PxPlane.prototype.get_n, set: PxPlane.prototype.set_n });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPlane.prototype['get_d'] = PxPlane.prototype.get_d = function() {
  var self = this.ptr;
  return _emscripten_bind_PxPlane_get_d_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPlane.prototype['set_d'] = PxPlane.prototype.set_d = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxPlane_set_d_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxPlane.prototype, 'd', { get: PxPlane.prototype.get_d, set: PxPlane.prototype.set_d });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPlane.prototype['__destroy__'] = PxPlane.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxPlane___destroy___0(self);
};

// Interface: PxPlaneGeometry

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxPlaneGeometry() {
  this.ptr = _emscripten_bind_PxPlaneGeometry_PxPlaneGeometry_0();
  getCache(PxPlaneGeometry)[this.ptr] = this;
};

PxPlaneGeometry.prototype = Object.create(PxGeometry.prototype);
PxPlaneGeometry.prototype.constructor = PxPlaneGeometry;
PxPlaneGeometry.prototype.__class__ = PxPlaneGeometry;
PxPlaneGeometry.__cache__ = {};
Module['PxPlaneGeometry'] = PxPlaneGeometry;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPlaneGeometry.prototype['getType'] = PxPlaneGeometry.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxPlaneGeometry_getType_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPlaneGeometry.prototype['__destroy__'] = PxPlaneGeometry.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxPlaneGeometry___destroy___0(self);
};

// Interface: PxPrismaticJoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxPrismaticJoint() { throw "cannot construct a PxPrismaticJoint, no constructor in IDL" }
PxPrismaticJoint.prototype = Object.create(PxJoint.prototype);
PxPrismaticJoint.prototype.constructor = PxPrismaticJoint;
PxPrismaticJoint.prototype.__class__ = PxPrismaticJoint;
PxPrismaticJoint.__cache__ = {};
Module['PxPrismaticJoint'] = PxPrismaticJoint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getPosition'] = PxPrismaticJoint.prototype.getPosition = function() {
  var self = this.ptr;
  return _emscripten_bind_PxPrismaticJoint_getPosition_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getVelocity'] = PxPrismaticJoint.prototype.getVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxPrismaticJoint_getVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setLimit'] = PxPrismaticJoint.prototype.setLimit = function(limit) {
  var self = this.ptr;
  if (limit && typeof limit === 'object') limit = limit.ptr;
  _emscripten_bind_PxPrismaticJoint_setLimit_1(self, limit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setPrismaticJointFlags'] = PxPrismaticJoint.prototype.setPrismaticJointFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxPrismaticJoint_setPrismaticJointFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setPrismaticJointFlag'] = PxPrismaticJoint.prototype.setPrismaticJointFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxPrismaticJoint_setPrismaticJointFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getPrismaticJointFlags'] = PxPrismaticJoint.prototype.getPrismaticJointFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPrismaticJoint_getPrismaticJointFlags_0(self), PxPrismaticJointFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['release'] = PxPrismaticJoint.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxPrismaticJoint_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getConcreteTypeName'] = PxPrismaticJoint.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxPrismaticJoint_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getConcreteType'] = PxPrismaticJoint.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxPrismaticJoint_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setBaseFlag'] = PxPrismaticJoint.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxPrismaticJoint_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setBaseFlags'] = PxPrismaticJoint.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxPrismaticJoint_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getBaseFlags'] = PxPrismaticJoint.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPrismaticJoint_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['isReleasable'] = PxPrismaticJoint.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxPrismaticJoint_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setActors'] = PxPrismaticJoint.prototype.setActors = function(actor0, actor1) {
  var self = this.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  _emscripten_bind_PxPrismaticJoint_setActors_2(self, actor0, actor1);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setLocalPose'] = PxPrismaticJoint.prototype.setLocalPose = function(actor, localPose) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (localPose && typeof localPose === 'object') localPose = localPose.ptr;
  _emscripten_bind_PxPrismaticJoint_setLocalPose_2(self, actor, localPose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getLocalPose'] = PxPrismaticJoint.prototype.getLocalPose = function(actor) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return wrapPointer(_emscripten_bind_PxPrismaticJoint_getLocalPose_1(self, actor), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getRelativeTransform'] = PxPrismaticJoint.prototype.getRelativeTransform = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPrismaticJoint_getRelativeTransform_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getRelativeLinearVelocity'] = PxPrismaticJoint.prototype.getRelativeLinearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPrismaticJoint_getRelativeLinearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getRelativeAngularVelocity'] = PxPrismaticJoint.prototype.getRelativeAngularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPrismaticJoint_getRelativeAngularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setBreakForce'] = PxPrismaticJoint.prototype.setBreakForce = function(force, torque) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  _emscripten_bind_PxPrismaticJoint_setBreakForce_2(self, force, torque);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setConstraintFlags'] = PxPrismaticJoint.prototype.setConstraintFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxPrismaticJoint_setConstraintFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setConstraintFlag'] = PxPrismaticJoint.prototype.setConstraintFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxPrismaticJoint_setConstraintFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getConstraintFlags'] = PxPrismaticJoint.prototype.getConstraintFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPrismaticJoint_getConstraintFlags_0(self), PxConstraintFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setInvMassScale0'] = PxPrismaticJoint.prototype.setInvMassScale0 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxPrismaticJoint_setInvMassScale0_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getInvMassScale0'] = PxPrismaticJoint.prototype.getInvMassScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxPrismaticJoint_getInvMassScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setInvMassScale1'] = PxPrismaticJoint.prototype.setInvMassScale1 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxPrismaticJoint_setInvMassScale1_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getInvMassScale1'] = PxPrismaticJoint.prototype.getInvMassScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxPrismaticJoint_getInvMassScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setInvInertiaScale0'] = PxPrismaticJoint.prototype.setInvInertiaScale0 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxPrismaticJoint_setInvInertiaScale0_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getInvInertiaScale0'] = PxPrismaticJoint.prototype.getInvInertiaScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxPrismaticJoint_getInvInertiaScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setInvInertiaScale1'] = PxPrismaticJoint.prototype.setInvInertiaScale1 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxPrismaticJoint_setInvInertiaScale1_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getInvInertiaScale1'] = PxPrismaticJoint.prototype.getInvInertiaScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxPrismaticJoint_getInvInertiaScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getConstraint'] = PxPrismaticJoint.prototype.getConstraint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPrismaticJoint_getConstraint_0(self), PxConstraint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['setName'] = PxPrismaticJoint.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxPrismaticJoint_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getName'] = PxPrismaticJoint.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxPrismaticJoint_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['getScene'] = PxPrismaticJoint.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPrismaticJoint_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['get_userData'] = PxPrismaticJoint.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPrismaticJoint_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['set_userData'] = PxPrismaticJoint.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxPrismaticJoint_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxPrismaticJoint.prototype, 'userData', { get: PxPrismaticJoint.prototype.get_userData, set: PxPrismaticJoint.prototype.set_userData });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJoint.prototype['__destroy__'] = PxPrismaticJoint.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxPrismaticJoint___destroy___0(self);
};

// Interface: PxPrismaticJointFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxPrismaticJointFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxPrismaticJointFlags_PxPrismaticJointFlags_1(flags);
  getCache(PxPrismaticJointFlags)[this.ptr] = this;
};

PxPrismaticJointFlags.prototype = Object.create(WrapperObject.prototype);
PxPrismaticJointFlags.prototype.constructor = PxPrismaticJointFlags;
PxPrismaticJointFlags.prototype.__class__ = PxPrismaticJointFlags;
PxPrismaticJointFlags.__cache__ = {};
Module['PxPrismaticJointFlags'] = PxPrismaticJointFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJointFlags.prototype['isSet'] = PxPrismaticJointFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxPrismaticJointFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJointFlags.prototype['raise'] = PxPrismaticJointFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxPrismaticJointFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJointFlags.prototype['clear'] = PxPrismaticJointFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxPrismaticJointFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPrismaticJointFlags.prototype['__destroy__'] = PxPrismaticJointFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxPrismaticJointFlags___destroy___0(self);
};

// Interface: PxPvd

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxPvd() { throw "cannot construct a PxPvd, no constructor in IDL" }
PxPvd.prototype = Object.create(WrapperObject.prototype);
PxPvd.prototype.constructor = PxPvd;
PxPvd.prototype.__class__ = PxPvd;
PxPvd.__cache__ = {};
Module['PxPvd'] = PxPvd;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvd.prototype['connect'] = PxPvd.prototype.connect = function(transport, flags) {
  var self = this.ptr;
  if (transport && typeof transport === 'object') transport = transport.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  return !!(_emscripten_bind_PxPvd_connect_2(self, transport, flags));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvd.prototype['release'] = PxPvd.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxPvd_release_0(self);
};


// Interface: PxPvdInstrumentationFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxPvdInstrumentationFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxPvdInstrumentationFlags_PxPvdInstrumentationFlags_1(flags);
  getCache(PxPvdInstrumentationFlags)[this.ptr] = this;
};

PxPvdInstrumentationFlags.prototype = Object.create(WrapperObject.prototype);
PxPvdInstrumentationFlags.prototype.constructor = PxPvdInstrumentationFlags;
PxPvdInstrumentationFlags.prototype.__class__ = PxPvdInstrumentationFlags;
PxPvdInstrumentationFlags.__cache__ = {};
Module['PxPvdInstrumentationFlags'] = PxPvdInstrumentationFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdInstrumentationFlags.prototype['isSet'] = PxPvdInstrumentationFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxPvdInstrumentationFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdInstrumentationFlags.prototype['raise'] = PxPvdInstrumentationFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxPvdInstrumentationFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdInstrumentationFlags.prototype['clear'] = PxPvdInstrumentationFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxPvdInstrumentationFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdInstrumentationFlags.prototype['__destroy__'] = PxPvdInstrumentationFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxPvdInstrumentationFlags___destroy___0(self);
};

// Interface: PxPvdSceneClient

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxPvdSceneClient() { throw "cannot construct a PxPvdSceneClient, no constructor in IDL" }
PxPvdSceneClient.prototype = Object.create(WrapperObject.prototype);
PxPvdSceneClient.prototype.constructor = PxPvdSceneClient;
PxPvdSceneClient.prototype.__class__ = PxPvdSceneClient;
PxPvdSceneClient.__cache__ = {};
Module['PxPvdSceneClient'] = PxPvdSceneClient;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdSceneClient.prototype['setScenePvdFlag'] = PxPvdSceneClient.prototype.setScenePvdFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxPvdSceneClient_setScenePvdFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdSceneClient.prototype['setScenePvdFlags'] = PxPvdSceneClient.prototype.setScenePvdFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxPvdSceneClient_setScenePvdFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdSceneClient.prototype['getScenePvdFlags'] = PxPvdSceneClient.prototype.getScenePvdFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxPvdSceneClient_getScenePvdFlags_0(self), PxPvdSceneFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdSceneClient.prototype['updateCamera'] = PxPvdSceneClient.prototype.updateCamera = function(name, origin, up, target) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  if (origin && typeof origin === 'object') origin = origin.ptr;
  if (up && typeof up === 'object') up = up.ptr;
  if (target && typeof target === 'object') target = target.ptr;
  _emscripten_bind_PxPvdSceneClient_updateCamera_4(self, name, origin, up, target);
};


// Interface: PxPvdSceneFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxPvdSceneFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxPvdSceneFlags_PxPvdSceneFlags_1(flags);
  getCache(PxPvdSceneFlags)[this.ptr] = this;
};

PxPvdSceneFlags.prototype = Object.create(WrapperObject.prototype);
PxPvdSceneFlags.prototype.constructor = PxPvdSceneFlags;
PxPvdSceneFlags.prototype.__class__ = PxPvdSceneFlags;
PxPvdSceneFlags.__cache__ = {};
Module['PxPvdSceneFlags'] = PxPvdSceneFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdSceneFlags.prototype['isSet'] = PxPvdSceneFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxPvdSceneFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdSceneFlags.prototype['raise'] = PxPvdSceneFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxPvdSceneFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdSceneFlags.prototype['clear'] = PxPvdSceneFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxPvdSceneFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxPvdSceneFlags.prototype['__destroy__'] = PxPvdSceneFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxPvdSceneFlags___destroy___0(self);
};

// Interface: PxQuat

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxQuat(nx, ny, nz, nw) {
  if (nx && typeof nx === 'object') nx = nx.ptr;
  if (ny && typeof ny === 'object') ny = ny.ptr;
  if (nz && typeof nz === 'object') nz = nz.ptr;
  if (nw && typeof nw === 'object') nw = nw.ptr;
  if (nx === undefined) { this.ptr = _emscripten_bind_PxQuat_PxQuat_0(); getCache(PxQuat)[this.ptr] = this;return }
  if (ny === undefined) { this.ptr = _emscripten_bind_PxQuat_PxQuat_1(nx); getCache(PxQuat)[this.ptr] = this;return }
  if (nz === undefined) { this.ptr = _emscripten_bind_PxQuat_PxQuat_2(nx, ny); getCache(PxQuat)[this.ptr] = this;return }
  if (nw === undefined) { this.ptr = _emscripten_bind_PxQuat_PxQuat_3(nx, ny, nz); getCache(PxQuat)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxQuat_PxQuat_4(nx, ny, nz, nw);
  getCache(PxQuat)[this.ptr] = this;
};

PxQuat.prototype = Object.create(WrapperObject.prototype);
PxQuat.prototype.constructor = PxQuat;
PxQuat.prototype.__class__ = PxQuat;
PxQuat.__cache__ = {};
Module['PxQuat'] = PxQuat;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['isIdentity'] = PxQuat.prototype.isIdentity = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxQuat_isIdentity_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['isFinite'] = PxQuat.prototype.isFinite = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxQuat_isFinite_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['isUnit'] = PxQuat.prototype.isUnit = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxQuat_isUnit_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['isSane'] = PxQuat.prototype.isSane = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxQuat_isSane_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['getAngle'] = PxQuat.prototype.getAngle = function(q) {
  var self = this.ptr;
  if (q && typeof q === 'object') q = q.ptr;
  if (q === undefined) { return _emscripten_bind_PxQuat_getAngle_0(self) }
  return _emscripten_bind_PxQuat_getAngle_1(self, q);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['magnitudeSquared'] = PxQuat.prototype.magnitudeSquared = function() {
  var self = this.ptr;
  return _emscripten_bind_PxQuat_magnitudeSquared_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['dot'] = PxQuat.prototype.dot = function(q) {
  var self = this.ptr;
  if (q && typeof q === 'object') q = q.ptr;
  return _emscripten_bind_PxQuat_dot_1(self, q);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['getNormalized'] = PxQuat.prototype.getNormalized = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxQuat_getNormalized_0(self), PxQuat);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['magnitude'] = PxQuat.prototype.magnitude = function() {
  var self = this.ptr;
  return _emscripten_bind_PxQuat_magnitude_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['normalize'] = PxQuat.prototype.normalize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxQuat_normalize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['getConjugate'] = PxQuat.prototype.getConjugate = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxQuat_getConjugate_0(self), PxQuat);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['getImaginaryPart'] = PxQuat.prototype.getImaginaryPart = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxQuat_getImaginaryPart_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['getBasisVector0'] = PxQuat.prototype.getBasisVector0 = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxQuat_getBasisVector0_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['getBasisVector1'] = PxQuat.prototype.getBasisVector1 = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxQuat_getBasisVector1_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['getBasisVector2'] = PxQuat.prototype.getBasisVector2 = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxQuat_getBasisVector2_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['rotate'] = PxQuat.prototype.rotate = function(v) {
  var self = this.ptr;
  if (v && typeof v === 'object') v = v.ptr;
  return wrapPointer(_emscripten_bind_PxQuat_rotate_1(self, v), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['rotateInv'] = PxQuat.prototype.rotateInv = function(v) {
  var self = this.ptr;
  if (v && typeof v === 'object') v = v.ptr;
  return wrapPointer(_emscripten_bind_PxQuat_rotateInv_1(self, v), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['get_x'] = PxQuat.prototype.get_x = function() {
  var self = this.ptr;
  return _emscripten_bind_PxQuat_get_x_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['set_x'] = PxQuat.prototype.set_x = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxQuat_set_x_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxQuat.prototype, 'x', { get: PxQuat.prototype.get_x, set: PxQuat.prototype.set_x });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['get_y'] = PxQuat.prototype.get_y = function() {
  var self = this.ptr;
  return _emscripten_bind_PxQuat_get_y_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['set_y'] = PxQuat.prototype.set_y = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxQuat_set_y_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxQuat.prototype, 'y', { get: PxQuat.prototype.get_y, set: PxQuat.prototype.set_y });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['get_z'] = PxQuat.prototype.get_z = function() {
  var self = this.ptr;
  return _emscripten_bind_PxQuat_get_z_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['set_z'] = PxQuat.prototype.set_z = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxQuat_set_z_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxQuat.prototype, 'z', { get: PxQuat.prototype.get_z, set: PxQuat.prototype.set_z });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['get_w'] = PxQuat.prototype.get_w = function() {
  var self = this.ptr;
  return _emscripten_bind_PxQuat_get_w_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['set_w'] = PxQuat.prototype.set_w = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxQuat_set_w_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxQuat.prototype, 'w', { get: PxQuat.prototype.get_w, set: PxQuat.prototype.set_w });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQuat.prototype['__destroy__'] = PxQuat.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxQuat___destroy___0(self);
};

// Interface: PxQueryFilterCallbackImpl

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxQueryFilterCallbackImpl() {
  this.ptr = _emscripten_bind_PxQueryFilterCallbackImpl_PxQueryFilterCallbackImpl_0();
  getCache(PxQueryFilterCallbackImpl)[this.ptr] = this;
};

PxQueryFilterCallbackImpl.prototype = Object.create(SimpleQueryFilterCallback.prototype);
PxQueryFilterCallbackImpl.prototype.constructor = PxQueryFilterCallbackImpl;
PxQueryFilterCallbackImpl.prototype.__class__ = PxQueryFilterCallbackImpl;
PxQueryFilterCallbackImpl.__cache__ = {};
Module['PxQueryFilterCallbackImpl'] = PxQueryFilterCallbackImpl;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryFilterCallbackImpl.prototype['simplePreFilter'] = PxQueryFilterCallbackImpl.prototype.simplePreFilter = function(filterData, shape, actor, queryFlags) {
  var self = this.ptr;
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (queryFlags && typeof queryFlags === 'object') queryFlags = queryFlags.ptr;
  return _emscripten_bind_PxQueryFilterCallbackImpl_simplePreFilter_4(self, filterData, shape, actor, queryFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryFilterCallbackImpl.prototype['simplePostFilter'] = PxQueryFilterCallbackImpl.prototype.simplePostFilter = function(filterData, hit, shape, actor) {
  var self = this.ptr;
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  if (hit && typeof hit === 'object') hit = hit.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return _emscripten_bind_PxQueryFilterCallbackImpl_simplePostFilter_4(self, filterData, hit, shape, actor);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryFilterCallbackImpl.prototype['__destroy__'] = PxQueryFilterCallbackImpl.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxQueryFilterCallbackImpl___destroy___0(self);
};

// Interface: PxQueryFilterData

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxQueryFilterData(fd, f) {
  if (fd && typeof fd === 'object') fd = fd.ptr;
  if (f && typeof f === 'object') f = f.ptr;
  if (fd === undefined) { this.ptr = _emscripten_bind_PxQueryFilterData_PxQueryFilterData_0(); getCache(PxQueryFilterData)[this.ptr] = this;return }
  if (f === undefined) { this.ptr = _emscripten_bind_PxQueryFilterData_PxQueryFilterData_1(fd); getCache(PxQueryFilterData)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxQueryFilterData_PxQueryFilterData_2(fd, f);
  getCache(PxQueryFilterData)[this.ptr] = this;
};

PxQueryFilterData.prototype = Object.create(WrapperObject.prototype);
PxQueryFilterData.prototype.constructor = PxQueryFilterData;
PxQueryFilterData.prototype.__class__ = PxQueryFilterData;
PxQueryFilterData.__cache__ = {};
Module['PxQueryFilterData'] = PxQueryFilterData;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryFilterData.prototype['get_data'] = PxQueryFilterData.prototype.get_data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxQueryFilterData_get_data_0(self), PxFilterData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryFilterData.prototype['set_data'] = PxQueryFilterData.prototype.set_data = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxQueryFilterData_set_data_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxQueryFilterData.prototype, 'data', { get: PxQueryFilterData.prototype.get_data, set: PxQueryFilterData.prototype.set_data });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryFilterData.prototype['get_flags'] = PxQueryFilterData.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxQueryFilterData_get_flags_0(self), PxQueryFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryFilterData.prototype['set_flags'] = PxQueryFilterData.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxQueryFilterData_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxQueryFilterData.prototype, 'flags', { get: PxQueryFilterData.prototype.get_flags, set: PxQueryFilterData.prototype.set_flags });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryFilterData.prototype['__destroy__'] = PxQueryFilterData.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxQueryFilterData___destroy___0(self);
};

// Interface: PxQueryFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxQueryFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxQueryFlags_PxQueryFlags_1(flags);
  getCache(PxQueryFlags)[this.ptr] = this;
};

PxQueryFlags.prototype = Object.create(WrapperObject.prototype);
PxQueryFlags.prototype.constructor = PxQueryFlags;
PxQueryFlags.prototype.__class__ = PxQueryFlags;
PxQueryFlags.__cache__ = {};
Module['PxQueryFlags'] = PxQueryFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryFlags.prototype['isSet'] = PxQueryFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxQueryFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryFlags.prototype['raise'] = PxQueryFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxQueryFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryFlags.prototype['clear'] = PxQueryFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxQueryFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxQueryFlags.prototype['__destroy__'] = PxQueryFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxQueryFlags___destroy___0(self);
};

// Interface: PxRackAndPinionJoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRackAndPinionJoint() { throw "cannot construct a PxRackAndPinionJoint, no constructor in IDL" }
PxRackAndPinionJoint.prototype = Object.create(PxJoint.prototype);
PxRackAndPinionJoint.prototype.constructor = PxRackAndPinionJoint;
PxRackAndPinionJoint.prototype.__class__ = PxRackAndPinionJoint;
PxRackAndPinionJoint.__cache__ = {};
Module['PxRackAndPinionJoint'] = PxRackAndPinionJoint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setJoints'] = PxRackAndPinionJoint.prototype.setJoints = function(hinge, prismatic) {
  var self = this.ptr;
  if (hinge && typeof hinge === 'object') hinge = hinge.ptr;
  if (prismatic && typeof prismatic === 'object') prismatic = prismatic.ptr;
  return !!(_emscripten_bind_PxRackAndPinionJoint_setJoints_2(self, hinge, prismatic));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setRatio'] = PxRackAndPinionJoint.prototype.setRatio = function(ratio) {
  var self = this.ptr;
  if (ratio && typeof ratio === 'object') ratio = ratio.ptr;
  _emscripten_bind_PxRackAndPinionJoint_setRatio_1(self, ratio);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getRatio'] = PxRackAndPinionJoint.prototype.getRatio = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRackAndPinionJoint_getRatio_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setData'] = PxRackAndPinionJoint.prototype.setData = function(nbRackTeeth, nbPinionTeeth, rackLength) {
  var self = this.ptr;
  if (nbRackTeeth && typeof nbRackTeeth === 'object') nbRackTeeth = nbRackTeeth.ptr;
  if (nbPinionTeeth && typeof nbPinionTeeth === 'object') nbPinionTeeth = nbPinionTeeth.ptr;
  if (rackLength && typeof rackLength === 'object') rackLength = rackLength.ptr;
  return !!(_emscripten_bind_PxRackAndPinionJoint_setData_3(self, nbRackTeeth, nbPinionTeeth, rackLength));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['release'] = PxRackAndPinionJoint.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxRackAndPinionJoint_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getConcreteTypeName'] = PxRackAndPinionJoint.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxRackAndPinionJoint_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getConcreteType'] = PxRackAndPinionJoint.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRackAndPinionJoint_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setBaseFlag'] = PxRackAndPinionJoint.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRackAndPinionJoint_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setBaseFlags'] = PxRackAndPinionJoint.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxRackAndPinionJoint_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getBaseFlags'] = PxRackAndPinionJoint.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRackAndPinionJoint_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['isReleasable'] = PxRackAndPinionJoint.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRackAndPinionJoint_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setActors'] = PxRackAndPinionJoint.prototype.setActors = function(actor0, actor1) {
  var self = this.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  _emscripten_bind_PxRackAndPinionJoint_setActors_2(self, actor0, actor1);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setLocalPose'] = PxRackAndPinionJoint.prototype.setLocalPose = function(actor, localPose) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (localPose && typeof localPose === 'object') localPose = localPose.ptr;
  _emscripten_bind_PxRackAndPinionJoint_setLocalPose_2(self, actor, localPose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getLocalPose'] = PxRackAndPinionJoint.prototype.getLocalPose = function(actor) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return wrapPointer(_emscripten_bind_PxRackAndPinionJoint_getLocalPose_1(self, actor), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getRelativeTransform'] = PxRackAndPinionJoint.prototype.getRelativeTransform = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRackAndPinionJoint_getRelativeTransform_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getRelativeLinearVelocity'] = PxRackAndPinionJoint.prototype.getRelativeLinearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRackAndPinionJoint_getRelativeLinearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getRelativeAngularVelocity'] = PxRackAndPinionJoint.prototype.getRelativeAngularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRackAndPinionJoint_getRelativeAngularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setBreakForce'] = PxRackAndPinionJoint.prototype.setBreakForce = function(force, torque) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  _emscripten_bind_PxRackAndPinionJoint_setBreakForce_2(self, force, torque);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setConstraintFlags'] = PxRackAndPinionJoint.prototype.setConstraintFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxRackAndPinionJoint_setConstraintFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setConstraintFlag'] = PxRackAndPinionJoint.prototype.setConstraintFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRackAndPinionJoint_setConstraintFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getConstraintFlags'] = PxRackAndPinionJoint.prototype.getConstraintFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRackAndPinionJoint_getConstraintFlags_0(self), PxConstraintFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setInvMassScale0'] = PxRackAndPinionJoint.prototype.setInvMassScale0 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxRackAndPinionJoint_setInvMassScale0_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getInvMassScale0'] = PxRackAndPinionJoint.prototype.getInvMassScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRackAndPinionJoint_getInvMassScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setInvMassScale1'] = PxRackAndPinionJoint.prototype.setInvMassScale1 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxRackAndPinionJoint_setInvMassScale1_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getInvMassScale1'] = PxRackAndPinionJoint.prototype.getInvMassScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRackAndPinionJoint_getInvMassScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setInvInertiaScale0'] = PxRackAndPinionJoint.prototype.setInvInertiaScale0 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale0_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getInvInertiaScale0'] = PxRackAndPinionJoint.prototype.getInvInertiaScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setInvInertiaScale1'] = PxRackAndPinionJoint.prototype.setInvInertiaScale1 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxRackAndPinionJoint_setInvInertiaScale1_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getInvInertiaScale1'] = PxRackAndPinionJoint.prototype.getInvInertiaScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRackAndPinionJoint_getInvInertiaScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getConstraint'] = PxRackAndPinionJoint.prototype.getConstraint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRackAndPinionJoint_getConstraint_0(self), PxConstraint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['setName'] = PxRackAndPinionJoint.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxRackAndPinionJoint_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getName'] = PxRackAndPinionJoint.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxRackAndPinionJoint_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['getScene'] = PxRackAndPinionJoint.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRackAndPinionJoint_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['get_userData'] = PxRackAndPinionJoint.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRackAndPinionJoint_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['set_userData'] = PxRackAndPinionJoint.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRackAndPinionJoint_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRackAndPinionJoint.prototype, 'userData', { get: PxRackAndPinionJoint.prototype.get_userData, set: PxRackAndPinionJoint.prototype.set_userData });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRackAndPinionJoint.prototype['__destroy__'] = PxRackAndPinionJoint.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxRackAndPinionJoint___destroy___0(self);
};

// Interface: PxRaycastBuffer10

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRaycastBuffer10() {
  this.ptr = _emscripten_bind_PxRaycastBuffer10_PxRaycastBuffer10_0();
  getCache(PxRaycastBuffer10)[this.ptr] = this;
};

PxRaycastBuffer10.prototype = Object.create(PxRaycastCallback.prototype);
PxRaycastBuffer10.prototype.constructor = PxRaycastBuffer10;
PxRaycastBuffer10.prototype.__class__ = PxRaycastBuffer10;
PxRaycastBuffer10.__cache__ = {};
Module['PxRaycastBuffer10'] = PxRaycastBuffer10;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastBuffer10.prototype['getNbAnyHits'] = PxRaycastBuffer10.prototype.getNbAnyHits = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRaycastBuffer10_getNbAnyHits_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastBuffer10.prototype['getAnyHit'] = PxRaycastBuffer10.prototype.getAnyHit = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxRaycastBuffer10_getAnyHit_1(self, index), PxRaycastHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastBuffer10.prototype['getNbTouches'] = PxRaycastBuffer10.prototype.getNbTouches = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRaycastBuffer10_getNbTouches_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastBuffer10.prototype['getTouches'] = PxRaycastBuffer10.prototype.getTouches = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRaycastBuffer10_getTouches_0(self), PxRaycastHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastBuffer10.prototype['getTouch'] = PxRaycastBuffer10.prototype.getTouch = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxRaycastBuffer10_getTouch_1(self, index), PxRaycastHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastBuffer10.prototype['getMaxNbTouches'] = PxRaycastBuffer10.prototype.getMaxNbTouches = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRaycastBuffer10_getMaxNbTouches_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastBuffer10.prototype['hasAnyHits'] = PxRaycastBuffer10.prototype.hasAnyHits = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRaycastBuffer10_hasAnyHits_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastBuffer10.prototype['get_block'] = PxRaycastBuffer10.prototype.get_block = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRaycastBuffer10_get_block_0(self), PxRaycastHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastBuffer10.prototype['set_block'] = PxRaycastBuffer10.prototype.set_block = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRaycastBuffer10_set_block_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRaycastBuffer10.prototype, 'block', { get: PxRaycastBuffer10.prototype.get_block, set: PxRaycastBuffer10.prototype.set_block });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastBuffer10.prototype['get_hasBlock'] = PxRaycastBuffer10.prototype.get_hasBlock = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRaycastBuffer10_get_hasBlock_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastBuffer10.prototype['set_hasBlock'] = PxRaycastBuffer10.prototype.set_hasBlock = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRaycastBuffer10_set_hasBlock_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRaycastBuffer10.prototype, 'hasBlock', { get: PxRaycastBuffer10.prototype.get_hasBlock, set: PxRaycastBuffer10.prototype.set_hasBlock });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastBuffer10.prototype['__destroy__'] = PxRaycastBuffer10.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxRaycastBuffer10___destroy___0(self);
};

// Interface: PxRaycastHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRaycastHit() {
  this.ptr = _emscripten_bind_PxRaycastHit_PxRaycastHit_0();
  getCache(PxRaycastHit)[this.ptr] = this;
};

PxRaycastHit.prototype = Object.create(PxGeomRaycastHit.prototype);
PxRaycastHit.prototype.constructor = PxRaycastHit;
PxRaycastHit.prototype.__class__ = PxRaycastHit;
PxRaycastHit.__cache__ = {};
Module['PxRaycastHit'] = PxRaycastHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['hadInitialOverlap'] = PxRaycastHit.prototype.hadInitialOverlap = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRaycastHit_hadInitialOverlap_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['get_actor'] = PxRaycastHit.prototype.get_actor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRaycastHit_get_actor_0(self), PxRigidActor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['set_actor'] = PxRaycastHit.prototype.set_actor = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRaycastHit_set_actor_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRaycastHit.prototype, 'actor', { get: PxRaycastHit.prototype.get_actor, set: PxRaycastHit.prototype.set_actor });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['get_shape'] = PxRaycastHit.prototype.get_shape = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRaycastHit_get_shape_0(self), PxShape);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['set_shape'] = PxRaycastHit.prototype.set_shape = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRaycastHit_set_shape_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRaycastHit.prototype, 'shape', { get: PxRaycastHit.prototype.get_shape, set: PxRaycastHit.prototype.set_shape });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['get_u'] = PxRaycastHit.prototype.get_u = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRaycastHit_get_u_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['set_u'] = PxRaycastHit.prototype.set_u = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRaycastHit_set_u_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRaycastHit.prototype, 'u', { get: PxRaycastHit.prototype.get_u, set: PxRaycastHit.prototype.set_u });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['get_v'] = PxRaycastHit.prototype.get_v = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRaycastHit_get_v_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['set_v'] = PxRaycastHit.prototype.set_v = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRaycastHit_set_v_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRaycastHit.prototype, 'v', { get: PxRaycastHit.prototype.get_v, set: PxRaycastHit.prototype.set_v });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['get_flags'] = PxRaycastHit.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRaycastHit_get_flags_0(self), PxHitFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['set_flags'] = PxRaycastHit.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRaycastHit_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRaycastHit.prototype, 'flags', { get: PxRaycastHit.prototype.get_flags, set: PxRaycastHit.prototype.set_flags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['get_position'] = PxRaycastHit.prototype.get_position = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRaycastHit_get_position_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['set_position'] = PxRaycastHit.prototype.set_position = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRaycastHit_set_position_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRaycastHit.prototype, 'position', { get: PxRaycastHit.prototype.get_position, set: PxRaycastHit.prototype.set_position });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['get_normal'] = PxRaycastHit.prototype.get_normal = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRaycastHit_get_normal_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['set_normal'] = PxRaycastHit.prototype.set_normal = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRaycastHit_set_normal_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRaycastHit.prototype, 'normal', { get: PxRaycastHit.prototype.get_normal, set: PxRaycastHit.prototype.set_normal });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['get_distance'] = PxRaycastHit.prototype.get_distance = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRaycastHit_get_distance_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['set_distance'] = PxRaycastHit.prototype.set_distance = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRaycastHit_set_distance_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRaycastHit.prototype, 'distance', { get: PxRaycastHit.prototype.get_distance, set: PxRaycastHit.prototype.set_distance });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['get_faceIndex'] = PxRaycastHit.prototype.get_faceIndex = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRaycastHit_get_faceIndex_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['set_faceIndex'] = PxRaycastHit.prototype.set_faceIndex = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRaycastHit_set_faceIndex_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRaycastHit.prototype, 'faceIndex', { get: PxRaycastHit.prototype.get_faceIndex, set: PxRaycastHit.prototype.set_faceIndex });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastHit.prototype['__destroy__'] = PxRaycastHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxRaycastHit___destroy___0(self);
};

// Interface: PxRaycastResult

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRaycastResult() {
  this.ptr = _emscripten_bind_PxRaycastResult_PxRaycastResult_0();
  getCache(PxRaycastResult)[this.ptr] = this;
};

PxRaycastResult.prototype = Object.create(PxRaycastCallback.prototype);
PxRaycastResult.prototype.constructor = PxRaycastResult;
PxRaycastResult.prototype.__class__ = PxRaycastResult;
PxRaycastResult.__cache__ = {};
Module['PxRaycastResult'] = PxRaycastResult;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastResult.prototype['getNbAnyHits'] = PxRaycastResult.prototype.getNbAnyHits = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRaycastResult_getNbAnyHits_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastResult.prototype['getAnyHit'] = PxRaycastResult.prototype.getAnyHit = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxRaycastResult_getAnyHit_1(self, index), PxRaycastHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastResult.prototype['getNbTouches'] = PxRaycastResult.prototype.getNbTouches = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRaycastResult_getNbTouches_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastResult.prototype['getTouch'] = PxRaycastResult.prototype.getTouch = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxRaycastResult_getTouch_1(self, index), PxRaycastHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastResult.prototype['clear'] = PxRaycastResult.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxRaycastResult_clear_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastResult.prototype['hasAnyHits'] = PxRaycastResult.prototype.hasAnyHits = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRaycastResult_hasAnyHits_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastResult.prototype['get_block'] = PxRaycastResult.prototype.get_block = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRaycastResult_get_block_0(self), PxRaycastHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastResult.prototype['set_block'] = PxRaycastResult.prototype.set_block = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRaycastResult_set_block_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRaycastResult.prototype, 'block', { get: PxRaycastResult.prototype.get_block, set: PxRaycastResult.prototype.set_block });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastResult.prototype['get_hasBlock'] = PxRaycastResult.prototype.get_hasBlock = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRaycastResult_get_hasBlock_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastResult.prototype['set_hasBlock'] = PxRaycastResult.prototype.set_hasBlock = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRaycastResult_set_hasBlock_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRaycastResult.prototype, 'hasBlock', { get: PxRaycastResult.prototype.get_hasBlock, set: PxRaycastResult.prototype.set_hasBlock });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRaycastResult.prototype['__destroy__'] = PxRaycastResult.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxRaycastResult___destroy___0(self);
};

// Interface: PxRealPtr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRealPtr() { throw "cannot construct a PxRealPtr, no constructor in IDL" }
PxRealPtr.prototype = Object.create(PxRealConstPtr.prototype);
PxRealPtr.prototype.constructor = PxRealPtr;
PxRealPtr.prototype.__class__ = PxRealPtr;
PxRealPtr.__cache__ = {};
Module['PxRealPtr'] = PxRealPtr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRealPtr.prototype['__destroy__'] = PxRealPtr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxRealPtr___destroy___0(self);
};

// Interface: PxRenderBuffer

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRenderBuffer() { throw "cannot construct a PxRenderBuffer, no constructor in IDL" }
PxRenderBuffer.prototype = Object.create(WrapperObject.prototype);
PxRenderBuffer.prototype.constructor = PxRenderBuffer;
PxRenderBuffer.prototype.__class__ = PxRenderBuffer;
PxRenderBuffer.__cache__ = {};
Module['PxRenderBuffer'] = PxRenderBuffer;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['getNbPoints'] = PxRenderBuffer.prototype.getNbPoints = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRenderBuffer_getNbPoints_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['getPoints'] = PxRenderBuffer.prototype.getPoints = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRenderBuffer_getPoints_0(self), PxDebugPoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['addPoint'] = PxRenderBuffer.prototype.addPoint = function(point) {
  var self = this.ptr;
  if (point && typeof point === 'object') point = point.ptr;
  _emscripten_bind_PxRenderBuffer_addPoint_1(self, point);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['getNbLines'] = PxRenderBuffer.prototype.getNbLines = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRenderBuffer_getNbLines_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['getLines'] = PxRenderBuffer.prototype.getLines = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRenderBuffer_getLines_0(self), PxDebugLine);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['addLine'] = PxRenderBuffer.prototype.addLine = function(line) {
  var self = this.ptr;
  if (line && typeof line === 'object') line = line.ptr;
  _emscripten_bind_PxRenderBuffer_addLine_1(self, line);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['reserveLines'] = PxRenderBuffer.prototype.reserveLines = function(nbLines) {
  var self = this.ptr;
  if (nbLines && typeof nbLines === 'object') nbLines = nbLines.ptr;
  return wrapPointer(_emscripten_bind_PxRenderBuffer_reserveLines_1(self, nbLines), PxDebugLine);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['reservePoints'] = PxRenderBuffer.prototype.reservePoints = function(nbLines) {
  var self = this.ptr;
  if (nbLines && typeof nbLines === 'object') nbLines = nbLines.ptr;
  return wrapPointer(_emscripten_bind_PxRenderBuffer_reservePoints_1(self, nbLines), PxDebugPoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['getNbTriangles'] = PxRenderBuffer.prototype.getNbTriangles = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRenderBuffer_getNbTriangles_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['getTriangles'] = PxRenderBuffer.prototype.getTriangles = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRenderBuffer_getTriangles_0(self), PxDebugTriangle);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['addTriangle'] = PxRenderBuffer.prototype.addTriangle = function(triangle) {
  var self = this.ptr;
  if (triangle && typeof triangle === 'object') triangle = triangle.ptr;
  _emscripten_bind_PxRenderBuffer_addTriangle_1(self, triangle);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['append'] = PxRenderBuffer.prototype.append = function(other) {
  var self = this.ptr;
  if (other && typeof other === 'object') other = other.ptr;
  _emscripten_bind_PxRenderBuffer_append_1(self, other);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['clear'] = PxRenderBuffer.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxRenderBuffer_clear_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['shift'] = PxRenderBuffer.prototype.shift = function(delta) {
  var self = this.ptr;
  if (delta && typeof delta === 'object') delta = delta.ptr;
  _emscripten_bind_PxRenderBuffer_shift_1(self, delta);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRenderBuffer.prototype['empty'] = PxRenderBuffer.prototype.empty = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRenderBuffer_empty_0(self));
};


// Interface: PxRevoluteJoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRevoluteJoint() { throw "cannot construct a PxRevoluteJoint, no constructor in IDL" }
PxRevoluteJoint.prototype = Object.create(PxJoint.prototype);
PxRevoluteJoint.prototype.constructor = PxRevoluteJoint;
PxRevoluteJoint.prototype.__class__ = PxRevoluteJoint;
PxRevoluteJoint.__cache__ = {};
Module['PxRevoluteJoint'] = PxRevoluteJoint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getAngle'] = PxRevoluteJoint.prototype.getAngle = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRevoluteJoint_getAngle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getVelocity'] = PxRevoluteJoint.prototype.getVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRevoluteJoint_getVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setLimit'] = PxRevoluteJoint.prototype.setLimit = function(limits) {
  var self = this.ptr;
  if (limits && typeof limits === 'object') limits = limits.ptr;
  _emscripten_bind_PxRevoluteJoint_setLimit_1(self, limits);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setDriveVelocity'] = PxRevoluteJoint.prototype.setDriveVelocity = function(velocity, autowake) {
  var self = this.ptr;
  if (velocity && typeof velocity === 'object') velocity = velocity.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxRevoluteJoint_setDriveVelocity_1(self, velocity); return }
  _emscripten_bind_PxRevoluteJoint_setDriveVelocity_2(self, velocity, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getDriveVelocity'] = PxRevoluteJoint.prototype.getDriveVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRevoluteJoint_getDriveVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setDriveForceLimit'] = PxRevoluteJoint.prototype.setDriveForceLimit = function(limit) {
  var self = this.ptr;
  if (limit && typeof limit === 'object') limit = limit.ptr;
  _emscripten_bind_PxRevoluteJoint_setDriveForceLimit_1(self, limit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getDriveForceLimit'] = PxRevoluteJoint.prototype.getDriveForceLimit = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRevoluteJoint_getDriveForceLimit_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setDriveGearRatio'] = PxRevoluteJoint.prototype.setDriveGearRatio = function(ratio) {
  var self = this.ptr;
  if (ratio && typeof ratio === 'object') ratio = ratio.ptr;
  _emscripten_bind_PxRevoluteJoint_setDriveGearRatio_1(self, ratio);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getDriveGearRatio'] = PxRevoluteJoint.prototype.getDriveGearRatio = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRevoluteJoint_getDriveGearRatio_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setRevoluteJointFlags'] = PxRevoluteJoint.prototype.setRevoluteJointFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxRevoluteJoint_setRevoluteJointFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setRevoluteJointFlag'] = PxRevoluteJoint.prototype.setRevoluteJointFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRevoluteJoint_setRevoluteJointFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getRevoluteJointFlags'] = PxRevoluteJoint.prototype.getRevoluteJointFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRevoluteJoint_getRevoluteJointFlags_0(self), PxRevoluteJointFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['release'] = PxRevoluteJoint.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxRevoluteJoint_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getConcreteTypeName'] = PxRevoluteJoint.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxRevoluteJoint_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getConcreteType'] = PxRevoluteJoint.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRevoluteJoint_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setBaseFlag'] = PxRevoluteJoint.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRevoluteJoint_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setBaseFlags'] = PxRevoluteJoint.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxRevoluteJoint_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getBaseFlags'] = PxRevoluteJoint.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRevoluteJoint_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['isReleasable'] = PxRevoluteJoint.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRevoluteJoint_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setActors'] = PxRevoluteJoint.prototype.setActors = function(actor0, actor1) {
  var self = this.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  _emscripten_bind_PxRevoluteJoint_setActors_2(self, actor0, actor1);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setLocalPose'] = PxRevoluteJoint.prototype.setLocalPose = function(actor, localPose) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (localPose && typeof localPose === 'object') localPose = localPose.ptr;
  _emscripten_bind_PxRevoluteJoint_setLocalPose_2(self, actor, localPose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getLocalPose'] = PxRevoluteJoint.prototype.getLocalPose = function(actor) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return wrapPointer(_emscripten_bind_PxRevoluteJoint_getLocalPose_1(self, actor), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getRelativeTransform'] = PxRevoluteJoint.prototype.getRelativeTransform = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRevoluteJoint_getRelativeTransform_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getRelativeLinearVelocity'] = PxRevoluteJoint.prototype.getRelativeLinearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRevoluteJoint_getRelativeLinearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getRelativeAngularVelocity'] = PxRevoluteJoint.prototype.getRelativeAngularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRevoluteJoint_getRelativeAngularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setBreakForce'] = PxRevoluteJoint.prototype.setBreakForce = function(force, torque) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  _emscripten_bind_PxRevoluteJoint_setBreakForce_2(self, force, torque);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setConstraintFlags'] = PxRevoluteJoint.prototype.setConstraintFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxRevoluteJoint_setConstraintFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setConstraintFlag'] = PxRevoluteJoint.prototype.setConstraintFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRevoluteJoint_setConstraintFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getConstraintFlags'] = PxRevoluteJoint.prototype.getConstraintFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRevoluteJoint_getConstraintFlags_0(self), PxConstraintFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setInvMassScale0'] = PxRevoluteJoint.prototype.setInvMassScale0 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxRevoluteJoint_setInvMassScale0_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getInvMassScale0'] = PxRevoluteJoint.prototype.getInvMassScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRevoluteJoint_getInvMassScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setInvMassScale1'] = PxRevoluteJoint.prototype.setInvMassScale1 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxRevoluteJoint_setInvMassScale1_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getInvMassScale1'] = PxRevoluteJoint.prototype.getInvMassScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRevoluteJoint_getInvMassScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setInvInertiaScale0'] = PxRevoluteJoint.prototype.setInvInertiaScale0 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxRevoluteJoint_setInvInertiaScale0_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getInvInertiaScale0'] = PxRevoluteJoint.prototype.getInvInertiaScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRevoluteJoint_getInvInertiaScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setInvInertiaScale1'] = PxRevoluteJoint.prototype.setInvInertiaScale1 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxRevoluteJoint_setInvInertiaScale1_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getInvInertiaScale1'] = PxRevoluteJoint.prototype.getInvInertiaScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRevoluteJoint_getInvInertiaScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getConstraint'] = PxRevoluteJoint.prototype.getConstraint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRevoluteJoint_getConstraint_0(self), PxConstraint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['setName'] = PxRevoluteJoint.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxRevoluteJoint_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getName'] = PxRevoluteJoint.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxRevoluteJoint_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['getScene'] = PxRevoluteJoint.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRevoluteJoint_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['get_userData'] = PxRevoluteJoint.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRevoluteJoint_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['set_userData'] = PxRevoluteJoint.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRevoluteJoint_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRevoluteJoint.prototype, 'userData', { get: PxRevoluteJoint.prototype.get_userData, set: PxRevoluteJoint.prototype.set_userData });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJoint.prototype['__destroy__'] = PxRevoluteJoint.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxRevoluteJoint___destroy___0(self);
};

// Interface: PxRevoluteJointFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRevoluteJointFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxRevoluteJointFlags_PxRevoluteJointFlags_1(flags);
  getCache(PxRevoluteJointFlags)[this.ptr] = this;
};

PxRevoluteJointFlags.prototype = Object.create(WrapperObject.prototype);
PxRevoluteJointFlags.prototype.constructor = PxRevoluteJointFlags;
PxRevoluteJointFlags.prototype.__class__ = PxRevoluteJointFlags;
PxRevoluteJointFlags.__cache__ = {};
Module['PxRevoluteJointFlags'] = PxRevoluteJointFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJointFlags.prototype['isSet'] = PxRevoluteJointFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxRevoluteJointFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJointFlags.prototype['raise'] = PxRevoluteJointFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxRevoluteJointFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJointFlags.prototype['clear'] = PxRevoluteJointFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxRevoluteJointFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRevoluteJointFlags.prototype['__destroy__'] = PxRevoluteJointFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxRevoluteJointFlags___destroy___0(self);
};

// Interface: PxRigidActorExt

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRigidActorExt() { throw "cannot construct a PxRigidActorExt, no constructor in IDL" }
PxRigidActorExt.prototype = Object.create(WrapperObject.prototype);
PxRigidActorExt.prototype.constructor = PxRigidActorExt;
PxRigidActorExt.prototype.__class__ = PxRigidActorExt;
PxRigidActorExt.__cache__ = {};
Module['PxRigidActorExt'] = PxRigidActorExt;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActorExt.prototype['createExclusiveShape'] = PxRigidActorExt.prototype.createExclusiveShape = function(actor, geometry, material, flags) {
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (geometry && typeof geometry === 'object') geometry = geometry.ptr;
  if (material && typeof material === 'object') material = material.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  if (flags === undefined) { return wrapPointer(_emscripten_bind_PxRigidActorExt_createExclusiveShape_3(actor, geometry, material), PxShape) }
  return wrapPointer(_emscripten_bind_PxRigidActorExt_createExclusiveShape_4(actor, geometry, material, flags), PxShape);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidActorExt.prototype['__destroy__'] = PxRigidActorExt.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxRigidActorExt___destroy___0(self);
};

// Interface: PxRigidBodyExt

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRigidBodyExt() { throw "cannot construct a PxRigidBodyExt, no constructor in IDL" }
PxRigidBodyExt.prototype = Object.create(WrapperObject.prototype);
PxRigidBodyExt.prototype.constructor = PxRigidBodyExt;
PxRigidBodyExt.prototype.__class__ = PxRigidBodyExt;
PxRigidBodyExt.__cache__ = {};
Module['PxRigidBodyExt'] = PxRigidBodyExt;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyExt.prototype['updateMassAndInertia'] = PxRigidBodyExt.prototype.updateMassAndInertia = function(body, density, massLocalPose, includeNonSimShapes) {
  if (body && typeof body === 'object') body = body.ptr;
  if (density && typeof density === 'object') density = density.ptr;
  if (massLocalPose && typeof massLocalPose === 'object') massLocalPose = massLocalPose.ptr;
  if (includeNonSimShapes && typeof includeNonSimShapes === 'object') includeNonSimShapes = includeNonSimShapes.ptr;
  if (massLocalPose === undefined) { return !!(_emscripten_bind_PxRigidBodyExt_updateMassAndInertia_2(body, density)) }
  if (includeNonSimShapes === undefined) { return !!(_emscripten_bind_PxRigidBodyExt_updateMassAndInertia_3(body, density, massLocalPose)) }
  return !!(_emscripten_bind_PxRigidBodyExt_updateMassAndInertia_4(body, density, massLocalPose, includeNonSimShapes));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyExt.prototype['setMassAndUpdateInertia'] = PxRigidBodyExt.prototype.setMassAndUpdateInertia = function(body, mass, massLocalPose, includeNonSimShapes) {
  if (body && typeof body === 'object') body = body.ptr;
  if (mass && typeof mass === 'object') mass = mass.ptr;
  if (massLocalPose && typeof massLocalPose === 'object') massLocalPose = massLocalPose.ptr;
  if (includeNonSimShapes && typeof includeNonSimShapes === 'object') includeNonSimShapes = includeNonSimShapes.ptr;
  if (massLocalPose === undefined) { return !!(_emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_2(body, mass)) }
  if (includeNonSimShapes === undefined) { return !!(_emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_3(body, mass, massLocalPose)) }
  return !!(_emscripten_bind_PxRigidBodyExt_setMassAndUpdateInertia_4(body, mass, massLocalPose, includeNonSimShapes));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyExt.prototype['addForceAtPos'] = PxRigidBodyExt.prototype.addForceAtPos = function(body, force, pos, mode, wakeup) {
  if (body && typeof body === 'object') body = body.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (pos && typeof pos === 'object') pos = pos.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  if (wakeup && typeof wakeup === 'object') wakeup = wakeup.ptr;
  if (mode === undefined) { _emscripten_bind_PxRigidBodyExt_addForceAtPos_3(body, force, pos); return }
  if (wakeup === undefined) { _emscripten_bind_PxRigidBodyExt_addForceAtPos_4(body, force, pos, mode); return }
  _emscripten_bind_PxRigidBodyExt_addForceAtPos_5(body, force, pos, mode, wakeup);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyExt.prototype['addForceAtLocalPos'] = PxRigidBodyExt.prototype.addForceAtLocalPos = function(body, force, pos, mode, wakeup) {
  if (body && typeof body === 'object') body = body.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (pos && typeof pos === 'object') pos = pos.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  if (wakeup && typeof wakeup === 'object') wakeup = wakeup.ptr;
  if (mode === undefined) { _emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_3(body, force, pos); return }
  if (wakeup === undefined) { _emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_4(body, force, pos, mode); return }
  _emscripten_bind_PxRigidBodyExt_addForceAtLocalPos_5(body, force, pos, mode, wakeup);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyExt.prototype['addLocalForceAtPos'] = PxRigidBodyExt.prototype.addLocalForceAtPos = function(body, force, pos, mode, wakeup) {
  if (body && typeof body === 'object') body = body.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (pos && typeof pos === 'object') pos = pos.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  if (wakeup && typeof wakeup === 'object') wakeup = wakeup.ptr;
  if (mode === undefined) { _emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_3(body, force, pos); return }
  if (wakeup === undefined) { _emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_4(body, force, pos, mode); return }
  _emscripten_bind_PxRigidBodyExt_addLocalForceAtPos_5(body, force, pos, mode, wakeup);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyExt.prototype['addLocalForceAtLocalPos'] = PxRigidBodyExt.prototype.addLocalForceAtLocalPos = function(body, force, pos, mode, wakeup) {
  if (body && typeof body === 'object') body = body.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (pos && typeof pos === 'object') pos = pos.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  if (wakeup && typeof wakeup === 'object') wakeup = wakeup.ptr;
  if (mode === undefined) { _emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_3(body, force, pos); return }
  if (wakeup === undefined) { _emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_4(body, force, pos, mode); return }
  _emscripten_bind_PxRigidBodyExt_addLocalForceAtLocalPos_5(body, force, pos, mode, wakeup);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyExt.prototype['getVelocityAtPos'] = PxRigidBodyExt.prototype.getVelocityAtPos = function(body, pos) {
  if (body && typeof body === 'object') body = body.ptr;
  if (pos && typeof pos === 'object') pos = pos.ptr;
  return wrapPointer(_emscripten_bind_PxRigidBodyExt_getVelocityAtPos_2(body, pos), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyExt.prototype['getLocalVelocityAtLocalPos'] = PxRigidBodyExt.prototype.getLocalVelocityAtLocalPos = function(body, pos) {
  if (body && typeof body === 'object') body = body.ptr;
  if (pos && typeof pos === 'object') pos = pos.ptr;
  return wrapPointer(_emscripten_bind_PxRigidBodyExt_getLocalVelocityAtLocalPos_2(body, pos), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyExt.prototype['getVelocityAtOffset'] = PxRigidBodyExt.prototype.getVelocityAtOffset = function(body, pos) {
  if (body && typeof body === 'object') body = body.ptr;
  if (pos && typeof pos === 'object') pos = pos.ptr;
  return wrapPointer(_emscripten_bind_PxRigidBodyExt_getVelocityAtOffset_2(body, pos), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyExt.prototype['computeVelocityDeltaFromImpulse'] = PxRigidBodyExt.prototype.computeVelocityDeltaFromImpulse = function(body, globalPose, point, impulse, invMassScale, invInertiaScale, deltaLinearVelocity, deltaAngularVelocity) {
  if (body && typeof body === 'object') body = body.ptr;
  if (globalPose && typeof globalPose === 'object') globalPose = globalPose.ptr;
  if (point && typeof point === 'object') point = point.ptr;
  if (impulse && typeof impulse === 'object') impulse = impulse.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  if (deltaLinearVelocity && typeof deltaLinearVelocity === 'object') deltaLinearVelocity = deltaLinearVelocity.ptr;
  if (deltaAngularVelocity && typeof deltaAngularVelocity === 'object') deltaAngularVelocity = deltaAngularVelocity.ptr;
  if (invInertiaScale === undefined) { _emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_5(body, globalPose, point, impulse, invMassScale); return }
  if (deltaLinearVelocity === undefined) { _emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_6(body, globalPose, point, impulse, invMassScale, invInertiaScale); return }
  if (deltaAngularVelocity === undefined) { _emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_7(body, globalPose, point, impulse, invMassScale, invInertiaScale, deltaLinearVelocity); return }
  _emscripten_bind_PxRigidBodyExt_computeVelocityDeltaFromImpulse_8(body, globalPose, point, impulse, invMassScale, invInertiaScale, deltaLinearVelocity, deltaAngularVelocity);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyExt.prototype['computeLinearAngularImpulse'] = PxRigidBodyExt.prototype.computeLinearAngularImpulse = function(body, globalPose, point, impulse, invMassScale, invInertiaScale, linearImpulse, angularImpulse) {
  if (body && typeof body === 'object') body = body.ptr;
  if (globalPose && typeof globalPose === 'object') globalPose = globalPose.ptr;
  if (point && typeof point === 'object') point = point.ptr;
  if (impulse && typeof impulse === 'object') impulse = impulse.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  if (linearImpulse && typeof linearImpulse === 'object') linearImpulse = linearImpulse.ptr;
  if (angularImpulse && typeof angularImpulse === 'object') angularImpulse = angularImpulse.ptr;
  _emscripten_bind_PxRigidBodyExt_computeLinearAngularImpulse_8(body, globalPose, point, impulse, invMassScale, invInertiaScale, linearImpulse, angularImpulse);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyExt.prototype['__destroy__'] = PxRigidBodyExt.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxRigidBodyExt___destroy___0(self);
};

// Interface: PxRigidBodyFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRigidBodyFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxRigidBodyFlags_PxRigidBodyFlags_1(flags);
  getCache(PxRigidBodyFlags)[this.ptr] = this;
};

PxRigidBodyFlags.prototype = Object.create(WrapperObject.prototype);
PxRigidBodyFlags.prototype.constructor = PxRigidBodyFlags;
PxRigidBodyFlags.prototype.__class__ = PxRigidBodyFlags;
PxRigidBodyFlags.__cache__ = {};
Module['PxRigidBodyFlags'] = PxRigidBodyFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyFlags.prototype['isSet'] = PxRigidBodyFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxRigidBodyFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyFlags.prototype['raise'] = PxRigidBodyFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxRigidBodyFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyFlags.prototype['clear'] = PxRigidBodyFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxRigidBodyFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidBodyFlags.prototype['__destroy__'] = PxRigidBodyFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxRigidBodyFlags___destroy___0(self);
};

// Interface: PxRigidDynamic

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRigidDynamic() { throw "cannot construct a PxRigidDynamic, no constructor in IDL" }
PxRigidDynamic.prototype = Object.create(PxRigidBody.prototype);
PxRigidDynamic.prototype.constructor = PxRigidDynamic;
PxRigidDynamic.prototype.__class__ = PxRigidDynamic;
PxRigidDynamic.__cache__ = {};
Module['PxRigidDynamic'] = PxRigidDynamic;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setKinematicTarget'] = PxRigidDynamic.prototype.setKinematicTarget = function(destination) {
  var self = this.ptr;
  if (destination && typeof destination === 'object') destination = destination.ptr;
  _emscripten_bind_PxRigidDynamic_setKinematicTarget_1(self, destination);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getKinematicTarget'] = PxRigidDynamic.prototype.getKinematicTarget = function(target) {
  var self = this.ptr;
  if (target && typeof target === 'object') target = target.ptr;
  return !!(_emscripten_bind_PxRigidDynamic_getKinematicTarget_1(self, target));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['isSleeping'] = PxRigidDynamic.prototype.isSleeping = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRigidDynamic_isSleeping_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setSleepThreshold'] = PxRigidDynamic.prototype.setSleepThreshold = function(threshold) {
  var self = this.ptr;
  if (threshold && typeof threshold === 'object') threshold = threshold.ptr;
  _emscripten_bind_PxRigidDynamic_setSleepThreshold_1(self, threshold);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getSleepThreshold'] = PxRigidDynamic.prototype.getSleepThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getSleepThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setStabilizationThreshold'] = PxRigidDynamic.prototype.setStabilizationThreshold = function(threshold) {
  var self = this.ptr;
  if (threshold && typeof threshold === 'object') threshold = threshold.ptr;
  _emscripten_bind_PxRigidDynamic_setStabilizationThreshold_1(self, threshold);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getStabilizationThreshold'] = PxRigidDynamic.prototype.getStabilizationThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getStabilizationThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getRigidDynamicLockFlags'] = PxRigidDynamic.prototype.getRigidDynamicLockFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidDynamic_getRigidDynamicLockFlags_0(self), PxRigidDynamicLockFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setRigidDynamicLockFlag'] = PxRigidDynamic.prototype.setRigidDynamicLockFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setRigidDynamicLockFlags'] = PxRigidDynamic.prototype.setRigidDynamicLockFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxRigidDynamic_setRigidDynamicLockFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setLinearVelocity'] = PxRigidDynamic.prototype.setLinearVelocity = function(linVel, autowake) {
  var self = this.ptr;
  if (linVel && typeof linVel === 'object') linVel = linVel.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxRigidDynamic_setLinearVelocity_1(self, linVel); return }
  _emscripten_bind_PxRigidDynamic_setLinearVelocity_2(self, linVel, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setAngularVelocity'] = PxRigidDynamic.prototype.setAngularVelocity = function(angVel, autowake) {
  var self = this.ptr;
  if (angVel && typeof angVel === 'object') angVel = angVel.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxRigidDynamic_setAngularVelocity_1(self, angVel); return }
  _emscripten_bind_PxRigidDynamic_setAngularVelocity_2(self, angVel, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setWakeCounter'] = PxRigidDynamic.prototype.setWakeCounter = function(wakeCounterValue) {
  var self = this.ptr;
  if (wakeCounterValue && typeof wakeCounterValue === 'object') wakeCounterValue = wakeCounterValue.ptr;
  _emscripten_bind_PxRigidDynamic_setWakeCounter_1(self, wakeCounterValue);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getWakeCounter'] = PxRigidDynamic.prototype.getWakeCounter = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getWakeCounter_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['wakeUp'] = PxRigidDynamic.prototype.wakeUp = function() {
  var self = this.ptr;
  _emscripten_bind_PxRigidDynamic_wakeUp_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['putToSleep'] = PxRigidDynamic.prototype.putToSleep = function() {
  var self = this.ptr;
  _emscripten_bind_PxRigidDynamic_putToSleep_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setSolverIterationCounts'] = PxRigidDynamic.prototype.setSolverIterationCounts = function(minPositionIters, minVelocityIters) {
  var self = this.ptr;
  if (minPositionIters && typeof minPositionIters === 'object') minPositionIters = minPositionIters.ptr;
  if (minVelocityIters && typeof minVelocityIters === 'object') minVelocityIters = minVelocityIters.ptr;
  if (minVelocityIters === undefined) { _emscripten_bind_PxRigidDynamic_setSolverIterationCounts_1(self, minPositionIters); return }
  _emscripten_bind_PxRigidDynamic_setSolverIterationCounts_2(self, minPositionIters, minVelocityIters);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getContactReportThreshold'] = PxRigidDynamic.prototype.getContactReportThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getContactReportThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setContactReportThreshold'] = PxRigidDynamic.prototype.setContactReportThreshold = function(threshold) {
  var self = this.ptr;
  if (threshold && typeof threshold === 'object') threshold = threshold.ptr;
  _emscripten_bind_PxRigidDynamic_setContactReportThreshold_1(self, threshold);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getType'] = PxRigidDynamic.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getScene'] = PxRigidDynamic.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidDynamic_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setName'] = PxRigidDynamic.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxRigidDynamic_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getName'] = PxRigidDynamic.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxRigidDynamic_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getWorldBounds'] = PxRigidDynamic.prototype.getWorldBounds = function(inflation) {
  var self = this.ptr;
  if (inflation && typeof inflation === 'object') inflation = inflation.ptr;
  if (inflation === undefined) { return wrapPointer(_emscripten_bind_PxRigidDynamic_getWorldBounds_0(self), PxBounds3) }
  return wrapPointer(_emscripten_bind_PxRigidDynamic_getWorldBounds_1(self, inflation), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setActorFlag'] = PxRigidDynamic.prototype.setActorFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRigidDynamic_setActorFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setActorFlags'] = PxRigidDynamic.prototype.setActorFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxRigidDynamic_setActorFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getActorFlags'] = PxRigidDynamic.prototype.getActorFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidDynamic_getActorFlags_0(self), PxActorFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setDominanceGroup'] = PxRigidDynamic.prototype.setDominanceGroup = function(dominanceGroup) {
  var self = this.ptr;
  if (dominanceGroup && typeof dominanceGroup === 'object') dominanceGroup = dominanceGroup.ptr;
  _emscripten_bind_PxRigidDynamic_setDominanceGroup_1(self, dominanceGroup);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getDominanceGroup'] = PxRigidDynamic.prototype.getDominanceGroup = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getDominanceGroup_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setOwnerClient'] = PxRigidDynamic.prototype.setOwnerClient = function(inClient) {
  var self = this.ptr;
  if (inClient && typeof inClient === 'object') inClient = inClient.ptr;
  _emscripten_bind_PxRigidDynamic_setOwnerClient_1(self, inClient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getOwnerClient'] = PxRigidDynamic.prototype.getOwnerClient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getOwnerClient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['release'] = PxRigidDynamic.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxRigidDynamic_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getConcreteTypeName'] = PxRigidDynamic.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxRigidDynamic_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getConcreteType'] = PxRigidDynamic.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setBaseFlag'] = PxRigidDynamic.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRigidDynamic_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setBaseFlags'] = PxRigidDynamic.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxRigidDynamic_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getBaseFlags'] = PxRigidDynamic.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidDynamic_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['isReleasable'] = PxRigidDynamic.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRigidDynamic_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getGlobalPose'] = PxRigidDynamic.prototype.getGlobalPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidDynamic_getGlobalPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setGlobalPose'] = PxRigidDynamic.prototype.setGlobalPose = function(pose, autowake) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxRigidDynamic_setGlobalPose_1(self, pose); return }
  _emscripten_bind_PxRigidDynamic_setGlobalPose_2(self, pose, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['attachShape'] = PxRigidDynamic.prototype.attachShape = function(shape) {
  var self = this.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  return !!(_emscripten_bind_PxRigidDynamic_attachShape_1(self, shape));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['detachShape'] = PxRigidDynamic.prototype.detachShape = function(shape, wakeOnLostTouch) {
  var self = this.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (wakeOnLostTouch && typeof wakeOnLostTouch === 'object') wakeOnLostTouch = wakeOnLostTouch.ptr;
  if (wakeOnLostTouch === undefined) { _emscripten_bind_PxRigidDynamic_detachShape_1(self, shape); return }
  _emscripten_bind_PxRigidDynamic_detachShape_2(self, shape, wakeOnLostTouch);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getNbShapes'] = PxRigidDynamic.prototype.getNbShapes = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getNbShapes_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getShapes'] = PxRigidDynamic.prototype.getShapes = function(userBuffer, bufferSize, startIndex) {
  var self = this.ptr;
  if (userBuffer && typeof userBuffer === 'object') userBuffer = userBuffer.ptr;
  if (bufferSize && typeof bufferSize === 'object') bufferSize = bufferSize.ptr;
  if (startIndex && typeof startIndex === 'object') startIndex = startIndex.ptr;
  return _emscripten_bind_PxRigidDynamic_getShapes_3(self, userBuffer, bufferSize, startIndex);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getNbConstraints'] = PxRigidDynamic.prototype.getNbConstraints = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getNbConstraints_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setCMassLocalPose'] = PxRigidDynamic.prototype.setCMassLocalPose = function(pose) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  _emscripten_bind_PxRigidDynamic_setCMassLocalPose_1(self, pose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getCMassLocalPose'] = PxRigidDynamic.prototype.getCMassLocalPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidDynamic_getCMassLocalPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setMass'] = PxRigidDynamic.prototype.setMass = function(mass) {
  var self = this.ptr;
  if (mass && typeof mass === 'object') mass = mass.ptr;
  _emscripten_bind_PxRigidDynamic_setMass_1(self, mass);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getMass'] = PxRigidDynamic.prototype.getMass = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getMass_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getInvMass'] = PxRigidDynamic.prototype.getInvMass = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getInvMass_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setMassSpaceInertiaTensor'] = PxRigidDynamic.prototype.setMassSpaceInertiaTensor = function(m) {
  var self = this.ptr;
  if (m && typeof m === 'object') m = m.ptr;
  _emscripten_bind_PxRigidDynamic_setMassSpaceInertiaTensor_1(self, m);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getMassSpaceInertiaTensor'] = PxRigidDynamic.prototype.getMassSpaceInertiaTensor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidDynamic_getMassSpaceInertiaTensor_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getMassSpaceInvInertiaTensor'] = PxRigidDynamic.prototype.getMassSpaceInvInertiaTensor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidDynamic_getMassSpaceInvInertiaTensor_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setLinearDamping'] = PxRigidDynamic.prototype.setLinearDamping = function(linDamp) {
  var self = this.ptr;
  if (linDamp && typeof linDamp === 'object') linDamp = linDamp.ptr;
  _emscripten_bind_PxRigidDynamic_setLinearDamping_1(self, linDamp);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getLinearDamping'] = PxRigidDynamic.prototype.getLinearDamping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getLinearDamping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setAngularDamping'] = PxRigidDynamic.prototype.setAngularDamping = function(angDamp) {
  var self = this.ptr;
  if (angDamp && typeof angDamp === 'object') angDamp = angDamp.ptr;
  _emscripten_bind_PxRigidDynamic_setAngularDamping_1(self, angDamp);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getAngularDamping'] = PxRigidDynamic.prototype.getAngularDamping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getAngularDamping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getLinearVelocity'] = PxRigidDynamic.prototype.getLinearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidDynamic_getLinearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getAngularVelocity'] = PxRigidDynamic.prototype.getAngularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidDynamic_getAngularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setMaxLinearVelocity'] = PxRigidDynamic.prototype.setMaxLinearVelocity = function(maxLinVel) {
  var self = this.ptr;
  if (maxLinVel && typeof maxLinVel === 'object') maxLinVel = maxLinVel.ptr;
  _emscripten_bind_PxRigidDynamic_setMaxLinearVelocity_1(self, maxLinVel);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getMaxLinearVelocity'] = PxRigidDynamic.prototype.getMaxLinearVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getMaxLinearVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setMaxAngularVelocity'] = PxRigidDynamic.prototype.setMaxAngularVelocity = function(maxAngVel) {
  var self = this.ptr;
  if (maxAngVel && typeof maxAngVel === 'object') maxAngVel = maxAngVel.ptr;
  _emscripten_bind_PxRigidDynamic_setMaxAngularVelocity_1(self, maxAngVel);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getMaxAngularVelocity'] = PxRigidDynamic.prototype.getMaxAngularVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getMaxAngularVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['addForce'] = PxRigidDynamic.prototype.addForce = function(force, mode, autowake) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (mode === undefined) { _emscripten_bind_PxRigidDynamic_addForce_1(self, force); return }
  if (autowake === undefined) { _emscripten_bind_PxRigidDynamic_addForce_2(self, force, mode); return }
  _emscripten_bind_PxRigidDynamic_addForce_3(self, force, mode, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['addTorque'] = PxRigidDynamic.prototype.addTorque = function(torque, mode, autowake) {
  var self = this.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (mode === undefined) { _emscripten_bind_PxRigidDynamic_addTorque_1(self, torque); return }
  if (autowake === undefined) { _emscripten_bind_PxRigidDynamic_addTorque_2(self, torque, mode); return }
  _emscripten_bind_PxRigidDynamic_addTorque_3(self, torque, mode, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['clearForce'] = PxRigidDynamic.prototype.clearForce = function(mode) {
  var self = this.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  _emscripten_bind_PxRigidDynamic_clearForce_1(self, mode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['clearTorque'] = PxRigidDynamic.prototype.clearTorque = function(mode) {
  var self = this.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  _emscripten_bind_PxRigidDynamic_clearTorque_1(self, mode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setForceAndTorque'] = PxRigidDynamic.prototype.setForceAndTorque = function(force, torque, mode) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  if (mode && typeof mode === 'object') mode = mode.ptr;
  if (mode === undefined) { _emscripten_bind_PxRigidDynamic_setForceAndTorque_2(self, force, torque); return }
  _emscripten_bind_PxRigidDynamic_setForceAndTorque_3(self, force, torque, mode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setRigidBodyFlag'] = PxRigidDynamic.prototype.setRigidBodyFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRigidDynamic_setRigidBodyFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setRigidBodyFlags'] = PxRigidDynamic.prototype.setRigidBodyFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxRigidDynamic_setRigidBodyFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getRigidBodyFlags'] = PxRigidDynamic.prototype.getRigidBodyFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidDynamic_getRigidBodyFlags_0(self), PxRigidBodyFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setMinCCDAdvanceCoefficient'] = PxRigidDynamic.prototype.setMinCCDAdvanceCoefficient = function(advanceCoefficient) {
  var self = this.ptr;
  if (advanceCoefficient && typeof advanceCoefficient === 'object') advanceCoefficient = advanceCoefficient.ptr;
  _emscripten_bind_PxRigidDynamic_setMinCCDAdvanceCoefficient_1(self, advanceCoefficient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getMinCCDAdvanceCoefficient'] = PxRigidDynamic.prototype.getMinCCDAdvanceCoefficient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getMinCCDAdvanceCoefficient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setMaxDepenetrationVelocity'] = PxRigidDynamic.prototype.setMaxDepenetrationVelocity = function(biasClamp) {
  var self = this.ptr;
  if (biasClamp && typeof biasClamp === 'object') biasClamp = biasClamp.ptr;
  _emscripten_bind_PxRigidDynamic_setMaxDepenetrationVelocity_1(self, biasClamp);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getMaxDepenetrationVelocity'] = PxRigidDynamic.prototype.getMaxDepenetrationVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getMaxDepenetrationVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setMaxContactImpulse'] = PxRigidDynamic.prototype.setMaxContactImpulse = function(maxImpulse) {
  var self = this.ptr;
  if (maxImpulse && typeof maxImpulse === 'object') maxImpulse = maxImpulse.ptr;
  _emscripten_bind_PxRigidDynamic_setMaxContactImpulse_1(self, maxImpulse);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getMaxContactImpulse'] = PxRigidDynamic.prototype.getMaxContactImpulse = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getMaxContactImpulse_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['setContactSlopCoefficient'] = PxRigidDynamic.prototype.setContactSlopCoefficient = function(slopCoefficient) {
  var self = this.ptr;
  if (slopCoefficient && typeof slopCoefficient === 'object') slopCoefficient = slopCoefficient.ptr;
  _emscripten_bind_PxRigidDynamic_setContactSlopCoefficient_1(self, slopCoefficient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['getContactSlopCoefficient'] = PxRigidDynamic.prototype.getContactSlopCoefficient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidDynamic_getContactSlopCoefficient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['get_userData'] = PxRigidDynamic.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidDynamic_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamic.prototype['set_userData'] = PxRigidDynamic.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRigidDynamic_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRigidDynamic.prototype, 'userData', { get: PxRigidDynamic.prototype.get_userData, set: PxRigidDynamic.prototype.set_userData });

// Interface: PxRigidDynamicLockFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRigidDynamicLockFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxRigidDynamicLockFlags_PxRigidDynamicLockFlags_1(flags);
  getCache(PxRigidDynamicLockFlags)[this.ptr] = this;
};

PxRigidDynamicLockFlags.prototype = Object.create(WrapperObject.prototype);
PxRigidDynamicLockFlags.prototype.constructor = PxRigidDynamicLockFlags;
PxRigidDynamicLockFlags.prototype.__class__ = PxRigidDynamicLockFlags;
PxRigidDynamicLockFlags.__cache__ = {};
Module['PxRigidDynamicLockFlags'] = PxRigidDynamicLockFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamicLockFlags.prototype['isSet'] = PxRigidDynamicLockFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxRigidDynamicLockFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamicLockFlags.prototype['raise'] = PxRigidDynamicLockFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxRigidDynamicLockFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamicLockFlags.prototype['clear'] = PxRigidDynamicLockFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxRigidDynamicLockFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidDynamicLockFlags.prototype['__destroy__'] = PxRigidDynamicLockFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxRigidDynamicLockFlags___destroy___0(self);
};

// Interface: PxRigidStatic

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxRigidStatic() { throw "cannot construct a PxRigidStatic, no constructor in IDL" }
PxRigidStatic.prototype = Object.create(PxRigidActor.prototype);
PxRigidStatic.prototype.constructor = PxRigidStatic;
PxRigidStatic.prototype.__class__ = PxRigidStatic;
PxRigidStatic.__cache__ = {};
Module['PxRigidStatic'] = PxRigidStatic;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['getType'] = PxRigidStatic.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidStatic_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['getScene'] = PxRigidStatic.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidStatic_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['setName'] = PxRigidStatic.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxRigidStatic_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['getName'] = PxRigidStatic.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxRigidStatic_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['getWorldBounds'] = PxRigidStatic.prototype.getWorldBounds = function(inflation) {
  var self = this.ptr;
  if (inflation && typeof inflation === 'object') inflation = inflation.ptr;
  if (inflation === undefined) { return wrapPointer(_emscripten_bind_PxRigidStatic_getWorldBounds_0(self), PxBounds3) }
  return wrapPointer(_emscripten_bind_PxRigidStatic_getWorldBounds_1(self, inflation), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['setActorFlag'] = PxRigidStatic.prototype.setActorFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRigidStatic_setActorFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['setActorFlags'] = PxRigidStatic.prototype.setActorFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxRigidStatic_setActorFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['getActorFlags'] = PxRigidStatic.prototype.getActorFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidStatic_getActorFlags_0(self), PxActorFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['setDominanceGroup'] = PxRigidStatic.prototype.setDominanceGroup = function(dominanceGroup) {
  var self = this.ptr;
  if (dominanceGroup && typeof dominanceGroup === 'object') dominanceGroup = dominanceGroup.ptr;
  _emscripten_bind_PxRigidStatic_setDominanceGroup_1(self, dominanceGroup);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['getDominanceGroup'] = PxRigidStatic.prototype.getDominanceGroup = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidStatic_getDominanceGroup_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['setOwnerClient'] = PxRigidStatic.prototype.setOwnerClient = function(inClient) {
  var self = this.ptr;
  if (inClient && typeof inClient === 'object') inClient = inClient.ptr;
  _emscripten_bind_PxRigidStatic_setOwnerClient_1(self, inClient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['getOwnerClient'] = PxRigidStatic.prototype.getOwnerClient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidStatic_getOwnerClient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['release'] = PxRigidStatic.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxRigidStatic_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['getConcreteTypeName'] = PxRigidStatic.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxRigidStatic_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['getConcreteType'] = PxRigidStatic.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidStatic_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['setBaseFlag'] = PxRigidStatic.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxRigidStatic_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['setBaseFlags'] = PxRigidStatic.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxRigidStatic_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['getBaseFlags'] = PxRigidStatic.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidStatic_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['isReleasable'] = PxRigidStatic.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxRigidStatic_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['getGlobalPose'] = PxRigidStatic.prototype.getGlobalPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidStatic_getGlobalPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['setGlobalPose'] = PxRigidStatic.prototype.setGlobalPose = function(pose, autowake) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (autowake && typeof autowake === 'object') autowake = autowake.ptr;
  if (autowake === undefined) { _emscripten_bind_PxRigidStatic_setGlobalPose_1(self, pose); return }
  _emscripten_bind_PxRigidStatic_setGlobalPose_2(self, pose, autowake);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['attachShape'] = PxRigidStatic.prototype.attachShape = function(shape) {
  var self = this.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  return !!(_emscripten_bind_PxRigidStatic_attachShape_1(self, shape));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['detachShape'] = PxRigidStatic.prototype.detachShape = function(shape, wakeOnLostTouch) {
  var self = this.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (wakeOnLostTouch && typeof wakeOnLostTouch === 'object') wakeOnLostTouch = wakeOnLostTouch.ptr;
  if (wakeOnLostTouch === undefined) { _emscripten_bind_PxRigidStatic_detachShape_1(self, shape); return }
  _emscripten_bind_PxRigidStatic_detachShape_2(self, shape, wakeOnLostTouch);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['getNbShapes'] = PxRigidStatic.prototype.getNbShapes = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidStatic_getNbShapes_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['getShapes'] = PxRigidStatic.prototype.getShapes = function(userBuffer, bufferSize, startIndex) {
  var self = this.ptr;
  if (userBuffer && typeof userBuffer === 'object') userBuffer = userBuffer.ptr;
  if (bufferSize && typeof bufferSize === 'object') bufferSize = bufferSize.ptr;
  if (startIndex && typeof startIndex === 'object') startIndex = startIndex.ptr;
  return _emscripten_bind_PxRigidStatic_getShapes_3(self, userBuffer, bufferSize, startIndex);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['getNbConstraints'] = PxRigidStatic.prototype.getNbConstraints = function() {
  var self = this.ptr;
  return _emscripten_bind_PxRigidStatic_getNbConstraints_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['get_userData'] = PxRigidStatic.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxRigidStatic_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxRigidStatic.prototype['set_userData'] = PxRigidStatic.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxRigidStatic_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxRigidStatic.prototype, 'userData', { get: PxRigidStatic.prototype.get_userData, set: PxRigidStatic.prototype.set_userData });

// Interface: PxSDFDesc

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSDFDesc() {
  this.ptr = _emscripten_bind_PxSDFDesc_PxSDFDesc_0();
  getCache(PxSDFDesc)[this.ptr] = this;
};

PxSDFDesc.prototype = Object.create(WrapperObject.prototype);
PxSDFDesc.prototype.constructor = PxSDFDesc;
PxSDFDesc.prototype.__class__ = PxSDFDesc;
PxSDFDesc.__cache__ = {};
Module['PxSDFDesc'] = PxSDFDesc;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['isValid'] = PxSDFDesc.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxSDFDesc_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['get_sdf'] = PxSDFDesc.prototype.get_sdf = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSDFDesc_get_sdf_0(self), PxBoundedData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['set_sdf'] = PxSDFDesc.prototype.set_sdf = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSDFDesc_set_sdf_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSDFDesc.prototype, 'sdf', { get: PxSDFDesc.prototype.get_sdf, set: PxSDFDesc.prototype.set_sdf });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['get_dims'] = PxSDFDesc.prototype.get_dims = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSDFDesc_get_dims_0(self), PxDim3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['set_dims'] = PxSDFDesc.prototype.set_dims = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSDFDesc_set_dims_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSDFDesc.prototype, 'dims', { get: PxSDFDesc.prototype.get_dims, set: PxSDFDesc.prototype.set_dims });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['get_meshLower'] = PxSDFDesc.prototype.get_meshLower = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSDFDesc_get_meshLower_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['set_meshLower'] = PxSDFDesc.prototype.set_meshLower = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSDFDesc_set_meshLower_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSDFDesc.prototype, 'meshLower', { get: PxSDFDesc.prototype.get_meshLower, set: PxSDFDesc.prototype.set_meshLower });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['get_spacing'] = PxSDFDesc.prototype.get_spacing = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSDFDesc_get_spacing_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['set_spacing'] = PxSDFDesc.prototype.set_spacing = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSDFDesc_set_spacing_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSDFDesc.prototype, 'spacing', { get: PxSDFDesc.prototype.get_spacing, set: PxSDFDesc.prototype.set_spacing });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['get_subgridSize'] = PxSDFDesc.prototype.get_subgridSize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSDFDesc_get_subgridSize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['set_subgridSize'] = PxSDFDesc.prototype.set_subgridSize = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSDFDesc_set_subgridSize_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSDFDesc.prototype, 'subgridSize', { get: PxSDFDesc.prototype.get_subgridSize, set: PxSDFDesc.prototype.set_subgridSize });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['get_bitsPerSubgridPixel'] = PxSDFDesc.prototype.get_bitsPerSubgridPixel = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSDFDesc_get_bitsPerSubgridPixel_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['set_bitsPerSubgridPixel'] = PxSDFDesc.prototype.set_bitsPerSubgridPixel = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSDFDesc_set_bitsPerSubgridPixel_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSDFDesc.prototype, 'bitsPerSubgridPixel', { get: PxSDFDesc.prototype.get_bitsPerSubgridPixel, set: PxSDFDesc.prototype.set_bitsPerSubgridPixel });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['get_sdfSubgrids3DTexBlockDim'] = PxSDFDesc.prototype.get_sdfSubgrids3DTexBlockDim = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSDFDesc_get_sdfSubgrids3DTexBlockDim_0(self), PxDim3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['set_sdfSubgrids3DTexBlockDim'] = PxSDFDesc.prototype.set_sdfSubgrids3DTexBlockDim = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSDFDesc_set_sdfSubgrids3DTexBlockDim_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSDFDesc.prototype, 'sdfSubgrids3DTexBlockDim', { get: PxSDFDesc.prototype.get_sdfSubgrids3DTexBlockDim, set: PxSDFDesc.prototype.set_sdfSubgrids3DTexBlockDim });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['get_sdfSubgrids'] = PxSDFDesc.prototype.get_sdfSubgrids = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSDFDesc_get_sdfSubgrids_0(self), PxBoundedData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['set_sdfSubgrids'] = PxSDFDesc.prototype.set_sdfSubgrids = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSDFDesc_set_sdfSubgrids_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSDFDesc.prototype, 'sdfSubgrids', { get: PxSDFDesc.prototype.get_sdfSubgrids, set: PxSDFDesc.prototype.set_sdfSubgrids });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['get_sdfStartSlots'] = PxSDFDesc.prototype.get_sdfStartSlots = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSDFDesc_get_sdfStartSlots_0(self), PxBoundedData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['set_sdfStartSlots'] = PxSDFDesc.prototype.set_sdfStartSlots = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSDFDesc_set_sdfStartSlots_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSDFDesc.prototype, 'sdfStartSlots', { get: PxSDFDesc.prototype.get_sdfStartSlots, set: PxSDFDesc.prototype.set_sdfStartSlots });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['get_subgridsMinSdfValue'] = PxSDFDesc.prototype.get_subgridsMinSdfValue = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSDFDesc_get_subgridsMinSdfValue_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['set_subgridsMinSdfValue'] = PxSDFDesc.prototype.set_subgridsMinSdfValue = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSDFDesc_set_subgridsMinSdfValue_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSDFDesc.prototype, 'subgridsMinSdfValue', { get: PxSDFDesc.prototype.get_subgridsMinSdfValue, set: PxSDFDesc.prototype.set_subgridsMinSdfValue });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['get_subgridsMaxSdfValue'] = PxSDFDesc.prototype.get_subgridsMaxSdfValue = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSDFDesc_get_subgridsMaxSdfValue_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['set_subgridsMaxSdfValue'] = PxSDFDesc.prototype.set_subgridsMaxSdfValue = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSDFDesc_set_subgridsMaxSdfValue_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSDFDesc.prototype, 'subgridsMaxSdfValue', { get: PxSDFDesc.prototype.get_subgridsMaxSdfValue, set: PxSDFDesc.prototype.set_subgridsMaxSdfValue });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['get_sdfBounds'] = PxSDFDesc.prototype.get_sdfBounds = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSDFDesc_get_sdfBounds_0(self), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['set_sdfBounds'] = PxSDFDesc.prototype.set_sdfBounds = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSDFDesc_set_sdfBounds_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSDFDesc.prototype, 'sdfBounds', { get: PxSDFDesc.prototype.get_sdfBounds, set: PxSDFDesc.prototype.set_sdfBounds });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['get_narrowBandThicknessRelativeToSdfBoundsDiagonal'] = PxSDFDesc.prototype.get_narrowBandThicknessRelativeToSdfBoundsDiagonal = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSDFDesc_get_narrowBandThicknessRelativeToSdfBoundsDiagonal_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['set_narrowBandThicknessRelativeToSdfBoundsDiagonal'] = PxSDFDesc.prototype.set_narrowBandThicknessRelativeToSdfBoundsDiagonal = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSDFDesc_set_narrowBandThicknessRelativeToSdfBoundsDiagonal_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSDFDesc.prototype, 'narrowBandThicknessRelativeToSdfBoundsDiagonal', { get: PxSDFDesc.prototype.get_narrowBandThicknessRelativeToSdfBoundsDiagonal, set: PxSDFDesc.prototype.set_narrowBandThicknessRelativeToSdfBoundsDiagonal });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['get_numThreadsForSdfConstruction'] = PxSDFDesc.prototype.get_numThreadsForSdfConstruction = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSDFDesc_get_numThreadsForSdfConstruction_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['set_numThreadsForSdfConstruction'] = PxSDFDesc.prototype.set_numThreadsForSdfConstruction = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSDFDesc_set_numThreadsForSdfConstruction_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSDFDesc.prototype, 'numThreadsForSdfConstruction', { get: PxSDFDesc.prototype.get_numThreadsForSdfConstruction, set: PxSDFDesc.prototype.set_numThreadsForSdfConstruction });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSDFDesc.prototype['__destroy__'] = PxSDFDesc.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSDFDesc___destroy___0(self);
};

// Interface: PxScene

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxScene() { throw "cannot construct a PxScene, no constructor in IDL" }
PxScene.prototype = Object.create(PxSceneSQSystem.prototype);
PxScene.prototype.constructor = PxScene;
PxScene.prototype.__class__ = PxScene;
PxScene.__cache__ = {};
Module['PxScene'] = PxScene;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['addActor'] = PxScene.prototype.addActor = function(actor, bvh) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (bvh && typeof bvh === 'object') bvh = bvh.ptr;
  if (bvh === undefined) { return !!(_emscripten_bind_PxScene_addActor_1(self, actor)) }
  return !!(_emscripten_bind_PxScene_addActor_2(self, actor, bvh));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['removeActor'] = PxScene.prototype.removeActor = function(actor, wakeOnLostTouch) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (wakeOnLostTouch && typeof wakeOnLostTouch === 'object') wakeOnLostTouch = wakeOnLostTouch.ptr;
  if (wakeOnLostTouch === undefined) { _emscripten_bind_PxScene_removeActor_1(self, actor); return }
  _emscripten_bind_PxScene_removeActor_2(self, actor, wakeOnLostTouch);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['addAggregate'] = PxScene.prototype.addAggregate = function(aggregate) {
  var self = this.ptr;
  if (aggregate && typeof aggregate === 'object') aggregate = aggregate.ptr;
  return !!(_emscripten_bind_PxScene_addAggregate_1(self, aggregate));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['removeAggregate'] = PxScene.prototype.removeAggregate = function(aggregate, wakeOnLostTouch) {
  var self = this.ptr;
  if (aggregate && typeof aggregate === 'object') aggregate = aggregate.ptr;
  if (wakeOnLostTouch && typeof wakeOnLostTouch === 'object') wakeOnLostTouch = wakeOnLostTouch.ptr;
  if (wakeOnLostTouch === undefined) { _emscripten_bind_PxScene_removeAggregate_1(self, aggregate); return }
  _emscripten_bind_PxScene_removeAggregate_2(self, aggregate, wakeOnLostTouch);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['addCollection'] = PxScene.prototype.addCollection = function(collection) {
  var self = this.ptr;
  if (collection && typeof collection === 'object') collection = collection.ptr;
  return !!(_emscripten_bind_PxScene_addCollection_1(self, collection));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getWakeCounterResetValue'] = PxScene.prototype.getWakeCounterResetValue = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getWakeCounterResetValue_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['shiftOrigin'] = PxScene.prototype.shiftOrigin = function(shift) {
  var self = this.ptr;
  if (shift && typeof shift === 'object') shift = shift.ptr;
  _emscripten_bind_PxScene_shiftOrigin_1(self, shift);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['addArticulation'] = PxScene.prototype.addArticulation = function(articulation) {
  var self = this.ptr;
  if (articulation && typeof articulation === 'object') articulation = articulation.ptr;
  return !!(_emscripten_bind_PxScene_addArticulation_1(self, articulation));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['removeArticulation'] = PxScene.prototype.removeArticulation = function(articulation, wakeOnLostTouch) {
  var self = this.ptr;
  if (articulation && typeof articulation === 'object') articulation = articulation.ptr;
  if (wakeOnLostTouch && typeof wakeOnLostTouch === 'object') wakeOnLostTouch = wakeOnLostTouch.ptr;
  if (wakeOnLostTouch === undefined) { _emscripten_bind_PxScene_removeArticulation_1(self, articulation); return }
  _emscripten_bind_PxScene_removeArticulation_2(self, articulation, wakeOnLostTouch);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getNbActors'] = PxScene.prototype.getNbActors = function(types) {
  var self = this.ptr;
  if (types && typeof types === 'object') types = types.ptr;
  return _emscripten_bind_PxScene_getNbActors_1(self, types);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getNbArticulations'] = PxScene.prototype.getNbArticulations = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getNbArticulations_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getNbConstraints'] = PxScene.prototype.getNbConstraints = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getNbConstraints_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getNbAggregates'] = PxScene.prototype.getNbAggregates = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getNbAggregates_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setDominanceGroupPair'] = PxScene.prototype.setDominanceGroupPair = function(group1, group2, dominance) {
  var self = this.ptr;
  if (group1 && typeof group1 === 'object') group1 = group1.ptr;
  if (group2 && typeof group2 === 'object') group2 = group2.ptr;
  if (dominance && typeof dominance === 'object') dominance = dominance.ptr;
  _emscripten_bind_PxScene_setDominanceGroupPair_3(self, group1, group2, dominance);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getCpuDispatcher'] = PxScene.prototype.getCpuDispatcher = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxScene_getCpuDispatcher_0(self), PxCpuDispatcher);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['createClient'] = PxScene.prototype.createClient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_createClient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setSimulationEventCallback'] = PxScene.prototype.setSimulationEventCallback = function(callback) {
  var self = this.ptr;
  if (callback && typeof callback === 'object') callback = callback.ptr;
  _emscripten_bind_PxScene_setSimulationEventCallback_1(self, callback);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getSimulationEventCallback'] = PxScene.prototype.getSimulationEventCallback = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxScene_getSimulationEventCallback_0(self), PxSimulationEventCallback);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setFilterShaderData'] = PxScene.prototype.setFilterShaderData = function(data, dataSize) {
  var self = this.ptr;
  if (data && typeof data === 'object') data = data.ptr;
  if (dataSize && typeof dataSize === 'object') dataSize = dataSize.ptr;
  _emscripten_bind_PxScene_setFilterShaderData_2(self, data, dataSize);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getFilterShaderData'] = PxScene.prototype.getFilterShaderData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxScene_getFilterShaderData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getFilterShaderDataSize'] = PxScene.prototype.getFilterShaderDataSize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getFilterShaderDataSize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getFilterShader'] = PxScene.prototype.getFilterShader = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxScene_getFilterShader_0(self), PxSimulationFilterShader);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['resetFiltering'] = PxScene.prototype.resetFiltering = function(actor) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return !!(_emscripten_bind_PxScene_resetFiltering_1(self, actor));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getKinematicKinematicFilteringMode'] = PxScene.prototype.getKinematicKinematicFilteringMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getKinematicKinematicFilteringMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getStaticKinematicFilteringMode'] = PxScene.prototype.getStaticKinematicFilteringMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getStaticKinematicFilteringMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['simulate'] = PxScene.prototype.simulate = function(elapsedTime, completionTask, scratchMemBlock, scratchMemBlockSize, controlSimulation) {
  var self = this.ptr;
  if (elapsedTime && typeof elapsedTime === 'object') elapsedTime = elapsedTime.ptr;
  if (completionTask && typeof completionTask === 'object') completionTask = completionTask.ptr;
  if (scratchMemBlock && typeof scratchMemBlock === 'object') scratchMemBlock = scratchMemBlock.ptr;
  if (scratchMemBlockSize && typeof scratchMemBlockSize === 'object') scratchMemBlockSize = scratchMemBlockSize.ptr;
  if (controlSimulation && typeof controlSimulation === 'object') controlSimulation = controlSimulation.ptr;
  if (completionTask === undefined) { return !!(_emscripten_bind_PxScene_simulate_1(self, elapsedTime)) }
  if (scratchMemBlock === undefined) { return !!(_emscripten_bind_PxScene_simulate_2(self, elapsedTime, completionTask)) }
  if (scratchMemBlockSize === undefined) { return !!(_emscripten_bind_PxScene_simulate_3(self, elapsedTime, completionTask, scratchMemBlock)) }
  if (controlSimulation === undefined) { return !!(_emscripten_bind_PxScene_simulate_4(self, elapsedTime, completionTask, scratchMemBlock, scratchMemBlockSize)) }
  return !!(_emscripten_bind_PxScene_simulate_5(self, elapsedTime, completionTask, scratchMemBlock, scratchMemBlockSize, controlSimulation));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['advance'] = PxScene.prototype.advance = function(completionTask) {
  var self = this.ptr;
  if (completionTask && typeof completionTask === 'object') completionTask = completionTask.ptr;
  if (completionTask === undefined) { return !!(_emscripten_bind_PxScene_advance_0(self)) }
  return !!(_emscripten_bind_PxScene_advance_1(self, completionTask));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['collide'] = PxScene.prototype.collide = function(elapsedTime, completionTask, scratchMemBlock, scratchMemBlockSize, controlSimulation) {
  var self = this.ptr;
  if (elapsedTime && typeof elapsedTime === 'object') elapsedTime = elapsedTime.ptr;
  if (completionTask && typeof completionTask === 'object') completionTask = completionTask.ptr;
  if (scratchMemBlock && typeof scratchMemBlock === 'object') scratchMemBlock = scratchMemBlock.ptr;
  if (scratchMemBlockSize && typeof scratchMemBlockSize === 'object') scratchMemBlockSize = scratchMemBlockSize.ptr;
  if (controlSimulation && typeof controlSimulation === 'object') controlSimulation = controlSimulation.ptr;
  if (completionTask === undefined) { return !!(_emscripten_bind_PxScene_collide_1(self, elapsedTime)) }
  if (scratchMemBlock === undefined) { return !!(_emscripten_bind_PxScene_collide_2(self, elapsedTime, completionTask)) }
  if (scratchMemBlockSize === undefined) { return !!(_emscripten_bind_PxScene_collide_3(self, elapsedTime, completionTask, scratchMemBlock)) }
  if (controlSimulation === undefined) { return !!(_emscripten_bind_PxScene_collide_4(self, elapsedTime, completionTask, scratchMemBlock, scratchMemBlockSize)) }
  return !!(_emscripten_bind_PxScene_collide_5(self, elapsedTime, completionTask, scratchMemBlock, scratchMemBlockSize, controlSimulation));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['checkResults'] = PxScene.prototype.checkResults = function(block) {
  var self = this.ptr;
  if (block && typeof block === 'object') block = block.ptr;
  if (block === undefined) { return !!(_emscripten_bind_PxScene_checkResults_0(self)) }
  return !!(_emscripten_bind_PxScene_checkResults_1(self, block));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['fetchCollision'] = PxScene.prototype.fetchCollision = function(block) {
  var self = this.ptr;
  if (block && typeof block === 'object') block = block.ptr;
  if (block === undefined) { return !!(_emscripten_bind_PxScene_fetchCollision_0(self)) }
  return !!(_emscripten_bind_PxScene_fetchCollision_1(self, block));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['fetchResults'] = PxScene.prototype.fetchResults = function(block) {
  var self = this.ptr;
  if (block && typeof block === 'object') block = block.ptr;
  if (block === undefined) { return !!(_emscripten_bind_PxScene_fetchResults_0(self)) }
  return !!(_emscripten_bind_PxScene_fetchResults_1(self, block));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['processCallbacks'] = PxScene.prototype.processCallbacks = function(continuation) {
  var self = this.ptr;
  if (continuation && typeof continuation === 'object') continuation = continuation.ptr;
  _emscripten_bind_PxScene_processCallbacks_1(self, continuation);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['fetchResultsParticleSystem'] = PxScene.prototype.fetchResultsParticleSystem = function() {
  var self = this.ptr;
  _emscripten_bind_PxScene_fetchResultsParticleSystem_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['flushSimulation'] = PxScene.prototype.flushSimulation = function(sendPendingReports) {
  var self = this.ptr;
  if (sendPendingReports && typeof sendPendingReports === 'object') sendPendingReports = sendPendingReports.ptr;
  if (sendPendingReports === undefined) { _emscripten_bind_PxScene_flushSimulation_0(self); return }
  _emscripten_bind_PxScene_flushSimulation_1(self, sendPendingReports);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setGravity'] = PxScene.prototype.setGravity = function(vec) {
  var self = this.ptr;
  if (vec && typeof vec === 'object') vec = vec.ptr;
  _emscripten_bind_PxScene_setGravity_1(self, vec);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getGravity'] = PxScene.prototype.getGravity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxScene_getGravity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setBounceThresholdVelocity'] = PxScene.prototype.setBounceThresholdVelocity = function(t) {
  var self = this.ptr;
  if (t && typeof t === 'object') t = t.ptr;
  _emscripten_bind_PxScene_setBounceThresholdVelocity_1(self, t);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getBounceThresholdVelocity'] = PxScene.prototype.getBounceThresholdVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getBounceThresholdVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setCCDMaxPasses'] = PxScene.prototype.setCCDMaxPasses = function(ccdMaxPasses) {
  var self = this.ptr;
  if (ccdMaxPasses && typeof ccdMaxPasses === 'object') ccdMaxPasses = ccdMaxPasses.ptr;
  _emscripten_bind_PxScene_setCCDMaxPasses_1(self, ccdMaxPasses);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getCCDMaxPasses'] = PxScene.prototype.getCCDMaxPasses = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getCCDMaxPasses_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setCCDMaxSeparation'] = PxScene.prototype.setCCDMaxSeparation = function(t) {
  var self = this.ptr;
  if (t && typeof t === 'object') t = t.ptr;
  _emscripten_bind_PxScene_setCCDMaxSeparation_1(self, t);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getCCDMaxSeparation'] = PxScene.prototype.getCCDMaxSeparation = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getCCDMaxSeparation_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setCCDThreshold'] = PxScene.prototype.setCCDThreshold = function(t) {
  var self = this.ptr;
  if (t && typeof t === 'object') t = t.ptr;
  _emscripten_bind_PxScene_setCCDThreshold_1(self, t);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getCCDThreshold'] = PxScene.prototype.getCCDThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getCCDThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setMaxBiasCoefficient'] = PxScene.prototype.setMaxBiasCoefficient = function(t) {
  var self = this.ptr;
  if (t && typeof t === 'object') t = t.ptr;
  _emscripten_bind_PxScene_setMaxBiasCoefficient_1(self, t);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getMaxBiasCoefficient'] = PxScene.prototype.getMaxBiasCoefficient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getMaxBiasCoefficient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setFrictionOffsetThreshold'] = PxScene.prototype.setFrictionOffsetThreshold = function(t) {
  var self = this.ptr;
  if (t && typeof t === 'object') t = t.ptr;
  _emscripten_bind_PxScene_setFrictionOffsetThreshold_1(self, t);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getFrictionOffsetThreshold'] = PxScene.prototype.getFrictionOffsetThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getFrictionOffsetThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setFrictionCorrelationDistance'] = PxScene.prototype.setFrictionCorrelationDistance = function(t) {
  var self = this.ptr;
  if (t && typeof t === 'object') t = t.ptr;
  _emscripten_bind_PxScene_setFrictionCorrelationDistance_1(self, t);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getFrictionCorrelationDistance'] = PxScene.prototype.getFrictionCorrelationDistance = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getFrictionCorrelationDistance_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getFrictionType'] = PxScene.prototype.getFrictionType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getFrictionType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getSolverType'] = PxScene.prototype.getSolverType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getSolverType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getRenderBuffer'] = PxScene.prototype.getRenderBuffer = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxScene_getRenderBuffer_0(self), PxRenderBuffer);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setVisualizationParameter'] = PxScene.prototype.setVisualizationParameter = function(param, value) {
  var self = this.ptr;
  if (param && typeof param === 'object') param = param.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  return !!(_emscripten_bind_PxScene_setVisualizationParameter_2(self, param, value));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getVisualizationParameter'] = PxScene.prototype.getVisualizationParameter = function(paramEnum) {
  var self = this.ptr;
  if (paramEnum && typeof paramEnum === 'object') paramEnum = paramEnum.ptr;
  return _emscripten_bind_PxScene_getVisualizationParameter_1(self, paramEnum);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setVisualizationCullingBox'] = PxScene.prototype.setVisualizationCullingBox = function(box) {
  var self = this.ptr;
  if (box && typeof box === 'object') box = box.ptr;
  _emscripten_bind_PxScene_setVisualizationCullingBox_1(self, box);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getVisualizationCullingBox'] = PxScene.prototype.getVisualizationCullingBox = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxScene_getVisualizationCullingBox_0(self), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getSimulationStatistics'] = PxScene.prototype.getSimulationStatistics = function(stats) {
  var self = this.ptr;
  if (stats && typeof stats === 'object') stats = stats.ptr;
  _emscripten_bind_PxScene_getSimulationStatistics_1(self, stats);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getBroadPhaseType'] = PxScene.prototype.getBroadPhaseType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getBroadPhaseType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getBroadPhaseCaps'] = PxScene.prototype.getBroadPhaseCaps = function(caps) {
  var self = this.ptr;
  if (caps && typeof caps === 'object') caps = caps.ptr;
  return !!(_emscripten_bind_PxScene_getBroadPhaseCaps_1(self, caps));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getNbBroadPhaseRegions'] = PxScene.prototype.getNbBroadPhaseRegions = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getNbBroadPhaseRegions_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getBroadPhaseRegions'] = PxScene.prototype.getBroadPhaseRegions = function(userBuffer, bufferSize, startIndex) {
  var self = this.ptr;
  if (userBuffer && typeof userBuffer === 'object') userBuffer = userBuffer.ptr;
  if (bufferSize && typeof bufferSize === 'object') bufferSize = bufferSize.ptr;
  if (startIndex && typeof startIndex === 'object') startIndex = startIndex.ptr;
  if (startIndex === undefined) { return _emscripten_bind_PxScene_getBroadPhaseRegions_2(self, userBuffer, bufferSize) }
  return _emscripten_bind_PxScene_getBroadPhaseRegions_3(self, userBuffer, bufferSize, startIndex);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['addBroadPhaseRegion'] = PxScene.prototype.addBroadPhaseRegion = function(region, populateRegion) {
  var self = this.ptr;
  if (region && typeof region === 'object') region = region.ptr;
  if (populateRegion && typeof populateRegion === 'object') populateRegion = populateRegion.ptr;
  if (populateRegion === undefined) { return _emscripten_bind_PxScene_addBroadPhaseRegion_1(self, region) }
  return _emscripten_bind_PxScene_addBroadPhaseRegion_2(self, region, populateRegion);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['removeBroadPhaseRegion'] = PxScene.prototype.removeBroadPhaseRegion = function(handle) {
  var self = this.ptr;
  if (handle && typeof handle === 'object') handle = handle.ptr;
  return !!(_emscripten_bind_PxScene_removeBroadPhaseRegion_1(self, handle));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['lockRead'] = PxScene.prototype.lockRead = function(file, line) {
  var self = this.ptr;
  ensureCache.prepare();
  if (file && typeof file === 'object') file = file.ptr;
  else file = ensureString(file);
  if (line && typeof line === 'object') line = line.ptr;
  if (file === undefined) { _emscripten_bind_PxScene_lockRead_0(self); return }
  if (line === undefined) { _emscripten_bind_PxScene_lockRead_1(self, file); return }
  _emscripten_bind_PxScene_lockRead_2(self, file, line);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['unlockRead'] = PxScene.prototype.unlockRead = function() {
  var self = this.ptr;
  _emscripten_bind_PxScene_unlockRead_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['lockWrite'] = PxScene.prototype.lockWrite = function(file, line) {
  var self = this.ptr;
  ensureCache.prepare();
  if (file && typeof file === 'object') file = file.ptr;
  else file = ensureString(file);
  if (line && typeof line === 'object') line = line.ptr;
  if (file === undefined) { _emscripten_bind_PxScene_lockWrite_0(self); return }
  if (line === undefined) { _emscripten_bind_PxScene_lockWrite_1(self, file); return }
  _emscripten_bind_PxScene_lockWrite_2(self, file, line);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['unlockWrite'] = PxScene.prototype.unlockWrite = function() {
  var self = this.ptr;
  _emscripten_bind_PxScene_unlockWrite_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setNbContactDataBlocks'] = PxScene.prototype.setNbContactDataBlocks = function(numBlocks) {
  var self = this.ptr;
  if (numBlocks && typeof numBlocks === 'object') numBlocks = numBlocks.ptr;
  _emscripten_bind_PxScene_setNbContactDataBlocks_1(self, numBlocks);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getNbContactDataBlocksUsed'] = PxScene.prototype.getNbContactDataBlocksUsed = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getNbContactDataBlocksUsed_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getMaxNbContactDataBlocksUsed'] = PxScene.prototype.getMaxNbContactDataBlocksUsed = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getMaxNbContactDataBlocksUsed_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getContactReportStreamBufferSize'] = PxScene.prototype.getContactReportStreamBufferSize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getContactReportStreamBufferSize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setSolverBatchSize'] = PxScene.prototype.setSolverBatchSize = function(solverBatchSize) {
  var self = this.ptr;
  if (solverBatchSize && typeof solverBatchSize === 'object') solverBatchSize = solverBatchSize.ptr;
  _emscripten_bind_PxScene_setSolverBatchSize_1(self, solverBatchSize);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getSolverBatchSize'] = PxScene.prototype.getSolverBatchSize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getSolverBatchSize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setSolverArticulationBatchSize'] = PxScene.prototype.setSolverArticulationBatchSize = function(solverBatchSize) {
  var self = this.ptr;
  if (solverBatchSize && typeof solverBatchSize === 'object') solverBatchSize = solverBatchSize.ptr;
  _emscripten_bind_PxScene_setSolverArticulationBatchSize_1(self, solverBatchSize);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getSolverArticulationBatchSize'] = PxScene.prototype.getSolverArticulationBatchSize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getSolverArticulationBatchSize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['release'] = PxScene.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxScene_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setFlag'] = PxScene.prototype.setFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxScene_setFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getFlags'] = PxScene.prototype.getFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxScene_getFlags_0(self), PxSceneFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setLimits'] = PxScene.prototype.setLimits = function(limits) {
  var self = this.ptr;
  if (limits && typeof limits === 'object') limits = limits.ptr;
  _emscripten_bind_PxScene_setLimits_1(self, limits);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getLimits'] = PxScene.prototype.getLimits = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxScene_getLimits_0(self), PxSceneLimits);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getPhysics'] = PxScene.prototype.getPhysics = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxScene_getPhysics_0(self), PxPhysics);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getTimestamp'] = PxScene.prototype.getTimestamp = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getTimestamp_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getScenePvdClient'] = PxScene.prototype.getScenePvdClient = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxScene_getScenePvdClient_0(self), PxPvdSceneClient);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setDynamicTreeRebuildRateHint'] = PxScene.prototype.setDynamicTreeRebuildRateHint = function(dynamicTreeRebuildRateHint) {
  var self = this.ptr;
  if (dynamicTreeRebuildRateHint && typeof dynamicTreeRebuildRateHint === 'object') dynamicTreeRebuildRateHint = dynamicTreeRebuildRateHint.ptr;
  _emscripten_bind_PxScene_setDynamicTreeRebuildRateHint_1(self, dynamicTreeRebuildRateHint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getDynamicTreeRebuildRateHint'] = PxScene.prototype.getDynamicTreeRebuildRateHint = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getDynamicTreeRebuildRateHint_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['forceRebuildDynamicTree'] = PxScene.prototype.forceRebuildDynamicTree = function(prunerIndex) {
  var self = this.ptr;
  if (prunerIndex && typeof prunerIndex === 'object') prunerIndex = prunerIndex.ptr;
  _emscripten_bind_PxScene_forceRebuildDynamicTree_1(self, prunerIndex);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setUpdateMode'] = PxScene.prototype.setUpdateMode = function(updateMode) {
  var self = this.ptr;
  if (updateMode && typeof updateMode === 'object') updateMode = updateMode.ptr;
  _emscripten_bind_PxScene_setUpdateMode_1(self, updateMode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getUpdateMode'] = PxScene.prototype.getUpdateMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getUpdateMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getStaticTimestamp'] = PxScene.prototype.getStaticTimestamp = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getStaticTimestamp_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['flushUpdates'] = PxScene.prototype.flushUpdates = function() {
  var self = this.ptr;
  _emscripten_bind_PxScene_flushUpdates_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['raycast'] = PxScene.prototype.raycast = function(origin, unitDir, distance, hitCall, hitFlags, filterData) {
  var self = this.ptr;
  if (origin && typeof origin === 'object') origin = origin.ptr;
  if (unitDir && typeof unitDir === 'object') unitDir = unitDir.ptr;
  if (distance && typeof distance === 'object') distance = distance.ptr;
  if (hitCall && typeof hitCall === 'object') hitCall = hitCall.ptr;
  if (hitFlags && typeof hitFlags === 'object') hitFlags = hitFlags.ptr;
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  if (hitFlags === undefined) { return !!(_emscripten_bind_PxScene_raycast_4(self, origin, unitDir, distance, hitCall)) }
  if (filterData === undefined) { return !!(_emscripten_bind_PxScene_raycast_5(self, origin, unitDir, distance, hitCall, hitFlags)) }
  return !!(_emscripten_bind_PxScene_raycast_6(self, origin, unitDir, distance, hitCall, hitFlags, filterData));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['sweep'] = PxScene.prototype.sweep = function(geometry, pose, unitDir, distance, hitCall, hitFlags, filterData) {
  var self = this.ptr;
  if (geometry && typeof geometry === 'object') geometry = geometry.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (unitDir && typeof unitDir === 'object') unitDir = unitDir.ptr;
  if (distance && typeof distance === 'object') distance = distance.ptr;
  if (hitCall && typeof hitCall === 'object') hitCall = hitCall.ptr;
  if (hitFlags && typeof hitFlags === 'object') hitFlags = hitFlags.ptr;
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  if (hitFlags === undefined) { return !!(_emscripten_bind_PxScene_sweep_5(self, geometry, pose, unitDir, distance, hitCall)) }
  if (filterData === undefined) { return !!(_emscripten_bind_PxScene_sweep_6(self, geometry, pose, unitDir, distance, hitCall, hitFlags)) }
  return !!(_emscripten_bind_PxScene_sweep_7(self, geometry, pose, unitDir, distance, hitCall, hitFlags, filterData));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['overlap'] = PxScene.prototype.overlap = function(geometry, pose, hitCall, filterData) {
  var self = this.ptr;
  if (geometry && typeof geometry === 'object') geometry = geometry.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  if (hitCall && typeof hitCall === 'object') hitCall = hitCall.ptr;
  if (filterData && typeof filterData === 'object') filterData = filterData.ptr;
  if (filterData === undefined) { return !!(_emscripten_bind_PxScene_overlap_3(self, geometry, pose, hitCall)) }
  return !!(_emscripten_bind_PxScene_overlap_4(self, geometry, pose, hitCall, filterData));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['setSceneQueryUpdateMode'] = PxScene.prototype.setSceneQueryUpdateMode = function(updateMode) {
  var self = this.ptr;
  if (updateMode && typeof updateMode === 'object') updateMode = updateMode.ptr;
  _emscripten_bind_PxScene_setSceneQueryUpdateMode_1(self, updateMode);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getSceneQueryUpdateMode'] = PxScene.prototype.getSceneQueryUpdateMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getSceneQueryUpdateMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getSceneQueryStaticTimestamp'] = PxScene.prototype.getSceneQueryStaticTimestamp = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getSceneQueryStaticTimestamp_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['flushQueryUpdates'] = PxScene.prototype.flushQueryUpdates = function() {
  var self = this.ptr;
  _emscripten_bind_PxScene_flushQueryUpdates_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['forceDynamicTreeRebuild'] = PxScene.prototype.forceDynamicTreeRebuild = function(rebuildStaticStructure, rebuildDynamicStructure) {
  var self = this.ptr;
  if (rebuildStaticStructure && typeof rebuildStaticStructure === 'object') rebuildStaticStructure = rebuildStaticStructure.ptr;
  if (rebuildDynamicStructure && typeof rebuildDynamicStructure === 'object') rebuildDynamicStructure = rebuildDynamicStructure.ptr;
  _emscripten_bind_PxScene_forceDynamicTreeRebuild_2(self, rebuildStaticStructure, rebuildDynamicStructure);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getStaticStructure'] = PxScene.prototype.getStaticStructure = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getStaticStructure_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['getDynamicStructure'] = PxScene.prototype.getDynamicStructure = function() {
  var self = this.ptr;
  return _emscripten_bind_PxScene_getDynamicStructure_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['sceneQueriesUpdate'] = PxScene.prototype.sceneQueriesUpdate = function(completionTask, controlSimulation) {
  var self = this.ptr;
  if (completionTask && typeof completionTask === 'object') completionTask = completionTask.ptr;
  if (controlSimulation && typeof controlSimulation === 'object') controlSimulation = controlSimulation.ptr;
  if (completionTask === undefined) { _emscripten_bind_PxScene_sceneQueriesUpdate_0(self); return }
  if (controlSimulation === undefined) { _emscripten_bind_PxScene_sceneQueriesUpdate_1(self, completionTask); return }
  _emscripten_bind_PxScene_sceneQueriesUpdate_2(self, completionTask, controlSimulation);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['checkQueries'] = PxScene.prototype.checkQueries = function(block) {
  var self = this.ptr;
  if (block && typeof block === 'object') block = block.ptr;
  if (block === undefined) { return !!(_emscripten_bind_PxScene_checkQueries_0(self)) }
  return !!(_emscripten_bind_PxScene_checkQueries_1(self, block));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['fetchQueries'] = PxScene.prototype.fetchQueries = function(block) {
  var self = this.ptr;
  if (block && typeof block === 'object') block = block.ptr;
  if (block === undefined) { return !!(_emscripten_bind_PxScene_fetchQueries_0(self)) }
  return !!(_emscripten_bind_PxScene_fetchQueries_1(self, block));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['get_userData'] = PxScene.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxScene_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxScene.prototype['set_userData'] = PxScene.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxScene_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxScene.prototype, 'userData', { get: PxScene.prototype.get_userData, set: PxScene.prototype.set_userData });

// Interface: PxSceneDesc

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSceneDesc(scale) {
  if (scale && typeof scale === 'object') scale = scale.ptr;
  this.ptr = _emscripten_bind_PxSceneDesc_PxSceneDesc_1(scale);
  getCache(PxSceneDesc)[this.ptr] = this;
};

PxSceneDesc.prototype = Object.create(WrapperObject.prototype);
PxSceneDesc.prototype.constructor = PxSceneDesc;
PxSceneDesc.prototype.__class__ = PxSceneDesc;
PxSceneDesc.__cache__ = {};
Module['PxSceneDesc'] = PxSceneDesc;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['setToDefault'] = PxSceneDesc.prototype.setToDefault = function(scale) {
  var self = this.ptr;
  if (scale && typeof scale === 'object') scale = scale.ptr;
  _emscripten_bind_PxSceneDesc_setToDefault_1(self, scale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['isValid'] = PxSceneDesc.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxSceneDesc_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_gravity'] = PxSceneDesc.prototype.get_gravity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSceneDesc_get_gravity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_gravity'] = PxSceneDesc.prototype.set_gravity = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_gravity_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'gravity', { get: PxSceneDesc.prototype.get_gravity, set: PxSceneDesc.prototype.set_gravity });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_simulationEventCallback'] = PxSceneDesc.prototype.get_simulationEventCallback = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSceneDesc_get_simulationEventCallback_0(self), PxSimulationEventCallback);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_simulationEventCallback'] = PxSceneDesc.prototype.set_simulationEventCallback = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_simulationEventCallback_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'simulationEventCallback', { get: PxSceneDesc.prototype.get_simulationEventCallback, set: PxSceneDesc.prototype.set_simulationEventCallback });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_filterShaderData'] = PxSceneDesc.prototype.get_filterShaderData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSceneDesc_get_filterShaderData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_filterShaderData'] = PxSceneDesc.prototype.set_filterShaderData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_filterShaderData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'filterShaderData', { get: PxSceneDesc.prototype.get_filterShaderData, set: PxSceneDesc.prototype.set_filterShaderData });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_filterShaderDataSize'] = PxSceneDesc.prototype.get_filterShaderDataSize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_filterShaderDataSize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_filterShaderDataSize'] = PxSceneDesc.prototype.set_filterShaderDataSize = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_filterShaderDataSize_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'filterShaderDataSize', { get: PxSceneDesc.prototype.get_filterShaderDataSize, set: PxSceneDesc.prototype.set_filterShaderDataSize });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_filterShader'] = PxSceneDesc.prototype.get_filterShader = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSceneDesc_get_filterShader_0(self), PxSimulationFilterShader);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_filterShader'] = PxSceneDesc.prototype.set_filterShader = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_filterShader_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'filterShader', { get: PxSceneDesc.prototype.get_filterShader, set: PxSceneDesc.prototype.set_filterShader });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_kineKineFilteringMode'] = PxSceneDesc.prototype.get_kineKineFilteringMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_kineKineFilteringMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_kineKineFilteringMode'] = PxSceneDesc.prototype.set_kineKineFilteringMode = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_kineKineFilteringMode_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'kineKineFilteringMode', { get: PxSceneDesc.prototype.get_kineKineFilteringMode, set: PxSceneDesc.prototype.set_kineKineFilteringMode });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_staticKineFilteringMode'] = PxSceneDesc.prototype.get_staticKineFilteringMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_staticKineFilteringMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_staticKineFilteringMode'] = PxSceneDesc.prototype.set_staticKineFilteringMode = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_staticKineFilteringMode_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'staticKineFilteringMode', { get: PxSceneDesc.prototype.get_staticKineFilteringMode, set: PxSceneDesc.prototype.set_staticKineFilteringMode });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_broadPhaseType'] = PxSceneDesc.prototype.get_broadPhaseType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_broadPhaseType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_broadPhaseType'] = PxSceneDesc.prototype.set_broadPhaseType = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_broadPhaseType_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'broadPhaseType', { get: PxSceneDesc.prototype.get_broadPhaseType, set: PxSceneDesc.prototype.set_broadPhaseType });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_limits'] = PxSceneDesc.prototype.get_limits = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSceneDesc_get_limits_0(self), PxSceneLimits);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_limits'] = PxSceneDesc.prototype.set_limits = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_limits_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'limits', { get: PxSceneDesc.prototype.get_limits, set: PxSceneDesc.prototype.set_limits });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_frictionType'] = PxSceneDesc.prototype.get_frictionType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_frictionType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_frictionType'] = PxSceneDesc.prototype.set_frictionType = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_frictionType_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'frictionType', { get: PxSceneDesc.prototype.get_frictionType, set: PxSceneDesc.prototype.set_frictionType });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_solverType'] = PxSceneDesc.prototype.get_solverType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_solverType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_solverType'] = PxSceneDesc.prototype.set_solverType = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_solverType_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'solverType', { get: PxSceneDesc.prototype.get_solverType, set: PxSceneDesc.prototype.set_solverType });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_bounceThresholdVelocity'] = PxSceneDesc.prototype.get_bounceThresholdVelocity = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_bounceThresholdVelocity_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_bounceThresholdVelocity'] = PxSceneDesc.prototype.set_bounceThresholdVelocity = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_bounceThresholdVelocity_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'bounceThresholdVelocity', { get: PxSceneDesc.prototype.get_bounceThresholdVelocity, set: PxSceneDesc.prototype.set_bounceThresholdVelocity });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_frictionOffsetThreshold'] = PxSceneDesc.prototype.get_frictionOffsetThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_frictionOffsetThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_frictionOffsetThreshold'] = PxSceneDesc.prototype.set_frictionOffsetThreshold = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_frictionOffsetThreshold_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'frictionOffsetThreshold', { get: PxSceneDesc.prototype.get_frictionOffsetThreshold, set: PxSceneDesc.prototype.set_frictionOffsetThreshold });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_frictionCorrelationDistance'] = PxSceneDesc.prototype.get_frictionCorrelationDistance = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_frictionCorrelationDistance_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_frictionCorrelationDistance'] = PxSceneDesc.prototype.set_frictionCorrelationDistance = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_frictionCorrelationDistance_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'frictionCorrelationDistance', { get: PxSceneDesc.prototype.get_frictionCorrelationDistance, set: PxSceneDesc.prototype.set_frictionCorrelationDistance });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_flags'] = PxSceneDesc.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSceneDesc_get_flags_0(self), PxSceneFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_flags'] = PxSceneDesc.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'flags', { get: PxSceneDesc.prototype.get_flags, set: PxSceneDesc.prototype.set_flags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_cpuDispatcher'] = PxSceneDesc.prototype.get_cpuDispatcher = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSceneDesc_get_cpuDispatcher_0(self), PxCpuDispatcher);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_cpuDispatcher'] = PxSceneDesc.prototype.set_cpuDispatcher = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_cpuDispatcher_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'cpuDispatcher', { get: PxSceneDesc.prototype.get_cpuDispatcher, set: PxSceneDesc.prototype.set_cpuDispatcher });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_userData'] = PxSceneDesc.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSceneDesc_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_userData'] = PxSceneDesc.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'userData', { get: PxSceneDesc.prototype.get_userData, set: PxSceneDesc.prototype.set_userData });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_solverBatchSize'] = PxSceneDesc.prototype.get_solverBatchSize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_solverBatchSize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_solverBatchSize'] = PxSceneDesc.prototype.set_solverBatchSize = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_solverBatchSize_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'solverBatchSize', { get: PxSceneDesc.prototype.get_solverBatchSize, set: PxSceneDesc.prototype.set_solverBatchSize });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_solverArticulationBatchSize'] = PxSceneDesc.prototype.get_solverArticulationBatchSize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_solverArticulationBatchSize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_solverArticulationBatchSize'] = PxSceneDesc.prototype.set_solverArticulationBatchSize = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_solverArticulationBatchSize_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'solverArticulationBatchSize', { get: PxSceneDesc.prototype.get_solverArticulationBatchSize, set: PxSceneDesc.prototype.set_solverArticulationBatchSize });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_nbContactDataBlocks'] = PxSceneDesc.prototype.get_nbContactDataBlocks = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_nbContactDataBlocks_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_nbContactDataBlocks'] = PxSceneDesc.prototype.set_nbContactDataBlocks = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_nbContactDataBlocks_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'nbContactDataBlocks', { get: PxSceneDesc.prototype.get_nbContactDataBlocks, set: PxSceneDesc.prototype.set_nbContactDataBlocks });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_maxNbContactDataBlocks'] = PxSceneDesc.prototype.get_maxNbContactDataBlocks = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_maxNbContactDataBlocks_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_maxNbContactDataBlocks'] = PxSceneDesc.prototype.set_maxNbContactDataBlocks = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_maxNbContactDataBlocks_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'maxNbContactDataBlocks', { get: PxSceneDesc.prototype.get_maxNbContactDataBlocks, set: PxSceneDesc.prototype.set_maxNbContactDataBlocks });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_maxBiasCoefficient'] = PxSceneDesc.prototype.get_maxBiasCoefficient = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_maxBiasCoefficient_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_maxBiasCoefficient'] = PxSceneDesc.prototype.set_maxBiasCoefficient = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_maxBiasCoefficient_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'maxBiasCoefficient', { get: PxSceneDesc.prototype.get_maxBiasCoefficient, set: PxSceneDesc.prototype.set_maxBiasCoefficient });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_contactReportStreamBufferSize'] = PxSceneDesc.prototype.get_contactReportStreamBufferSize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_contactReportStreamBufferSize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_contactReportStreamBufferSize'] = PxSceneDesc.prototype.set_contactReportStreamBufferSize = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_contactReportStreamBufferSize_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'contactReportStreamBufferSize', { get: PxSceneDesc.prototype.get_contactReportStreamBufferSize, set: PxSceneDesc.prototype.set_contactReportStreamBufferSize });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_ccdMaxPasses'] = PxSceneDesc.prototype.get_ccdMaxPasses = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_ccdMaxPasses_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_ccdMaxPasses'] = PxSceneDesc.prototype.set_ccdMaxPasses = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_ccdMaxPasses_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'ccdMaxPasses', { get: PxSceneDesc.prototype.get_ccdMaxPasses, set: PxSceneDesc.prototype.set_ccdMaxPasses });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_ccdThreshold'] = PxSceneDesc.prototype.get_ccdThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_ccdThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_ccdThreshold'] = PxSceneDesc.prototype.set_ccdThreshold = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_ccdThreshold_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'ccdThreshold', { get: PxSceneDesc.prototype.get_ccdThreshold, set: PxSceneDesc.prototype.set_ccdThreshold });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_ccdMaxSeparation'] = PxSceneDesc.prototype.get_ccdMaxSeparation = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_ccdMaxSeparation_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_ccdMaxSeparation'] = PxSceneDesc.prototype.set_ccdMaxSeparation = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_ccdMaxSeparation_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'ccdMaxSeparation', { get: PxSceneDesc.prototype.get_ccdMaxSeparation, set: PxSceneDesc.prototype.set_ccdMaxSeparation });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_wakeCounterResetValue'] = PxSceneDesc.prototype.get_wakeCounterResetValue = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_wakeCounterResetValue_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_wakeCounterResetValue'] = PxSceneDesc.prototype.set_wakeCounterResetValue = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_wakeCounterResetValue_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'wakeCounterResetValue', { get: PxSceneDesc.prototype.get_wakeCounterResetValue, set: PxSceneDesc.prototype.set_wakeCounterResetValue });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_sanityBounds'] = PxSceneDesc.prototype.get_sanityBounds = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSceneDesc_get_sanityBounds_0(self), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_sanityBounds'] = PxSceneDesc.prototype.set_sanityBounds = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_sanityBounds_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'sanityBounds', { get: PxSceneDesc.prototype.get_sanityBounds, set: PxSceneDesc.prototype.set_sanityBounds });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_gpuMaxNumPartitions'] = PxSceneDesc.prototype.get_gpuMaxNumPartitions = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_gpuMaxNumPartitions_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_gpuMaxNumPartitions'] = PxSceneDesc.prototype.set_gpuMaxNumPartitions = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_gpuMaxNumPartitions_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'gpuMaxNumPartitions', { get: PxSceneDesc.prototype.get_gpuMaxNumPartitions, set: PxSceneDesc.prototype.set_gpuMaxNumPartitions });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_gpuMaxNumStaticPartitions'] = PxSceneDesc.prototype.get_gpuMaxNumStaticPartitions = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_gpuMaxNumStaticPartitions_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_gpuMaxNumStaticPartitions'] = PxSceneDesc.prototype.set_gpuMaxNumStaticPartitions = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_gpuMaxNumStaticPartitions_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'gpuMaxNumStaticPartitions', { get: PxSceneDesc.prototype.get_gpuMaxNumStaticPartitions, set: PxSceneDesc.prototype.set_gpuMaxNumStaticPartitions });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_gpuComputeVersion'] = PxSceneDesc.prototype.get_gpuComputeVersion = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_gpuComputeVersion_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_gpuComputeVersion'] = PxSceneDesc.prototype.set_gpuComputeVersion = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_gpuComputeVersion_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'gpuComputeVersion', { get: PxSceneDesc.prototype.get_gpuComputeVersion, set: PxSceneDesc.prototype.set_gpuComputeVersion });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_contactPairSlabSize'] = PxSceneDesc.prototype.get_contactPairSlabSize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_contactPairSlabSize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_contactPairSlabSize'] = PxSceneDesc.prototype.set_contactPairSlabSize = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_contactPairSlabSize_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'contactPairSlabSize', { get: PxSceneDesc.prototype.get_contactPairSlabSize, set: PxSceneDesc.prototype.set_contactPairSlabSize });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_staticStructure'] = PxSceneDesc.prototype.get_staticStructure = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_staticStructure_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_staticStructure'] = PxSceneDesc.prototype.set_staticStructure = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_staticStructure_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'staticStructure', { get: PxSceneDesc.prototype.get_staticStructure, set: PxSceneDesc.prototype.set_staticStructure });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_dynamicStructure'] = PxSceneDesc.prototype.get_dynamicStructure = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_dynamicStructure_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_dynamicStructure'] = PxSceneDesc.prototype.set_dynamicStructure = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_dynamicStructure_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'dynamicStructure', { get: PxSceneDesc.prototype.get_dynamicStructure, set: PxSceneDesc.prototype.set_dynamicStructure });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_dynamicTreeRebuildRateHint'] = PxSceneDesc.prototype.get_dynamicTreeRebuildRateHint = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_dynamicTreeRebuildRateHint_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_dynamicTreeRebuildRateHint'] = PxSceneDesc.prototype.set_dynamicTreeRebuildRateHint = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_dynamicTreeRebuildRateHint_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'dynamicTreeRebuildRateHint', { get: PxSceneDesc.prototype.get_dynamicTreeRebuildRateHint, set: PxSceneDesc.prototype.set_dynamicTreeRebuildRateHint });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_dynamicTreeSecondaryPruner'] = PxSceneDesc.prototype.get_dynamicTreeSecondaryPruner = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_dynamicTreeSecondaryPruner_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_dynamicTreeSecondaryPruner'] = PxSceneDesc.prototype.set_dynamicTreeSecondaryPruner = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_dynamicTreeSecondaryPruner_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'dynamicTreeSecondaryPruner', { get: PxSceneDesc.prototype.get_dynamicTreeSecondaryPruner, set: PxSceneDesc.prototype.set_dynamicTreeSecondaryPruner });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_staticBVHBuildStrategy'] = PxSceneDesc.prototype.get_staticBVHBuildStrategy = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_staticBVHBuildStrategy_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_staticBVHBuildStrategy'] = PxSceneDesc.prototype.set_staticBVHBuildStrategy = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_staticBVHBuildStrategy_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'staticBVHBuildStrategy', { get: PxSceneDesc.prototype.get_staticBVHBuildStrategy, set: PxSceneDesc.prototype.set_staticBVHBuildStrategy });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_dynamicBVHBuildStrategy'] = PxSceneDesc.prototype.get_dynamicBVHBuildStrategy = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_dynamicBVHBuildStrategy_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_dynamicBVHBuildStrategy'] = PxSceneDesc.prototype.set_dynamicBVHBuildStrategy = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_dynamicBVHBuildStrategy_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'dynamicBVHBuildStrategy', { get: PxSceneDesc.prototype.get_dynamicBVHBuildStrategy, set: PxSceneDesc.prototype.set_dynamicBVHBuildStrategy });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_staticNbObjectsPerNode'] = PxSceneDesc.prototype.get_staticNbObjectsPerNode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_staticNbObjectsPerNode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_staticNbObjectsPerNode'] = PxSceneDesc.prototype.set_staticNbObjectsPerNode = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_staticNbObjectsPerNode_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'staticNbObjectsPerNode', { get: PxSceneDesc.prototype.get_staticNbObjectsPerNode, set: PxSceneDesc.prototype.set_staticNbObjectsPerNode });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_dynamicNbObjectsPerNode'] = PxSceneDesc.prototype.get_dynamicNbObjectsPerNode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_dynamicNbObjectsPerNode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_dynamicNbObjectsPerNode'] = PxSceneDesc.prototype.set_dynamicNbObjectsPerNode = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_dynamicNbObjectsPerNode_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'dynamicNbObjectsPerNode', { get: PxSceneDesc.prototype.get_dynamicNbObjectsPerNode, set: PxSceneDesc.prototype.set_dynamicNbObjectsPerNode });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['get_sceneQueryUpdateMode'] = PxSceneDesc.prototype.get_sceneQueryUpdateMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneDesc_get_sceneQueryUpdateMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['set_sceneQueryUpdateMode'] = PxSceneDesc.prototype.set_sceneQueryUpdateMode = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneDesc_set_sceneQueryUpdateMode_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneDesc.prototype, 'sceneQueryUpdateMode', { get: PxSceneDesc.prototype.get_sceneQueryUpdateMode, set: PxSceneDesc.prototype.set_sceneQueryUpdateMode });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneDesc.prototype['__destroy__'] = PxSceneDesc.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSceneDesc___destroy___0(self);
};

// Interface: PxSceneFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSceneFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxSceneFlags_PxSceneFlags_1(flags);
  getCache(PxSceneFlags)[this.ptr] = this;
};

PxSceneFlags.prototype = Object.create(WrapperObject.prototype);
PxSceneFlags.prototype.constructor = PxSceneFlags;
PxSceneFlags.prototype.__class__ = PxSceneFlags;
PxSceneFlags.__cache__ = {};
Module['PxSceneFlags'] = PxSceneFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneFlags.prototype['isSet'] = PxSceneFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxSceneFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneFlags.prototype['raise'] = PxSceneFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxSceneFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneFlags.prototype['clear'] = PxSceneFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxSceneFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneFlags.prototype['__destroy__'] = PxSceneFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSceneFlags___destroy___0(self);
};

// Interface: PxSceneLimits

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSceneLimits() {
  this.ptr = _emscripten_bind_PxSceneLimits_PxSceneLimits_0();
  getCache(PxSceneLimits)[this.ptr] = this;
};

PxSceneLimits.prototype = Object.create(WrapperObject.prototype);
PxSceneLimits.prototype.constructor = PxSceneLimits;
PxSceneLimits.prototype.__class__ = PxSceneLimits;
PxSceneLimits.__cache__ = {};
Module['PxSceneLimits'] = PxSceneLimits;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['setToDefault'] = PxSceneLimits.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxSceneLimits_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['isValid'] = PxSceneLimits.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxSceneLimits_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['get_maxNbActors'] = PxSceneLimits.prototype.get_maxNbActors = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneLimits_get_maxNbActors_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['set_maxNbActors'] = PxSceneLimits.prototype.set_maxNbActors = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneLimits_set_maxNbActors_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneLimits.prototype, 'maxNbActors', { get: PxSceneLimits.prototype.get_maxNbActors, set: PxSceneLimits.prototype.set_maxNbActors });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['get_maxNbBodies'] = PxSceneLimits.prototype.get_maxNbBodies = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneLimits_get_maxNbBodies_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['set_maxNbBodies'] = PxSceneLimits.prototype.set_maxNbBodies = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneLimits_set_maxNbBodies_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneLimits.prototype, 'maxNbBodies', { get: PxSceneLimits.prototype.get_maxNbBodies, set: PxSceneLimits.prototype.set_maxNbBodies });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['get_maxNbStaticShapes'] = PxSceneLimits.prototype.get_maxNbStaticShapes = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneLimits_get_maxNbStaticShapes_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['set_maxNbStaticShapes'] = PxSceneLimits.prototype.set_maxNbStaticShapes = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneLimits_set_maxNbStaticShapes_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneLimits.prototype, 'maxNbStaticShapes', { get: PxSceneLimits.prototype.get_maxNbStaticShapes, set: PxSceneLimits.prototype.set_maxNbStaticShapes });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['get_maxNbDynamicShapes'] = PxSceneLimits.prototype.get_maxNbDynamicShapes = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneLimits_get_maxNbDynamicShapes_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['set_maxNbDynamicShapes'] = PxSceneLimits.prototype.set_maxNbDynamicShapes = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneLimits_set_maxNbDynamicShapes_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneLimits.prototype, 'maxNbDynamicShapes', { get: PxSceneLimits.prototype.get_maxNbDynamicShapes, set: PxSceneLimits.prototype.set_maxNbDynamicShapes });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['get_maxNbAggregates'] = PxSceneLimits.prototype.get_maxNbAggregates = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneLimits_get_maxNbAggregates_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['set_maxNbAggregates'] = PxSceneLimits.prototype.set_maxNbAggregates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneLimits_set_maxNbAggregates_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneLimits.prototype, 'maxNbAggregates', { get: PxSceneLimits.prototype.get_maxNbAggregates, set: PxSceneLimits.prototype.set_maxNbAggregates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['get_maxNbConstraints'] = PxSceneLimits.prototype.get_maxNbConstraints = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneLimits_get_maxNbConstraints_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['set_maxNbConstraints'] = PxSceneLimits.prototype.set_maxNbConstraints = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneLimits_set_maxNbConstraints_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneLimits.prototype, 'maxNbConstraints', { get: PxSceneLimits.prototype.get_maxNbConstraints, set: PxSceneLimits.prototype.set_maxNbConstraints });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['get_maxNbRegions'] = PxSceneLimits.prototype.get_maxNbRegions = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneLimits_get_maxNbRegions_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['set_maxNbRegions'] = PxSceneLimits.prototype.set_maxNbRegions = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneLimits_set_maxNbRegions_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneLimits.prototype, 'maxNbRegions', { get: PxSceneLimits.prototype.get_maxNbRegions, set: PxSceneLimits.prototype.set_maxNbRegions });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['get_maxNbBroadPhaseOverlaps'] = PxSceneLimits.prototype.get_maxNbBroadPhaseOverlaps = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSceneLimits_get_maxNbBroadPhaseOverlaps_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['set_maxNbBroadPhaseOverlaps'] = PxSceneLimits.prototype.set_maxNbBroadPhaseOverlaps = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSceneLimits_set_maxNbBroadPhaseOverlaps_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSceneLimits.prototype, 'maxNbBroadPhaseOverlaps', { get: PxSceneLimits.prototype.get_maxNbBroadPhaseOverlaps, set: PxSceneLimits.prototype.set_maxNbBroadPhaseOverlaps });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSceneLimits.prototype['__destroy__'] = PxSceneLimits.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSceneLimits___destroy___0(self);
};

// Interface: PxSerialization

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSerialization() { throw "cannot construct a PxSerialization, no constructor in IDL" }
PxSerialization.prototype = Object.create(WrapperObject.prototype);
PxSerialization.prototype.constructor = PxSerialization;
PxSerialization.prototype.__class__ = PxSerialization;
PxSerialization.__cache__ = {};
Module['PxSerialization'] = PxSerialization;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSerialization.prototype['isSerializable'] = PxSerialization.prototype.isSerializable = function(collection, sr, externalReferences) {
  if (collection && typeof collection === 'object') collection = collection.ptr;
  if (sr && typeof sr === 'object') sr = sr.ptr;
  if (externalReferences && typeof externalReferences === 'object') externalReferences = externalReferences.ptr;
  if (externalReferences === undefined) { return !!(_emscripten_bind_PxSerialization_isSerializable_2(collection, sr)) }
  return !!(_emscripten_bind_PxSerialization_isSerializable_3(collection, sr, externalReferences));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSerialization.prototype['complete'] = PxSerialization.prototype.complete = function(collection, sr, exceptFor, followJoints) {
  if (collection && typeof collection === 'object') collection = collection.ptr;
  if (sr && typeof sr === 'object') sr = sr.ptr;
  if (exceptFor && typeof exceptFor === 'object') exceptFor = exceptFor.ptr;
  if (followJoints && typeof followJoints === 'object') followJoints = followJoints.ptr;
  if (exceptFor === undefined) { _emscripten_bind_PxSerialization_complete_2(collection, sr); return }
  if (followJoints === undefined) { _emscripten_bind_PxSerialization_complete_3(collection, sr, exceptFor); return }
  _emscripten_bind_PxSerialization_complete_4(collection, sr, exceptFor, followJoints);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSerialization.prototype['createSerialObjectIds'] = PxSerialization.prototype.createSerialObjectIds = function(collection, base) {
  if (collection && typeof collection === 'object') collection = collection.ptr;
  if (base && typeof base === 'object') base = base.ptr;
  _emscripten_bind_PxSerialization_createSerialObjectIds_2(collection, base);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSerialization.prototype['createCollectionFromXml'] = PxSerialization.prototype.createCollectionFromXml = function(inputData, params, sr, externalRefs) {
  if (inputData && typeof inputData === 'object') inputData = inputData.ptr;
  if (params && typeof params === 'object') params = params.ptr;
  if (sr && typeof sr === 'object') sr = sr.ptr;
  if (externalRefs && typeof externalRefs === 'object') externalRefs = externalRefs.ptr;
  if (externalRefs === undefined) { return wrapPointer(_emscripten_bind_PxSerialization_createCollectionFromXml_3(inputData, params, sr), PxCollection) }
  return wrapPointer(_emscripten_bind_PxSerialization_createCollectionFromXml_4(inputData, params, sr, externalRefs), PxCollection);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSerialization.prototype['createCollectionFromBinary'] = PxSerialization.prototype.createCollectionFromBinary = function(memBlock, sr, externalRefs) {
  if (memBlock && typeof memBlock === 'object') memBlock = memBlock.ptr;
  if (sr && typeof sr === 'object') sr = sr.ptr;
  if (externalRefs && typeof externalRefs === 'object') externalRefs = externalRefs.ptr;
  if (externalRefs === undefined) { return wrapPointer(_emscripten_bind_PxSerialization_createCollectionFromBinary_2(memBlock, sr), PxCollection) }
  return wrapPointer(_emscripten_bind_PxSerialization_createCollectionFromBinary_3(memBlock, sr, externalRefs), PxCollection);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSerialization.prototype['serializeCollectionToXml'] = PxSerialization.prototype.serializeCollectionToXml = function(outputStream, collection, sr, params, externalRefs) {
  if (outputStream && typeof outputStream === 'object') outputStream = outputStream.ptr;
  if (collection && typeof collection === 'object') collection = collection.ptr;
  if (sr && typeof sr === 'object') sr = sr.ptr;
  if (params && typeof params === 'object') params = params.ptr;
  if (externalRefs && typeof externalRefs === 'object') externalRefs = externalRefs.ptr;
  if (params === undefined) { return !!(_emscripten_bind_PxSerialization_serializeCollectionToXml_3(outputStream, collection, sr)) }
  if (externalRefs === undefined) { return !!(_emscripten_bind_PxSerialization_serializeCollectionToXml_4(outputStream, collection, sr, params)) }
  return !!(_emscripten_bind_PxSerialization_serializeCollectionToXml_5(outputStream, collection, sr, params, externalRefs));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSerialization.prototype['serializeCollectionToBinary'] = PxSerialization.prototype.serializeCollectionToBinary = function(outputStream, collection, sr, externalRefs, exportNames) {
  if (outputStream && typeof outputStream === 'object') outputStream = outputStream.ptr;
  if (collection && typeof collection === 'object') collection = collection.ptr;
  if (sr && typeof sr === 'object') sr = sr.ptr;
  if (externalRefs && typeof externalRefs === 'object') externalRefs = externalRefs.ptr;
  if (exportNames && typeof exportNames === 'object') exportNames = exportNames.ptr;
  if (externalRefs === undefined) { return !!(_emscripten_bind_PxSerialization_serializeCollectionToBinary_3(outputStream, collection, sr)) }
  if (exportNames === undefined) { return !!(_emscripten_bind_PxSerialization_serializeCollectionToBinary_4(outputStream, collection, sr, externalRefs)) }
  return !!(_emscripten_bind_PxSerialization_serializeCollectionToBinary_5(outputStream, collection, sr, externalRefs, exportNames));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSerialization.prototype['createSerializationRegistry'] = PxSerialization.prototype.createSerializationRegistry = function(physics) {
  if (physics && typeof physics === 'object') physics = physics.ptr;
  return wrapPointer(_emscripten_bind_PxSerialization_createSerializationRegistry_1(physics), PxSerializationRegistry);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSerialization.prototype['__destroy__'] = PxSerialization.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSerialization___destroy___0(self);
};

// Interface: PxSerializationRegistry

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSerializationRegistry() { throw "cannot construct a PxSerializationRegistry, no constructor in IDL" }
PxSerializationRegistry.prototype = Object.create(WrapperObject.prototype);
PxSerializationRegistry.prototype.constructor = PxSerializationRegistry;
PxSerializationRegistry.prototype.__class__ = PxSerializationRegistry;
PxSerializationRegistry.__cache__ = {};
Module['PxSerializationRegistry'] = PxSerializationRegistry;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSerializationRegistry.prototype['release'] = PxSerializationRegistry.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxSerializationRegistry_release_0(self);
};


// Interface: PxShape

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxShape() { throw "cannot construct a PxShape, no constructor in IDL" }
PxShape.prototype = Object.create(PxRefCounted.prototype);
PxShape.prototype.constructor = PxShape;
PxShape.prototype.__class__ = PxShape;
PxShape.__cache__ = {};
Module['PxShape'] = PxShape;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['setGeometry'] = PxShape.prototype.setGeometry = function(geometry) {
  var self = this.ptr;
  if (geometry && typeof geometry === 'object') geometry = geometry.ptr;
  _emscripten_bind_PxShape_setGeometry_1(self, geometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getGeometry'] = PxShape.prototype.getGeometry = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxShape_getGeometry_0(self), PxGeometry);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getActor'] = PxShape.prototype.getActor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxShape_getActor_0(self), PxRigidActor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['setMaterials'] = PxShape.prototype.setMaterials = function(materials, materialCount) {
  var self = this.ptr;
  if (materials && typeof materials === 'object') materials = materials.ptr;
  if (materialCount && typeof materialCount === 'object') materialCount = materialCount.ptr;
  _emscripten_bind_PxShape_setMaterials_2(self, materials, materialCount);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getNbMaterials'] = PxShape.prototype.getNbMaterials = function() {
  var self = this.ptr;
  return _emscripten_bind_PxShape_getNbMaterials_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getMaterials'] = PxShape.prototype.getMaterials = function(userBuffer, bufferSize, startIndex) {
  var self = this.ptr;
  if (userBuffer && typeof userBuffer === 'object') userBuffer = userBuffer.ptr;
  if (bufferSize && typeof bufferSize === 'object') bufferSize = bufferSize.ptr;
  if (startIndex && typeof startIndex === 'object') startIndex = startIndex.ptr;
  return _emscripten_bind_PxShape_getMaterials_3(self, userBuffer, bufferSize, startIndex);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getMaterialFromInternalFaceIndex'] = PxShape.prototype.getMaterialFromInternalFaceIndex = function(faceIndex) {
  var self = this.ptr;
  if (faceIndex && typeof faceIndex === 'object') faceIndex = faceIndex.ptr;
  return wrapPointer(_emscripten_bind_PxShape_getMaterialFromInternalFaceIndex_1(self, faceIndex), PxBaseMaterial);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['setContactOffset'] = PxShape.prototype.setContactOffset = function(contactOffset) {
  var self = this.ptr;
  if (contactOffset && typeof contactOffset === 'object') contactOffset = contactOffset.ptr;
  _emscripten_bind_PxShape_setContactOffset_1(self, contactOffset);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getContactOffset'] = PxShape.prototype.getContactOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxShape_getContactOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['setRestOffset'] = PxShape.prototype.setRestOffset = function(restOffset) {
  var self = this.ptr;
  if (restOffset && typeof restOffset === 'object') restOffset = restOffset.ptr;
  _emscripten_bind_PxShape_setRestOffset_1(self, restOffset);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getRestOffset'] = PxShape.prototype.getRestOffset = function() {
  var self = this.ptr;
  return _emscripten_bind_PxShape_getRestOffset_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['setTorsionalPatchRadius'] = PxShape.prototype.setTorsionalPatchRadius = function(radius) {
  var self = this.ptr;
  if (radius && typeof radius === 'object') radius = radius.ptr;
  _emscripten_bind_PxShape_setTorsionalPatchRadius_1(self, radius);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getTorsionalPatchRadius'] = PxShape.prototype.getTorsionalPatchRadius = function() {
  var self = this.ptr;
  return _emscripten_bind_PxShape_getTorsionalPatchRadius_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['setMinTorsionalPatchRadius'] = PxShape.prototype.setMinTorsionalPatchRadius = function(radius) {
  var self = this.ptr;
  if (radius && typeof radius === 'object') radius = radius.ptr;
  _emscripten_bind_PxShape_setMinTorsionalPatchRadius_1(self, radius);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getMinTorsionalPatchRadius'] = PxShape.prototype.getMinTorsionalPatchRadius = function() {
  var self = this.ptr;
  return _emscripten_bind_PxShape_getMinTorsionalPatchRadius_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['setFlag'] = PxShape.prototype.setFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxShape_setFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['setFlags'] = PxShape.prototype.setFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxShape_setFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getFlags'] = PxShape.prototype.getFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxShape_getFlags_0(self), PxShapeFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['isExclusive'] = PxShape.prototype.isExclusive = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxShape_isExclusive_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['setName'] = PxShape.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxShape_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getName'] = PxShape.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxShape_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['setLocalPose'] = PxShape.prototype.setLocalPose = function(pose) {
  var self = this.ptr;
  if (pose && typeof pose === 'object') pose = pose.ptr;
  _emscripten_bind_PxShape_setLocalPose_1(self, pose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getLocalPose'] = PxShape.prototype.getLocalPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxShape_getLocalPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['setSimulationFilterData'] = PxShape.prototype.setSimulationFilterData = function(data) {
  var self = this.ptr;
  if (data && typeof data === 'object') data = data.ptr;
  _emscripten_bind_PxShape_setSimulationFilterData_1(self, data);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getSimulationFilterData'] = PxShape.prototype.getSimulationFilterData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxShape_getSimulationFilterData_0(self), PxFilterData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['setQueryFilterData'] = PxShape.prototype.setQueryFilterData = function(data) {
  var self = this.ptr;
  if (data && typeof data === 'object') data = data.ptr;
  _emscripten_bind_PxShape_setQueryFilterData_1(self, data);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getQueryFilterData'] = PxShape.prototype.getQueryFilterData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxShape_getQueryFilterData_0(self), PxFilterData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['release'] = PxShape.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxShape_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getConcreteTypeName'] = PxShape.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxShape_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getConcreteType'] = PxShape.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxShape_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['setBaseFlag'] = PxShape.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxShape_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['setBaseFlags'] = PxShape.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxShape_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getBaseFlags'] = PxShape.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxShape_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['isReleasable'] = PxShape.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxShape_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['getReferenceCount'] = PxShape.prototype.getReferenceCount = function() {
  var self = this.ptr;
  return _emscripten_bind_PxShape_getReferenceCount_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['acquireReference'] = PxShape.prototype.acquireReference = function() {
  var self = this.ptr;
  _emscripten_bind_PxShape_acquireReference_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['get_userData'] = PxShape.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxShape_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShape.prototype['set_userData'] = PxShape.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxShape_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxShape.prototype, 'userData', { get: PxShape.prototype.get_userData, set: PxShape.prototype.set_userData });

// Interface: PxShapeExt

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxShapeExt() { throw "cannot construct a PxShapeExt, no constructor in IDL" }
PxShapeExt.prototype = Object.create(WrapperObject.prototype);
PxShapeExt.prototype.constructor = PxShapeExt;
PxShapeExt.prototype.__class__ = PxShapeExt;
PxShapeExt.__cache__ = {};
Module['PxShapeExt'] = PxShapeExt;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShapeExt.prototype['getGlobalPose'] = PxShapeExt.prototype.getGlobalPose = function(shape, actor) {
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return wrapPointer(_emscripten_bind_PxShapeExt_getGlobalPose_2(shape, actor), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShapeExt.prototype['raycast'] = PxShapeExt.prototype.raycast = function(shape, actor, rayOrigin, rayDir, maxDist, hitFlags, maxHits, rayHits) {
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (rayOrigin && typeof rayOrigin === 'object') rayOrigin = rayOrigin.ptr;
  if (rayDir && typeof rayDir === 'object') rayDir = rayDir.ptr;
  if (maxDist && typeof maxDist === 'object') maxDist = maxDist.ptr;
  if (hitFlags && typeof hitFlags === 'object') hitFlags = hitFlags.ptr;
  if (maxHits && typeof maxHits === 'object') maxHits = maxHits.ptr;
  if (rayHits && typeof rayHits === 'object') rayHits = rayHits.ptr;
  return _emscripten_bind_PxShapeExt_raycast_8(shape, actor, rayOrigin, rayDir, maxDist, hitFlags, maxHits, rayHits);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShapeExt.prototype['overlap'] = PxShapeExt.prototype.overlap = function(shape, actor, otherGeom, otherGeomPose) {
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (otherGeom && typeof otherGeom === 'object') otherGeom = otherGeom.ptr;
  if (otherGeomPose && typeof otherGeomPose === 'object') otherGeomPose = otherGeomPose.ptr;
  return !!(_emscripten_bind_PxShapeExt_overlap_4(shape, actor, otherGeom, otherGeomPose));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShapeExt.prototype['sweep'] = PxShapeExt.prototype.sweep = function(shape, actor, unitDir, distance, otherGeom, otherGeomPose, sweepHit, hitFlags) {
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (unitDir && typeof unitDir === 'object') unitDir = unitDir.ptr;
  if (distance && typeof distance === 'object') distance = distance.ptr;
  if (otherGeom && typeof otherGeom === 'object') otherGeom = otherGeom.ptr;
  if (otherGeomPose && typeof otherGeomPose === 'object') otherGeomPose = otherGeomPose.ptr;
  if (sweepHit && typeof sweepHit === 'object') sweepHit = sweepHit.ptr;
  if (hitFlags && typeof hitFlags === 'object') hitFlags = hitFlags.ptr;
  return !!(_emscripten_bind_PxShapeExt_sweep_8(shape, actor, unitDir, distance, otherGeom, otherGeomPose, sweepHit, hitFlags));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShapeExt.prototype['getWorldBounds'] = PxShapeExt.prototype.getWorldBounds = function(shape, actor, inflation) {
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (inflation && typeof inflation === 'object') inflation = inflation.ptr;
  if (inflation === undefined) { return wrapPointer(_emscripten_bind_PxShapeExt_getWorldBounds_2(shape, actor), PxBounds3) }
  return wrapPointer(_emscripten_bind_PxShapeExt_getWorldBounds_3(shape, actor, inflation), PxBounds3);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShapeExt.prototype['__destroy__'] = PxShapeExt.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxShapeExt___destroy___0(self);
};

// Interface: PxShapeFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxShapeFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxShapeFlags_PxShapeFlags_1(flags);
  getCache(PxShapeFlags)[this.ptr] = this;
};

PxShapeFlags.prototype = Object.create(WrapperObject.prototype);
PxShapeFlags.prototype.constructor = PxShapeFlags;
PxShapeFlags.prototype.__class__ = PxShapeFlags;
PxShapeFlags.__cache__ = {};
Module['PxShapeFlags'] = PxShapeFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShapeFlags.prototype['isSet'] = PxShapeFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxShapeFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShapeFlags.prototype['raise'] = PxShapeFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxShapeFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShapeFlags.prototype['clear'] = PxShapeFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxShapeFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShapeFlags.prototype['__destroy__'] = PxShapeFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxShapeFlags___destroy___0(self);
};

// Interface: PxShapePtr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxShapePtr() { throw "cannot construct a PxShapePtr, no constructor in IDL" }
PxShapePtr.prototype = Object.create(WrapperObject.prototype);
PxShapePtr.prototype.constructor = PxShapePtr;
PxShapePtr.prototype.__class__ = PxShapePtr;
PxShapePtr.__cache__ = {};
Module['PxShapePtr'] = PxShapePtr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxShapePtr.prototype['__destroy__'] = PxShapePtr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxShapePtr___destroy___0(self);
};

// Interface: PxSimulationEventCallbackImpl

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSimulationEventCallbackImpl() {
  this.ptr = _emscripten_bind_PxSimulationEventCallbackImpl_PxSimulationEventCallbackImpl_0();
  getCache(PxSimulationEventCallbackImpl)[this.ptr] = this;
};

PxSimulationEventCallbackImpl.prototype = Object.create(SimpleSimulationEventCallback.prototype);
PxSimulationEventCallbackImpl.prototype.constructor = PxSimulationEventCallbackImpl;
PxSimulationEventCallbackImpl.prototype.__class__ = PxSimulationEventCallbackImpl;
PxSimulationEventCallbackImpl.__cache__ = {};
Module['PxSimulationEventCallbackImpl'] = PxSimulationEventCallbackImpl;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationEventCallbackImpl.prototype['onConstraintBreak'] = PxSimulationEventCallbackImpl.prototype.onConstraintBreak = function(constraints, count) {
  var self = this.ptr;
  if (constraints && typeof constraints === 'object') constraints = constraints.ptr;
  if (count && typeof count === 'object') count = count.ptr;
  _emscripten_bind_PxSimulationEventCallbackImpl_onConstraintBreak_2(self, constraints, count);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationEventCallbackImpl.prototype['onWake'] = PxSimulationEventCallbackImpl.prototype.onWake = function(actors, count) {
  var self = this.ptr;
  if (actors && typeof actors === 'object') actors = actors.ptr;
  if (count && typeof count === 'object') count = count.ptr;
  _emscripten_bind_PxSimulationEventCallbackImpl_onWake_2(self, actors, count);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationEventCallbackImpl.prototype['onSleep'] = PxSimulationEventCallbackImpl.prototype.onSleep = function(actors, count) {
  var self = this.ptr;
  if (actors && typeof actors === 'object') actors = actors.ptr;
  if (count && typeof count === 'object') count = count.ptr;
  _emscripten_bind_PxSimulationEventCallbackImpl_onSleep_2(self, actors, count);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationEventCallbackImpl.prototype['onContact'] = PxSimulationEventCallbackImpl.prototype.onContact = function(pairHeader, pairs, nbPairs) {
  var self = this.ptr;
  if (pairHeader && typeof pairHeader === 'object') pairHeader = pairHeader.ptr;
  if (pairs && typeof pairs === 'object') pairs = pairs.ptr;
  if (nbPairs && typeof nbPairs === 'object') nbPairs = nbPairs.ptr;
  _emscripten_bind_PxSimulationEventCallbackImpl_onContact_3(self, pairHeader, pairs, nbPairs);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationEventCallbackImpl.prototype['onTrigger'] = PxSimulationEventCallbackImpl.prototype.onTrigger = function(pairs, count) {
  var self = this.ptr;
  if (pairs && typeof pairs === 'object') pairs = pairs.ptr;
  if (count && typeof count === 'object') count = count.ptr;
  _emscripten_bind_PxSimulationEventCallbackImpl_onTrigger_2(self, pairs, count);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationEventCallbackImpl.prototype['__destroy__'] = PxSimulationEventCallbackImpl.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSimulationEventCallbackImpl___destroy___0(self);
};

// Interface: PxSimulationStatistics

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSimulationStatistics() { throw "cannot construct a PxSimulationStatistics, no constructor in IDL" }
PxSimulationStatistics.prototype = Object.create(WrapperObject.prototype);
PxSimulationStatistics.prototype.constructor = PxSimulationStatistics;
PxSimulationStatistics.prototype.__class__ = PxSimulationStatistics;
PxSimulationStatistics.__cache__ = {};
Module['PxSimulationStatistics'] = PxSimulationStatistics;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbActiveConstraints'] = PxSimulationStatistics.prototype.get_nbActiveConstraints = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbActiveConstraints_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbActiveConstraints'] = PxSimulationStatistics.prototype.set_nbActiveConstraints = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbActiveConstraints_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbActiveConstraints', { get: PxSimulationStatistics.prototype.get_nbActiveConstraints, set: PxSimulationStatistics.prototype.set_nbActiveConstraints });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbActiveDynamicBodies'] = PxSimulationStatistics.prototype.get_nbActiveDynamicBodies = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbActiveDynamicBodies_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbActiveDynamicBodies'] = PxSimulationStatistics.prototype.set_nbActiveDynamicBodies = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbActiveDynamicBodies_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbActiveDynamicBodies', { get: PxSimulationStatistics.prototype.get_nbActiveDynamicBodies, set: PxSimulationStatistics.prototype.set_nbActiveDynamicBodies });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbActiveKinematicBodies'] = PxSimulationStatistics.prototype.get_nbActiveKinematicBodies = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbActiveKinematicBodies_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbActiveKinematicBodies'] = PxSimulationStatistics.prototype.set_nbActiveKinematicBodies = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbActiveKinematicBodies_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbActiveKinematicBodies', { get: PxSimulationStatistics.prototype.get_nbActiveKinematicBodies, set: PxSimulationStatistics.prototype.set_nbActiveKinematicBodies });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbStaticBodies'] = PxSimulationStatistics.prototype.get_nbStaticBodies = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbStaticBodies_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbStaticBodies'] = PxSimulationStatistics.prototype.set_nbStaticBodies = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbStaticBodies_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbStaticBodies', { get: PxSimulationStatistics.prototype.get_nbStaticBodies, set: PxSimulationStatistics.prototype.set_nbStaticBodies });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbDynamicBodies'] = PxSimulationStatistics.prototype.get_nbDynamicBodies = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbDynamicBodies_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbDynamicBodies'] = PxSimulationStatistics.prototype.set_nbDynamicBodies = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbDynamicBodies_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbDynamicBodies', { get: PxSimulationStatistics.prototype.get_nbDynamicBodies, set: PxSimulationStatistics.prototype.set_nbDynamicBodies });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbKinematicBodies'] = PxSimulationStatistics.prototype.get_nbKinematicBodies = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbKinematicBodies_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbKinematicBodies'] = PxSimulationStatistics.prototype.set_nbKinematicBodies = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbKinematicBodies_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbKinematicBodies', { get: PxSimulationStatistics.prototype.get_nbKinematicBodies, set: PxSimulationStatistics.prototype.set_nbKinematicBodies });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbShapes'] = PxSimulationStatistics.prototype.get_nbShapes = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbShapes_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbShapes'] = PxSimulationStatistics.prototype.set_nbShapes = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbShapes_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbShapes', { get: PxSimulationStatistics.prototype.get_nbShapes, set: PxSimulationStatistics.prototype.set_nbShapes });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbAggregates'] = PxSimulationStatistics.prototype.get_nbAggregates = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbAggregates_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbAggregates'] = PxSimulationStatistics.prototype.set_nbAggregates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbAggregates_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbAggregates', { get: PxSimulationStatistics.prototype.get_nbAggregates, set: PxSimulationStatistics.prototype.set_nbAggregates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbArticulations'] = PxSimulationStatistics.prototype.get_nbArticulations = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbArticulations_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbArticulations'] = PxSimulationStatistics.prototype.set_nbArticulations = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbArticulations_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbArticulations', { get: PxSimulationStatistics.prototype.get_nbArticulations, set: PxSimulationStatistics.prototype.set_nbArticulations });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbAxisSolverConstraints'] = PxSimulationStatistics.prototype.get_nbAxisSolverConstraints = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbAxisSolverConstraints_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbAxisSolverConstraints'] = PxSimulationStatistics.prototype.set_nbAxisSolverConstraints = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbAxisSolverConstraints_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbAxisSolverConstraints', { get: PxSimulationStatistics.prototype.get_nbAxisSolverConstraints, set: PxSimulationStatistics.prototype.set_nbAxisSolverConstraints });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_compressedContactSize'] = PxSimulationStatistics.prototype.get_compressedContactSize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_compressedContactSize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_compressedContactSize'] = PxSimulationStatistics.prototype.set_compressedContactSize = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_compressedContactSize_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'compressedContactSize', { get: PxSimulationStatistics.prototype.get_compressedContactSize, set: PxSimulationStatistics.prototype.set_compressedContactSize });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_requiredContactConstraintMemory'] = PxSimulationStatistics.prototype.get_requiredContactConstraintMemory = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_requiredContactConstraintMemory_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_requiredContactConstraintMemory'] = PxSimulationStatistics.prototype.set_requiredContactConstraintMemory = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_requiredContactConstraintMemory_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'requiredContactConstraintMemory', { get: PxSimulationStatistics.prototype.get_requiredContactConstraintMemory, set: PxSimulationStatistics.prototype.set_requiredContactConstraintMemory });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_peakConstraintMemory'] = PxSimulationStatistics.prototype.get_peakConstraintMemory = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_peakConstraintMemory_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_peakConstraintMemory'] = PxSimulationStatistics.prototype.set_peakConstraintMemory = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_peakConstraintMemory_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'peakConstraintMemory', { get: PxSimulationStatistics.prototype.get_peakConstraintMemory, set: PxSimulationStatistics.prototype.set_peakConstraintMemory });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbDiscreteContactPairsTotal'] = PxSimulationStatistics.prototype.get_nbDiscreteContactPairsTotal = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsTotal_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbDiscreteContactPairsTotal'] = PxSimulationStatistics.prototype.set_nbDiscreteContactPairsTotal = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsTotal_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbDiscreteContactPairsTotal', { get: PxSimulationStatistics.prototype.get_nbDiscreteContactPairsTotal, set: PxSimulationStatistics.prototype.set_nbDiscreteContactPairsTotal });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbDiscreteContactPairsWithCacheHits'] = PxSimulationStatistics.prototype.get_nbDiscreteContactPairsWithCacheHits = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithCacheHits_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbDiscreteContactPairsWithCacheHits'] = PxSimulationStatistics.prototype.set_nbDiscreteContactPairsWithCacheHits = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithCacheHits_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbDiscreteContactPairsWithCacheHits', { get: PxSimulationStatistics.prototype.get_nbDiscreteContactPairsWithCacheHits, set: PxSimulationStatistics.prototype.set_nbDiscreteContactPairsWithCacheHits });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbDiscreteContactPairsWithContacts'] = PxSimulationStatistics.prototype.get_nbDiscreteContactPairsWithContacts = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbDiscreteContactPairsWithContacts_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbDiscreteContactPairsWithContacts'] = PxSimulationStatistics.prototype.set_nbDiscreteContactPairsWithContacts = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbDiscreteContactPairsWithContacts_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbDiscreteContactPairsWithContacts', { get: PxSimulationStatistics.prototype.get_nbDiscreteContactPairsWithContacts, set: PxSimulationStatistics.prototype.set_nbDiscreteContactPairsWithContacts });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbNewPairs'] = PxSimulationStatistics.prototype.get_nbNewPairs = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbNewPairs_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbNewPairs'] = PxSimulationStatistics.prototype.set_nbNewPairs = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbNewPairs_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbNewPairs', { get: PxSimulationStatistics.prototype.get_nbNewPairs, set: PxSimulationStatistics.prototype.set_nbNewPairs });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbLostPairs'] = PxSimulationStatistics.prototype.get_nbLostPairs = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbLostPairs_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbLostPairs'] = PxSimulationStatistics.prototype.set_nbLostPairs = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbLostPairs_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbLostPairs', { get: PxSimulationStatistics.prototype.get_nbLostPairs, set: PxSimulationStatistics.prototype.set_nbLostPairs });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbNewTouches'] = PxSimulationStatistics.prototype.get_nbNewTouches = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbNewTouches_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbNewTouches'] = PxSimulationStatistics.prototype.set_nbNewTouches = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbNewTouches_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbNewTouches', { get: PxSimulationStatistics.prototype.get_nbNewTouches, set: PxSimulationStatistics.prototype.set_nbNewTouches });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbLostTouches'] = PxSimulationStatistics.prototype.get_nbLostTouches = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbLostTouches_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbLostTouches'] = PxSimulationStatistics.prototype.set_nbLostTouches = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbLostTouches_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbLostTouches', { get: PxSimulationStatistics.prototype.get_nbLostTouches, set: PxSimulationStatistics.prototype.set_nbLostTouches });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbPartitions'] = PxSimulationStatistics.prototype.get_nbPartitions = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbPartitions_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbPartitions'] = PxSimulationStatistics.prototype.set_nbPartitions = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbPartitions_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbPartitions', { get: PxSimulationStatistics.prototype.get_nbPartitions, set: PxSimulationStatistics.prototype.set_nbPartitions });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbBroadPhaseAdds'] = PxSimulationStatistics.prototype.get_nbBroadPhaseAdds = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseAdds_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbBroadPhaseAdds'] = PxSimulationStatistics.prototype.set_nbBroadPhaseAdds = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseAdds_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbBroadPhaseAdds', { get: PxSimulationStatistics.prototype.get_nbBroadPhaseAdds, set: PxSimulationStatistics.prototype.set_nbBroadPhaseAdds });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['get_nbBroadPhaseRemoves'] = PxSimulationStatistics.prototype.get_nbBroadPhaseRemoves = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSimulationStatistics_get_nbBroadPhaseRemoves_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['set_nbBroadPhaseRemoves'] = PxSimulationStatistics.prototype.set_nbBroadPhaseRemoves = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSimulationStatistics_set_nbBroadPhaseRemoves_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSimulationStatistics.prototype, 'nbBroadPhaseRemoves', { get: PxSimulationStatistics.prototype.get_nbBroadPhaseRemoves, set: PxSimulationStatistics.prototype.set_nbBroadPhaseRemoves });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSimulationStatistics.prototype['__destroy__'] = PxSimulationStatistics.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSimulationStatistics___destroy___0(self);
};

// Interface: PxSpatialForce

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSpatialForce() { throw "cannot construct a PxSpatialForce, no constructor in IDL" }
PxSpatialForce.prototype = Object.create(WrapperObject.prototype);
PxSpatialForce.prototype.constructor = PxSpatialForce;
PxSpatialForce.prototype.__class__ = PxSpatialForce;
PxSpatialForce.__cache__ = {};
Module['PxSpatialForce'] = PxSpatialForce;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpatialForce.prototype['get_force'] = PxSpatialForce.prototype.get_force = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSpatialForce_get_force_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpatialForce.prototype['set_force'] = PxSpatialForce.prototype.set_force = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSpatialForce_set_force_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSpatialForce.prototype, 'force', { get: PxSpatialForce.prototype.get_force, set: PxSpatialForce.prototype.set_force });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpatialForce.prototype['get_torque'] = PxSpatialForce.prototype.get_torque = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSpatialForce_get_torque_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpatialForce.prototype['set_torque'] = PxSpatialForce.prototype.set_torque = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSpatialForce_set_torque_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSpatialForce.prototype, 'torque', { get: PxSpatialForce.prototype.get_torque, set: PxSpatialForce.prototype.set_torque });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpatialForce.prototype['__destroy__'] = PxSpatialForce.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSpatialForce___destroy___0(self);
};

// Interface: PxSpatialVelocity

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSpatialVelocity() { throw "cannot construct a PxSpatialVelocity, no constructor in IDL" }
PxSpatialVelocity.prototype = Object.create(WrapperObject.prototype);
PxSpatialVelocity.prototype.constructor = PxSpatialVelocity;
PxSpatialVelocity.prototype.__class__ = PxSpatialVelocity;
PxSpatialVelocity.__cache__ = {};
Module['PxSpatialVelocity'] = PxSpatialVelocity;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpatialVelocity.prototype['get_linear'] = PxSpatialVelocity.prototype.get_linear = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSpatialVelocity_get_linear_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpatialVelocity.prototype['set_linear'] = PxSpatialVelocity.prototype.set_linear = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSpatialVelocity_set_linear_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSpatialVelocity.prototype, 'linear', { get: PxSpatialVelocity.prototype.get_linear, set: PxSpatialVelocity.prototype.set_linear });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpatialVelocity.prototype['get_angular'] = PxSpatialVelocity.prototype.get_angular = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSpatialVelocity_get_angular_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpatialVelocity.prototype['set_angular'] = PxSpatialVelocity.prototype.set_angular = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSpatialVelocity_set_angular_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSpatialVelocity.prototype, 'angular', { get: PxSpatialVelocity.prototype.get_angular, set: PxSpatialVelocity.prototype.set_angular });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSpatialVelocity.prototype['__destroy__'] = PxSpatialVelocity.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSpatialVelocity___destroy___0(self);
};

// Interface: PxSphereGeometry

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSphereGeometry(ir) {
  if (ir && typeof ir === 'object') ir = ir.ptr;
  this.ptr = _emscripten_bind_PxSphereGeometry_PxSphereGeometry_1(ir);
  getCache(PxSphereGeometry)[this.ptr] = this;
};

PxSphereGeometry.prototype = Object.create(PxGeometry.prototype);
PxSphereGeometry.prototype.constructor = PxSphereGeometry;
PxSphereGeometry.prototype.__class__ = PxSphereGeometry;
PxSphereGeometry.__cache__ = {};
Module['PxSphereGeometry'] = PxSphereGeometry;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphereGeometry.prototype['getType'] = PxSphereGeometry.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSphereGeometry_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphereGeometry.prototype['get_radius'] = PxSphereGeometry.prototype.get_radius = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSphereGeometry_get_radius_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphereGeometry.prototype['set_radius'] = PxSphereGeometry.prototype.set_radius = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSphereGeometry_set_radius_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSphereGeometry.prototype, 'radius', { get: PxSphereGeometry.prototype.get_radius, set: PxSphereGeometry.prototype.set_radius });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphereGeometry.prototype['__destroy__'] = PxSphereGeometry.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSphereGeometry___destroy___0(self);
};

// Interface: PxSphericalJoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSphericalJoint() { throw "cannot construct a PxSphericalJoint, no constructor in IDL" }
PxSphericalJoint.prototype = Object.create(PxJoint.prototype);
PxSphericalJoint.prototype.constructor = PxSphericalJoint;
PxSphericalJoint.prototype.__class__ = PxSphericalJoint;
PxSphericalJoint.__cache__ = {};
Module['PxSphericalJoint'] = PxSphericalJoint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setLimitCone'] = PxSphericalJoint.prototype.setLimitCone = function(limitCone) {
  var self = this.ptr;
  if (limitCone && typeof limitCone === 'object') limitCone = limitCone.ptr;
  _emscripten_bind_PxSphericalJoint_setLimitCone_1(self, limitCone);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getSwingYAngle'] = PxSphericalJoint.prototype.getSwingYAngle = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSphericalJoint_getSwingYAngle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getSwingZAngle'] = PxSphericalJoint.prototype.getSwingZAngle = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSphericalJoint_getSwingZAngle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setSphericalJointFlags'] = PxSphericalJoint.prototype.setSphericalJointFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxSphericalJoint_setSphericalJointFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setSphericalJointFlag'] = PxSphericalJoint.prototype.setSphericalJointFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxSphericalJoint_setSphericalJointFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getSphericalJointFlags'] = PxSphericalJoint.prototype.getSphericalJointFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSphericalJoint_getSphericalJointFlags_0(self), PxSphericalJointFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['release'] = PxSphericalJoint.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxSphericalJoint_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getConcreteTypeName'] = PxSphericalJoint.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxSphericalJoint_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getConcreteType'] = PxSphericalJoint.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSphericalJoint_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setBaseFlag'] = PxSphericalJoint.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxSphericalJoint_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setBaseFlags'] = PxSphericalJoint.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxSphericalJoint_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getBaseFlags'] = PxSphericalJoint.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSphericalJoint_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['isReleasable'] = PxSphericalJoint.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxSphericalJoint_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setActors'] = PxSphericalJoint.prototype.setActors = function(actor0, actor1) {
  var self = this.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  _emscripten_bind_PxSphericalJoint_setActors_2(self, actor0, actor1);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setLocalPose'] = PxSphericalJoint.prototype.setLocalPose = function(actor, localPose) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (localPose && typeof localPose === 'object') localPose = localPose.ptr;
  _emscripten_bind_PxSphericalJoint_setLocalPose_2(self, actor, localPose);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getLocalPose'] = PxSphericalJoint.prototype.getLocalPose = function(actor) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  return wrapPointer(_emscripten_bind_PxSphericalJoint_getLocalPose_1(self, actor), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getRelativeTransform'] = PxSphericalJoint.prototype.getRelativeTransform = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSphericalJoint_getRelativeTransform_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getRelativeLinearVelocity'] = PxSphericalJoint.prototype.getRelativeLinearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSphericalJoint_getRelativeLinearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getRelativeAngularVelocity'] = PxSphericalJoint.prototype.getRelativeAngularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSphericalJoint_getRelativeAngularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setBreakForce'] = PxSphericalJoint.prototype.setBreakForce = function(force, torque) {
  var self = this.ptr;
  if (force && typeof force === 'object') force = force.ptr;
  if (torque && typeof torque === 'object') torque = torque.ptr;
  _emscripten_bind_PxSphericalJoint_setBreakForce_2(self, force, torque);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setConstraintFlags'] = PxSphericalJoint.prototype.setConstraintFlags = function(flags) {
  var self = this.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  _emscripten_bind_PxSphericalJoint_setConstraintFlags_1(self, flags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setConstraintFlag'] = PxSphericalJoint.prototype.setConstraintFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxSphericalJoint_setConstraintFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getConstraintFlags'] = PxSphericalJoint.prototype.getConstraintFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSphericalJoint_getConstraintFlags_0(self), PxConstraintFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setInvMassScale0'] = PxSphericalJoint.prototype.setInvMassScale0 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxSphericalJoint_setInvMassScale0_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getInvMassScale0'] = PxSphericalJoint.prototype.getInvMassScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSphericalJoint_getInvMassScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setInvMassScale1'] = PxSphericalJoint.prototype.setInvMassScale1 = function(invMassScale) {
  var self = this.ptr;
  if (invMassScale && typeof invMassScale === 'object') invMassScale = invMassScale.ptr;
  _emscripten_bind_PxSphericalJoint_setInvMassScale1_1(self, invMassScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getInvMassScale1'] = PxSphericalJoint.prototype.getInvMassScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSphericalJoint_getInvMassScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setInvInertiaScale0'] = PxSphericalJoint.prototype.setInvInertiaScale0 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxSphericalJoint_setInvInertiaScale0_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getInvInertiaScale0'] = PxSphericalJoint.prototype.getInvInertiaScale0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSphericalJoint_getInvInertiaScale0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setInvInertiaScale1'] = PxSphericalJoint.prototype.setInvInertiaScale1 = function(invInertiaScale) {
  var self = this.ptr;
  if (invInertiaScale && typeof invInertiaScale === 'object') invInertiaScale = invInertiaScale.ptr;
  _emscripten_bind_PxSphericalJoint_setInvInertiaScale1_1(self, invInertiaScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getInvInertiaScale1'] = PxSphericalJoint.prototype.getInvInertiaScale1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSphericalJoint_getInvInertiaScale1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getConstraint'] = PxSphericalJoint.prototype.getConstraint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSphericalJoint_getConstraint_0(self), PxConstraint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['setName'] = PxSphericalJoint.prototype.setName = function(name) {
  var self = this.ptr;
  ensureCache.prepare();
  if (name && typeof name === 'object') name = name.ptr;
  else name = ensureString(name);
  _emscripten_bind_PxSphericalJoint_setName_1(self, name);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getName'] = PxSphericalJoint.prototype.getName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxSphericalJoint_getName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['getScene'] = PxSphericalJoint.prototype.getScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSphericalJoint_getScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['get_userData'] = PxSphericalJoint.prototype.get_userData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSphericalJoint_get_userData_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['set_userData'] = PxSphericalJoint.prototype.set_userData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSphericalJoint_set_userData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSphericalJoint.prototype, 'userData', { get: PxSphericalJoint.prototype.get_userData, set: PxSphericalJoint.prototype.set_userData });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJoint.prototype['__destroy__'] = PxSphericalJoint.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSphericalJoint___destroy___0(self);
};

// Interface: PxSphericalJointFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSphericalJointFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxSphericalJointFlags_PxSphericalJointFlags_1(flags);
  getCache(PxSphericalJointFlags)[this.ptr] = this;
};

PxSphericalJointFlags.prototype = Object.create(WrapperObject.prototype);
PxSphericalJointFlags.prototype.constructor = PxSphericalJointFlags;
PxSphericalJointFlags.prototype.__class__ = PxSphericalJointFlags;
PxSphericalJointFlags.__cache__ = {};
Module['PxSphericalJointFlags'] = PxSphericalJointFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJointFlags.prototype['isSet'] = PxSphericalJointFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxSphericalJointFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJointFlags.prototype['raise'] = PxSphericalJointFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxSphericalJointFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJointFlags.prototype['clear'] = PxSphericalJointFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxSphericalJointFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSphericalJointFlags.prototype['__destroy__'] = PxSphericalJointFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSphericalJointFlags___destroy___0(self);
};

// Interface: PxSweepBuffer10

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSweepBuffer10() {
  this.ptr = _emscripten_bind_PxSweepBuffer10_PxSweepBuffer10_0();
  getCache(PxSweepBuffer10)[this.ptr] = this;
};

PxSweepBuffer10.prototype = Object.create(PxSweepCallback.prototype);
PxSweepBuffer10.prototype.constructor = PxSweepBuffer10;
PxSweepBuffer10.prototype.__class__ = PxSweepBuffer10;
PxSweepBuffer10.__cache__ = {};
Module['PxSweepBuffer10'] = PxSweepBuffer10;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepBuffer10.prototype['getNbAnyHits'] = PxSweepBuffer10.prototype.getNbAnyHits = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSweepBuffer10_getNbAnyHits_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepBuffer10.prototype['getAnyHit'] = PxSweepBuffer10.prototype.getAnyHit = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxSweepBuffer10_getAnyHit_1(self, index), PxSweepHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepBuffer10.prototype['getNbTouches'] = PxSweepBuffer10.prototype.getNbTouches = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSweepBuffer10_getNbTouches_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepBuffer10.prototype['getTouches'] = PxSweepBuffer10.prototype.getTouches = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSweepBuffer10_getTouches_0(self), PxSweepHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepBuffer10.prototype['getTouch'] = PxSweepBuffer10.prototype.getTouch = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxSweepBuffer10_getTouch_1(self, index), PxSweepHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepBuffer10.prototype['getMaxNbTouches'] = PxSweepBuffer10.prototype.getMaxNbTouches = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSweepBuffer10_getMaxNbTouches_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepBuffer10.prototype['hasAnyHits'] = PxSweepBuffer10.prototype.hasAnyHits = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxSweepBuffer10_hasAnyHits_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepBuffer10.prototype['get_block'] = PxSweepBuffer10.prototype.get_block = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSweepBuffer10_get_block_0(self), PxSweepHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepBuffer10.prototype['set_block'] = PxSweepBuffer10.prototype.set_block = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSweepBuffer10_set_block_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSweepBuffer10.prototype, 'block', { get: PxSweepBuffer10.prototype.get_block, set: PxSweepBuffer10.prototype.set_block });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepBuffer10.prototype['get_hasBlock'] = PxSweepBuffer10.prototype.get_hasBlock = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxSweepBuffer10_get_hasBlock_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepBuffer10.prototype['set_hasBlock'] = PxSweepBuffer10.prototype.set_hasBlock = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSweepBuffer10_set_hasBlock_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSweepBuffer10.prototype, 'hasBlock', { get: PxSweepBuffer10.prototype.get_hasBlock, set: PxSweepBuffer10.prototype.set_hasBlock });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepBuffer10.prototype['__destroy__'] = PxSweepBuffer10.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSweepBuffer10___destroy___0(self);
};

// Interface: PxSweepHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSweepHit() {
  this.ptr = _emscripten_bind_PxSweepHit_PxSweepHit_0();
  getCache(PxSweepHit)[this.ptr] = this;
};

PxSweepHit.prototype = Object.create(PxGeomSweepHit.prototype);
PxSweepHit.prototype.constructor = PxSweepHit;
PxSweepHit.prototype.__class__ = PxSweepHit;
PxSweepHit.__cache__ = {};
Module['PxSweepHit'] = PxSweepHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['hadInitialOverlap'] = PxSweepHit.prototype.hadInitialOverlap = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxSweepHit_hadInitialOverlap_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['get_actor'] = PxSweepHit.prototype.get_actor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSweepHit_get_actor_0(self), PxRigidActor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['set_actor'] = PxSweepHit.prototype.set_actor = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSweepHit_set_actor_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSweepHit.prototype, 'actor', { get: PxSweepHit.prototype.get_actor, set: PxSweepHit.prototype.set_actor });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['get_shape'] = PxSweepHit.prototype.get_shape = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSweepHit_get_shape_0(self), PxShape);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['set_shape'] = PxSweepHit.prototype.set_shape = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSweepHit_set_shape_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSweepHit.prototype, 'shape', { get: PxSweepHit.prototype.get_shape, set: PxSweepHit.prototype.set_shape });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['get_flags'] = PxSweepHit.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSweepHit_get_flags_0(self), PxHitFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['set_flags'] = PxSweepHit.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSweepHit_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSweepHit.prototype, 'flags', { get: PxSweepHit.prototype.get_flags, set: PxSweepHit.prototype.set_flags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['get_position'] = PxSweepHit.prototype.get_position = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSweepHit_get_position_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['set_position'] = PxSweepHit.prototype.set_position = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSweepHit_set_position_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSweepHit.prototype, 'position', { get: PxSweepHit.prototype.get_position, set: PxSweepHit.prototype.set_position });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['get_normal'] = PxSweepHit.prototype.get_normal = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSweepHit_get_normal_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['set_normal'] = PxSweepHit.prototype.set_normal = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSweepHit_set_normal_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSweepHit.prototype, 'normal', { get: PxSweepHit.prototype.get_normal, set: PxSweepHit.prototype.set_normal });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['get_distance'] = PxSweepHit.prototype.get_distance = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSweepHit_get_distance_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['set_distance'] = PxSweepHit.prototype.set_distance = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSweepHit_set_distance_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSweepHit.prototype, 'distance', { get: PxSweepHit.prototype.get_distance, set: PxSweepHit.prototype.set_distance });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['get_faceIndex'] = PxSweepHit.prototype.get_faceIndex = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSweepHit_get_faceIndex_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['set_faceIndex'] = PxSweepHit.prototype.set_faceIndex = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSweepHit_set_faceIndex_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSweepHit.prototype, 'faceIndex', { get: PxSweepHit.prototype.get_faceIndex, set: PxSweepHit.prototype.set_faceIndex });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepHit.prototype['__destroy__'] = PxSweepHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSweepHit___destroy___0(self);
};

// Interface: PxSweepResult

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxSweepResult() {
  this.ptr = _emscripten_bind_PxSweepResult_PxSweepResult_0();
  getCache(PxSweepResult)[this.ptr] = this;
};

PxSweepResult.prototype = Object.create(PxSweepCallback.prototype);
PxSweepResult.prototype.constructor = PxSweepResult;
PxSweepResult.prototype.__class__ = PxSweepResult;
PxSweepResult.__cache__ = {};
Module['PxSweepResult'] = PxSweepResult;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepResult.prototype['getNbAnyHits'] = PxSweepResult.prototype.getNbAnyHits = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSweepResult_getNbAnyHits_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepResult.prototype['getAnyHit'] = PxSweepResult.prototype.getAnyHit = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxSweepResult_getAnyHit_1(self, index), PxSweepHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepResult.prototype['getNbTouches'] = PxSweepResult.prototype.getNbTouches = function() {
  var self = this.ptr;
  return _emscripten_bind_PxSweepResult_getNbTouches_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepResult.prototype['getTouch'] = PxSweepResult.prototype.getTouch = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_PxSweepResult_getTouch_1(self, index), PxSweepHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepResult.prototype['clear'] = PxSweepResult.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxSweepResult_clear_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepResult.prototype['hasAnyHits'] = PxSweepResult.prototype.hasAnyHits = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxSweepResult_hasAnyHits_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepResult.prototype['get_block'] = PxSweepResult.prototype.get_block = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxSweepResult_get_block_0(self), PxSweepHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepResult.prototype['set_block'] = PxSweepResult.prototype.set_block = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSweepResult_set_block_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSweepResult.prototype, 'block', { get: PxSweepResult.prototype.get_block, set: PxSweepResult.prototype.set_block });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepResult.prototype['get_hasBlock'] = PxSweepResult.prototype.get_hasBlock = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxSweepResult_get_hasBlock_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepResult.prototype['set_hasBlock'] = PxSweepResult.prototype.set_hasBlock = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxSweepResult_set_hasBlock_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxSweepResult.prototype, 'hasBlock', { get: PxSweepResult.prototype.get_hasBlock, set: PxSweepResult.prototype.set_hasBlock });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxSweepResult.prototype['__destroy__'] = PxSweepResult.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxSweepResult___destroy___0(self);
};

// Interface: PxTetMaker

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTetMaker() { throw "cannot construct a PxTetMaker, no constructor in IDL" }
PxTetMaker.prototype = Object.create(WrapperObject.prototype);
PxTetMaker.prototype.constructor = PxTetMaker;
PxTetMaker.prototype.__class__ = PxTetMaker;
PxTetMaker.__cache__ = {};
Module['PxTetMaker'] = PxTetMaker;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetMaker.prototype['createConformingTetrahedronMesh'] = PxTetMaker.prototype.createConformingTetrahedronMesh = function(triangleMesh, outVertices, outTetIndices, validate, volumeThreshold) {
  if (triangleMesh && typeof triangleMesh === 'object') triangleMesh = triangleMesh.ptr;
  if (outVertices && typeof outVertices === 'object') outVertices = outVertices.ptr;
  if (outTetIndices && typeof outTetIndices === 'object') outTetIndices = outTetIndices.ptr;
  if (validate && typeof validate === 'object') validate = validate.ptr;
  if (volumeThreshold && typeof volumeThreshold === 'object') volumeThreshold = volumeThreshold.ptr;
  return !!(_emscripten_bind_PxTetMaker_createConformingTetrahedronMesh_5(triangleMesh, outVertices, outTetIndices, validate, volumeThreshold));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetMaker.prototype['createVoxelTetrahedronMesh'] = PxTetMaker.prototype.createVoxelTetrahedronMesh = function(tetMesh, numVoxelsAlongLongestBoundingBoxAxis, outVertices, outTetIndices) {
  if (tetMesh && typeof tetMesh === 'object') tetMesh = tetMesh.ptr;
  if (numVoxelsAlongLongestBoundingBoxAxis && typeof numVoxelsAlongLongestBoundingBoxAxis === 'object') numVoxelsAlongLongestBoundingBoxAxis = numVoxelsAlongLongestBoundingBoxAxis.ptr;
  if (outVertices && typeof outVertices === 'object') outVertices = outVertices.ptr;
  if (outTetIndices && typeof outTetIndices === 'object') outTetIndices = outTetIndices.ptr;
  return !!(_emscripten_bind_PxTetMaker_createVoxelTetrahedronMesh_4(tetMesh, numVoxelsAlongLongestBoundingBoxAxis, outVertices, outTetIndices));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetMaker.prototype['createVoxelTetrahedronMeshFromEdgeLength'] = PxTetMaker.prototype.createVoxelTetrahedronMeshFromEdgeLength = function(tetMesh, voxelEdgeLength, outVertices, outTetIndices) {
  if (tetMesh && typeof tetMesh === 'object') tetMesh = tetMesh.ptr;
  if (voxelEdgeLength && typeof voxelEdgeLength === 'object') voxelEdgeLength = voxelEdgeLength.ptr;
  if (outVertices && typeof outVertices === 'object') outVertices = outVertices.ptr;
  if (outTetIndices && typeof outTetIndices === 'object') outTetIndices = outTetIndices.ptr;
  return !!(_emscripten_bind_PxTetMaker_createVoxelTetrahedronMeshFromEdgeLength_4(tetMesh, voxelEdgeLength, outVertices, outTetIndices));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetMaker.prototype['validateTriangleMesh'] = PxTetMaker.prototype.validateTriangleMesh = function(triangleMesh, minVolumeThreshold, minTriangleAngleRadians) {
  if (triangleMesh && typeof triangleMesh === 'object') triangleMesh = triangleMesh.ptr;
  if (minVolumeThreshold && typeof minVolumeThreshold === 'object') minVolumeThreshold = minVolumeThreshold.ptr;
  if (minTriangleAngleRadians && typeof minTriangleAngleRadians === 'object') minTriangleAngleRadians = minTriangleAngleRadians.ptr;
  return wrapPointer(_emscripten_bind_PxTetMaker_validateTriangleMesh_3(triangleMesh, minVolumeThreshold, minTriangleAngleRadians), PxTriangleMeshAnalysisResults);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetMaker.prototype['validateTetrahedronMesh'] = PxTetMaker.prototype.validateTetrahedronMesh = function(points, tetrahedra, minTetVolumeThreshold) {
  if (points && typeof points === 'object') points = points.ptr;
  if (tetrahedra && typeof tetrahedra === 'object') tetrahedra = tetrahedra.ptr;
  if (minTetVolumeThreshold && typeof minTetVolumeThreshold === 'object') minTetVolumeThreshold = minTetVolumeThreshold.ptr;
  return wrapPointer(_emscripten_bind_PxTetMaker_validateTetrahedronMesh_3(points, tetrahedra, minTetVolumeThreshold), PxTetrahedronMeshAnalysisResults);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetMaker.prototype['simplifyTriangleMesh'] = PxTetMaker.prototype.simplifyTriangleMesh = function(inputVertices, inputIndices, targetTriangleCount, maximalEdgeLength, outputVertices, outputIndices, vertexMap, edgeLengthCostWeight, flatnessDetectionThreshold, projectSimplifiedPointsOnInputMeshSurface, outputVertexToInputTriangle, removeDisconnectedPatches) {
  if (inputVertices && typeof inputVertices === 'object') inputVertices = inputVertices.ptr;
  if (inputIndices && typeof inputIndices === 'object') inputIndices = inputIndices.ptr;
  if (targetTriangleCount && typeof targetTriangleCount === 'object') targetTriangleCount = targetTriangleCount.ptr;
  if (maximalEdgeLength && typeof maximalEdgeLength === 'object') maximalEdgeLength = maximalEdgeLength.ptr;
  if (outputVertices && typeof outputVertices === 'object') outputVertices = outputVertices.ptr;
  if (outputIndices && typeof outputIndices === 'object') outputIndices = outputIndices.ptr;
  if (vertexMap && typeof vertexMap === 'object') vertexMap = vertexMap.ptr;
  if (edgeLengthCostWeight && typeof edgeLengthCostWeight === 'object') edgeLengthCostWeight = edgeLengthCostWeight.ptr;
  if (flatnessDetectionThreshold && typeof flatnessDetectionThreshold === 'object') flatnessDetectionThreshold = flatnessDetectionThreshold.ptr;
  if (projectSimplifiedPointsOnInputMeshSurface && typeof projectSimplifiedPointsOnInputMeshSurface === 'object') projectSimplifiedPointsOnInputMeshSurface = projectSimplifiedPointsOnInputMeshSurface.ptr;
  if (outputVertexToInputTriangle && typeof outputVertexToInputTriangle === 'object') outputVertexToInputTriangle = outputVertexToInputTriangle.ptr;
  if (removeDisconnectedPatches && typeof removeDisconnectedPatches === 'object') removeDisconnectedPatches = removeDisconnectedPatches.ptr;
  if (vertexMap === undefined) { _emscripten_bind_PxTetMaker_simplifyTriangleMesh_6(inputVertices, inputIndices, targetTriangleCount, maximalEdgeLength, outputVertices, outputIndices); return }
  if (edgeLengthCostWeight === undefined) { _emscripten_bind_PxTetMaker_simplifyTriangleMesh_7(inputVertices, inputIndices, targetTriangleCount, maximalEdgeLength, outputVertices, outputIndices, vertexMap); return }
  if (flatnessDetectionThreshold === undefined) { _emscripten_bind_PxTetMaker_simplifyTriangleMesh_8(inputVertices, inputIndices, targetTriangleCount, maximalEdgeLength, outputVertices, outputIndices, vertexMap, edgeLengthCostWeight); return }
  if (projectSimplifiedPointsOnInputMeshSurface === undefined) { _emscripten_bind_PxTetMaker_simplifyTriangleMesh_9(inputVertices, inputIndices, targetTriangleCount, maximalEdgeLength, outputVertices, outputIndices, vertexMap, edgeLengthCostWeight, flatnessDetectionThreshold); return }
  if (outputVertexToInputTriangle === undefined) { _emscripten_bind_PxTetMaker_simplifyTriangleMesh_10(inputVertices, inputIndices, targetTriangleCount, maximalEdgeLength, outputVertices, outputIndices, vertexMap, edgeLengthCostWeight, flatnessDetectionThreshold, projectSimplifiedPointsOnInputMeshSurface); return }
  if (removeDisconnectedPatches === undefined) { _emscripten_bind_PxTetMaker_simplifyTriangleMesh_11(inputVertices, inputIndices, targetTriangleCount, maximalEdgeLength, outputVertices, outputIndices, vertexMap, edgeLengthCostWeight, flatnessDetectionThreshold, projectSimplifiedPointsOnInputMeshSurface, outputVertexToInputTriangle); return }
  _emscripten_bind_PxTetMaker_simplifyTriangleMesh_12(inputVertices, inputIndices, targetTriangleCount, maximalEdgeLength, outputVertices, outputIndices, vertexMap, edgeLengthCostWeight, flatnessDetectionThreshold, projectSimplifiedPointsOnInputMeshSurface, outputVertexToInputTriangle, removeDisconnectedPatches);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetMaker.prototype['remeshTriangleMesh'] = PxTetMaker.prototype.remeshTriangleMesh = function(inputVertices, inputIndices, gridResolution, outputVertices, outputIndices, vertexMap) {
  if (inputVertices && typeof inputVertices === 'object') inputVertices = inputVertices.ptr;
  if (inputIndices && typeof inputIndices === 'object') inputIndices = inputIndices.ptr;
  if (gridResolution && typeof gridResolution === 'object') gridResolution = gridResolution.ptr;
  if (outputVertices && typeof outputVertices === 'object') outputVertices = outputVertices.ptr;
  if (outputIndices && typeof outputIndices === 'object') outputIndices = outputIndices.ptr;
  if (vertexMap && typeof vertexMap === 'object') vertexMap = vertexMap.ptr;
  if (vertexMap === undefined) { _emscripten_bind_PxTetMaker_remeshTriangleMesh_5(inputVertices, inputIndices, gridResolution, outputVertices, outputIndices); return }
  _emscripten_bind_PxTetMaker_remeshTriangleMesh_6(inputVertices, inputIndices, gridResolution, outputVertices, outputIndices, vertexMap);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetMaker.prototype['createTreeBasedTetrahedralMesh'] = PxTetMaker.prototype.createTreeBasedTetrahedralMesh = function(inputVertices, inputIndices, useTreeNodes, outputVertices, outputIndices, volumeThreshold) {
  if (inputVertices && typeof inputVertices === 'object') inputVertices = inputVertices.ptr;
  if (inputIndices && typeof inputIndices === 'object') inputIndices = inputIndices.ptr;
  if (useTreeNodes && typeof useTreeNodes === 'object') useTreeNodes = useTreeNodes.ptr;
  if (outputVertices && typeof outputVertices === 'object') outputVertices = outputVertices.ptr;
  if (outputIndices && typeof outputIndices === 'object') outputIndices = outputIndices.ptr;
  if (volumeThreshold && typeof volumeThreshold === 'object') volumeThreshold = volumeThreshold.ptr;
  _emscripten_bind_PxTetMaker_createTreeBasedTetrahedralMesh_6(inputVertices, inputIndices, useTreeNodes, outputVertices, outputIndices, volumeThreshold);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetMaker.prototype['createRelaxedVoxelTetrahedralMesh'] = PxTetMaker.prototype.createRelaxedVoxelTetrahedralMesh = function(inputVertices, inputIndices, outputVertices, outputIndices, resolution, numRelaxationIterations, relMinTetVolume) {
  if (inputVertices && typeof inputVertices === 'object') inputVertices = inputVertices.ptr;
  if (inputIndices && typeof inputIndices === 'object') inputIndices = inputIndices.ptr;
  if (outputVertices && typeof outputVertices === 'object') outputVertices = outputVertices.ptr;
  if (outputIndices && typeof outputIndices === 'object') outputIndices = outputIndices.ptr;
  if (resolution && typeof resolution === 'object') resolution = resolution.ptr;
  if (numRelaxationIterations && typeof numRelaxationIterations === 'object') numRelaxationIterations = numRelaxationIterations.ptr;
  if (relMinTetVolume && typeof relMinTetVolume === 'object') relMinTetVolume = relMinTetVolume.ptr;
  if (numRelaxationIterations === undefined) { _emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_5(inputVertices, inputIndices, outputVertices, outputIndices, resolution); return }
  if (relMinTetVolume === undefined) { _emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_6(inputVertices, inputIndices, outputVertices, outputIndices, resolution, numRelaxationIterations); return }
  _emscripten_bind_PxTetMaker_createRelaxedVoxelTetrahedralMesh_7(inputVertices, inputIndices, outputVertices, outputIndices, resolution, numRelaxationIterations, relMinTetVolume);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetMaker.prototype['detectTriangleIslands'] = PxTetMaker.prototype.detectTriangleIslands = function(triangles, numTriangles, islandIndexPerTriangle) {
  if (triangles && typeof triangles === 'object') triangles = triangles.ptr;
  if (numTriangles && typeof numTriangles === 'object') numTriangles = numTriangles.ptr;
  if (islandIndexPerTriangle && typeof islandIndexPerTriangle === 'object') islandIndexPerTriangle = islandIndexPerTriangle.ptr;
  _emscripten_bind_PxTetMaker_detectTriangleIslands_3(triangles, numTriangles, islandIndexPerTriangle);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetMaker.prototype['findLargestIslandId'] = PxTetMaker.prototype.findLargestIslandId = function(islandIndexPerTriangle, numTriangles) {
  if (islandIndexPerTriangle && typeof islandIndexPerTriangle === 'object') islandIndexPerTriangle = islandIndexPerTriangle.ptr;
  if (numTriangles && typeof numTriangles === 'object') numTriangles = numTriangles.ptr;
  return _emscripten_bind_PxTetMaker_findLargestIslandId_2(islandIndexPerTriangle, numTriangles);
};


// Interface: PxTetrahedronMesh

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTetrahedronMesh() { throw "cannot construct a PxTetrahedronMesh, no constructor in IDL" }
PxTetrahedronMesh.prototype = Object.create(PxRefCounted.prototype);
PxTetrahedronMesh.prototype.constructor = PxTetrahedronMesh;
PxTetrahedronMesh.prototype.__class__ = PxTetrahedronMesh;
PxTetrahedronMesh.__cache__ = {};
Module['PxTetrahedronMesh'] = PxTetrahedronMesh;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['getNbVertices'] = PxTetrahedronMesh.prototype.getNbVertices = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTetrahedronMesh_getNbVertices_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['getVertices'] = PxTetrahedronMesh.prototype.getVertices = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTetrahedronMesh_getVertices_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['getNbTetrahedrons'] = PxTetrahedronMesh.prototype.getNbTetrahedrons = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTetrahedronMesh_getNbTetrahedrons_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['getTetrahedrons'] = PxTetrahedronMesh.prototype.getTetrahedrons = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTetrahedronMesh_getTetrahedrons_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['getTetrahedronMeshFlags'] = PxTetrahedronMesh.prototype.getTetrahedronMeshFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTetrahedronMesh_getTetrahedronMeshFlags_0(self), PxTetrahedronMeshFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['getTetrahedraRemap'] = PxTetrahedronMesh.prototype.getTetrahedraRemap = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTetrahedronMesh_getTetrahedraRemap_0(self), PxU32ConstPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['getLocalBounds'] = PxTetrahedronMesh.prototype.getLocalBounds = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTetrahedronMesh_getLocalBounds_0(self), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['release'] = PxTetrahedronMesh.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxTetrahedronMesh_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['getConcreteTypeName'] = PxTetrahedronMesh.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxTetrahedronMesh_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['getConcreteType'] = PxTetrahedronMesh.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTetrahedronMesh_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['setBaseFlag'] = PxTetrahedronMesh.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxTetrahedronMesh_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['setBaseFlags'] = PxTetrahedronMesh.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxTetrahedronMesh_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['getBaseFlags'] = PxTetrahedronMesh.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTetrahedronMesh_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['isReleasable'] = PxTetrahedronMesh.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxTetrahedronMesh_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['getReferenceCount'] = PxTetrahedronMesh.prototype.getReferenceCount = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTetrahedronMesh_getReferenceCount_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMesh.prototype['acquireReference'] = PxTetrahedronMesh.prototype.acquireReference = function() {
  var self = this.ptr;
  _emscripten_bind_PxTetrahedronMesh_acquireReference_0(self);
};


// Interface: PxTetrahedronMeshAnalysisResults

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTetrahedronMeshAnalysisResults(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxTetrahedronMeshAnalysisResults_PxTetrahedronMeshAnalysisResults_1(flags);
  getCache(PxTetrahedronMeshAnalysisResults)[this.ptr] = this;
};

PxTetrahedronMeshAnalysisResults.prototype = Object.create(WrapperObject.prototype);
PxTetrahedronMeshAnalysisResults.prototype.constructor = PxTetrahedronMeshAnalysisResults;
PxTetrahedronMeshAnalysisResults.prototype.__class__ = PxTetrahedronMeshAnalysisResults;
PxTetrahedronMeshAnalysisResults.__cache__ = {};
Module['PxTetrahedronMeshAnalysisResults'] = PxTetrahedronMeshAnalysisResults;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshAnalysisResults.prototype['isSet'] = PxTetrahedronMeshAnalysisResults.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxTetrahedronMeshAnalysisResults_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshAnalysisResults.prototype['raise'] = PxTetrahedronMeshAnalysisResults.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxTetrahedronMeshAnalysisResults_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshAnalysisResults.prototype['clear'] = PxTetrahedronMeshAnalysisResults.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxTetrahedronMeshAnalysisResults_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshAnalysisResults.prototype['__destroy__'] = PxTetrahedronMeshAnalysisResults.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxTetrahedronMeshAnalysisResults___destroy___0(self);
};

// Interface: PxTetrahedronMeshDesc

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTetrahedronMeshDesc(meshVertices, meshTetIndices, meshFormat, numberOfTetsPerHexElement) {
  if (meshVertices && typeof meshVertices === 'object') meshVertices = meshVertices.ptr;
  if (meshTetIndices && typeof meshTetIndices === 'object') meshTetIndices = meshTetIndices.ptr;
  if (meshFormat && typeof meshFormat === 'object') meshFormat = meshFormat.ptr;
  if (numberOfTetsPerHexElement && typeof numberOfTetsPerHexElement === 'object') numberOfTetsPerHexElement = numberOfTetsPerHexElement.ptr;
  if (meshVertices === undefined) { this.ptr = _emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_0(); getCache(PxTetrahedronMeshDesc)[this.ptr] = this;return }
  if (meshTetIndices === undefined) { this.ptr = _emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_1(meshVertices); getCache(PxTetrahedronMeshDesc)[this.ptr] = this;return }
  if (meshFormat === undefined) { this.ptr = _emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_2(meshVertices, meshTetIndices); getCache(PxTetrahedronMeshDesc)[this.ptr] = this;return }
  if (numberOfTetsPerHexElement === undefined) { this.ptr = _emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_3(meshVertices, meshTetIndices, meshFormat); getCache(PxTetrahedronMeshDesc)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxTetrahedronMeshDesc_PxTetrahedronMeshDesc_4(meshVertices, meshTetIndices, meshFormat, numberOfTetsPerHexElement);
  getCache(PxTetrahedronMeshDesc)[this.ptr] = this;
};

PxTetrahedronMeshDesc.prototype = Object.create(WrapperObject.prototype);
PxTetrahedronMeshDesc.prototype.constructor = PxTetrahedronMeshDesc;
PxTetrahedronMeshDesc.prototype.__class__ = PxTetrahedronMeshDesc;
PxTetrahedronMeshDesc.__cache__ = {};
Module['PxTetrahedronMeshDesc'] = PxTetrahedronMeshDesc;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshDesc.prototype['isValid'] = PxTetrahedronMeshDesc.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxTetrahedronMeshDesc_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshDesc.prototype['get_materialIndices'] = PxTetrahedronMeshDesc.prototype.get_materialIndices = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTetrahedronMeshDesc_get_materialIndices_0(self), PxTypedBoundedData_PxU16);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshDesc.prototype['set_materialIndices'] = PxTetrahedronMeshDesc.prototype.set_materialIndices = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTetrahedronMeshDesc_set_materialIndices_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTetrahedronMeshDesc.prototype, 'materialIndices', { get: PxTetrahedronMeshDesc.prototype.get_materialIndices, set: PxTetrahedronMeshDesc.prototype.set_materialIndices });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshDesc.prototype['get_points'] = PxTetrahedronMeshDesc.prototype.get_points = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTetrahedronMeshDesc_get_points_0(self), PxBoundedData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshDesc.prototype['set_points'] = PxTetrahedronMeshDesc.prototype.set_points = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTetrahedronMeshDesc_set_points_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTetrahedronMeshDesc.prototype, 'points', { get: PxTetrahedronMeshDesc.prototype.get_points, set: PxTetrahedronMeshDesc.prototype.set_points });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshDesc.prototype['get_tetrahedrons'] = PxTetrahedronMeshDesc.prototype.get_tetrahedrons = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTetrahedronMeshDesc_get_tetrahedrons_0(self), PxBoundedData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshDesc.prototype['set_tetrahedrons'] = PxTetrahedronMeshDesc.prototype.set_tetrahedrons = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTetrahedronMeshDesc_set_tetrahedrons_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTetrahedronMeshDesc.prototype, 'tetrahedrons', { get: PxTetrahedronMeshDesc.prototype.get_tetrahedrons, set: PxTetrahedronMeshDesc.prototype.set_tetrahedrons });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshDesc.prototype['get_flags'] = PxTetrahedronMeshDesc.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTetrahedronMeshDesc_get_flags_0(self), PxMeshFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshDesc.prototype['set_flags'] = PxTetrahedronMeshDesc.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTetrahedronMeshDesc_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTetrahedronMeshDesc.prototype, 'flags', { get: PxTetrahedronMeshDesc.prototype.get_flags, set: PxTetrahedronMeshDesc.prototype.set_flags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshDesc.prototype['get_tetsPerElement'] = PxTetrahedronMeshDesc.prototype.get_tetsPerElement = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTetrahedronMeshDesc_get_tetsPerElement_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshDesc.prototype['set_tetsPerElement'] = PxTetrahedronMeshDesc.prototype.set_tetsPerElement = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTetrahedronMeshDesc_set_tetsPerElement_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTetrahedronMeshDesc.prototype, 'tetsPerElement', { get: PxTetrahedronMeshDesc.prototype.get_tetsPerElement, set: PxTetrahedronMeshDesc.prototype.set_tetsPerElement });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshDesc.prototype['__destroy__'] = PxTetrahedronMeshDesc.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxTetrahedronMeshDesc___destroy___0(self);
};

// Interface: PxTetrahedronMeshExt

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTetrahedronMeshExt() { throw "cannot construct a PxTetrahedronMeshExt, no constructor in IDL" }
PxTetrahedronMeshExt.prototype = Object.create(WrapperObject.prototype);
PxTetrahedronMeshExt.prototype.constructor = PxTetrahedronMeshExt;
PxTetrahedronMeshExt.prototype.__class__ = PxTetrahedronMeshExt;
PxTetrahedronMeshExt.__cache__ = {};
Module['PxTetrahedronMeshExt'] = PxTetrahedronMeshExt;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshExt.prototype['findTetrahedronContainingPoint'] = PxTetrahedronMeshExt.prototype.findTetrahedronContainingPoint = function(mesh, point, bary, tolerance) {
  if (mesh && typeof mesh === 'object') mesh = mesh.ptr;
  if (point && typeof point === 'object') point = point.ptr;
  if (bary && typeof bary === 'object') bary = bary.ptr;
  if (tolerance && typeof tolerance === 'object') tolerance = tolerance.ptr;
  return _emscripten_bind_PxTetrahedronMeshExt_findTetrahedronContainingPoint_4(mesh, point, bary, tolerance);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshExt.prototype['findTetrahedronClosestToPoint'] = PxTetrahedronMeshExt.prototype.findTetrahedronClosestToPoint = function(mesh, point, bary) {
  if (mesh && typeof mesh === 'object') mesh = mesh.ptr;
  if (point && typeof point === 'object') point = point.ptr;
  if (bary && typeof bary === 'object') bary = bary.ptr;
  return _emscripten_bind_PxTetrahedronMeshExt_findTetrahedronClosestToPoint_3(mesh, point, bary);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshExt.prototype['createPointsToTetrahedronMap'] = PxTetrahedronMeshExt.prototype.createPointsToTetrahedronMap = function(tetMeshVertices, tetMeshIndices, pointsToEmbed, barycentricCoordinates, tetLinks) {
  if (tetMeshVertices && typeof tetMeshVertices === 'object') tetMeshVertices = tetMeshVertices.ptr;
  if (tetMeshIndices && typeof tetMeshIndices === 'object') tetMeshIndices = tetMeshIndices.ptr;
  if (pointsToEmbed && typeof pointsToEmbed === 'object') pointsToEmbed = pointsToEmbed.ptr;
  if (barycentricCoordinates && typeof barycentricCoordinates === 'object') barycentricCoordinates = barycentricCoordinates.ptr;
  if (tetLinks && typeof tetLinks === 'object') tetLinks = tetLinks.ptr;
  _emscripten_bind_PxTetrahedronMeshExt_createPointsToTetrahedronMap_5(tetMeshVertices, tetMeshIndices, pointsToEmbed, barycentricCoordinates, tetLinks);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshExt.prototype['extractTetMeshSurface'] = PxTetrahedronMeshExt.prototype.extractTetMeshSurface = function(mesh, surfaceTriangles, surfaceTriangleToTet, flipTriangleOrientation) {
  if (mesh && typeof mesh === 'object') mesh = mesh.ptr;
  if (surfaceTriangles && typeof surfaceTriangles === 'object') surfaceTriangles = surfaceTriangles.ptr;
  if (surfaceTriangleToTet && typeof surfaceTriangleToTet === 'object') surfaceTriangleToTet = surfaceTriangleToTet.ptr;
  if (flipTriangleOrientation && typeof flipTriangleOrientation === 'object') flipTriangleOrientation = flipTriangleOrientation.ptr;
  if (surfaceTriangleToTet === undefined) { _emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_2(mesh, surfaceTriangles); return }
  if (flipTriangleOrientation === undefined) { _emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_3(mesh, surfaceTriangles, surfaceTriangleToTet); return }
  _emscripten_bind_PxTetrahedronMeshExt_extractTetMeshSurface_4(mesh, surfaceTriangles, surfaceTriangleToTet, flipTriangleOrientation);
};


// Interface: PxTetrahedronMeshFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTetrahedronMeshFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxTetrahedronMeshFlags_PxTetrahedronMeshFlags_1(flags);
  getCache(PxTetrahedronMeshFlags)[this.ptr] = this;
};

PxTetrahedronMeshFlags.prototype = Object.create(WrapperObject.prototype);
PxTetrahedronMeshFlags.prototype.constructor = PxTetrahedronMeshFlags;
PxTetrahedronMeshFlags.prototype.__class__ = PxTetrahedronMeshFlags;
PxTetrahedronMeshFlags.__cache__ = {};
Module['PxTetrahedronMeshFlags'] = PxTetrahedronMeshFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshFlags.prototype['isSet'] = PxTetrahedronMeshFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxTetrahedronMeshFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshFlags.prototype['raise'] = PxTetrahedronMeshFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxTetrahedronMeshFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshFlags.prototype['clear'] = PxTetrahedronMeshFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxTetrahedronMeshFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshFlags.prototype['__destroy__'] = PxTetrahedronMeshFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxTetrahedronMeshFlags___destroy___0(self);
};

// Interface: PxTetrahedronMeshGeometry

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTetrahedronMeshGeometry(mesh) {
  if (mesh && typeof mesh === 'object') mesh = mesh.ptr;
  this.ptr = _emscripten_bind_PxTetrahedronMeshGeometry_PxTetrahedronMeshGeometry_1(mesh);
  getCache(PxTetrahedronMeshGeometry)[this.ptr] = this;
};

PxTetrahedronMeshGeometry.prototype = Object.create(PxGeometry.prototype);
PxTetrahedronMeshGeometry.prototype.constructor = PxTetrahedronMeshGeometry;
PxTetrahedronMeshGeometry.prototype.__class__ = PxTetrahedronMeshGeometry;
PxTetrahedronMeshGeometry.__cache__ = {};
Module['PxTetrahedronMeshGeometry'] = PxTetrahedronMeshGeometry;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshGeometry.prototype['isValid'] = PxTetrahedronMeshGeometry.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxTetrahedronMeshGeometry_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshGeometry.prototype['getType'] = PxTetrahedronMeshGeometry.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTetrahedronMeshGeometry_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshGeometry.prototype['get_tetrahedronMesh'] = PxTetrahedronMeshGeometry.prototype.get_tetrahedronMesh = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTetrahedronMeshGeometry_get_tetrahedronMesh_0(self), PxTetrahedronMesh);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTetrahedronMeshGeometry.prototype['set_tetrahedronMesh'] = PxTetrahedronMeshGeometry.prototype.set_tetrahedronMesh = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTetrahedronMeshGeometry_set_tetrahedronMesh_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTetrahedronMeshGeometry.prototype, 'tetrahedronMesh', { get: PxTetrahedronMeshGeometry.prototype.get_tetrahedronMesh, set: PxTetrahedronMeshGeometry.prototype.set_tetrahedronMesh });

// Interface: PxTolerancesScale

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTolerancesScale() {
  this.ptr = _emscripten_bind_PxTolerancesScale_PxTolerancesScale_0();
  getCache(PxTolerancesScale)[this.ptr] = this;
};

PxTolerancesScale.prototype = Object.create(WrapperObject.prototype);
PxTolerancesScale.prototype.constructor = PxTolerancesScale;
PxTolerancesScale.prototype.__class__ = PxTolerancesScale;
PxTolerancesScale.__cache__ = {};
Module['PxTolerancesScale'] = PxTolerancesScale;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTolerancesScale.prototype['isValid'] = PxTolerancesScale.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxTolerancesScale_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTolerancesScale.prototype['get_length'] = PxTolerancesScale.prototype.get_length = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTolerancesScale_get_length_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTolerancesScale.prototype['set_length'] = PxTolerancesScale.prototype.set_length = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTolerancesScale_set_length_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTolerancesScale.prototype, 'length', { get: PxTolerancesScale.prototype.get_length, set: PxTolerancesScale.prototype.set_length });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTolerancesScale.prototype['get_speed'] = PxTolerancesScale.prototype.get_speed = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTolerancesScale_get_speed_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTolerancesScale.prototype['set_speed'] = PxTolerancesScale.prototype.set_speed = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTolerancesScale_set_speed_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTolerancesScale.prototype, 'speed', { get: PxTolerancesScale.prototype.get_speed, set: PxTolerancesScale.prototype.set_speed });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTolerancesScale.prototype['__destroy__'] = PxTolerancesScale.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxTolerancesScale___destroy___0(self);
};

// Interface: PxTopLevelFunctions

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTopLevelFunctions() { throw "cannot construct a PxTopLevelFunctions, no constructor in IDL" }
PxTopLevelFunctions.prototype = Object.create(WrapperObject.prototype);
PxTopLevelFunctions.prototype.constructor = PxTopLevelFunctions;
PxTopLevelFunctions.prototype.__class__ = PxTopLevelFunctions;
PxTopLevelFunctions.__cache__ = {};
Module['PxTopLevelFunctions'] = PxTopLevelFunctions;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['DefaultFilterShader'] = PxTopLevelFunctions.prototype.DefaultFilterShader = function() {
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_DefaultFilterShader_0(), PxSimulationFilterShader);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['setupPassThroughFilterShader'] = PxTopLevelFunctions.prototype.setupPassThroughFilterShader = function(sceneDesc, filterShader) {
  if (sceneDesc && typeof sceneDesc === 'object') sceneDesc = sceneDesc.ptr;
  if (filterShader && typeof filterShader === 'object') filterShader = filterShader.ptr;
  _emscripten_bind_PxTopLevelFunctions_setupPassThroughFilterShader_2(sceneDesc, filterShader);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CreateControllerManager'] = PxTopLevelFunctions.prototype.CreateControllerManager = function(scene, lockingEnabled) {
  if (scene && typeof scene === 'object') scene = scene.ptr;
  if (lockingEnabled && typeof lockingEnabled === 'object') lockingEnabled = lockingEnabled.ptr;
  if (lockingEnabled === undefined) { return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreateControllerManager_1(scene), PxControllerManager) }
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreateControllerManager_2(scene, lockingEnabled), PxControllerManager);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CreateFoundation'] = PxTopLevelFunctions.prototype.CreateFoundation = function(version, allocator, errorCallback) {
  if (version && typeof version === 'object') version = version.ptr;
  if (allocator && typeof allocator === 'object') allocator = allocator.ptr;
  if (errorCallback && typeof errorCallback === 'object') errorCallback = errorCallback.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreateFoundation_3(version, allocator, errorCallback), PxFoundation);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CreatePhysics'] = PxTopLevelFunctions.prototype.CreatePhysics = function(version, foundation, params, pvd, omniPvd) {
  if (version && typeof version === 'object') version = version.ptr;
  if (foundation && typeof foundation === 'object') foundation = foundation.ptr;
  if (params && typeof params === 'object') params = params.ptr;
  if (pvd && typeof pvd === 'object') pvd = pvd.ptr;
  if (omniPvd && typeof omniPvd === 'object') omniPvd = omniPvd.ptr;
  if (pvd === undefined) { return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreatePhysics_3(version, foundation, params), PxPhysics) }
  if (omniPvd === undefined) { return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreatePhysics_4(version, foundation, params, pvd), PxPhysics) }
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreatePhysics_5(version, foundation, params, pvd, omniPvd), PxPhysics);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['DefaultCpuDispatcherCreate'] = PxTopLevelFunctions.prototype.DefaultCpuDispatcherCreate = function(numThreads) {
  if (numThreads && typeof numThreads === 'object') numThreads = numThreads.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_DefaultCpuDispatcherCreate_1(numThreads), PxDefaultCpuDispatcher);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['InitExtensions'] = PxTopLevelFunctions.prototype.InitExtensions = function(physics) {
  if (physics && typeof physics === 'object') physics = physics.ptr;
  return !!(_emscripten_bind_PxTopLevelFunctions_InitExtensions_1(physics));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CloseExtensions'] = PxTopLevelFunctions.prototype.CloseExtensions = function() {
  _emscripten_bind_PxTopLevelFunctions_CloseExtensions_0();
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CreatePvd'] = PxTopLevelFunctions.prototype.CreatePvd = function(foundation) {
  if (foundation && typeof foundation === 'object') foundation = foundation.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreatePvd_1(foundation), PxPvd);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['D6JointCreate'] = PxTopLevelFunctions.prototype.D6JointCreate = function(physics, actor0, localFrame0, actor1, localFrame1) {
  if (physics && typeof physics === 'object') physics = physics.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (localFrame0 && typeof localFrame0 === 'object') localFrame0 = localFrame0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  if (localFrame1 && typeof localFrame1 === 'object') localFrame1 = localFrame1.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_D6JointCreate_5(physics, actor0, localFrame0, actor1, localFrame1), PxD6Joint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['DistanceJointCreate'] = PxTopLevelFunctions.prototype.DistanceJointCreate = function(physics, actor0, localFrame0, actor1, localFrame1) {
  if (physics && typeof physics === 'object') physics = physics.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (localFrame0 && typeof localFrame0 === 'object') localFrame0 = localFrame0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  if (localFrame1 && typeof localFrame1 === 'object') localFrame1 = localFrame1.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_DistanceJointCreate_5(physics, actor0, localFrame0, actor1, localFrame1), PxDistanceJoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['FixedJointCreate'] = PxTopLevelFunctions.prototype.FixedJointCreate = function(physics, actor0, localFrame0, actor1, localFrame1) {
  if (physics && typeof physics === 'object') physics = physics.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (localFrame0 && typeof localFrame0 === 'object') localFrame0 = localFrame0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  if (localFrame1 && typeof localFrame1 === 'object') localFrame1 = localFrame1.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_FixedJointCreate_5(physics, actor0, localFrame0, actor1, localFrame1), PxFixedJoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['GearJointCreate'] = PxTopLevelFunctions.prototype.GearJointCreate = function(physics, actor0, localFrame0, actor1, localFrame1) {
  if (physics && typeof physics === 'object') physics = physics.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (localFrame0 && typeof localFrame0 === 'object') localFrame0 = localFrame0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  if (localFrame1 && typeof localFrame1 === 'object') localFrame1 = localFrame1.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_GearJointCreate_5(physics, actor0, localFrame0, actor1, localFrame1), PxGearJoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['PrismaticJointCreate'] = PxTopLevelFunctions.prototype.PrismaticJointCreate = function(physics, actor0, localFrame0, actor1, localFrame1) {
  if (physics && typeof physics === 'object') physics = physics.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (localFrame0 && typeof localFrame0 === 'object') localFrame0 = localFrame0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  if (localFrame1 && typeof localFrame1 === 'object') localFrame1 = localFrame1.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_PrismaticJointCreate_5(physics, actor0, localFrame0, actor1, localFrame1), PxPrismaticJoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['RackAndPinionJointCreate'] = PxTopLevelFunctions.prototype.RackAndPinionJointCreate = function(physics, actor0, localFrame0, actor1, localFrame1) {
  if (physics && typeof physics === 'object') physics = physics.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (localFrame0 && typeof localFrame0 === 'object') localFrame0 = localFrame0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  if (localFrame1 && typeof localFrame1 === 'object') localFrame1 = localFrame1.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_RackAndPinionJointCreate_5(physics, actor0, localFrame0, actor1, localFrame1), PxRackAndPinionJoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['RevoluteJointCreate'] = PxTopLevelFunctions.prototype.RevoluteJointCreate = function(physics, actor0, localFrame0, actor1, localFrame1) {
  if (physics && typeof physics === 'object') physics = physics.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (localFrame0 && typeof localFrame0 === 'object') localFrame0 = localFrame0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  if (localFrame1 && typeof localFrame1 === 'object') localFrame1 = localFrame1.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_RevoluteJointCreate_5(physics, actor0, localFrame0, actor1, localFrame1), PxRevoluteJoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['SphericalJointCreate'] = PxTopLevelFunctions.prototype.SphericalJointCreate = function(physics, actor0, localFrame0, actor1, localFrame1) {
  if (physics && typeof physics === 'object') physics = physics.ptr;
  if (actor0 && typeof actor0 === 'object') actor0 = actor0.ptr;
  if (localFrame0 && typeof localFrame0 === 'object') localFrame0 = localFrame0.ptr;
  if (actor1 && typeof actor1 === 'object') actor1 = actor1.ptr;
  if (localFrame1 && typeof localFrame1 === 'object') localFrame1 = localFrame1.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_SphericalJointCreate_5(physics, actor0, localFrame0, actor1, localFrame1), PxSphericalJoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CreateConvexMesh'] = PxTopLevelFunctions.prototype.CreateConvexMesh = function(params, desc) {
  if (params && typeof params === 'object') params = params.ptr;
  if (desc && typeof desc === 'object') desc = desc.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreateConvexMesh_2(params, desc), PxConvexMesh);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CreateTriangleMesh'] = PxTopLevelFunctions.prototype.CreateTriangleMesh = function(params, desc) {
  if (params && typeof params === 'object') params = params.ptr;
  if (desc && typeof desc === 'object') desc = desc.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreateTriangleMesh_2(params, desc), PxTriangleMesh);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CreateHeightField'] = PxTopLevelFunctions.prototype.CreateHeightField = function(desc) {
  if (desc && typeof desc === 'object') desc = desc.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreateHeightField_1(desc), PxHeightField);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CookTriangleMesh'] = PxTopLevelFunctions.prototype.CookTriangleMesh = function(params, desc, stream) {
  if (params && typeof params === 'object') params = params.ptr;
  if (desc && typeof desc === 'object') desc = desc.ptr;
  if (stream && typeof stream === 'object') stream = stream.ptr;
  return !!(_emscripten_bind_PxTopLevelFunctions_CookTriangleMesh_3(params, desc, stream));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CookConvexMesh'] = PxTopLevelFunctions.prototype.CookConvexMesh = function(params, desc, stream) {
  if (params && typeof params === 'object') params = params.ptr;
  if (desc && typeof desc === 'object') desc = desc.ptr;
  if (stream && typeof stream === 'object') stream = stream.ptr;
  return !!(_emscripten_bind_PxTopLevelFunctions_CookConvexMesh_3(params, desc, stream));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CreateDynamicFromShape'] = PxTopLevelFunctions.prototype.CreateDynamicFromShape = function(sdk, transform, shape, density) {
  if (sdk && typeof sdk === 'object') sdk = sdk.ptr;
  if (transform && typeof transform === 'object') transform = transform.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (density && typeof density === 'object') density = density.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreateDynamicFromShape_4(sdk, transform, shape, density), PxRigidDynamic);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CreateDynamic'] = PxTopLevelFunctions.prototype.CreateDynamic = function(sdk, transform, geometry, material, density, shapeOffset) {
  if (sdk && typeof sdk === 'object') sdk = sdk.ptr;
  if (transform && typeof transform === 'object') transform = transform.ptr;
  if (geometry && typeof geometry === 'object') geometry = geometry.ptr;
  if (material && typeof material === 'object') material = material.ptr;
  if (density && typeof density === 'object') density = density.ptr;
  if (shapeOffset && typeof shapeOffset === 'object') shapeOffset = shapeOffset.ptr;
  if (shapeOffset === undefined) { return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreateDynamic_5(sdk, transform, geometry, material, density), PxRigidDynamic) }
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreateDynamic_6(sdk, transform, geometry, material, density, shapeOffset), PxRigidDynamic);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CreateKinematicFromShape'] = PxTopLevelFunctions.prototype.CreateKinematicFromShape = function(sdk, transform, shape, density) {
  if (sdk && typeof sdk === 'object') sdk = sdk.ptr;
  if (transform && typeof transform === 'object') transform = transform.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  if (density && typeof density === 'object') density = density.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreateKinematicFromShape_4(sdk, transform, shape, density), PxRigidDynamic);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CreateKinematic'] = PxTopLevelFunctions.prototype.CreateKinematic = function(sdk, transform, geometry, material, density, shapeOffset) {
  if (sdk && typeof sdk === 'object') sdk = sdk.ptr;
  if (transform && typeof transform === 'object') transform = transform.ptr;
  if (geometry && typeof geometry === 'object') geometry = geometry.ptr;
  if (material && typeof material === 'object') material = material.ptr;
  if (density && typeof density === 'object') density = density.ptr;
  if (shapeOffset && typeof shapeOffset === 'object') shapeOffset = shapeOffset.ptr;
  if (shapeOffset === undefined) { return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreateKinematic_5(sdk, transform, geometry, material, density), PxRigidDynamic) }
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreateKinematic_6(sdk, transform, geometry, material, density, shapeOffset), PxRigidDynamic);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CreateStaticFromShape'] = PxTopLevelFunctions.prototype.CreateStaticFromShape = function(sdk, transform, shape) {
  if (sdk && typeof sdk === 'object') sdk = sdk.ptr;
  if (transform && typeof transform === 'object') transform = transform.ptr;
  if (shape && typeof shape === 'object') shape = shape.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreateStaticFromShape_3(sdk, transform, shape), PxRigidStatic);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CreateStatic'] = PxTopLevelFunctions.prototype.CreateStatic = function(sdk, transform, geometry, material, shapeOffset) {
  if (sdk && typeof sdk === 'object') sdk = sdk.ptr;
  if (transform && typeof transform === 'object') transform = transform.ptr;
  if (geometry && typeof geometry === 'object') geometry = geometry.ptr;
  if (material && typeof material === 'object') material = material.ptr;
  if (shapeOffset && typeof shapeOffset === 'object') shapeOffset = shapeOffset.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreateStatic_5(sdk, transform, geometry, material, shapeOffset), PxRigidStatic);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CreatePlane'] = PxTopLevelFunctions.prototype.CreatePlane = function(sdk, plane, material) {
  if (sdk && typeof sdk === 'object') sdk = sdk.ptr;
  if (plane && typeof plane === 'object') plane = plane.ptr;
  if (material && typeof material === 'object') material = material.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CreatePlane_3(sdk, plane, material), PxRigidStatic);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CloneShape'] = PxTopLevelFunctions.prototype.CloneShape = function(physics, from, isExclusive) {
  if (physics && typeof physics === 'object') physics = physics.ptr;
  if (from && typeof from === 'object') from = from.ptr;
  if (isExclusive && typeof isExclusive === 'object') isExclusive = isExclusive.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CloneShape_3(physics, from, isExclusive), PxShape);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CloneStatic'] = PxTopLevelFunctions.prototype.CloneStatic = function(physicsSDK, transform, from) {
  if (physicsSDK && typeof physicsSDK === 'object') physicsSDK = physicsSDK.ptr;
  if (transform && typeof transform === 'object') transform = transform.ptr;
  if (from && typeof from === 'object') from = from.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CloneStatic_3(physicsSDK, transform, from), PxRigidStatic);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['CloneDynamic'] = PxTopLevelFunctions.prototype.CloneDynamic = function(physicsSDK, transform, from) {
  if (physicsSDK && typeof physicsSDK === 'object') physicsSDK = physicsSDK.ptr;
  if (transform && typeof transform === 'object') transform = transform.ptr;
  if (from && typeof from === 'object') from = from.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_CloneDynamic_3(physicsSDK, transform, from), PxRigidDynamic);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['ScaleRigidActor'] = PxTopLevelFunctions.prototype.ScaleRigidActor = function(actor, scale, scaleMassProps) {
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (scale && typeof scale === 'object') scale = scale.ptr;
  if (scaleMassProps && typeof scaleMassProps === 'object') scaleMassProps = scaleMassProps.ptr;
  _emscripten_bind_PxTopLevelFunctions_ScaleRigidActor_3(actor, scale, scaleMassProps);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['IntegrateTransform'] = PxTopLevelFunctions.prototype.IntegrateTransform = function(curTrans, linvel, angvel, timeStep, result) {
  if (curTrans && typeof curTrans === 'object') curTrans = curTrans.ptr;
  if (linvel && typeof linvel === 'object') linvel = linvel.ptr;
  if (angvel && typeof angvel === 'object') angvel = angvel.ptr;
  if (timeStep && typeof timeStep === 'object') timeStep = timeStep.ptr;
  if (result && typeof result === 'object') result = result.ptr;
  _emscripten_bind_PxTopLevelFunctions_IntegrateTransform_5(curTrans, linvel, angvel, timeStep, result);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['GetTriangleMeshSDFDimensions'] = PxTopLevelFunctions.prototype.GetTriangleMeshSDFDimensions = function(mesh) {
  if (mesh && typeof mesh === 'object') mesh = mesh.ptr;
  return wrapPointer(_emscripten_bind_PxTopLevelFunctions_GetTriangleMeshSDFDimensions_1(mesh), PxDim3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTopLevelFunctions.prototype['get_PHYSICS_VERSION'] = PxTopLevelFunctions.prototype.get_PHYSICS_VERSION = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTopLevelFunctions_get_PHYSICS_VERSION_0(self);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTopLevelFunctions.prototype, 'PHYSICS_VERSION', { get: PxTopLevelFunctions.prototype.get_PHYSICS_VERSION });

// Interface: PxTransform

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTransform(p0, q0) {
  if (p0 && typeof p0 === 'object') p0 = p0.ptr;
  if (q0 && typeof q0 === 'object') q0 = q0.ptr;
  if (p0 === undefined) { this.ptr = _emscripten_bind_PxTransform_PxTransform_0(); getCache(PxTransform)[this.ptr] = this;return }
  if (q0 === undefined) { this.ptr = _emscripten_bind_PxTransform_PxTransform_1(p0); getCache(PxTransform)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxTransform_PxTransform_2(p0, q0);
  getCache(PxTransform)[this.ptr] = this;
};

PxTransform.prototype = Object.create(WrapperObject.prototype);
PxTransform.prototype.constructor = PxTransform;
PxTransform.prototype.__class__ = PxTransform;
PxTransform.__cache__ = {};
Module['PxTransform'] = PxTransform;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTransform.prototype['getInverse'] = PxTransform.prototype.getInverse = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTransform_getInverse_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTransform.prototype['transform'] = PxTransform.prototype.transform = function(input) {
  var self = this.ptr;
  if (input && typeof input === 'object') input = input.ptr;
  return wrapPointer(_emscripten_bind_PxTransform_transform_1(self, input), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTransform.prototype['transformInv'] = PxTransform.prototype.transformInv = function(input) {
  var self = this.ptr;
  if (input && typeof input === 'object') input = input.ptr;
  return wrapPointer(_emscripten_bind_PxTransform_transformInv_1(self, input), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTransform.prototype['isValid'] = PxTransform.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxTransform_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTransform.prototype['isSane'] = PxTransform.prototype.isSane = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxTransform_isSane_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTransform.prototype['isFinite'] = PxTransform.prototype.isFinite = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxTransform_isFinite_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTransform.prototype['getNormalized'] = PxTransform.prototype.getNormalized = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTransform_getNormalized_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTransform.prototype['get_q'] = PxTransform.prototype.get_q = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTransform_get_q_0(self), PxQuat);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTransform.prototype['set_q'] = PxTransform.prototype.set_q = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTransform_set_q_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTransform.prototype, 'q', { get: PxTransform.prototype.get_q, set: PxTransform.prototype.set_q });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTransform.prototype['get_p'] = PxTransform.prototype.get_p = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTransform_get_p_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTransform.prototype['set_p'] = PxTransform.prototype.set_p = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTransform_set_p_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTransform.prototype, 'p', { get: PxTransform.prototype.get_p, set: PxTransform.prototype.set_p });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTransform.prototype['__destroy__'] = PxTransform.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxTransform___destroy___0(self);
};

// Interface: PxTriangle

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTriangle(p0, p1, p2) {
  if (p0 && typeof p0 === 'object') p0 = p0.ptr;
  if (p1 && typeof p1 === 'object') p1 = p1.ptr;
  if (p2 && typeof p2 === 'object') p2 = p2.ptr;
  if (p0 === undefined) { this.ptr = _emscripten_bind_PxTriangle_PxTriangle_0(); getCache(PxTriangle)[this.ptr] = this;return }
  if (p1 === undefined) { this.ptr = _emscripten_bind_PxTriangle_PxTriangle_1(p0); getCache(PxTriangle)[this.ptr] = this;return }
  if (p2 === undefined) { this.ptr = _emscripten_bind_PxTriangle_PxTriangle_2(p0, p1); getCache(PxTriangle)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxTriangle_PxTriangle_3(p0, p1, p2);
  getCache(PxTriangle)[this.ptr] = this;
};

PxTriangle.prototype = Object.create(WrapperObject.prototype);
PxTriangle.prototype.constructor = PxTriangle;
PxTriangle.prototype.__class__ = PxTriangle;
PxTriangle.__cache__ = {};
Module['PxTriangle'] = PxTriangle;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangle.prototype['normal'] = PxTriangle.prototype.normal = function(normal) {
  var self = this.ptr;
  if (normal && typeof normal === 'object') normal = normal.ptr;
  _emscripten_bind_PxTriangle_normal_1(self, normal);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangle.prototype['denormalizedNormal'] = PxTriangle.prototype.denormalizedNormal = function(normal) {
  var self = this.ptr;
  if (normal && typeof normal === 'object') normal = normal.ptr;
  _emscripten_bind_PxTriangle_denormalizedNormal_1(self, normal);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangle.prototype['area'] = PxTriangle.prototype.area = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTriangle_area_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangle.prototype['pointFromUV'] = PxTriangle.prototype.pointFromUV = function(u, v) {
  var self = this.ptr;
  if (u && typeof u === 'object') u = u.ptr;
  if (v && typeof v === 'object') v = v.ptr;
  return wrapPointer(_emscripten_bind_PxTriangle_pointFromUV_2(self, u, v), PxVec3);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangle.prototype['__destroy__'] = PxTriangle.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxTriangle___destroy___0(self);
};

// Interface: PxTriangleMesh

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTriangleMesh() { throw "cannot construct a PxTriangleMesh, no constructor in IDL" }
PxTriangleMesh.prototype = Object.create(PxRefCounted.prototype);
PxTriangleMesh.prototype.constructor = PxTriangleMesh;
PxTriangleMesh.prototype.__class__ = PxTriangleMesh;
PxTriangleMesh.__cache__ = {};
Module['PxTriangleMesh'] = PxTriangleMesh;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['getNbVertices'] = PxTriangleMesh.prototype.getNbVertices = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTriangleMesh_getNbVertices_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['getVertices'] = PxTriangleMesh.prototype.getVertices = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMesh_getVertices_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['getVerticesForModification'] = PxTriangleMesh.prototype.getVerticesForModification = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMesh_getVerticesForModification_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['refitBVH'] = PxTriangleMesh.prototype.refitBVH = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMesh_refitBVH_0(self), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['getNbTriangles'] = PxTriangleMesh.prototype.getNbTriangles = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTriangleMesh_getNbTriangles_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['getTriangles'] = PxTriangleMesh.prototype.getTriangles = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMesh_getTriangles_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['getTriangleMeshFlags'] = PxTriangleMesh.prototype.getTriangleMeshFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMesh_getTriangleMeshFlags_0(self), PxTriangleMeshFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['getTrianglesRemap'] = PxTriangleMesh.prototype.getTrianglesRemap = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMesh_getTrianglesRemap_0(self), PxU32ConstPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['getTriangleMaterialIndex'] = PxTriangleMesh.prototype.getTriangleMaterialIndex = function(triangleIndex) {
  var self = this.ptr;
  if (triangleIndex && typeof triangleIndex === 'object') triangleIndex = triangleIndex.ptr;
  return _emscripten_bind_PxTriangleMesh_getTriangleMaterialIndex_1(self, triangleIndex);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['getLocalBounds'] = PxTriangleMesh.prototype.getLocalBounds = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMesh_getLocalBounds_0(self), PxBounds3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['getSDF'] = PxTriangleMesh.prototype.getSDF = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMesh_getSDF_0(self), PxRealConstPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['setPreferSDFProjection'] = PxTriangleMesh.prototype.setPreferSDFProjection = function(prefer) {
  var self = this.ptr;
  if (prefer && typeof prefer === 'object') prefer = prefer.ptr;
  _emscripten_bind_PxTriangleMesh_setPreferSDFProjection_1(self, prefer);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['release'] = PxTriangleMesh.prototype.release = function() {
  var self = this.ptr;
  _emscripten_bind_PxTriangleMesh_release_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['getConcreteTypeName'] = PxTriangleMesh.prototype.getConcreteTypeName = function() {
  var self = this.ptr;
  return UTF8ToString(_emscripten_bind_PxTriangleMesh_getConcreteTypeName_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['getConcreteType'] = PxTriangleMesh.prototype.getConcreteType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTriangleMesh_getConcreteType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['setBaseFlag'] = PxTriangleMesh.prototype.setBaseFlag = function(flag, value) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxTriangleMesh_setBaseFlag_2(self, flag, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['setBaseFlags'] = PxTriangleMesh.prototype.setBaseFlags = function(inFlags) {
  var self = this.ptr;
  if (inFlags && typeof inFlags === 'object') inFlags = inFlags.ptr;
  _emscripten_bind_PxTriangleMesh_setBaseFlags_1(self, inFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['getBaseFlags'] = PxTriangleMesh.prototype.getBaseFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMesh_getBaseFlags_0(self), PxBaseFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['isReleasable'] = PxTriangleMesh.prototype.isReleasable = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxTriangleMesh_isReleasable_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['getReferenceCount'] = PxTriangleMesh.prototype.getReferenceCount = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTriangleMesh_getReferenceCount_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMesh.prototype['acquireReference'] = PxTriangleMesh.prototype.acquireReference = function() {
  var self = this.ptr;
  _emscripten_bind_PxTriangleMesh_acquireReference_0(self);
};


// Interface: PxTriangleMeshAnalysisResults

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTriangleMeshAnalysisResults(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxTriangleMeshAnalysisResults_PxTriangleMeshAnalysisResults_1(flags);
  getCache(PxTriangleMeshAnalysisResults)[this.ptr] = this;
};

PxTriangleMeshAnalysisResults.prototype = Object.create(WrapperObject.prototype);
PxTriangleMeshAnalysisResults.prototype.constructor = PxTriangleMeshAnalysisResults;
PxTriangleMeshAnalysisResults.prototype.__class__ = PxTriangleMeshAnalysisResults;
PxTriangleMeshAnalysisResults.__cache__ = {};
Module['PxTriangleMeshAnalysisResults'] = PxTriangleMeshAnalysisResults;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshAnalysisResults.prototype['isSet'] = PxTriangleMeshAnalysisResults.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxTriangleMeshAnalysisResults_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshAnalysisResults.prototype['raise'] = PxTriangleMeshAnalysisResults.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxTriangleMeshAnalysisResults_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshAnalysisResults.prototype['clear'] = PxTriangleMeshAnalysisResults.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxTriangleMeshAnalysisResults_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshAnalysisResults.prototype['__destroy__'] = PxTriangleMeshAnalysisResults.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxTriangleMeshAnalysisResults___destroy___0(self);
};

// Interface: PxTriangleMeshDesc

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTriangleMeshDesc() {
  this.ptr = _emscripten_bind_PxTriangleMeshDesc_PxTriangleMeshDesc_0();
  getCache(PxTriangleMeshDesc)[this.ptr] = this;
};

PxTriangleMeshDesc.prototype = Object.create(PxSimpleTriangleMesh.prototype);
PxTriangleMeshDesc.prototype.constructor = PxTriangleMeshDesc;
PxTriangleMeshDesc.prototype.__class__ = PxTriangleMeshDesc;
PxTriangleMeshDesc.__cache__ = {};
Module['PxTriangleMeshDesc'] = PxTriangleMeshDesc;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshDesc.prototype['setToDefault'] = PxTriangleMeshDesc.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxTriangleMeshDesc_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshDesc.prototype['isValid'] = PxTriangleMeshDesc.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxTriangleMeshDesc_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshDesc.prototype['get_materialIndices'] = PxTriangleMeshDesc.prototype.get_materialIndices = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMeshDesc_get_materialIndices_0(self), PxTypedBoundedData_PxU16Const);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshDesc.prototype['set_materialIndices'] = PxTriangleMeshDesc.prototype.set_materialIndices = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTriangleMeshDesc_set_materialIndices_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTriangleMeshDesc.prototype, 'materialIndices', { get: PxTriangleMeshDesc.prototype.get_materialIndices, set: PxTriangleMeshDesc.prototype.set_materialIndices });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshDesc.prototype['get_sdfDesc'] = PxTriangleMeshDesc.prototype.get_sdfDesc = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMeshDesc_get_sdfDesc_0(self), PxSDFDesc);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshDesc.prototype['set_sdfDesc'] = PxTriangleMeshDesc.prototype.set_sdfDesc = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTriangleMeshDesc_set_sdfDesc_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTriangleMeshDesc.prototype, 'sdfDesc', { get: PxTriangleMeshDesc.prototype.get_sdfDesc, set: PxTriangleMeshDesc.prototype.set_sdfDesc });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshDesc.prototype['get_points'] = PxTriangleMeshDesc.prototype.get_points = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMeshDesc_get_points_0(self), PxBoundedData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshDesc.prototype['set_points'] = PxTriangleMeshDesc.prototype.set_points = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTriangleMeshDesc_set_points_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTriangleMeshDesc.prototype, 'points', { get: PxTriangleMeshDesc.prototype.get_points, set: PxTriangleMeshDesc.prototype.set_points });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshDesc.prototype['get_triangles'] = PxTriangleMeshDesc.prototype.get_triangles = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMeshDesc_get_triangles_0(self), PxBoundedData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshDesc.prototype['set_triangles'] = PxTriangleMeshDesc.prototype.set_triangles = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTriangleMeshDesc_set_triangles_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTriangleMeshDesc.prototype, 'triangles', { get: PxTriangleMeshDesc.prototype.get_triangles, set: PxTriangleMeshDesc.prototype.set_triangles });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshDesc.prototype['get_flags'] = PxTriangleMeshDesc.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMeshDesc_get_flags_0(self), PxMeshFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshDesc.prototype['set_flags'] = PxTriangleMeshDesc.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTriangleMeshDesc_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTriangleMeshDesc.prototype, 'flags', { get: PxTriangleMeshDesc.prototype.get_flags, set: PxTriangleMeshDesc.prototype.set_flags });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshDesc.prototype['__destroy__'] = PxTriangleMeshDesc.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxTriangleMeshDesc___destroy___0(self);
};

// Interface: PxTriangleMeshFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTriangleMeshFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxTriangleMeshFlags_PxTriangleMeshFlags_1(flags);
  getCache(PxTriangleMeshFlags)[this.ptr] = this;
};

PxTriangleMeshFlags.prototype = Object.create(WrapperObject.prototype);
PxTriangleMeshFlags.prototype.constructor = PxTriangleMeshFlags;
PxTriangleMeshFlags.prototype.__class__ = PxTriangleMeshFlags;
PxTriangleMeshFlags.__cache__ = {};
Module['PxTriangleMeshFlags'] = PxTriangleMeshFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshFlags.prototype['isSet'] = PxTriangleMeshFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxTriangleMeshFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshFlags.prototype['raise'] = PxTriangleMeshFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxTriangleMeshFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshFlags.prototype['clear'] = PxTriangleMeshFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxTriangleMeshFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshFlags.prototype['__destroy__'] = PxTriangleMeshFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxTriangleMeshFlags___destroy___0(self);
};

// Interface: PxTriangleMeshGeometry

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTriangleMeshGeometry(mesh, scaling, flags) {
  if (mesh && typeof mesh === 'object') mesh = mesh.ptr;
  if (scaling && typeof scaling === 'object') scaling = scaling.ptr;
  if (flags && typeof flags === 'object') flags = flags.ptr;
  if (scaling === undefined) { this.ptr = _emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_1(mesh); getCache(PxTriangleMeshGeometry)[this.ptr] = this;return }
  if (flags === undefined) { this.ptr = _emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_2(mesh, scaling); getCache(PxTriangleMeshGeometry)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxTriangleMeshGeometry_PxTriangleMeshGeometry_3(mesh, scaling, flags);
  getCache(PxTriangleMeshGeometry)[this.ptr] = this;
};

PxTriangleMeshGeometry.prototype = Object.create(PxGeometry.prototype);
PxTriangleMeshGeometry.prototype.constructor = PxTriangleMeshGeometry;
PxTriangleMeshGeometry.prototype.__class__ = PxTriangleMeshGeometry;
PxTriangleMeshGeometry.__cache__ = {};
Module['PxTriangleMeshGeometry'] = PxTriangleMeshGeometry;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshGeometry.prototype['isValid'] = PxTriangleMeshGeometry.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxTriangleMeshGeometry_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshGeometry.prototype['getType'] = PxTriangleMeshGeometry.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTriangleMeshGeometry_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshGeometry.prototype['get_scale'] = PxTriangleMeshGeometry.prototype.get_scale = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMeshGeometry_get_scale_0(self), PxMeshScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshGeometry.prototype['set_scale'] = PxTriangleMeshGeometry.prototype.set_scale = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTriangleMeshGeometry_set_scale_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTriangleMeshGeometry.prototype, 'scale', { get: PxTriangleMeshGeometry.prototype.get_scale, set: PxTriangleMeshGeometry.prototype.set_scale });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshGeometry.prototype['get_meshFlags'] = PxTriangleMeshGeometry.prototype.get_meshFlags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMeshGeometry_get_meshFlags_0(self), PxMeshGeometryFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshGeometry.prototype['set_meshFlags'] = PxTriangleMeshGeometry.prototype.set_meshFlags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTriangleMeshGeometry_set_meshFlags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTriangleMeshGeometry.prototype, 'meshFlags', { get: PxTriangleMeshGeometry.prototype.get_meshFlags, set: PxTriangleMeshGeometry.prototype.set_meshFlags });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshGeometry.prototype['get_triangleMesh'] = PxTriangleMeshGeometry.prototype.get_triangleMesh = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriangleMeshGeometry_get_triangleMesh_0(self), PxTriangleMesh);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshGeometry.prototype['set_triangleMesh'] = PxTriangleMeshGeometry.prototype.set_triangleMesh = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTriangleMeshGeometry_set_triangleMesh_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTriangleMeshGeometry.prototype, 'triangleMesh', { get: PxTriangleMeshGeometry.prototype.get_triangleMesh, set: PxTriangleMeshGeometry.prototype.set_triangleMesh });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriangleMeshGeometry.prototype['__destroy__'] = PxTriangleMeshGeometry.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxTriangleMeshGeometry___destroy___0(self);
};

// Interface: PxTriggerPair

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTriggerPair() { throw "cannot construct a PxTriggerPair, no constructor in IDL" }
PxTriggerPair.prototype = Object.create(WrapperObject.prototype);
PxTriggerPair.prototype.constructor = PxTriggerPair;
PxTriggerPair.prototype.__class__ = PxTriggerPair;
PxTriggerPair.__cache__ = {};
Module['PxTriggerPair'] = PxTriggerPair;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPair.prototype['get_triggerShape'] = PxTriggerPair.prototype.get_triggerShape = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriggerPair_get_triggerShape_0(self), PxShape);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPair.prototype['set_triggerShape'] = PxTriggerPair.prototype.set_triggerShape = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTriggerPair_set_triggerShape_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTriggerPair.prototype, 'triggerShape', { get: PxTriggerPair.prototype.get_triggerShape, set: PxTriggerPair.prototype.set_triggerShape });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPair.prototype['get_triggerActor'] = PxTriggerPair.prototype.get_triggerActor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriggerPair_get_triggerActor_0(self), PxActor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPair.prototype['set_triggerActor'] = PxTriggerPair.prototype.set_triggerActor = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTriggerPair_set_triggerActor_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTriggerPair.prototype, 'triggerActor', { get: PxTriggerPair.prototype.get_triggerActor, set: PxTriggerPair.prototype.set_triggerActor });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPair.prototype['get_otherShape'] = PxTriggerPair.prototype.get_otherShape = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriggerPair_get_otherShape_0(self), PxShape);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPair.prototype['set_otherShape'] = PxTriggerPair.prototype.set_otherShape = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTriggerPair_set_otherShape_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTriggerPair.prototype, 'otherShape', { get: PxTriggerPair.prototype.get_otherShape, set: PxTriggerPair.prototype.set_otherShape });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPair.prototype['get_otherActor'] = PxTriggerPair.prototype.get_otherActor = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriggerPair_get_otherActor_0(self), PxActor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPair.prototype['set_otherActor'] = PxTriggerPair.prototype.set_otherActor = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTriggerPair_set_otherActor_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTriggerPair.prototype, 'otherActor', { get: PxTriggerPair.prototype.get_otherActor, set: PxTriggerPair.prototype.set_otherActor });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPair.prototype['get_status'] = PxTriggerPair.prototype.get_status = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTriggerPair_get_status_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPair.prototype['set_status'] = PxTriggerPair.prototype.set_status = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTriggerPair_set_status_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTriggerPair.prototype, 'status', { get: PxTriggerPair.prototype.get_status, set: PxTriggerPair.prototype.set_status });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPair.prototype['get_flags'] = PxTriggerPair.prototype.get_flags = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTriggerPair_get_flags_0(self), PxTriggerPairFlags);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPair.prototype['set_flags'] = PxTriggerPair.prototype.set_flags = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTriggerPair_set_flags_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTriggerPair.prototype, 'flags', { get: PxTriggerPair.prototype.get_flags, set: PxTriggerPair.prototype.set_flags });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPair.prototype['__destroy__'] = PxTriggerPair.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxTriggerPair___destroy___0(self);
};

// Interface: PxTriggerPairFlags

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTriggerPairFlags(flags) {
  if (flags && typeof flags === 'object') flags = flags.ptr;
  this.ptr = _emscripten_bind_PxTriggerPairFlags_PxTriggerPairFlags_1(flags);
  getCache(PxTriggerPairFlags)[this.ptr] = this;
};

PxTriggerPairFlags.prototype = Object.create(WrapperObject.prototype);
PxTriggerPairFlags.prototype.constructor = PxTriggerPairFlags;
PxTriggerPairFlags.prototype.__class__ = PxTriggerPairFlags;
PxTriggerPairFlags.__cache__ = {};
Module['PxTriggerPairFlags'] = PxTriggerPairFlags;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPairFlags.prototype['isSet'] = PxTriggerPairFlags.prototype.isSet = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  return !!(_emscripten_bind_PxTriggerPairFlags_isSet_1(self, flag));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPairFlags.prototype['raise'] = PxTriggerPairFlags.prototype.raise = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxTriggerPairFlags_raise_1(self, flag);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPairFlags.prototype['clear'] = PxTriggerPairFlags.prototype.clear = function(flag) {
  var self = this.ptr;
  if (flag && typeof flag === 'object') flag = flag.ptr;
  _emscripten_bind_PxTriggerPairFlags_clear_1(self, flag);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTriggerPairFlags.prototype['__destroy__'] = PxTriggerPairFlags.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxTriggerPairFlags___destroy___0(self);
};

// Interface: PxTypedBoundedData_PxU16

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTypedBoundedData_PxU16() { throw "cannot construct a PxTypedBoundedData_PxU16, no constructor in IDL" }
PxTypedBoundedData_PxU16.prototype = Object.create(WrapperObject.prototype);
PxTypedBoundedData_PxU16.prototype.constructor = PxTypedBoundedData_PxU16;
PxTypedBoundedData_PxU16.prototype.__class__ = PxTypedBoundedData_PxU16;
PxTypedBoundedData_PxU16.__cache__ = {};
Module['PxTypedBoundedData_PxU16'] = PxTypedBoundedData_PxU16;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTypedBoundedData_PxU16.prototype['get_stride'] = PxTypedBoundedData_PxU16.prototype.get_stride = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTypedBoundedData_PxU16_get_stride_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTypedBoundedData_PxU16.prototype['set_stride'] = PxTypedBoundedData_PxU16.prototype.set_stride = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTypedBoundedData_PxU16_set_stride_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTypedBoundedData_PxU16.prototype, 'stride', { get: PxTypedBoundedData_PxU16.prototype.get_stride, set: PxTypedBoundedData_PxU16.prototype.set_stride });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTypedBoundedData_PxU16.prototype['get_data'] = PxTypedBoundedData_PxU16.prototype.get_data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTypedBoundedData_PxU16_get_data_0(self), PxU16Ptr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTypedBoundedData_PxU16.prototype['set_data'] = PxTypedBoundedData_PxU16.prototype.set_data = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTypedBoundedData_PxU16_set_data_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTypedBoundedData_PxU16.prototype, 'data', { get: PxTypedBoundedData_PxU16.prototype.get_data, set: PxTypedBoundedData_PxU16.prototype.set_data });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTypedBoundedData_PxU16.prototype['__destroy__'] = PxTypedBoundedData_PxU16.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxTypedBoundedData_PxU16___destroy___0(self);
};

// Interface: PxTypedBoundedData_PxU16Const

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxTypedBoundedData_PxU16Const() { throw "cannot construct a PxTypedBoundedData_PxU16Const, no constructor in IDL" }
PxTypedBoundedData_PxU16Const.prototype = Object.create(WrapperObject.prototype);
PxTypedBoundedData_PxU16Const.prototype.constructor = PxTypedBoundedData_PxU16Const;
PxTypedBoundedData_PxU16Const.prototype.__class__ = PxTypedBoundedData_PxU16Const;
PxTypedBoundedData_PxU16Const.__cache__ = {};
Module['PxTypedBoundedData_PxU16Const'] = PxTypedBoundedData_PxU16Const;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTypedBoundedData_PxU16Const.prototype['get_stride'] = PxTypedBoundedData_PxU16Const.prototype.get_stride = function() {
  var self = this.ptr;
  return _emscripten_bind_PxTypedBoundedData_PxU16Const_get_stride_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTypedBoundedData_PxU16Const.prototype['set_stride'] = PxTypedBoundedData_PxU16Const.prototype.set_stride = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTypedBoundedData_PxU16Const_set_stride_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTypedBoundedData_PxU16Const.prototype, 'stride', { get: PxTypedBoundedData_PxU16Const.prototype.get_stride, set: PxTypedBoundedData_PxU16Const.prototype.set_stride });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTypedBoundedData_PxU16Const.prototype['get_data'] = PxTypedBoundedData_PxU16Const.prototype.get_data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxTypedBoundedData_PxU16Const_get_data_0(self), PxU16ConstPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTypedBoundedData_PxU16Const.prototype['set_data'] = PxTypedBoundedData_PxU16Const.prototype.set_data = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxTypedBoundedData_PxU16Const_set_data_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxTypedBoundedData_PxU16Const.prototype, 'data', { get: PxTypedBoundedData_PxU16Const.prototype.get_data, set: PxTypedBoundedData_PxU16Const.prototype.set_data });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxTypedBoundedData_PxU16Const.prototype['__destroy__'] = PxTypedBoundedData_PxU16Const.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxTypedBoundedData_PxU16Const___destroy___0(self);
};

// Interface: PxU16Ptr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxU16Ptr() { throw "cannot construct a PxU16Ptr, no constructor in IDL" }
PxU16Ptr.prototype = Object.create(PxU16ConstPtr.prototype);
PxU16Ptr.prototype.constructor = PxU16Ptr;
PxU16Ptr.prototype.__class__ = PxU16Ptr;
PxU16Ptr.__cache__ = {};
Module['PxU16Ptr'] = PxU16Ptr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxU16Ptr.prototype['__destroy__'] = PxU16Ptr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxU16Ptr___destroy___0(self);
};

// Interface: PxU32Ptr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxU32Ptr() { throw "cannot construct a PxU32Ptr, no constructor in IDL" }
PxU32Ptr.prototype = Object.create(PxU32ConstPtr.prototype);
PxU32Ptr.prototype.constructor = PxU32Ptr;
PxU32Ptr.prototype.__class__ = PxU32Ptr;
PxU32Ptr.__cache__ = {};
Module['PxU32Ptr'] = PxU32Ptr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxU32Ptr.prototype['__destroy__'] = PxU32Ptr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxU32Ptr___destroy___0(self);
};

// Interface: PxU8Ptr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxU8Ptr() { throw "cannot construct a PxU8Ptr, no constructor in IDL" }
PxU8Ptr.prototype = Object.create(PxU8ConstPtr.prototype);
PxU8Ptr.prototype.constructor = PxU8Ptr;
PxU8Ptr.prototype.__class__ = PxU8Ptr;
PxU8Ptr.__cache__ = {};
Module['PxU8Ptr'] = PxU8Ptr;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxU8Ptr.prototype['__destroy__'] = PxU8Ptr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxU8Ptr___destroy___0(self);
};

// Interface: PxUserControllerHitReportImpl

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxUserControllerHitReportImpl() {
  this.ptr = _emscripten_bind_PxUserControllerHitReportImpl_PxUserControllerHitReportImpl_0();
  getCache(PxUserControllerHitReportImpl)[this.ptr] = this;
};

PxUserControllerHitReportImpl.prototype = Object.create(PxUserControllerHitReport.prototype);
PxUserControllerHitReportImpl.prototype.constructor = PxUserControllerHitReportImpl;
PxUserControllerHitReportImpl.prototype.__class__ = PxUserControllerHitReportImpl;
PxUserControllerHitReportImpl.__cache__ = {};
Module['PxUserControllerHitReportImpl'] = PxUserControllerHitReportImpl;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxUserControllerHitReportImpl.prototype['onShapeHit'] = PxUserControllerHitReportImpl.prototype.onShapeHit = function(hit) {
  var self = this.ptr;
  if (hit && typeof hit === 'object') hit = hit.ptr;
  _emscripten_bind_PxUserControllerHitReportImpl_onShapeHit_1(self, hit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxUserControllerHitReportImpl.prototype['onControllerHit'] = PxUserControllerHitReportImpl.prototype.onControllerHit = function(hit) {
  var self = this.ptr;
  if (hit && typeof hit === 'object') hit = hit.ptr;
  _emscripten_bind_PxUserControllerHitReportImpl_onControllerHit_1(self, hit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxUserControllerHitReportImpl.prototype['onObstacleHit'] = PxUserControllerHitReportImpl.prototype.onObstacleHit = function(hit) {
  var self = this.ptr;
  if (hit && typeof hit === 'object') hit = hit.ptr;
  _emscripten_bind_PxUserControllerHitReportImpl_onObstacleHit_1(self, hit);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxUserControllerHitReportImpl.prototype['__destroy__'] = PxUserControllerHitReportImpl.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxUserControllerHitReportImpl___destroy___0(self);
};

// Interface: PxVec3

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVec3(x, y, z) {
  if (x && typeof x === 'object') x = x.ptr;
  if (y && typeof y === 'object') y = y.ptr;
  if (z && typeof z === 'object') z = z.ptr;
  if (x === undefined) { this.ptr = _emscripten_bind_PxVec3_PxVec3_0(); getCache(PxVec3)[this.ptr] = this;return }
  if (y === undefined) { this.ptr = _emscripten_bind_PxVec3_PxVec3_1(x); getCache(PxVec3)[this.ptr] = this;return }
  if (z === undefined) { this.ptr = _emscripten_bind_PxVec3_PxVec3_2(x, y); getCache(PxVec3)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxVec3_PxVec3_3(x, y, z);
  getCache(PxVec3)[this.ptr] = this;
};

PxVec3.prototype = Object.create(WrapperObject.prototype);
PxVec3.prototype.constructor = PxVec3;
PxVec3.prototype.__class__ = PxVec3;
PxVec3.__cache__ = {};
Module['PxVec3'] = PxVec3;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['isZero'] = PxVec3.prototype.isZero = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVec3_isZero_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['isFinite'] = PxVec3.prototype.isFinite = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVec3_isFinite_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['isNormalized'] = PxVec3.prototype.isNormalized = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVec3_isNormalized_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['magnitudeSquared'] = PxVec3.prototype.magnitudeSquared = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec3_magnitudeSquared_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['magnitude'] = PxVec3.prototype.magnitude = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec3_magnitude_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['dot'] = PxVec3.prototype.dot = function(v) {
  var self = this.ptr;
  if (v && typeof v === 'object') v = v.ptr;
  return _emscripten_bind_PxVec3_dot_1(self, v);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['cross'] = PxVec3.prototype.cross = function(v) {
  var self = this.ptr;
  if (v && typeof v === 'object') v = v.ptr;
  return wrapPointer(_emscripten_bind_PxVec3_cross_1(self, v), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['getNormalized'] = PxVec3.prototype.getNormalized = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVec3_getNormalized_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['normalize'] = PxVec3.prototype.normalize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec3_normalize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['normalizeSafe'] = PxVec3.prototype.normalizeSafe = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec3_normalizeSafe_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['normalizeFast'] = PxVec3.prototype.normalizeFast = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec3_normalizeFast_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['multiply'] = PxVec3.prototype.multiply = function(a) {
  var self = this.ptr;
  if (a && typeof a === 'object') a = a.ptr;
  return wrapPointer(_emscripten_bind_PxVec3_multiply_1(self, a), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['minimum'] = PxVec3.prototype.minimum = function(v) {
  var self = this.ptr;
  if (v && typeof v === 'object') v = v.ptr;
  return wrapPointer(_emscripten_bind_PxVec3_minimum_1(self, v), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['minElement'] = PxVec3.prototype.minElement = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec3_minElement_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['maximum'] = PxVec3.prototype.maximum = function(v) {
  var self = this.ptr;
  if (v && typeof v === 'object') v = v.ptr;
  return wrapPointer(_emscripten_bind_PxVec3_maximum_1(self, v), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['maxElement'] = PxVec3.prototype.maxElement = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec3_maxElement_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['abs'] = PxVec3.prototype.abs = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVec3_abs_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['get_x'] = PxVec3.prototype.get_x = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec3_get_x_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['set_x'] = PxVec3.prototype.set_x = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVec3_set_x_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVec3.prototype, 'x', { get: PxVec3.prototype.get_x, set: PxVec3.prototype.set_x });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['get_y'] = PxVec3.prototype.get_y = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec3_get_y_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['set_y'] = PxVec3.prototype.set_y = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVec3_set_y_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVec3.prototype, 'y', { get: PxVec3.prototype.get_y, set: PxVec3.prototype.set_y });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['get_z'] = PxVec3.prototype.get_z = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec3_get_z_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['set_z'] = PxVec3.prototype.set_z = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVec3_set_z_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVec3.prototype, 'z', { get: PxVec3.prototype.get_z, set: PxVec3.prototype.set_z });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec3.prototype['__destroy__'] = PxVec3.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVec3___destroy___0(self);
};

// Interface: PxVec4

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVec4(x, y, z, w) {
  if (x && typeof x === 'object') x = x.ptr;
  if (y && typeof y === 'object') y = y.ptr;
  if (z && typeof z === 'object') z = z.ptr;
  if (w && typeof w === 'object') w = w.ptr;
  if (x === undefined) { this.ptr = _emscripten_bind_PxVec4_PxVec4_0(); getCache(PxVec4)[this.ptr] = this;return }
  if (y === undefined) { this.ptr = _emscripten_bind_PxVec4_PxVec4_1(x); getCache(PxVec4)[this.ptr] = this;return }
  if (z === undefined) { this.ptr = _emscripten_bind_PxVec4_PxVec4_2(x, y); getCache(PxVec4)[this.ptr] = this;return }
  if (w === undefined) { this.ptr = _emscripten_bind_PxVec4_PxVec4_3(x, y, z); getCache(PxVec4)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxVec4_PxVec4_4(x, y, z, w);
  getCache(PxVec4)[this.ptr] = this;
};

PxVec4.prototype = Object.create(WrapperObject.prototype);
PxVec4.prototype.constructor = PxVec4;
PxVec4.prototype.__class__ = PxVec4;
PxVec4.__cache__ = {};
Module['PxVec4'] = PxVec4;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['isZero'] = PxVec4.prototype.isZero = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVec4_isZero_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['isFinite'] = PxVec4.prototype.isFinite = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVec4_isFinite_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['isNormalized'] = PxVec4.prototype.isNormalized = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVec4_isNormalized_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['magnitudeSquared'] = PxVec4.prototype.magnitudeSquared = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec4_magnitudeSquared_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['magnitude'] = PxVec4.prototype.magnitude = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec4_magnitude_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['dot'] = PxVec4.prototype.dot = function(v) {
  var self = this.ptr;
  if (v && typeof v === 'object') v = v.ptr;
  return _emscripten_bind_PxVec4_dot_1(self, v);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['getNormalized'] = PxVec4.prototype.getNormalized = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVec4_getNormalized_0(self), PxVec4);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['normalize'] = PxVec4.prototype.normalize = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec4_normalize_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['multiply'] = PxVec4.prototype.multiply = function(a) {
  var self = this.ptr;
  if (a && typeof a === 'object') a = a.ptr;
  return wrapPointer(_emscripten_bind_PxVec4_multiply_1(self, a), PxVec4);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['minimum'] = PxVec4.prototype.minimum = function(v) {
  var self = this.ptr;
  if (v && typeof v === 'object') v = v.ptr;
  return wrapPointer(_emscripten_bind_PxVec4_minimum_1(self, v), PxVec4);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['maximum'] = PxVec4.prototype.maximum = function(v) {
  var self = this.ptr;
  if (v && typeof v === 'object') v = v.ptr;
  return wrapPointer(_emscripten_bind_PxVec4_maximum_1(self, v), PxVec4);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['getXYZ'] = PxVec4.prototype.getXYZ = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVec4_getXYZ_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['get_x'] = PxVec4.prototype.get_x = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec4_get_x_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['set_x'] = PxVec4.prototype.set_x = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVec4_set_x_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVec4.prototype, 'x', { get: PxVec4.prototype.get_x, set: PxVec4.prototype.set_x });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['get_y'] = PxVec4.prototype.get_y = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec4_get_y_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['set_y'] = PxVec4.prototype.set_y = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVec4_set_y_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVec4.prototype, 'y', { get: PxVec4.prototype.get_y, set: PxVec4.prototype.set_y });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['get_z'] = PxVec4.prototype.get_z = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec4_get_z_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['set_z'] = PxVec4.prototype.set_z = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVec4_set_z_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVec4.prototype, 'z', { get: PxVec4.prototype.get_z, set: PxVec4.prototype.set_z });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['get_w'] = PxVec4.prototype.get_w = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVec4_get_w_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['set_w'] = PxVec4.prototype.set_w = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVec4_set_w_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVec4.prototype, 'w', { get: PxVec4.prototype.get_w, set: PxVec4.prototype.set_w });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVec4.prototype['__destroy__'] = PxVec4.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVec4___destroy___0(self);
};

// Interface: PxVehicleAckermannParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleAckermannParams() {
  this.ptr = _emscripten_bind_PxVehicleAckermannParams_PxVehicleAckermannParams_0();
  getCache(PxVehicleAckermannParams)[this.ptr] = this;
};

PxVehicleAckermannParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleAckermannParams.prototype.constructor = PxVehicleAckermannParams;
PxVehicleAckermannParams.prototype.__class__ = PxVehicleAckermannParams;
PxVehicleAckermannParams.__cache__ = {};
Module['PxVehicleAckermannParams'] = PxVehicleAckermannParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAckermannParams.prototype['isValid'] = PxVehicleAckermannParams.prototype.isValid = function(axleDesc) {
  var self = this.ptr;
  if (axleDesc && typeof axleDesc === 'object') axleDesc = axleDesc.ptr;
  return !!(_emscripten_bind_PxVehicleAckermannParams_isValid_1(self, axleDesc));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAckermannParams.prototype['transformAndScale'] = PxVehicleAckermannParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleAckermannParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleAckermannParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAckermannParams.prototype['get_wheelIds'] = PxVehicleAckermannParams.prototype.get_wheelIds = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleAckermannParams_get_wheelIds_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAckermannParams.prototype['set_wheelIds'] = PxVehicleAckermannParams.prototype.set_wheelIds = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleAckermannParams_set_wheelIds_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAckermannParams.prototype, 'wheelIds', { get: PxVehicleAckermannParams.prototype.get_wheelIds, set: PxVehicleAckermannParams.prototype.set_wheelIds });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAckermannParams.prototype['get_wheelBase'] = PxVehicleAckermannParams.prototype.get_wheelBase = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleAckermannParams_get_wheelBase_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAckermannParams.prototype['set_wheelBase'] = PxVehicleAckermannParams.prototype.set_wheelBase = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleAckermannParams_set_wheelBase_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAckermannParams.prototype, 'wheelBase', { get: PxVehicleAckermannParams.prototype.get_wheelBase, set: PxVehicleAckermannParams.prototype.set_wheelBase });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAckermannParams.prototype['get_trackWidth'] = PxVehicleAckermannParams.prototype.get_trackWidth = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleAckermannParams_get_trackWidth_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAckermannParams.prototype['set_trackWidth'] = PxVehicleAckermannParams.prototype.set_trackWidth = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleAckermannParams_set_trackWidth_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAckermannParams.prototype, 'trackWidth', { get: PxVehicleAckermannParams.prototype.get_trackWidth, set: PxVehicleAckermannParams.prototype.set_trackWidth });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAckermannParams.prototype['get_strength'] = PxVehicleAckermannParams.prototype.get_strength = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleAckermannParams_get_strength_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAckermannParams.prototype['set_strength'] = PxVehicleAckermannParams.prototype.set_strength = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleAckermannParams_set_strength_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAckermannParams.prototype, 'strength', { get: PxVehicleAckermannParams.prototype.get_strength, set: PxVehicleAckermannParams.prototype.set_strength });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAckermannParams.prototype['__destroy__'] = PxVehicleAckermannParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleAckermannParams___destroy___0(self);
};

// Interface: PxVehicleAntiRollForceParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleAntiRollForceParams() {
  this.ptr = _emscripten_bind_PxVehicleAntiRollForceParams_PxVehicleAntiRollForceParams_0();
  getCache(PxVehicleAntiRollForceParams)[this.ptr] = this;
};

PxVehicleAntiRollForceParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleAntiRollForceParams.prototype.constructor = PxVehicleAntiRollForceParams;
PxVehicleAntiRollForceParams.prototype.__class__ = PxVehicleAntiRollForceParams;
PxVehicleAntiRollForceParams.__cache__ = {};
Module['PxVehicleAntiRollForceParams'] = PxVehicleAntiRollForceParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAntiRollForceParams.prototype['transformAndScale'] = PxVehicleAntiRollForceParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleAntiRollForceParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleAntiRollForceParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAntiRollForceParams.prototype['isValid'] = PxVehicleAntiRollForceParams.prototype.isValid = function(axleDesc) {
  var self = this.ptr;
  if (axleDesc && typeof axleDesc === 'object') axleDesc = axleDesc.ptr;
  return !!(_emscripten_bind_PxVehicleAntiRollForceParams_isValid_1(self, axleDesc));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAntiRollForceParams.prototype['get_wheel0'] = PxVehicleAntiRollForceParams.prototype.get_wheel0 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleAntiRollForceParams_get_wheel0_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAntiRollForceParams.prototype['set_wheel0'] = PxVehicleAntiRollForceParams.prototype.set_wheel0 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleAntiRollForceParams_set_wheel0_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAntiRollForceParams.prototype, 'wheel0', { get: PxVehicleAntiRollForceParams.prototype.get_wheel0, set: PxVehicleAntiRollForceParams.prototype.set_wheel0 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAntiRollForceParams.prototype['get_wheel1'] = PxVehicleAntiRollForceParams.prototype.get_wheel1 = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleAntiRollForceParams_get_wheel1_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAntiRollForceParams.prototype['set_wheel1'] = PxVehicleAntiRollForceParams.prototype.set_wheel1 = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleAntiRollForceParams_set_wheel1_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAntiRollForceParams.prototype, 'wheel1', { get: PxVehicleAntiRollForceParams.prototype.get_wheel1, set: PxVehicleAntiRollForceParams.prototype.set_wheel1 });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAntiRollForceParams.prototype['get_stiffness'] = PxVehicleAntiRollForceParams.prototype.get_stiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleAntiRollForceParams_get_stiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAntiRollForceParams.prototype['set_stiffness'] = PxVehicleAntiRollForceParams.prototype.set_stiffness = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleAntiRollForceParams_set_stiffness_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAntiRollForceParams.prototype, 'stiffness', { get: PxVehicleAntiRollForceParams.prototype.get_stiffness, set: PxVehicleAntiRollForceParams.prototype.set_stiffness });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAntiRollForceParams.prototype['__destroy__'] = PxVehicleAntiRollForceParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleAntiRollForceParams___destroy___0(self);
};

// Interface: PxVehicleAntiRollTorque

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleAntiRollTorque() {
  this.ptr = _emscripten_bind_PxVehicleAntiRollTorque_PxVehicleAntiRollTorque_0();
  getCache(PxVehicleAntiRollTorque)[this.ptr] = this;
};

PxVehicleAntiRollTorque.prototype = Object.create(WrapperObject.prototype);
PxVehicleAntiRollTorque.prototype.constructor = PxVehicleAntiRollTorque;
PxVehicleAntiRollTorque.prototype.__class__ = PxVehicleAntiRollTorque;
PxVehicleAntiRollTorque.__cache__ = {};
Module['PxVehicleAntiRollTorque'] = PxVehicleAntiRollTorque;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAntiRollTorque.prototype['setToDefault'] = PxVehicleAntiRollTorque.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleAntiRollTorque_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAntiRollTorque.prototype['get_antiRollTorque'] = PxVehicleAntiRollTorque.prototype.get_antiRollTorque = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleAntiRollTorque_get_antiRollTorque_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAntiRollTorque.prototype['set_antiRollTorque'] = PxVehicleAntiRollTorque.prototype.set_antiRollTorque = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleAntiRollTorque_set_antiRollTorque_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAntiRollTorque.prototype, 'antiRollTorque', { get: PxVehicleAntiRollTorque.prototype.get_antiRollTorque, set: PxVehicleAntiRollTorque.prototype.set_antiRollTorque });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAntiRollTorque.prototype['__destroy__'] = PxVehicleAntiRollTorque.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleAntiRollTorque___destroy___0(self);
};

// Interface: PxVehicleAutoboxParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleAutoboxParams() {
  this.ptr = _emscripten_bind_PxVehicleAutoboxParams_PxVehicleAutoboxParams_0();
  getCache(PxVehicleAutoboxParams)[this.ptr] = this;
};

PxVehicleAutoboxParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleAutoboxParams.prototype.constructor = PxVehicleAutoboxParams;
PxVehicleAutoboxParams.prototype.__class__ = PxVehicleAutoboxParams;
PxVehicleAutoboxParams.__cache__ = {};
Module['PxVehicleAutoboxParams'] = PxVehicleAutoboxParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxParams.prototype['transformAndScale'] = PxVehicleAutoboxParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleAutoboxParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleAutoboxParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxParams.prototype['isValid'] = PxVehicleAutoboxParams.prototype.isValid = function(gearboxParams) {
  var self = this.ptr;
  if (gearboxParams && typeof gearboxParams === 'object') gearboxParams = gearboxParams.ptr;
  return !!(_emscripten_bind_PxVehicleAutoboxParams_isValid_1(self, gearboxParams));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxParams.prototype['get_upRatios'] = PxVehicleAutoboxParams.prototype.get_upRatios = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleAutoboxParams_get_upRatios_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxParams.prototype['set_upRatios'] = PxVehicleAutoboxParams.prototype.set_upRatios = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleAutoboxParams_set_upRatios_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAutoboxParams.prototype, 'upRatios', { get: PxVehicleAutoboxParams.prototype.get_upRatios, set: PxVehicleAutoboxParams.prototype.set_upRatios });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxParams.prototype['get_downRatios'] = PxVehicleAutoboxParams.prototype.get_downRatios = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleAutoboxParams_get_downRatios_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxParams.prototype['set_downRatios'] = PxVehicleAutoboxParams.prototype.set_downRatios = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleAutoboxParams_set_downRatios_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAutoboxParams.prototype, 'downRatios', { get: PxVehicleAutoboxParams.prototype.get_downRatios, set: PxVehicleAutoboxParams.prototype.set_downRatios });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxParams.prototype['get_latency'] = PxVehicleAutoboxParams.prototype.get_latency = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleAutoboxParams_get_latency_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxParams.prototype['set_latency'] = PxVehicleAutoboxParams.prototype.set_latency = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleAutoboxParams_set_latency_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAutoboxParams.prototype, 'latency', { get: PxVehicleAutoboxParams.prototype.get_latency, set: PxVehicleAutoboxParams.prototype.set_latency });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxParams.prototype['__destroy__'] = PxVehicleAutoboxParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleAutoboxParams___destroy___0(self);
};

// Interface: PxVehicleAutoboxState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleAutoboxState() {
  this.ptr = _emscripten_bind_PxVehicleAutoboxState_PxVehicleAutoboxState_0();
  getCache(PxVehicleAutoboxState)[this.ptr] = this;
};

PxVehicleAutoboxState.prototype = Object.create(WrapperObject.prototype);
PxVehicleAutoboxState.prototype.constructor = PxVehicleAutoboxState;
PxVehicleAutoboxState.prototype.__class__ = PxVehicleAutoboxState;
PxVehicleAutoboxState.__cache__ = {};
Module['PxVehicleAutoboxState'] = PxVehicleAutoboxState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxState.prototype['setToDefault'] = PxVehicleAutoboxState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleAutoboxState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxState.prototype['get_timeSinceLastShift'] = PxVehicleAutoboxState.prototype.get_timeSinceLastShift = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleAutoboxState_get_timeSinceLastShift_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxState.prototype['set_timeSinceLastShift'] = PxVehicleAutoboxState.prototype.set_timeSinceLastShift = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleAutoboxState_set_timeSinceLastShift_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAutoboxState.prototype, 'timeSinceLastShift', { get: PxVehicleAutoboxState.prototype.get_timeSinceLastShift, set: PxVehicleAutoboxState.prototype.set_timeSinceLastShift });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxState.prototype['get_activeAutoboxGearShift'] = PxVehicleAutoboxState.prototype.get_activeAutoboxGearShift = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleAutoboxState_get_activeAutoboxGearShift_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxState.prototype['set_activeAutoboxGearShift'] = PxVehicleAutoboxState.prototype.set_activeAutoboxGearShift = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleAutoboxState_set_activeAutoboxGearShift_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAutoboxState.prototype, 'activeAutoboxGearShift', { get: PxVehicleAutoboxState.prototype.get_activeAutoboxGearShift, set: PxVehicleAutoboxState.prototype.set_activeAutoboxGearShift });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAutoboxState.prototype['__destroy__'] = PxVehicleAutoboxState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleAutoboxState___destroy___0(self);
};

// Interface: PxVehicleAxleDescription

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleAxleDescription() {
  this.ptr = _emscripten_bind_PxVehicleAxleDescription_PxVehicleAxleDescription_0();
  getCache(PxVehicleAxleDescription)[this.ptr] = this;
};

PxVehicleAxleDescription.prototype = Object.create(WrapperObject.prototype);
PxVehicleAxleDescription.prototype.constructor = PxVehicleAxleDescription;
PxVehicleAxleDescription.prototype.__class__ = PxVehicleAxleDescription;
PxVehicleAxleDescription.__cache__ = {};
Module['PxVehicleAxleDescription'] = PxVehicleAxleDescription;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['setToDefault'] = PxVehicleAxleDescription.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleAxleDescription_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['getNbWheelsOnAxle'] = PxVehicleAxleDescription.prototype.getNbWheelsOnAxle = function(i) {
  var self = this.ptr;
  if (i && typeof i === 'object') i = i.ptr;
  return _emscripten_bind_PxVehicleAxleDescription_getNbWheelsOnAxle_1(self, i);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['getWheelOnAxle'] = PxVehicleAxleDescription.prototype.getWheelOnAxle = function(j, i) {
  var self = this.ptr;
  if (j && typeof j === 'object') j = j.ptr;
  if (i && typeof i === 'object') i = i.ptr;
  return _emscripten_bind_PxVehicleAxleDescription_getWheelOnAxle_2(self, j, i);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['getAxle'] = PxVehicleAxleDescription.prototype.getAxle = function(wheelId) {
  var self = this.ptr;
  if (wheelId && typeof wheelId === 'object') wheelId = wheelId.ptr;
  return _emscripten_bind_PxVehicleAxleDescription_getAxle_1(self, wheelId);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['isValid'] = PxVehicleAxleDescription.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleAxleDescription_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['get_nbAxles'] = PxVehicleAxleDescription.prototype.get_nbAxles = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleAxleDescription_get_nbAxles_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['set_nbAxles'] = PxVehicleAxleDescription.prototype.set_nbAxles = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleAxleDescription_set_nbAxles_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAxleDescription.prototype, 'nbAxles', { get: PxVehicleAxleDescription.prototype.get_nbAxles, set: PxVehicleAxleDescription.prototype.set_nbAxles });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['get_nbWheelsPerAxle'] = PxVehicleAxleDescription.prototype.get_nbWheelsPerAxle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleAxleDescription_get_nbWheelsPerAxle_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['set_nbWheelsPerAxle'] = PxVehicleAxleDescription.prototype.set_nbWheelsPerAxle = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleAxleDescription_set_nbWheelsPerAxle_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAxleDescription.prototype, 'nbWheelsPerAxle', { get: PxVehicleAxleDescription.prototype.get_nbWheelsPerAxle, set: PxVehicleAxleDescription.prototype.set_nbWheelsPerAxle });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['get_axleToWheelIds'] = PxVehicleAxleDescription.prototype.get_axleToWheelIds = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleAxleDescription_get_axleToWheelIds_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['set_axleToWheelIds'] = PxVehicleAxleDescription.prototype.set_axleToWheelIds = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleAxleDescription_set_axleToWheelIds_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAxleDescription.prototype, 'axleToWheelIds', { get: PxVehicleAxleDescription.prototype.get_axleToWheelIds, set: PxVehicleAxleDescription.prototype.set_axleToWheelIds });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['get_wheelIdsInAxleOrder'] = PxVehicleAxleDescription.prototype.get_wheelIdsInAxleOrder = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleAxleDescription_get_wheelIdsInAxleOrder_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['set_wheelIdsInAxleOrder'] = PxVehicleAxleDescription.prototype.set_wheelIdsInAxleOrder = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleAxleDescription_set_wheelIdsInAxleOrder_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAxleDescription.prototype, 'wheelIdsInAxleOrder', { get: PxVehicleAxleDescription.prototype.get_wheelIdsInAxleOrder, set: PxVehicleAxleDescription.prototype.set_wheelIdsInAxleOrder });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['get_nbWheels'] = PxVehicleAxleDescription.prototype.get_nbWheels = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleAxleDescription_get_nbWheels_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['set_nbWheels'] = PxVehicleAxleDescription.prototype.set_nbWheels = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleAxleDescription_set_nbWheels_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleAxleDescription.prototype, 'nbWheels', { get: PxVehicleAxleDescription.prototype.get_nbWheels, set: PxVehicleAxleDescription.prototype.set_nbWheels });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleAxleDescription.prototype['__destroy__'] = PxVehicleAxleDescription.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleAxleDescription___destroy___0(self);
};

// Interface: PxVehicleBrakeCommandResponseParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleBrakeCommandResponseParams() {
  this.ptr = _emscripten_bind_PxVehicleBrakeCommandResponseParams_PxVehicleBrakeCommandResponseParams_0();
  getCache(PxVehicleBrakeCommandResponseParams)[this.ptr] = this;
};

PxVehicleBrakeCommandResponseParams.prototype = Object.create(PxVehicleCommandResponseParams.prototype);
PxVehicleBrakeCommandResponseParams.prototype.constructor = PxVehicleBrakeCommandResponseParams;
PxVehicleBrakeCommandResponseParams.prototype.__class__ = PxVehicleBrakeCommandResponseParams;
PxVehicleBrakeCommandResponseParams.__cache__ = {};
Module['PxVehicleBrakeCommandResponseParams'] = PxVehicleBrakeCommandResponseParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleBrakeCommandResponseParams.prototype['transformAndScale'] = PxVehicleBrakeCommandResponseParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleBrakeCommandResponseParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleBrakeCommandResponseParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleBrakeCommandResponseParams.prototype['isValid'] = PxVehicleBrakeCommandResponseParams.prototype.isValid = function(axleDesc) {
  var self = this.ptr;
  if (axleDesc && typeof axleDesc === 'object') axleDesc = axleDesc.ptr;
  return !!(_emscripten_bind_PxVehicleBrakeCommandResponseParams_isValid_1(self, axleDesc));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleBrakeCommandResponseParams.prototype['get_nonlinearResponse'] = PxVehicleBrakeCommandResponseParams.prototype.get_nonlinearResponse = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleBrakeCommandResponseParams_get_nonlinearResponse_0(self), PxVehicleCommandNonLinearResponseParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleBrakeCommandResponseParams.prototype['set_nonlinearResponse'] = PxVehicleBrakeCommandResponseParams.prototype.set_nonlinearResponse = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleBrakeCommandResponseParams_set_nonlinearResponse_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleBrakeCommandResponseParams.prototype, 'nonlinearResponse', { get: PxVehicleBrakeCommandResponseParams.prototype.get_nonlinearResponse, set: PxVehicleBrakeCommandResponseParams.prototype.set_nonlinearResponse });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleBrakeCommandResponseParams.prototype['get_wheelResponseMultipliers'] = PxVehicleBrakeCommandResponseParams.prototype.get_wheelResponseMultipliers = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleBrakeCommandResponseParams_get_wheelResponseMultipliers_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleBrakeCommandResponseParams.prototype['set_wheelResponseMultipliers'] = PxVehicleBrakeCommandResponseParams.prototype.set_wheelResponseMultipliers = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleBrakeCommandResponseParams_set_wheelResponseMultipliers_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleBrakeCommandResponseParams.prototype, 'wheelResponseMultipliers', { get: PxVehicleBrakeCommandResponseParams.prototype.get_wheelResponseMultipliers, set: PxVehicleBrakeCommandResponseParams.prototype.set_wheelResponseMultipliers });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleBrakeCommandResponseParams.prototype['get_maxResponse'] = PxVehicleBrakeCommandResponseParams.prototype.get_maxResponse = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleBrakeCommandResponseParams_get_maxResponse_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleBrakeCommandResponseParams.prototype['set_maxResponse'] = PxVehicleBrakeCommandResponseParams.prototype.set_maxResponse = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleBrakeCommandResponseParams_set_maxResponse_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleBrakeCommandResponseParams.prototype, 'maxResponse', { get: PxVehicleBrakeCommandResponseParams.prototype.get_maxResponse, set: PxVehicleBrakeCommandResponseParams.prototype.set_maxResponse });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleBrakeCommandResponseParams.prototype['__destroy__'] = PxVehicleBrakeCommandResponseParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleBrakeCommandResponseParams___destroy___0(self);
};

// Interface: PxVehicleClutchCommandResponseParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleClutchCommandResponseParams() {
  this.ptr = _emscripten_bind_PxVehicleClutchCommandResponseParams_PxVehicleClutchCommandResponseParams_0();
  getCache(PxVehicleClutchCommandResponseParams)[this.ptr] = this;
};

PxVehicleClutchCommandResponseParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleClutchCommandResponseParams.prototype.constructor = PxVehicleClutchCommandResponseParams;
PxVehicleClutchCommandResponseParams.prototype.__class__ = PxVehicleClutchCommandResponseParams;
PxVehicleClutchCommandResponseParams.__cache__ = {};
Module['PxVehicleClutchCommandResponseParams'] = PxVehicleClutchCommandResponseParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchCommandResponseParams.prototype['transformAndScale'] = PxVehicleClutchCommandResponseParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleClutchCommandResponseParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleClutchCommandResponseParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchCommandResponseParams.prototype['isValid'] = PxVehicleClutchCommandResponseParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleClutchCommandResponseParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchCommandResponseParams.prototype['get_maxResponse'] = PxVehicleClutchCommandResponseParams.prototype.get_maxResponse = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleClutchCommandResponseParams_get_maxResponse_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchCommandResponseParams.prototype['set_maxResponse'] = PxVehicleClutchCommandResponseParams.prototype.set_maxResponse = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleClutchCommandResponseParams_set_maxResponse_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleClutchCommandResponseParams.prototype, 'maxResponse', { get: PxVehicleClutchCommandResponseParams.prototype.get_maxResponse, set: PxVehicleClutchCommandResponseParams.prototype.set_maxResponse });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchCommandResponseParams.prototype['__destroy__'] = PxVehicleClutchCommandResponseParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleClutchCommandResponseParams___destroy___0(self);
};

// Interface: PxVehicleClutchCommandResponseState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleClutchCommandResponseState() {
  this.ptr = _emscripten_bind_PxVehicleClutchCommandResponseState_PxVehicleClutchCommandResponseState_0();
  getCache(PxVehicleClutchCommandResponseState)[this.ptr] = this;
};

PxVehicleClutchCommandResponseState.prototype = Object.create(WrapperObject.prototype);
PxVehicleClutchCommandResponseState.prototype.constructor = PxVehicleClutchCommandResponseState;
PxVehicleClutchCommandResponseState.prototype.__class__ = PxVehicleClutchCommandResponseState;
PxVehicleClutchCommandResponseState.__cache__ = {};
Module['PxVehicleClutchCommandResponseState'] = PxVehicleClutchCommandResponseState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchCommandResponseState.prototype['setToDefault'] = PxVehicleClutchCommandResponseState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleClutchCommandResponseState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchCommandResponseState.prototype['get_normalisedCommandResponse'] = PxVehicleClutchCommandResponseState.prototype.get_normalisedCommandResponse = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleClutchCommandResponseState_get_normalisedCommandResponse_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchCommandResponseState.prototype['set_normalisedCommandResponse'] = PxVehicleClutchCommandResponseState.prototype.set_normalisedCommandResponse = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleClutchCommandResponseState_set_normalisedCommandResponse_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleClutchCommandResponseState.prototype, 'normalisedCommandResponse', { get: PxVehicleClutchCommandResponseState.prototype.get_normalisedCommandResponse, set: PxVehicleClutchCommandResponseState.prototype.set_normalisedCommandResponse });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchCommandResponseState.prototype['get_commandResponse'] = PxVehicleClutchCommandResponseState.prototype.get_commandResponse = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleClutchCommandResponseState_get_commandResponse_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchCommandResponseState.prototype['set_commandResponse'] = PxVehicleClutchCommandResponseState.prototype.set_commandResponse = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleClutchCommandResponseState_set_commandResponse_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleClutchCommandResponseState.prototype, 'commandResponse', { get: PxVehicleClutchCommandResponseState.prototype.get_commandResponse, set: PxVehicleClutchCommandResponseState.prototype.set_commandResponse });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchCommandResponseState.prototype['__destroy__'] = PxVehicleClutchCommandResponseState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleClutchCommandResponseState___destroy___0(self);
};

// Interface: PxVehicleClutchParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleClutchParams() {
  this.ptr = _emscripten_bind_PxVehicleClutchParams_PxVehicleClutchParams_0();
  getCache(PxVehicleClutchParams)[this.ptr] = this;
};

PxVehicleClutchParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleClutchParams.prototype.constructor = PxVehicleClutchParams;
PxVehicleClutchParams.prototype.__class__ = PxVehicleClutchParams;
PxVehicleClutchParams.__cache__ = {};
Module['PxVehicleClutchParams'] = PxVehicleClutchParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchParams.prototype['transformAndScale'] = PxVehicleClutchParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleClutchParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleClutchParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchParams.prototype['isValid'] = PxVehicleClutchParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleClutchParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchParams.prototype['get_accuracyMode'] = PxVehicleClutchParams.prototype.get_accuracyMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleClutchParams_get_accuracyMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchParams.prototype['set_accuracyMode'] = PxVehicleClutchParams.prototype.set_accuracyMode = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleClutchParams_set_accuracyMode_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleClutchParams.prototype, 'accuracyMode', { get: PxVehicleClutchParams.prototype.get_accuracyMode, set: PxVehicleClutchParams.prototype.set_accuracyMode });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchParams.prototype['get_estimateIterations'] = PxVehicleClutchParams.prototype.get_estimateIterations = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleClutchParams_get_estimateIterations_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchParams.prototype['set_estimateIterations'] = PxVehicleClutchParams.prototype.set_estimateIterations = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleClutchParams_set_estimateIterations_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleClutchParams.prototype, 'estimateIterations', { get: PxVehicleClutchParams.prototype.get_estimateIterations, set: PxVehicleClutchParams.prototype.set_estimateIterations });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchParams.prototype['__destroy__'] = PxVehicleClutchParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleClutchParams___destroy___0(self);
};

// Interface: PxVehicleClutchSlipState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleClutchSlipState() {
  this.ptr = _emscripten_bind_PxVehicleClutchSlipState_PxVehicleClutchSlipState_0();
  getCache(PxVehicleClutchSlipState)[this.ptr] = this;
};

PxVehicleClutchSlipState.prototype = Object.create(WrapperObject.prototype);
PxVehicleClutchSlipState.prototype.constructor = PxVehicleClutchSlipState;
PxVehicleClutchSlipState.prototype.__class__ = PxVehicleClutchSlipState;
PxVehicleClutchSlipState.__cache__ = {};
Module['PxVehicleClutchSlipState'] = PxVehicleClutchSlipState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchSlipState.prototype['setToDefault'] = PxVehicleClutchSlipState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleClutchSlipState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchSlipState.prototype['get_clutchSlip'] = PxVehicleClutchSlipState.prototype.get_clutchSlip = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleClutchSlipState_get_clutchSlip_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchSlipState.prototype['set_clutchSlip'] = PxVehicleClutchSlipState.prototype.set_clutchSlip = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleClutchSlipState_set_clutchSlip_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleClutchSlipState.prototype, 'clutchSlip', { get: PxVehicleClutchSlipState.prototype.get_clutchSlip, set: PxVehicleClutchSlipState.prototype.set_clutchSlip });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleClutchSlipState.prototype['__destroy__'] = PxVehicleClutchSlipState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleClutchSlipState___destroy___0(self);
};

// Interface: PxVehicleCommandNonLinearResponseParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleCommandNonLinearResponseParams() {
  this.ptr = _emscripten_bind_PxVehicleCommandNonLinearResponseParams_PxVehicleCommandNonLinearResponseParams_0();
  getCache(PxVehicleCommandNonLinearResponseParams)[this.ptr] = this;
};

PxVehicleCommandNonLinearResponseParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleCommandNonLinearResponseParams.prototype.constructor = PxVehicleCommandNonLinearResponseParams;
PxVehicleCommandNonLinearResponseParams.prototype.__class__ = PxVehicleCommandNonLinearResponseParams;
PxVehicleCommandNonLinearResponseParams.__cache__ = {};
Module['PxVehicleCommandNonLinearResponseParams'] = PxVehicleCommandNonLinearResponseParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['clear'] = PxVehicleCommandNonLinearResponseParams.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_clear_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['addResponse'] = PxVehicleCommandNonLinearResponseParams.prototype.addResponse = function(commandValueSpeedResponses) {
  var self = this.ptr;
  if (commandValueSpeedResponses && typeof commandValueSpeedResponses === 'object') commandValueSpeedResponses = commandValueSpeedResponses.ptr;
  return !!(_emscripten_bind_PxVehicleCommandNonLinearResponseParams_addResponse_1(self, commandValueSpeedResponses));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['get_speedResponses'] = PxVehicleCommandNonLinearResponseParams.prototype.get_speedResponses = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponses_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['set_speedResponses'] = PxVehicleCommandNonLinearResponseParams.prototype.set_speedResponses = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponses_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleCommandNonLinearResponseParams.prototype, 'speedResponses', { get: PxVehicleCommandNonLinearResponseParams.prototype.get_speedResponses, set: PxVehicleCommandNonLinearResponseParams.prototype.set_speedResponses });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['get_nbSpeedResponses'] = PxVehicleCommandNonLinearResponseParams.prototype.get_nbSpeedResponses = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponses_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['set_nbSpeedResponses'] = PxVehicleCommandNonLinearResponseParams.prototype.set_nbSpeedResponses = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponses_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleCommandNonLinearResponseParams.prototype, 'nbSpeedResponses', { get: PxVehicleCommandNonLinearResponseParams.prototype.get_nbSpeedResponses, set: PxVehicleCommandNonLinearResponseParams.prototype.set_nbSpeedResponses });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['get_speedResponsesPerCommandValue'] = PxVehicleCommandNonLinearResponseParams.prototype.get_speedResponsesPerCommandValue = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_speedResponsesPerCommandValue_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['set_speedResponsesPerCommandValue'] = PxVehicleCommandNonLinearResponseParams.prototype.set_speedResponsesPerCommandValue = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_speedResponsesPerCommandValue_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleCommandNonLinearResponseParams.prototype, 'speedResponsesPerCommandValue', { get: PxVehicleCommandNonLinearResponseParams.prototype.get_speedResponsesPerCommandValue, set: PxVehicleCommandNonLinearResponseParams.prototype.set_speedResponsesPerCommandValue });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['get_nbSpeedResponsesPerCommandValue'] = PxVehicleCommandNonLinearResponseParams.prototype.get_nbSpeedResponsesPerCommandValue = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbSpeedResponsesPerCommandValue_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['set_nbSpeedResponsesPerCommandValue'] = PxVehicleCommandNonLinearResponseParams.prototype.set_nbSpeedResponsesPerCommandValue = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbSpeedResponsesPerCommandValue_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleCommandNonLinearResponseParams.prototype, 'nbSpeedResponsesPerCommandValue', { get: PxVehicleCommandNonLinearResponseParams.prototype.get_nbSpeedResponsesPerCommandValue, set: PxVehicleCommandNonLinearResponseParams.prototype.set_nbSpeedResponsesPerCommandValue });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['get_commandValues'] = PxVehicleCommandNonLinearResponseParams.prototype.get_commandValues = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_commandValues_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['set_commandValues'] = PxVehicleCommandNonLinearResponseParams.prototype.set_commandValues = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_commandValues_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleCommandNonLinearResponseParams.prototype, 'commandValues', { get: PxVehicleCommandNonLinearResponseParams.prototype.get_commandValues, set: PxVehicleCommandNonLinearResponseParams.prototype.set_commandValues });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['get_nbCommandValues'] = PxVehicleCommandNonLinearResponseParams.prototype.get_nbCommandValues = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleCommandNonLinearResponseParams_get_nbCommandValues_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['set_nbCommandValues'] = PxVehicleCommandNonLinearResponseParams.prototype.set_nbCommandValues = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams_set_nbCommandValues_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleCommandNonLinearResponseParams.prototype, 'nbCommandValues', { get: PxVehicleCommandNonLinearResponseParams.prototype.get_nbCommandValues, set: PxVehicleCommandNonLinearResponseParams.prototype.set_nbCommandValues });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandNonLinearResponseParams.prototype['__destroy__'] = PxVehicleCommandNonLinearResponseParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleCommandNonLinearResponseParams___destroy___0(self);
};

// Interface: PxVehicleCommandState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleCommandState() {
  this.ptr = _emscripten_bind_PxVehicleCommandState_PxVehicleCommandState_0();
  getCache(PxVehicleCommandState)[this.ptr] = this;
};

PxVehicleCommandState.prototype = Object.create(WrapperObject.prototype);
PxVehicleCommandState.prototype.constructor = PxVehicleCommandState;
PxVehicleCommandState.prototype.__class__ = PxVehicleCommandState;
PxVehicleCommandState.__cache__ = {};
Module['PxVehicleCommandState'] = PxVehicleCommandState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandState.prototype['setToDefault'] = PxVehicleCommandState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleCommandState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandState.prototype['get_brakes'] = PxVehicleCommandState.prototype.get_brakes = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleCommandState_get_brakes_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandState.prototype['set_brakes'] = PxVehicleCommandState.prototype.set_brakes = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleCommandState_set_brakes_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleCommandState.prototype, 'brakes', { get: PxVehicleCommandState.prototype.get_brakes, set: PxVehicleCommandState.prototype.set_brakes });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandState.prototype['get_nbBrakes'] = PxVehicleCommandState.prototype.get_nbBrakes = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleCommandState_get_nbBrakes_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandState.prototype['set_nbBrakes'] = PxVehicleCommandState.prototype.set_nbBrakes = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleCommandState_set_nbBrakes_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleCommandState.prototype, 'nbBrakes', { get: PxVehicleCommandState.prototype.get_nbBrakes, set: PxVehicleCommandState.prototype.set_nbBrakes });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandState.prototype['get_throttle'] = PxVehicleCommandState.prototype.get_throttle = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleCommandState_get_throttle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandState.prototype['set_throttle'] = PxVehicleCommandState.prototype.set_throttle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleCommandState_set_throttle_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleCommandState.prototype, 'throttle', { get: PxVehicleCommandState.prototype.get_throttle, set: PxVehicleCommandState.prototype.set_throttle });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandState.prototype['get_steer'] = PxVehicleCommandState.prototype.get_steer = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleCommandState_get_steer_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandState.prototype['set_steer'] = PxVehicleCommandState.prototype.set_steer = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleCommandState_set_steer_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleCommandState.prototype, 'steer', { get: PxVehicleCommandState.prototype.get_steer, set: PxVehicleCommandState.prototype.set_steer });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandState.prototype['__destroy__'] = PxVehicleCommandState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleCommandState___destroy___0(self);
};

// Interface: PxVehicleCommandValueResponseTable

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleCommandValueResponseTable() {
  this.ptr = _emscripten_bind_PxVehicleCommandValueResponseTable_PxVehicleCommandValueResponseTable_0();
  getCache(PxVehicleCommandValueResponseTable)[this.ptr] = this;
};

PxVehicleCommandValueResponseTable.prototype = Object.create(WrapperObject.prototype);
PxVehicleCommandValueResponseTable.prototype.constructor = PxVehicleCommandValueResponseTable;
PxVehicleCommandValueResponseTable.prototype.__class__ = PxVehicleCommandValueResponseTable;
PxVehicleCommandValueResponseTable.__cache__ = {};
Module['PxVehicleCommandValueResponseTable'] = PxVehicleCommandValueResponseTable;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandValueResponseTable.prototype['get_commandValue'] = PxVehicleCommandValueResponseTable.prototype.get_commandValue = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleCommandValueResponseTable_get_commandValue_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandValueResponseTable.prototype['set_commandValue'] = PxVehicleCommandValueResponseTable.prototype.set_commandValue = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleCommandValueResponseTable_set_commandValue_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleCommandValueResponseTable.prototype, 'commandValue', { get: PxVehicleCommandValueResponseTable.prototype.get_commandValue, set: PxVehicleCommandValueResponseTable.prototype.set_commandValue });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleCommandValueResponseTable.prototype['__destroy__'] = PxVehicleCommandValueResponseTable.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleCommandValueResponseTable___destroy___0(self);
};

// Interface: PxVehicleComponent

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleComponent() { throw "cannot construct a PxVehicleComponent, no constructor in IDL" }
PxVehicleComponent.prototype = Object.create(WrapperObject.prototype);
PxVehicleComponent.prototype.constructor = PxVehicleComponent;
PxVehicleComponent.prototype.__class__ = PxVehicleComponent;
PxVehicleComponent.__cache__ = {};
Module['PxVehicleComponent'] = PxVehicleComponent;

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleComponent.prototype['__destroy__'] = PxVehicleComponent.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleComponent___destroy___0(self);
};

// Interface: PxVehicleComponentSequence

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleComponentSequence() {
  this.ptr = _emscripten_bind_PxVehicleComponentSequence_PxVehicleComponentSequence_0();
  getCache(PxVehicleComponentSequence)[this.ptr] = this;
};

PxVehicleComponentSequence.prototype = Object.create(WrapperObject.prototype);
PxVehicleComponentSequence.prototype.constructor = PxVehicleComponentSequence;
PxVehicleComponentSequence.prototype.__class__ = PxVehicleComponentSequence;
PxVehicleComponentSequence.__cache__ = {};
Module['PxVehicleComponentSequence'] = PxVehicleComponentSequence;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleComponentSequence.prototype['add'] = PxVehicleComponentSequence.prototype.add = function(component) {
  var self = this.ptr;
  if (component && typeof component === 'object') component = component.ptr;
  return !!(_emscripten_bind_PxVehicleComponentSequence_add_1(self, component));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleComponentSequence.prototype['beginSubstepGroup'] = PxVehicleComponentSequence.prototype.beginSubstepGroup = function(nbSubSteps) {
  var self = this.ptr;
  if (nbSubSteps && typeof nbSubSteps === 'object') nbSubSteps = nbSubSteps.ptr;
  if (nbSubSteps === undefined) { return _emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_0(self) }
  return _emscripten_bind_PxVehicleComponentSequence_beginSubstepGroup_1(self, nbSubSteps);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleComponentSequence.prototype['endSubstepGroup'] = PxVehicleComponentSequence.prototype.endSubstepGroup = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleComponentSequence_endSubstepGroup_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleComponentSequence.prototype['setSubsteps'] = PxVehicleComponentSequence.prototype.setSubsteps = function(subGroupHandle, nbSteps) {
  var self = this.ptr;
  if (subGroupHandle && typeof subGroupHandle === 'object') subGroupHandle = subGroupHandle.ptr;
  if (nbSteps && typeof nbSteps === 'object') nbSteps = nbSteps.ptr;
  _emscripten_bind_PxVehicleComponentSequence_setSubsteps_2(self, subGroupHandle, nbSteps);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleComponentSequence.prototype['update'] = PxVehicleComponentSequence.prototype.update = function(dt, context) {
  var self = this.ptr;
  if (dt && typeof dt === 'object') dt = dt.ptr;
  if (context && typeof context === 'object') context = context.ptr;
  _emscripten_bind_PxVehicleComponentSequence_update_2(self, dt, context);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleComponentSequence.prototype['__destroy__'] = PxVehicleComponentSequence.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleComponentSequence___destroy___0(self);
};

// Interface: PxVehicleConstraintConnector

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleConstraintConnector(vehicleConstraintState) {
  if (vehicleConstraintState && typeof vehicleConstraintState === 'object') vehicleConstraintState = vehicleConstraintState.ptr;
  if (vehicleConstraintState === undefined) { this.ptr = _emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_0(); getCache(PxVehicleConstraintConnector)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_PxVehicleConstraintConnector_PxVehicleConstraintConnector_1(vehicleConstraintState);
  getCache(PxVehicleConstraintConnector)[this.ptr] = this;
};

PxVehicleConstraintConnector.prototype = Object.create(PxConstraintConnector.prototype);
PxVehicleConstraintConnector.prototype.constructor = PxVehicleConstraintConnector;
PxVehicleConstraintConnector.prototype.__class__ = PxVehicleConstraintConnector;
PxVehicleConstraintConnector.__cache__ = {};
Module['PxVehicleConstraintConnector'] = PxVehicleConstraintConnector;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleConstraintConnector.prototype['setConstraintState'] = PxVehicleConstraintConnector.prototype.setConstraintState = function(constraintState) {
  var self = this.ptr;
  if (constraintState && typeof constraintState === 'object') constraintState = constraintState.ptr;
  _emscripten_bind_PxVehicleConstraintConnector_setConstraintState_1(self, constraintState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleConstraintConnector.prototype['getConstantBlock'] = PxVehicleConstraintConnector.prototype.getConstantBlock = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleConstraintConnector_getConstantBlock_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleConstraintConnector.prototype['prepareData'] = PxVehicleConstraintConnector.prototype.prepareData = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleConstraintConnector_prepareData_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleConstraintConnector.prototype['updateOmniPvdProperties'] = PxVehicleConstraintConnector.prototype.updateOmniPvdProperties = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleConstraintConnector_updateOmniPvdProperties_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleConstraintConnector.prototype['onConstraintRelease'] = PxVehicleConstraintConnector.prototype.onConstraintRelease = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleConstraintConnector_onConstraintRelease_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleConstraintConnector.prototype['onComShift'] = PxVehicleConstraintConnector.prototype.onComShift = function(actor) {
  var self = this.ptr;
  if (actor && typeof actor === 'object') actor = actor.ptr;
  _emscripten_bind_PxVehicleConstraintConnector_onComShift_1(self, actor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleConstraintConnector.prototype['onOriginShift'] = PxVehicleConstraintConnector.prototype.onOriginShift = function(shift) {
  var self = this.ptr;
  if (shift && typeof shift === 'object') shift = shift.ptr;
  _emscripten_bind_PxVehicleConstraintConnector_onOriginShift_1(self, shift);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleConstraintConnector.prototype['getSerializable'] = PxVehicleConstraintConnector.prototype.getSerializable = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleConstraintConnector_getSerializable_0(self), PxBase);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleConstraintConnector.prototype['getPrep'] = PxVehicleConstraintConnector.prototype.getPrep = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleConstraintConnector_getPrep_0(self), PxConstraintSolverPrep);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleConstraintConnector.prototype['connectToConstraint'] = PxVehicleConstraintConnector.prototype.connectToConstraint = function(constraint) {
  var self = this.ptr;
  if (constraint && typeof constraint === 'object') constraint = constraint.ptr;
  _emscripten_bind_PxVehicleConstraintConnector_connectToConstraint_1(self, constraint);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleConstraintConnector.prototype['__destroy__'] = PxVehicleConstraintConnector.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleConstraintConnector___destroy___0(self);
};

// Interface: PxVehicleDifferentialState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleDifferentialState() {
  this.ptr = _emscripten_bind_PxVehicleDifferentialState_PxVehicleDifferentialState_0();
  getCache(PxVehicleDifferentialState)[this.ptr] = this;
};

PxVehicleDifferentialState.prototype = Object.create(WrapperObject.prototype);
PxVehicleDifferentialState.prototype.constructor = PxVehicleDifferentialState;
PxVehicleDifferentialState.prototype.__class__ = PxVehicleDifferentialState;
PxVehicleDifferentialState.__cache__ = {};
Module['PxVehicleDifferentialState'] = PxVehicleDifferentialState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDifferentialState.prototype['setToDefault'] = PxVehicleDifferentialState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleDifferentialState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDifferentialState.prototype['get_connectedWheels'] = PxVehicleDifferentialState.prototype.get_connectedWheels = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleDifferentialState_get_connectedWheels_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDifferentialState.prototype['set_connectedWheels'] = PxVehicleDifferentialState.prototype.set_connectedWheels = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleDifferentialState_set_connectedWheels_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleDifferentialState.prototype, 'connectedWheels', { get: PxVehicleDifferentialState.prototype.get_connectedWheels, set: PxVehicleDifferentialState.prototype.set_connectedWheels });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDifferentialState.prototype['get_nbConnectedWheels'] = PxVehicleDifferentialState.prototype.get_nbConnectedWheels = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleDifferentialState_get_nbConnectedWheels_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDifferentialState.prototype['set_nbConnectedWheels'] = PxVehicleDifferentialState.prototype.set_nbConnectedWheels = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleDifferentialState_set_nbConnectedWheels_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleDifferentialState.prototype, 'nbConnectedWheels', { get: PxVehicleDifferentialState.prototype.get_nbConnectedWheels, set: PxVehicleDifferentialState.prototype.set_nbConnectedWheels });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDifferentialState.prototype['get_torqueRatiosAllWheels'] = PxVehicleDifferentialState.prototype.get_torqueRatiosAllWheels = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleDifferentialState_get_torqueRatiosAllWheels_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDifferentialState.prototype['set_torqueRatiosAllWheels'] = PxVehicleDifferentialState.prototype.set_torqueRatiosAllWheels = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleDifferentialState_set_torqueRatiosAllWheels_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleDifferentialState.prototype, 'torqueRatiosAllWheels', { get: PxVehicleDifferentialState.prototype.get_torqueRatiosAllWheels, set: PxVehicleDifferentialState.prototype.set_torqueRatiosAllWheels });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDifferentialState.prototype['get_aveWheelSpeedContributionAllWheels'] = PxVehicleDifferentialState.prototype.get_aveWheelSpeedContributionAllWheels = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleDifferentialState_get_aveWheelSpeedContributionAllWheels_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDifferentialState.prototype['set_aveWheelSpeedContributionAllWheels'] = PxVehicleDifferentialState.prototype.set_aveWheelSpeedContributionAllWheels = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleDifferentialState_set_aveWheelSpeedContributionAllWheels_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleDifferentialState.prototype, 'aveWheelSpeedContributionAllWheels', { get: PxVehicleDifferentialState.prototype.get_aveWheelSpeedContributionAllWheels, set: PxVehicleDifferentialState.prototype.set_aveWheelSpeedContributionAllWheels });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDifferentialState.prototype['__destroy__'] = PxVehicleDifferentialState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleDifferentialState___destroy___0(self);
};

// Interface: PxVehicleDirectDriveThrottleCommandResponseParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleDirectDriveThrottleCommandResponseParams() {
  this.ptr = _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_PxVehicleDirectDriveThrottleCommandResponseParams_0();
  getCache(PxVehicleDirectDriveThrottleCommandResponseParams)[this.ptr] = this;
};

PxVehicleDirectDriveThrottleCommandResponseParams.prototype = Object.create(PxVehicleCommandResponseParams.prototype);
PxVehicleDirectDriveThrottleCommandResponseParams.prototype.constructor = PxVehicleDirectDriveThrottleCommandResponseParams;
PxVehicleDirectDriveThrottleCommandResponseParams.prototype.__class__ = PxVehicleDirectDriveThrottleCommandResponseParams;
PxVehicleDirectDriveThrottleCommandResponseParams.__cache__ = {};
Module['PxVehicleDirectDriveThrottleCommandResponseParams'] = PxVehicleDirectDriveThrottleCommandResponseParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDirectDriveThrottleCommandResponseParams.prototype['transformAndScale'] = PxVehicleDirectDriveThrottleCommandResponseParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleDirectDriveThrottleCommandResponseParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDirectDriveThrottleCommandResponseParams.prototype['isValid'] = PxVehicleDirectDriveThrottleCommandResponseParams.prototype.isValid = function(axleDesc) {
  var self = this.ptr;
  if (axleDesc && typeof axleDesc === 'object') axleDesc = axleDesc.ptr;
  return !!(_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_isValid_1(self, axleDesc));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDirectDriveThrottleCommandResponseParams.prototype['get_nonlinearResponse'] = PxVehicleDirectDriveThrottleCommandResponseParams.prototype.get_nonlinearResponse = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_nonlinearResponse_0(self), PxVehicleCommandNonLinearResponseParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDirectDriveThrottleCommandResponseParams.prototype['set_nonlinearResponse'] = PxVehicleDirectDriveThrottleCommandResponseParams.prototype.set_nonlinearResponse = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_nonlinearResponse_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleDirectDriveThrottleCommandResponseParams.prototype, 'nonlinearResponse', { get: PxVehicleDirectDriveThrottleCommandResponseParams.prototype.get_nonlinearResponse, set: PxVehicleDirectDriveThrottleCommandResponseParams.prototype.set_nonlinearResponse });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDirectDriveThrottleCommandResponseParams.prototype['get_wheelResponseMultipliers'] = PxVehicleDirectDriveThrottleCommandResponseParams.prototype.get_wheelResponseMultipliers = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_wheelResponseMultipliers_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDirectDriveThrottleCommandResponseParams.prototype['set_wheelResponseMultipliers'] = PxVehicleDirectDriveThrottleCommandResponseParams.prototype.set_wheelResponseMultipliers = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_wheelResponseMultipliers_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleDirectDriveThrottleCommandResponseParams.prototype, 'wheelResponseMultipliers', { get: PxVehicleDirectDriveThrottleCommandResponseParams.prototype.get_wheelResponseMultipliers, set: PxVehicleDirectDriveThrottleCommandResponseParams.prototype.set_wheelResponseMultipliers });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDirectDriveThrottleCommandResponseParams.prototype['get_maxResponse'] = PxVehicleDirectDriveThrottleCommandResponseParams.prototype.get_maxResponse = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_get_maxResponse_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDirectDriveThrottleCommandResponseParams.prototype['set_maxResponse'] = PxVehicleDirectDriveThrottleCommandResponseParams.prototype.set_maxResponse = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams_set_maxResponse_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleDirectDriveThrottleCommandResponseParams.prototype, 'maxResponse', { get: PxVehicleDirectDriveThrottleCommandResponseParams.prototype.get_maxResponse, set: PxVehicleDirectDriveThrottleCommandResponseParams.prototype.set_maxResponse });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDirectDriveThrottleCommandResponseParams.prototype['__destroy__'] = PxVehicleDirectDriveThrottleCommandResponseParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleDirectDriveThrottleCommandResponseParams___destroy___0(self);
};

// Interface: PxVehicleDirectDriveTransmissionCommandState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleDirectDriveTransmissionCommandState() {
  this.ptr = _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_PxVehicleDirectDriveTransmissionCommandState_0();
  getCache(PxVehicleDirectDriveTransmissionCommandState)[this.ptr] = this;
};

PxVehicleDirectDriveTransmissionCommandState.prototype = Object.create(WrapperObject.prototype);
PxVehicleDirectDriveTransmissionCommandState.prototype.constructor = PxVehicleDirectDriveTransmissionCommandState;
PxVehicleDirectDriveTransmissionCommandState.prototype.__class__ = PxVehicleDirectDriveTransmissionCommandState;
PxVehicleDirectDriveTransmissionCommandState.__cache__ = {};
Module['PxVehicleDirectDriveTransmissionCommandState'] = PxVehicleDirectDriveTransmissionCommandState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDirectDriveTransmissionCommandState.prototype['setToDefault'] = PxVehicleDirectDriveTransmissionCommandState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDirectDriveTransmissionCommandState.prototype['get_gear'] = PxVehicleDirectDriveTransmissionCommandState.prototype.get_gear = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_get_gear_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDirectDriveTransmissionCommandState.prototype['set_gear'] = PxVehicleDirectDriveTransmissionCommandState.prototype.set_gear = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState_set_gear_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleDirectDriveTransmissionCommandState.prototype, 'gear', { get: PxVehicleDirectDriveTransmissionCommandState.prototype.get_gear, set: PxVehicleDirectDriveTransmissionCommandState.prototype.set_gear });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleDirectDriveTransmissionCommandState.prototype['__destroy__'] = PxVehicleDirectDriveTransmissionCommandState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleDirectDriveTransmissionCommandState___destroy___0(self);
};

// Interface: PxVehicleEngineDriveThrottleCommandResponseState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleEngineDriveThrottleCommandResponseState() {
  this.ptr = _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_PxVehicleEngineDriveThrottleCommandResponseState_0();
  getCache(PxVehicleEngineDriveThrottleCommandResponseState)[this.ptr] = this;
};

PxVehicleEngineDriveThrottleCommandResponseState.prototype = Object.create(WrapperObject.prototype);
PxVehicleEngineDriveThrottleCommandResponseState.prototype.constructor = PxVehicleEngineDriveThrottleCommandResponseState;
PxVehicleEngineDriveThrottleCommandResponseState.prototype.__class__ = PxVehicleEngineDriveThrottleCommandResponseState;
PxVehicleEngineDriveThrottleCommandResponseState.__cache__ = {};
Module['PxVehicleEngineDriveThrottleCommandResponseState'] = PxVehicleEngineDriveThrottleCommandResponseState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineDriveThrottleCommandResponseState.prototype['setToDefault'] = PxVehicleEngineDriveThrottleCommandResponseState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineDriveThrottleCommandResponseState.prototype['get_commandResponse'] = PxVehicleEngineDriveThrottleCommandResponseState.prototype.get_commandResponse = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_get_commandResponse_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineDriveThrottleCommandResponseState.prototype['set_commandResponse'] = PxVehicleEngineDriveThrottleCommandResponseState.prototype.set_commandResponse = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState_set_commandResponse_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleEngineDriveThrottleCommandResponseState.prototype, 'commandResponse', { get: PxVehicleEngineDriveThrottleCommandResponseState.prototype.get_commandResponse, set: PxVehicleEngineDriveThrottleCommandResponseState.prototype.set_commandResponse });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineDriveThrottleCommandResponseState.prototype['__destroy__'] = PxVehicleEngineDriveThrottleCommandResponseState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleEngineDriveThrottleCommandResponseState___destroy___0(self);
};

// Interface: PxVehicleEngineParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleEngineParams() {
  this.ptr = _emscripten_bind_PxVehicleEngineParams_PxVehicleEngineParams_0();
  getCache(PxVehicleEngineParams)[this.ptr] = this;
};

PxVehicleEngineParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleEngineParams.prototype.constructor = PxVehicleEngineParams;
PxVehicleEngineParams.prototype.__class__ = PxVehicleEngineParams;
PxVehicleEngineParams.__cache__ = {};
Module['PxVehicleEngineParams'] = PxVehicleEngineParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['transformAndScale'] = PxVehicleEngineParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleEngineParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleEngineParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['isValid'] = PxVehicleEngineParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleEngineParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['get_torqueCurve'] = PxVehicleEngineParams.prototype.get_torqueCurve = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleEngineParams_get_torqueCurve_0(self), PxVehicleTorqueCurveLookupTable);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['set_torqueCurve'] = PxVehicleEngineParams.prototype.set_torqueCurve = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleEngineParams_set_torqueCurve_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleEngineParams.prototype, 'torqueCurve', { get: PxVehicleEngineParams.prototype.get_torqueCurve, set: PxVehicleEngineParams.prototype.set_torqueCurve });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['get_moi'] = PxVehicleEngineParams.prototype.get_moi = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleEngineParams_get_moi_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['set_moi'] = PxVehicleEngineParams.prototype.set_moi = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleEngineParams_set_moi_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleEngineParams.prototype, 'moi', { get: PxVehicleEngineParams.prototype.get_moi, set: PxVehicleEngineParams.prototype.set_moi });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['get_peakTorque'] = PxVehicleEngineParams.prototype.get_peakTorque = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleEngineParams_get_peakTorque_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['set_peakTorque'] = PxVehicleEngineParams.prototype.set_peakTorque = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleEngineParams_set_peakTorque_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleEngineParams.prototype, 'peakTorque', { get: PxVehicleEngineParams.prototype.get_peakTorque, set: PxVehicleEngineParams.prototype.set_peakTorque });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['get_idleOmega'] = PxVehicleEngineParams.prototype.get_idleOmega = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleEngineParams_get_idleOmega_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['set_idleOmega'] = PxVehicleEngineParams.prototype.set_idleOmega = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleEngineParams_set_idleOmega_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleEngineParams.prototype, 'idleOmega', { get: PxVehicleEngineParams.prototype.get_idleOmega, set: PxVehicleEngineParams.prototype.set_idleOmega });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['get_maxOmega'] = PxVehicleEngineParams.prototype.get_maxOmega = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleEngineParams_get_maxOmega_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['set_maxOmega'] = PxVehicleEngineParams.prototype.set_maxOmega = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleEngineParams_set_maxOmega_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleEngineParams.prototype, 'maxOmega', { get: PxVehicleEngineParams.prototype.get_maxOmega, set: PxVehicleEngineParams.prototype.set_maxOmega });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['get_dampingRateFullThrottle'] = PxVehicleEngineParams.prototype.get_dampingRateFullThrottle = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleEngineParams_get_dampingRateFullThrottle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['set_dampingRateFullThrottle'] = PxVehicleEngineParams.prototype.set_dampingRateFullThrottle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleEngineParams_set_dampingRateFullThrottle_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleEngineParams.prototype, 'dampingRateFullThrottle', { get: PxVehicleEngineParams.prototype.get_dampingRateFullThrottle, set: PxVehicleEngineParams.prototype.set_dampingRateFullThrottle });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['get_dampingRateZeroThrottleClutchEngaged'] = PxVehicleEngineParams.prototype.get_dampingRateZeroThrottleClutchEngaged = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchEngaged_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['set_dampingRateZeroThrottleClutchEngaged'] = PxVehicleEngineParams.prototype.set_dampingRateZeroThrottleClutchEngaged = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchEngaged_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleEngineParams.prototype, 'dampingRateZeroThrottleClutchEngaged', { get: PxVehicleEngineParams.prototype.get_dampingRateZeroThrottleClutchEngaged, set: PxVehicleEngineParams.prototype.set_dampingRateZeroThrottleClutchEngaged });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['get_dampingRateZeroThrottleClutchDisengaged'] = PxVehicleEngineParams.prototype.get_dampingRateZeroThrottleClutchDisengaged = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleEngineParams_get_dampingRateZeroThrottleClutchDisengaged_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['set_dampingRateZeroThrottleClutchDisengaged'] = PxVehicleEngineParams.prototype.set_dampingRateZeroThrottleClutchDisengaged = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleEngineParams_set_dampingRateZeroThrottleClutchDisengaged_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleEngineParams.prototype, 'dampingRateZeroThrottleClutchDisengaged', { get: PxVehicleEngineParams.prototype.get_dampingRateZeroThrottleClutchDisengaged, set: PxVehicleEngineParams.prototype.set_dampingRateZeroThrottleClutchDisengaged });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineParams.prototype['__destroy__'] = PxVehicleEngineParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleEngineParams___destroy___0(self);
};

// Interface: PxVehicleEngineState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleEngineState() {
  this.ptr = _emscripten_bind_PxVehicleEngineState_PxVehicleEngineState_0();
  getCache(PxVehicleEngineState)[this.ptr] = this;
};

PxVehicleEngineState.prototype = Object.create(WrapperObject.prototype);
PxVehicleEngineState.prototype.constructor = PxVehicleEngineState;
PxVehicleEngineState.prototype.__class__ = PxVehicleEngineState;
PxVehicleEngineState.__cache__ = {};
Module['PxVehicleEngineState'] = PxVehicleEngineState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineState.prototype['setToDefault'] = PxVehicleEngineState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleEngineState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineState.prototype['get_rotationSpeed'] = PxVehicleEngineState.prototype.get_rotationSpeed = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleEngineState_get_rotationSpeed_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineState.prototype['set_rotationSpeed'] = PxVehicleEngineState.prototype.set_rotationSpeed = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleEngineState_set_rotationSpeed_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleEngineState.prototype, 'rotationSpeed', { get: PxVehicleEngineState.prototype.get_rotationSpeed, set: PxVehicleEngineState.prototype.set_rotationSpeed });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleEngineState.prototype['__destroy__'] = PxVehicleEngineState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleEngineState___destroy___0(self);
};

// Interface: PxVehicleFixedSizeLookupTableFloat_3

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleFixedSizeLookupTableFloat_3() {
  this.ptr = _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_PxVehicleFixedSizeLookupTableFloat_3_0();
  getCache(PxVehicleFixedSizeLookupTableFloat_3)[this.ptr] = this;
};

PxVehicleFixedSizeLookupTableFloat_3.prototype = Object.create(WrapperObject.prototype);
PxVehicleFixedSizeLookupTableFloat_3.prototype.constructor = PxVehicleFixedSizeLookupTableFloat_3;
PxVehicleFixedSizeLookupTableFloat_3.prototype.__class__ = PxVehicleFixedSizeLookupTableFloat_3;
PxVehicleFixedSizeLookupTableFloat_3.__cache__ = {};
Module['PxVehicleFixedSizeLookupTableFloat_3'] = PxVehicleFixedSizeLookupTableFloat_3;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFixedSizeLookupTableFloat_3.prototype['addPair'] = PxVehicleFixedSizeLookupTableFloat_3.prototype.addPair = function(x, y) {
  var self = this.ptr;
  if (x && typeof x === 'object') x = x.ptr;
  if (y && typeof y === 'object') y = y.ptr;
  return !!(_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_addPair_2(self, x, y));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFixedSizeLookupTableFloat_3.prototype['interpolate'] = PxVehicleFixedSizeLookupTableFloat_3.prototype.interpolate = function(x) {
  var self = this.ptr;
  if (x && typeof x === 'object') x = x.ptr;
  return _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_interpolate_1(self, x);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFixedSizeLookupTableFloat_3.prototype['clear'] = PxVehicleFixedSizeLookupTableFloat_3.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_clear_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFixedSizeLookupTableFloat_3.prototype['isValid'] = PxVehicleFixedSizeLookupTableFloat_3.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3_isValid_0(self));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFixedSizeLookupTableFloat_3.prototype['__destroy__'] = PxVehicleFixedSizeLookupTableFloat_3.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleFixedSizeLookupTableFloat_3___destroy___0(self);
};

// Interface: PxVehicleFixedSizeLookupTableVec3_3

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleFixedSizeLookupTableVec3_3() {
  this.ptr = _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_PxVehicleFixedSizeLookupTableVec3_3_0();
  getCache(PxVehicleFixedSizeLookupTableVec3_3)[this.ptr] = this;
};

PxVehicleFixedSizeLookupTableVec3_3.prototype = Object.create(WrapperObject.prototype);
PxVehicleFixedSizeLookupTableVec3_3.prototype.constructor = PxVehicleFixedSizeLookupTableVec3_3;
PxVehicleFixedSizeLookupTableVec3_3.prototype.__class__ = PxVehicleFixedSizeLookupTableVec3_3;
PxVehicleFixedSizeLookupTableVec3_3.__cache__ = {};
Module['PxVehicleFixedSizeLookupTableVec3_3'] = PxVehicleFixedSizeLookupTableVec3_3;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFixedSizeLookupTableVec3_3.prototype['addPair'] = PxVehicleFixedSizeLookupTableVec3_3.prototype.addPair = function(x, y) {
  var self = this.ptr;
  if (x && typeof x === 'object') x = x.ptr;
  if (y && typeof y === 'object') y = y.ptr;
  return !!(_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_addPair_2(self, x, y));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFixedSizeLookupTableVec3_3.prototype['interpolate'] = PxVehicleFixedSizeLookupTableVec3_3.prototype.interpolate = function(x) {
  var self = this.ptr;
  if (x && typeof x === 'object') x = x.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_interpolate_1(self, x), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFixedSizeLookupTableVec3_3.prototype['clear'] = PxVehicleFixedSizeLookupTableVec3_3.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_clear_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFixedSizeLookupTableVec3_3.prototype['isValid'] = PxVehicleFixedSizeLookupTableVec3_3.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3_isValid_0(self));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFixedSizeLookupTableVec3_3.prototype['__destroy__'] = PxVehicleFixedSizeLookupTableVec3_3.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleFixedSizeLookupTableVec3_3___destroy___0(self);
};

// Interface: PxVehicleFourWheelDriveDifferentialParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleFourWheelDriveDifferentialParams() {
  this.ptr = _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_PxVehicleFourWheelDriveDifferentialParams_0();
  getCache(PxVehicleFourWheelDriveDifferentialParams)[this.ptr] = this;
};

PxVehicleFourWheelDriveDifferentialParams.prototype = Object.create(PxVehicleMultiWheelDriveDifferentialParams.prototype);
PxVehicleFourWheelDriveDifferentialParams.prototype.constructor = PxVehicleFourWheelDriveDifferentialParams;
PxVehicleFourWheelDriveDifferentialParams.prototype.__class__ = PxVehicleFourWheelDriveDifferentialParams;
PxVehicleFourWheelDriveDifferentialParams.__cache__ = {};
Module['PxVehicleFourWheelDriveDifferentialParams'] = PxVehicleFourWheelDriveDifferentialParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['setToDefault'] = PxVehicleFourWheelDriveDifferentialParams.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['transformAndScale'] = PxVehicleFourWheelDriveDifferentialParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleFourWheelDriveDifferentialParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['isValid'] = PxVehicleFourWheelDriveDifferentialParams.prototype.isValid = function(axleDesc) {
  var self = this.ptr;
  if (axleDesc && typeof axleDesc === 'object') axleDesc = axleDesc.ptr;
  return !!(_emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_isValid_1(self, axleDesc));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['get_frontWheelIds'] = PxVehicleFourWheelDriveDifferentialParams.prototype.get_frontWheelIds = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontWheelIds_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['set_frontWheelIds'] = PxVehicleFourWheelDriveDifferentialParams.prototype.set_frontWheelIds = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontWheelIds_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleFourWheelDriveDifferentialParams.prototype, 'frontWheelIds', { get: PxVehicleFourWheelDriveDifferentialParams.prototype.get_frontWheelIds, set: PxVehicleFourWheelDriveDifferentialParams.prototype.set_frontWheelIds });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['get_rearWheelIds'] = PxVehicleFourWheelDriveDifferentialParams.prototype.get_rearWheelIds = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearWheelIds_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['set_rearWheelIds'] = PxVehicleFourWheelDriveDifferentialParams.prototype.set_rearWheelIds = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearWheelIds_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleFourWheelDriveDifferentialParams.prototype, 'rearWheelIds', { get: PxVehicleFourWheelDriveDifferentialParams.prototype.get_rearWheelIds, set: PxVehicleFourWheelDriveDifferentialParams.prototype.set_rearWheelIds });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['get_frontBias'] = PxVehicleFourWheelDriveDifferentialParams.prototype.get_frontBias = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontBias_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['set_frontBias'] = PxVehicleFourWheelDriveDifferentialParams.prototype.set_frontBias = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontBias_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleFourWheelDriveDifferentialParams.prototype, 'frontBias', { get: PxVehicleFourWheelDriveDifferentialParams.prototype.get_frontBias, set: PxVehicleFourWheelDriveDifferentialParams.prototype.set_frontBias });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['get_frontTarget'] = PxVehicleFourWheelDriveDifferentialParams.prototype.get_frontTarget = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_frontTarget_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['set_frontTarget'] = PxVehicleFourWheelDriveDifferentialParams.prototype.set_frontTarget = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_frontTarget_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleFourWheelDriveDifferentialParams.prototype, 'frontTarget', { get: PxVehicleFourWheelDriveDifferentialParams.prototype.get_frontTarget, set: PxVehicleFourWheelDriveDifferentialParams.prototype.set_frontTarget });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['get_rearBias'] = PxVehicleFourWheelDriveDifferentialParams.prototype.get_rearBias = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearBias_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['set_rearBias'] = PxVehicleFourWheelDriveDifferentialParams.prototype.set_rearBias = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearBias_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleFourWheelDriveDifferentialParams.prototype, 'rearBias', { get: PxVehicleFourWheelDriveDifferentialParams.prototype.get_rearBias, set: PxVehicleFourWheelDriveDifferentialParams.prototype.set_rearBias });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['get_rearTarget'] = PxVehicleFourWheelDriveDifferentialParams.prototype.get_rearTarget = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rearTarget_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['set_rearTarget'] = PxVehicleFourWheelDriveDifferentialParams.prototype.set_rearTarget = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rearTarget_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleFourWheelDriveDifferentialParams.prototype, 'rearTarget', { get: PxVehicleFourWheelDriveDifferentialParams.prototype.get_rearTarget, set: PxVehicleFourWheelDriveDifferentialParams.prototype.set_rearTarget });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['get_centerBias'] = PxVehicleFourWheelDriveDifferentialParams.prototype.get_centerBias = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerBias_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['set_centerBias'] = PxVehicleFourWheelDriveDifferentialParams.prototype.set_centerBias = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerBias_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleFourWheelDriveDifferentialParams.prototype, 'centerBias', { get: PxVehicleFourWheelDriveDifferentialParams.prototype.get_centerBias, set: PxVehicleFourWheelDriveDifferentialParams.prototype.set_centerBias });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['get_centerTarget'] = PxVehicleFourWheelDriveDifferentialParams.prototype.get_centerTarget = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_centerTarget_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['set_centerTarget'] = PxVehicleFourWheelDriveDifferentialParams.prototype.set_centerTarget = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_centerTarget_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleFourWheelDriveDifferentialParams.prototype, 'centerTarget', { get: PxVehicleFourWheelDriveDifferentialParams.prototype.get_centerTarget, set: PxVehicleFourWheelDriveDifferentialParams.prototype.set_centerTarget });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['get_rate'] = PxVehicleFourWheelDriveDifferentialParams.prototype.get_rate = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_rate_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['set_rate'] = PxVehicleFourWheelDriveDifferentialParams.prototype.set_rate = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_rate_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleFourWheelDriveDifferentialParams.prototype, 'rate', { get: PxVehicleFourWheelDriveDifferentialParams.prototype.get_rate, set: PxVehicleFourWheelDriveDifferentialParams.prototype.set_rate });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['get_torqueRatios'] = PxVehicleFourWheelDriveDifferentialParams.prototype.get_torqueRatios = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_torqueRatios_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['set_torqueRatios'] = PxVehicleFourWheelDriveDifferentialParams.prototype.set_torqueRatios = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_torqueRatios_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleFourWheelDriveDifferentialParams.prototype, 'torqueRatios', { get: PxVehicleFourWheelDriveDifferentialParams.prototype.get_torqueRatios, set: PxVehicleFourWheelDriveDifferentialParams.prototype.set_torqueRatios });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['get_aveWheelSpeedRatios'] = PxVehicleFourWheelDriveDifferentialParams.prototype.get_aveWheelSpeedRatios = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_get_aveWheelSpeedRatios_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['set_aveWheelSpeedRatios'] = PxVehicleFourWheelDriveDifferentialParams.prototype.set_aveWheelSpeedRatios = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams_set_aveWheelSpeedRatios_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleFourWheelDriveDifferentialParams.prototype, 'aveWheelSpeedRatios', { get: PxVehicleFourWheelDriveDifferentialParams.prototype.get_aveWheelSpeedRatios, set: PxVehicleFourWheelDriveDifferentialParams.prototype.set_aveWheelSpeedRatios });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFourWheelDriveDifferentialParams.prototype['__destroy__'] = PxVehicleFourWheelDriveDifferentialParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleFourWheelDriveDifferentialParams___destroy___0(self);
};

// Interface: PxVehicleFrame

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleFrame() {
  this.ptr = _emscripten_bind_PxVehicleFrame_PxVehicleFrame_0();
  getCache(PxVehicleFrame)[this.ptr] = this;
};

PxVehicleFrame.prototype = Object.create(WrapperObject.prototype);
PxVehicleFrame.prototype.constructor = PxVehicleFrame;
PxVehicleFrame.prototype.__class__ = PxVehicleFrame;
PxVehicleFrame.__cache__ = {};
Module['PxVehicleFrame'] = PxVehicleFrame;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFrame.prototype['setToDefault'] = PxVehicleFrame.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleFrame_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFrame.prototype['getFrame'] = PxVehicleFrame.prototype.getFrame = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleFrame_getFrame_0(self), PxMat33);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFrame.prototype['isValid'] = PxVehicleFrame.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleFrame_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFrame.prototype['get_lngAxis'] = PxVehicleFrame.prototype.get_lngAxis = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleFrame_get_lngAxis_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFrame.prototype['set_lngAxis'] = PxVehicleFrame.prototype.set_lngAxis = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleFrame_set_lngAxis_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleFrame.prototype, 'lngAxis', { get: PxVehicleFrame.prototype.get_lngAxis, set: PxVehicleFrame.prototype.set_lngAxis });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFrame.prototype['get_latAxis'] = PxVehicleFrame.prototype.get_latAxis = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleFrame_get_latAxis_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFrame.prototype['set_latAxis'] = PxVehicleFrame.prototype.set_latAxis = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleFrame_set_latAxis_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleFrame.prototype, 'latAxis', { get: PxVehicleFrame.prototype.get_latAxis, set: PxVehicleFrame.prototype.set_latAxis });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFrame.prototype['get_vrtAxis'] = PxVehicleFrame.prototype.get_vrtAxis = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleFrame_get_vrtAxis_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFrame.prototype['set_vrtAxis'] = PxVehicleFrame.prototype.set_vrtAxis = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleFrame_set_vrtAxis_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleFrame.prototype, 'vrtAxis', { get: PxVehicleFrame.prototype.get_vrtAxis, set: PxVehicleFrame.prototype.set_vrtAxis });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleFrame.prototype['__destroy__'] = PxVehicleFrame.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleFrame___destroy___0(self);
};

// Interface: PxVehicleGearboxParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleGearboxParams() {
  this.ptr = _emscripten_bind_PxVehicleGearboxParams_PxVehicleGearboxParams_0();
  getCache(PxVehicleGearboxParams)[this.ptr] = this;
};

PxVehicleGearboxParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleGearboxParams.prototype.constructor = PxVehicleGearboxParams;
PxVehicleGearboxParams.prototype.__class__ = PxVehicleGearboxParams;
PxVehicleGearboxParams.__cache__ = {};
Module['PxVehicleGearboxParams'] = PxVehicleGearboxParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxParams.prototype['transformAndScale'] = PxVehicleGearboxParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleGearboxParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleGearboxParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxParams.prototype['isValid'] = PxVehicleGearboxParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleGearboxParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxParams.prototype['get_neutralGear'] = PxVehicleGearboxParams.prototype.get_neutralGear = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleGearboxParams_get_neutralGear_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxParams.prototype['set_neutralGear'] = PxVehicleGearboxParams.prototype.set_neutralGear = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleGearboxParams_set_neutralGear_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleGearboxParams.prototype, 'neutralGear', { get: PxVehicleGearboxParams.prototype.get_neutralGear, set: PxVehicleGearboxParams.prototype.set_neutralGear });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxParams.prototype['get_ratios'] = PxVehicleGearboxParams.prototype.get_ratios = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleGearboxParams_get_ratios_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxParams.prototype['set_ratios'] = PxVehicleGearboxParams.prototype.set_ratios = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleGearboxParams_set_ratios_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleGearboxParams.prototype, 'ratios', { get: PxVehicleGearboxParams.prototype.get_ratios, set: PxVehicleGearboxParams.prototype.set_ratios });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxParams.prototype['get_finalRatio'] = PxVehicleGearboxParams.prototype.get_finalRatio = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleGearboxParams_get_finalRatio_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxParams.prototype['set_finalRatio'] = PxVehicleGearboxParams.prototype.set_finalRatio = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleGearboxParams_set_finalRatio_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleGearboxParams.prototype, 'finalRatio', { get: PxVehicleGearboxParams.prototype.get_finalRatio, set: PxVehicleGearboxParams.prototype.set_finalRatio });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxParams.prototype['get_nbRatios'] = PxVehicleGearboxParams.prototype.get_nbRatios = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleGearboxParams_get_nbRatios_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxParams.prototype['set_nbRatios'] = PxVehicleGearboxParams.prototype.set_nbRatios = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleGearboxParams_set_nbRatios_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleGearboxParams.prototype, 'nbRatios', { get: PxVehicleGearboxParams.prototype.get_nbRatios, set: PxVehicleGearboxParams.prototype.set_nbRatios });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxParams.prototype['get_switchTime'] = PxVehicleGearboxParams.prototype.get_switchTime = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleGearboxParams_get_switchTime_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxParams.prototype['set_switchTime'] = PxVehicleGearboxParams.prototype.set_switchTime = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleGearboxParams_set_switchTime_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleGearboxParams.prototype, 'switchTime', { get: PxVehicleGearboxParams.prototype.get_switchTime, set: PxVehicleGearboxParams.prototype.set_switchTime });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxParams.prototype['__destroy__'] = PxVehicleGearboxParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleGearboxParams___destroy___0(self);
};

// Interface: PxVehicleGearboxState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleGearboxState() {
  this.ptr = _emscripten_bind_PxVehicleGearboxState_PxVehicleGearboxState_0();
  getCache(PxVehicleGearboxState)[this.ptr] = this;
};

PxVehicleGearboxState.prototype = Object.create(WrapperObject.prototype);
PxVehicleGearboxState.prototype.constructor = PxVehicleGearboxState;
PxVehicleGearboxState.prototype.__class__ = PxVehicleGearboxState;
PxVehicleGearboxState.__cache__ = {};
Module['PxVehicleGearboxState'] = PxVehicleGearboxState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxState.prototype['setToDefault'] = PxVehicleGearboxState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleGearboxState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxState.prototype['get_currentGear'] = PxVehicleGearboxState.prototype.get_currentGear = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleGearboxState_get_currentGear_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxState.prototype['set_currentGear'] = PxVehicleGearboxState.prototype.set_currentGear = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleGearboxState_set_currentGear_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleGearboxState.prototype, 'currentGear', { get: PxVehicleGearboxState.prototype.get_currentGear, set: PxVehicleGearboxState.prototype.set_currentGear });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxState.prototype['get_targetGear'] = PxVehicleGearboxState.prototype.get_targetGear = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleGearboxState_get_targetGear_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxState.prototype['set_targetGear'] = PxVehicleGearboxState.prototype.set_targetGear = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleGearboxState_set_targetGear_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleGearboxState.prototype, 'targetGear', { get: PxVehicleGearboxState.prototype.get_targetGear, set: PxVehicleGearboxState.prototype.set_targetGear });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxState.prototype['get_gearSwitchTime'] = PxVehicleGearboxState.prototype.get_gearSwitchTime = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleGearboxState_get_gearSwitchTime_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxState.prototype['set_gearSwitchTime'] = PxVehicleGearboxState.prototype.set_gearSwitchTime = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleGearboxState_set_gearSwitchTime_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleGearboxState.prototype, 'gearSwitchTime', { get: PxVehicleGearboxState.prototype.get_gearSwitchTime, set: PxVehicleGearboxState.prototype.set_gearSwitchTime });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleGearboxState.prototype['__destroy__'] = PxVehicleGearboxState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleGearboxState___destroy___0(self);
};

// Interface: PxVehiclePhysXActor

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehiclePhysXActor() { throw "cannot construct a PxVehiclePhysXActor, no constructor in IDL" }
PxVehiclePhysXActor.prototype = Object.create(WrapperObject.prototype);
PxVehiclePhysXActor.prototype.constructor = PxVehiclePhysXActor;
PxVehiclePhysXActor.prototype.__class__ = PxVehiclePhysXActor;
PxVehiclePhysXActor.__cache__ = {};
Module['PxVehiclePhysXActor'] = PxVehiclePhysXActor;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXActor.prototype['setToDefault'] = PxVehiclePhysXActor.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehiclePhysXActor_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXActor.prototype['get_rigidBody'] = PxVehiclePhysXActor.prototype.get_rigidBody = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXActor_get_rigidBody_0(self), PxRigidBody);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXActor.prototype['set_rigidBody'] = PxVehiclePhysXActor.prototype.set_rigidBody = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXActor_set_rigidBody_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXActor.prototype, 'rigidBody', { get: PxVehiclePhysXActor.prototype.get_rigidBody, set: PxVehiclePhysXActor.prototype.set_rigidBody });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXActor.prototype['get_wheelShapes'] = PxVehiclePhysXActor.prototype.get_wheelShapes = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXActor_get_wheelShapes_1(self, arg0), PxShape);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXActor.prototype['set_wheelShapes'] = PxVehiclePhysXActor.prototype.set_wheelShapes = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehiclePhysXActor_set_wheelShapes_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXActor.prototype, 'wheelShapes', { get: PxVehiclePhysXActor.prototype.get_wheelShapes, set: PxVehiclePhysXActor.prototype.set_wheelShapes });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXActor.prototype['__destroy__'] = PxVehiclePhysXActor.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehiclePhysXActor___destroy___0(self);
};

// Interface: PxVehiclePhysXConstraintState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehiclePhysXConstraintState() {
  this.ptr = _emscripten_bind_PxVehiclePhysXConstraintState_PxVehiclePhysXConstraintState_0();
  getCache(PxVehiclePhysXConstraintState)[this.ptr] = this;
};

PxVehiclePhysXConstraintState.prototype = Object.create(WrapperObject.prototype);
PxVehiclePhysXConstraintState.prototype.constructor = PxVehiclePhysXConstraintState;
PxVehiclePhysXConstraintState.prototype.__class__ = PxVehiclePhysXConstraintState;
PxVehiclePhysXConstraintState.__cache__ = {};
Module['PxVehiclePhysXConstraintState'] = PxVehiclePhysXConstraintState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['setToDefault'] = PxVehiclePhysXConstraintState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehiclePhysXConstraintState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['get_tireActiveStatus'] = PxVehiclePhysXConstraintState.prototype.get_tireActiveStatus = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return !!(_emscripten_bind_PxVehiclePhysXConstraintState_get_tireActiveStatus_1(self, arg0));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['set_tireActiveStatus'] = PxVehiclePhysXConstraintState.prototype.set_tireActiveStatus = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehiclePhysXConstraintState_set_tireActiveStatus_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXConstraintState.prototype, 'tireActiveStatus', { get: PxVehiclePhysXConstraintState.prototype.get_tireActiveStatus, set: PxVehiclePhysXConstraintState.prototype.set_tireActiveStatus });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['get_tireLinears'] = PxVehiclePhysXConstraintState.prototype.get_tireLinears = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXConstraintState_get_tireLinears_1(self, arg0), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['set_tireLinears'] = PxVehiclePhysXConstraintState.prototype.set_tireLinears = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehiclePhysXConstraintState_set_tireLinears_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXConstraintState.prototype, 'tireLinears', { get: PxVehiclePhysXConstraintState.prototype.get_tireLinears, set: PxVehiclePhysXConstraintState.prototype.set_tireLinears });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['get_tireAngulars'] = PxVehiclePhysXConstraintState.prototype.get_tireAngulars = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXConstraintState_get_tireAngulars_1(self, arg0), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['set_tireAngulars'] = PxVehiclePhysXConstraintState.prototype.set_tireAngulars = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehiclePhysXConstraintState_set_tireAngulars_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXConstraintState.prototype, 'tireAngulars', { get: PxVehiclePhysXConstraintState.prototype.get_tireAngulars, set: PxVehiclePhysXConstraintState.prototype.set_tireAngulars });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['get_tireDamping'] = PxVehiclePhysXConstraintState.prototype.get_tireDamping = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehiclePhysXConstraintState_get_tireDamping_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['set_tireDamping'] = PxVehiclePhysXConstraintState.prototype.set_tireDamping = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehiclePhysXConstraintState_set_tireDamping_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXConstraintState.prototype, 'tireDamping', { get: PxVehiclePhysXConstraintState.prototype.get_tireDamping, set: PxVehiclePhysXConstraintState.prototype.set_tireDamping });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['get_suspActiveStatus'] = PxVehiclePhysXConstraintState.prototype.get_suspActiveStatus = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehiclePhysXConstraintState_get_suspActiveStatus_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['set_suspActiveStatus'] = PxVehiclePhysXConstraintState.prototype.set_suspActiveStatus = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXConstraintState_set_suspActiveStatus_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXConstraintState.prototype, 'suspActiveStatus', { get: PxVehiclePhysXConstraintState.prototype.get_suspActiveStatus, set: PxVehiclePhysXConstraintState.prototype.set_suspActiveStatus });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['get_suspLinear'] = PxVehiclePhysXConstraintState.prototype.get_suspLinear = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXConstraintState_get_suspLinear_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['set_suspLinear'] = PxVehiclePhysXConstraintState.prototype.set_suspLinear = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXConstraintState_set_suspLinear_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXConstraintState.prototype, 'suspLinear', { get: PxVehiclePhysXConstraintState.prototype.get_suspLinear, set: PxVehiclePhysXConstraintState.prototype.set_suspLinear });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['get_suspAngular'] = PxVehiclePhysXConstraintState.prototype.get_suspAngular = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXConstraintState_get_suspAngular_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['set_suspAngular'] = PxVehiclePhysXConstraintState.prototype.set_suspAngular = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXConstraintState_set_suspAngular_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXConstraintState.prototype, 'suspAngular', { get: PxVehiclePhysXConstraintState.prototype.get_suspAngular, set: PxVehiclePhysXConstraintState.prototype.set_suspAngular });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['get_suspGeometricError'] = PxVehiclePhysXConstraintState.prototype.get_suspGeometricError = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehiclePhysXConstraintState_get_suspGeometricError_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['set_suspGeometricError'] = PxVehiclePhysXConstraintState.prototype.set_suspGeometricError = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXConstraintState_set_suspGeometricError_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXConstraintState.prototype, 'suspGeometricError', { get: PxVehiclePhysXConstraintState.prototype.get_suspGeometricError, set: PxVehiclePhysXConstraintState.prototype.set_suspGeometricError });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['get_restitution'] = PxVehiclePhysXConstraintState.prototype.get_restitution = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehiclePhysXConstraintState_get_restitution_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['set_restitution'] = PxVehiclePhysXConstraintState.prototype.set_restitution = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXConstraintState_set_restitution_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXConstraintState.prototype, 'restitution', { get: PxVehiclePhysXConstraintState.prototype.get_restitution, set: PxVehiclePhysXConstraintState.prototype.set_restitution });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraintState.prototype['__destroy__'] = PxVehiclePhysXConstraintState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehiclePhysXConstraintState___destroy___0(self);
};

// Interface: PxVehiclePhysXConstraints

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehiclePhysXConstraints() { throw "cannot construct a PxVehiclePhysXConstraints, no constructor in IDL" }
PxVehiclePhysXConstraints.prototype = Object.create(WrapperObject.prototype);
PxVehiclePhysXConstraints.prototype.constructor = PxVehiclePhysXConstraints;
PxVehiclePhysXConstraints.prototype.__class__ = PxVehiclePhysXConstraints;
PxVehiclePhysXConstraints.__cache__ = {};
Module['PxVehiclePhysXConstraints'] = PxVehiclePhysXConstraints;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraints.prototype['setToDefault'] = PxVehiclePhysXConstraints.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehiclePhysXConstraints_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraints.prototype['get_constraintStates'] = PxVehiclePhysXConstraints.prototype.get_constraintStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXConstraints_get_constraintStates_1(self, arg0), PxVehiclePhysXConstraintState);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraints.prototype['set_constraintStates'] = PxVehiclePhysXConstraints.prototype.set_constraintStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehiclePhysXConstraints_set_constraintStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXConstraints.prototype, 'constraintStates', { get: PxVehiclePhysXConstraints.prototype.get_constraintStates, set: PxVehiclePhysXConstraints.prototype.set_constraintStates });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraints.prototype['get_constraints'] = PxVehiclePhysXConstraints.prototype.get_constraints = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXConstraints_get_constraints_1(self, arg0), PxConstraint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraints.prototype['set_constraints'] = PxVehiclePhysXConstraints.prototype.set_constraints = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehiclePhysXConstraints_set_constraints_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXConstraints.prototype, 'constraints', { get: PxVehiclePhysXConstraints.prototype.get_constraints, set: PxVehiclePhysXConstraints.prototype.set_constraints });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraints.prototype['get_constraintConnectors'] = PxVehiclePhysXConstraints.prototype.get_constraintConnectors = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXConstraints_get_constraintConnectors_1(self, arg0), PxVehicleConstraintConnector);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraints.prototype['set_constraintConnectors'] = PxVehiclePhysXConstraints.prototype.set_constraintConnectors = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehiclePhysXConstraints_set_constraintConnectors_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXConstraints.prototype, 'constraintConnectors', { get: PxVehiclePhysXConstraints.prototype.get_constraintConnectors, set: PxVehiclePhysXConstraints.prototype.set_constraintConnectors });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXConstraints.prototype['__destroy__'] = PxVehiclePhysXConstraints.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehiclePhysXConstraints___destroy___0(self);
};

// Interface: PxVehiclePhysXMaterialFriction

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehiclePhysXMaterialFriction() {
  this.ptr = _emscripten_bind_PxVehiclePhysXMaterialFriction_PxVehiclePhysXMaterialFriction_0();
  getCache(PxVehiclePhysXMaterialFriction)[this.ptr] = this;
};

PxVehiclePhysXMaterialFriction.prototype = Object.create(WrapperObject.prototype);
PxVehiclePhysXMaterialFriction.prototype.constructor = PxVehiclePhysXMaterialFriction;
PxVehiclePhysXMaterialFriction.prototype.__class__ = PxVehiclePhysXMaterialFriction;
PxVehiclePhysXMaterialFriction.__cache__ = {};
Module['PxVehiclePhysXMaterialFriction'] = PxVehiclePhysXMaterialFriction;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXMaterialFriction.prototype['isValid'] = PxVehiclePhysXMaterialFriction.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehiclePhysXMaterialFriction_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXMaterialFriction.prototype['get_material'] = PxVehiclePhysXMaterialFriction.prototype.get_material = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXMaterialFriction_get_material_0(self), PxMaterial);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXMaterialFriction.prototype['set_material'] = PxVehiclePhysXMaterialFriction.prototype.set_material = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXMaterialFriction_set_material_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXMaterialFriction.prototype, 'material', { get: PxVehiclePhysXMaterialFriction.prototype.get_material, set: PxVehiclePhysXMaterialFriction.prototype.set_material });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXMaterialFriction.prototype['get_friction'] = PxVehiclePhysXMaterialFriction.prototype.get_friction = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehiclePhysXMaterialFriction_get_friction_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXMaterialFriction.prototype['set_friction'] = PxVehiclePhysXMaterialFriction.prototype.set_friction = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXMaterialFriction_set_friction_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXMaterialFriction.prototype, 'friction', { get: PxVehiclePhysXMaterialFriction.prototype.get_friction, set: PxVehiclePhysXMaterialFriction.prototype.set_friction });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXMaterialFriction.prototype['__destroy__'] = PxVehiclePhysXMaterialFriction.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehiclePhysXMaterialFriction___destroy___0(self);
};

// Interface: PxVehiclePhysXMaterialFrictionParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehiclePhysXMaterialFrictionParams() { throw "cannot construct a PxVehiclePhysXMaterialFrictionParams, no constructor in IDL" }
PxVehiclePhysXMaterialFrictionParams.prototype = Object.create(WrapperObject.prototype);
PxVehiclePhysXMaterialFrictionParams.prototype.constructor = PxVehiclePhysXMaterialFrictionParams;
PxVehiclePhysXMaterialFrictionParams.prototype.__class__ = PxVehiclePhysXMaterialFrictionParams;
PxVehiclePhysXMaterialFrictionParams.__cache__ = {};
Module['PxVehiclePhysXMaterialFrictionParams'] = PxVehiclePhysXMaterialFrictionParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXMaterialFrictionParams.prototype['isValid'] = PxVehiclePhysXMaterialFrictionParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXMaterialFrictionParams.prototype['get_materialFrictions'] = PxVehiclePhysXMaterialFrictionParams.prototype.get_materialFrictions = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_materialFrictions_0(self), PxVehiclePhysXMaterialFriction);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXMaterialFrictionParams.prototype['set_materialFrictions'] = PxVehiclePhysXMaterialFrictionParams.prototype.set_materialFrictions = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_materialFrictions_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXMaterialFrictionParams.prototype, 'materialFrictions', { get: PxVehiclePhysXMaterialFrictionParams.prototype.get_materialFrictions, set: PxVehiclePhysXMaterialFrictionParams.prototype.set_materialFrictions });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXMaterialFrictionParams.prototype['get_nbMaterialFrictions'] = PxVehiclePhysXMaterialFrictionParams.prototype.get_nbMaterialFrictions = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_nbMaterialFrictions_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXMaterialFrictionParams.prototype['set_nbMaterialFrictions'] = PxVehiclePhysXMaterialFrictionParams.prototype.set_nbMaterialFrictions = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_nbMaterialFrictions_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXMaterialFrictionParams.prototype, 'nbMaterialFrictions', { get: PxVehiclePhysXMaterialFrictionParams.prototype.get_nbMaterialFrictions, set: PxVehiclePhysXMaterialFrictionParams.prototype.set_nbMaterialFrictions });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXMaterialFrictionParams.prototype['get_defaultFriction'] = PxVehiclePhysXMaterialFrictionParams.prototype.get_defaultFriction = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_get_defaultFriction_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXMaterialFrictionParams.prototype['set_defaultFriction'] = PxVehiclePhysXMaterialFrictionParams.prototype.set_defaultFriction = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXMaterialFrictionParams_set_defaultFriction_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXMaterialFrictionParams.prototype, 'defaultFriction', { get: PxVehiclePhysXMaterialFrictionParams.prototype.get_defaultFriction, set: PxVehiclePhysXMaterialFrictionParams.prototype.set_defaultFriction });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXMaterialFrictionParams.prototype['__destroy__'] = PxVehiclePhysXMaterialFrictionParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehiclePhysXMaterialFrictionParams___destroy___0(self);
};

// Interface: PxVehiclePhysXRoadGeometryQueryParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehiclePhysXRoadGeometryQueryParams() { throw "cannot construct a PxVehiclePhysXRoadGeometryQueryParams, no constructor in IDL" }
PxVehiclePhysXRoadGeometryQueryParams.prototype = Object.create(WrapperObject.prototype);
PxVehiclePhysXRoadGeometryQueryParams.prototype.constructor = PxVehiclePhysXRoadGeometryQueryParams;
PxVehiclePhysXRoadGeometryQueryParams.prototype.__class__ = PxVehiclePhysXRoadGeometryQueryParams;
PxVehiclePhysXRoadGeometryQueryParams.__cache__ = {};
Module['PxVehiclePhysXRoadGeometryQueryParams'] = PxVehiclePhysXRoadGeometryQueryParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXRoadGeometryQueryParams.prototype['transformAndScale'] = PxVehiclePhysXRoadGeometryQueryParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehiclePhysXRoadGeometryQueryParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXRoadGeometryQueryParams.prototype['isValid'] = PxVehiclePhysXRoadGeometryQueryParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXRoadGeometryQueryParams.prototype['get_roadGeometryQueryType'] = PxVehiclePhysXRoadGeometryQueryParams.prototype.get_roadGeometryQueryType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_roadGeometryQueryType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXRoadGeometryQueryParams.prototype['set_roadGeometryQueryType'] = PxVehiclePhysXRoadGeometryQueryParams.prototype.set_roadGeometryQueryType = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_roadGeometryQueryType_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXRoadGeometryQueryParams.prototype, 'roadGeometryQueryType', { get: PxVehiclePhysXRoadGeometryQueryParams.prototype.get_roadGeometryQueryType, set: PxVehiclePhysXRoadGeometryQueryParams.prototype.set_roadGeometryQueryType });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXRoadGeometryQueryParams.prototype['get_defaultFilterData'] = PxVehiclePhysXRoadGeometryQueryParams.prototype.get_defaultFilterData = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_defaultFilterData_0(self), PxQueryFilterData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXRoadGeometryQueryParams.prototype['set_defaultFilterData'] = PxVehiclePhysXRoadGeometryQueryParams.prototype.set_defaultFilterData = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_defaultFilterData_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXRoadGeometryQueryParams.prototype, 'defaultFilterData', { get: PxVehiclePhysXRoadGeometryQueryParams.prototype.get_defaultFilterData, set: PxVehiclePhysXRoadGeometryQueryParams.prototype.set_defaultFilterData });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXRoadGeometryQueryParams.prototype['get_filterDataEntries'] = PxVehiclePhysXRoadGeometryQueryParams.prototype.get_filterDataEntries = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterDataEntries_0(self), PxQueryFilterData);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXRoadGeometryQueryParams.prototype['set_filterDataEntries'] = PxVehiclePhysXRoadGeometryQueryParams.prototype.set_filterDataEntries = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterDataEntries_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXRoadGeometryQueryParams.prototype, 'filterDataEntries', { get: PxVehiclePhysXRoadGeometryQueryParams.prototype.get_filterDataEntries, set: PxVehiclePhysXRoadGeometryQueryParams.prototype.set_filterDataEntries });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXRoadGeometryQueryParams.prototype['get_filterCallback'] = PxVehiclePhysXRoadGeometryQueryParams.prototype.get_filterCallback = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_get_filterCallback_0(self), PxQueryFilterCallback);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXRoadGeometryQueryParams.prototype['set_filterCallback'] = PxVehiclePhysXRoadGeometryQueryParams.prototype.set_filterCallback = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams_set_filterCallback_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXRoadGeometryQueryParams.prototype, 'filterCallback', { get: PxVehiclePhysXRoadGeometryQueryParams.prototype.get_filterCallback, set: PxVehiclePhysXRoadGeometryQueryParams.prototype.set_filterCallback });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXRoadGeometryQueryParams.prototype['__destroy__'] = PxVehiclePhysXRoadGeometryQueryParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehiclePhysXRoadGeometryQueryParams___destroy___0(self);
};

// Interface: PxVehiclePhysXSimulationContext

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehiclePhysXSimulationContext() {
  this.ptr = _emscripten_bind_PxVehiclePhysXSimulationContext_PxVehiclePhysXSimulationContext_0();
  getCache(PxVehiclePhysXSimulationContext)[this.ptr] = this;
};

PxVehiclePhysXSimulationContext.prototype = Object.create(PxVehicleSimulationContext.prototype);
PxVehiclePhysXSimulationContext.prototype.constructor = PxVehiclePhysXSimulationContext;
PxVehiclePhysXSimulationContext.prototype.__class__ = PxVehiclePhysXSimulationContext;
PxVehiclePhysXSimulationContext.__cache__ = {};
Module['PxVehiclePhysXSimulationContext'] = PxVehiclePhysXSimulationContext;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['transformAndScale'] = PxVehiclePhysXSimulationContext.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXSimulationContext_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehiclePhysXSimulationContext);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['getType'] = PxVehiclePhysXSimulationContext.prototype.getType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehiclePhysXSimulationContext_getType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['setToDefault'] = PxVehiclePhysXSimulationContext.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehiclePhysXSimulationContext_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['get_physxUnitCylinderSweepMesh'] = PxVehiclePhysXSimulationContext.prototype.get_physxUnitCylinderSweepMesh = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxUnitCylinderSweepMesh_0(self), PxConvexMesh);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['set_physxUnitCylinderSweepMesh'] = PxVehiclePhysXSimulationContext.prototype.set_physxUnitCylinderSweepMesh = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxUnitCylinderSweepMesh_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSimulationContext.prototype, 'physxUnitCylinderSweepMesh', { get: PxVehiclePhysXSimulationContext.prototype.get_physxUnitCylinderSweepMesh, set: PxVehiclePhysXSimulationContext.prototype.set_physxUnitCylinderSweepMesh });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['get_physxScene'] = PxVehiclePhysXSimulationContext.prototype.get_physxScene = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXSimulationContext_get_physxScene_0(self), PxScene);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['set_physxScene'] = PxVehiclePhysXSimulationContext.prototype.set_physxScene = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxScene_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSimulationContext.prototype, 'physxScene', { get: PxVehiclePhysXSimulationContext.prototype.get_physxScene, set: PxVehiclePhysXSimulationContext.prototype.set_physxScene });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['get_physxActorUpdateMode'] = PxVehiclePhysXSimulationContext.prototype.get_physxActorUpdateMode = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorUpdateMode_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['set_physxActorUpdateMode'] = PxVehiclePhysXSimulationContext.prototype.set_physxActorUpdateMode = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorUpdateMode_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSimulationContext.prototype, 'physxActorUpdateMode', { get: PxVehiclePhysXSimulationContext.prototype.get_physxActorUpdateMode, set: PxVehiclePhysXSimulationContext.prototype.set_physxActorUpdateMode });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['get_physxActorWakeCounterResetValue'] = PxVehiclePhysXSimulationContext.prototype.get_physxActorWakeCounterResetValue = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterResetValue_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['set_physxActorWakeCounterResetValue'] = PxVehiclePhysXSimulationContext.prototype.set_physxActorWakeCounterResetValue = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterResetValue_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSimulationContext.prototype, 'physxActorWakeCounterResetValue', { get: PxVehiclePhysXSimulationContext.prototype.get_physxActorWakeCounterResetValue, set: PxVehiclePhysXSimulationContext.prototype.set_physxActorWakeCounterResetValue });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['get_physxActorWakeCounterThreshold'] = PxVehiclePhysXSimulationContext.prototype.get_physxActorWakeCounterThreshold = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehiclePhysXSimulationContext_get_physxActorWakeCounterThreshold_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['set_physxActorWakeCounterThreshold'] = PxVehiclePhysXSimulationContext.prototype.set_physxActorWakeCounterThreshold = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_physxActorWakeCounterThreshold_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSimulationContext.prototype, 'physxActorWakeCounterThreshold', { get: PxVehiclePhysXSimulationContext.prototype.get_physxActorWakeCounterThreshold, set: PxVehiclePhysXSimulationContext.prototype.set_physxActorWakeCounterThreshold });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['get_gravity'] = PxVehiclePhysXSimulationContext.prototype.get_gravity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXSimulationContext_get_gravity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['set_gravity'] = PxVehiclePhysXSimulationContext.prototype.set_gravity = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_gravity_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSimulationContext.prototype, 'gravity', { get: PxVehiclePhysXSimulationContext.prototype.get_gravity, set: PxVehiclePhysXSimulationContext.prototype.set_gravity });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['get_frame'] = PxVehiclePhysXSimulationContext.prototype.get_frame = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXSimulationContext_get_frame_0(self), PxVehicleFrame);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['set_frame'] = PxVehiclePhysXSimulationContext.prototype.set_frame = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_frame_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSimulationContext.prototype, 'frame', { get: PxVehiclePhysXSimulationContext.prototype.get_frame, set: PxVehiclePhysXSimulationContext.prototype.set_frame });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['get_scale'] = PxVehiclePhysXSimulationContext.prototype.get_scale = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXSimulationContext_get_scale_0(self), PxVehicleScale);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['set_scale'] = PxVehiclePhysXSimulationContext.prototype.set_scale = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_scale_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSimulationContext.prototype, 'scale', { get: PxVehiclePhysXSimulationContext.prototype.get_scale, set: PxVehiclePhysXSimulationContext.prototype.set_scale });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['get_tireSlipParams'] = PxVehiclePhysXSimulationContext.prototype.get_tireSlipParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXSimulationContext_get_tireSlipParams_0(self), PxVehicleTireSlipParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['set_tireSlipParams'] = PxVehiclePhysXSimulationContext.prototype.set_tireSlipParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_tireSlipParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSimulationContext.prototype, 'tireSlipParams', { get: PxVehiclePhysXSimulationContext.prototype.get_tireSlipParams, set: PxVehiclePhysXSimulationContext.prototype.set_tireSlipParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['get_tireStickyParams'] = PxVehiclePhysXSimulationContext.prototype.get_tireStickyParams = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXSimulationContext_get_tireStickyParams_0(self), PxVehicleTireStickyParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['set_tireStickyParams'] = PxVehiclePhysXSimulationContext.prototype.set_tireStickyParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_tireStickyParams_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSimulationContext.prototype, 'tireStickyParams', { get: PxVehiclePhysXSimulationContext.prototype.get_tireStickyParams, set: PxVehiclePhysXSimulationContext.prototype.set_tireStickyParams });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['get_thresholdForwardSpeedForWheelAngleIntegration'] = PxVehiclePhysXSimulationContext.prototype.get_thresholdForwardSpeedForWheelAngleIntegration = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehiclePhysXSimulationContext_get_thresholdForwardSpeedForWheelAngleIntegration_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['set_thresholdForwardSpeedForWheelAngleIntegration'] = PxVehiclePhysXSimulationContext.prototype.set_thresholdForwardSpeedForWheelAngleIntegration = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_thresholdForwardSpeedForWheelAngleIntegration_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSimulationContext.prototype, 'thresholdForwardSpeedForWheelAngleIntegration', { get: PxVehiclePhysXSimulationContext.prototype.get_thresholdForwardSpeedForWheelAngleIntegration, set: PxVehiclePhysXSimulationContext.prototype.set_thresholdForwardSpeedForWheelAngleIntegration });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['get_pvdContext'] = PxVehiclePhysXSimulationContext.prototype.get_pvdContext = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXSimulationContext_get_pvdContext_0(self), PxVehiclePvdContext);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSimulationContext.prototype['set_pvdContext'] = PxVehiclePhysXSimulationContext.prototype.set_pvdContext = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSimulationContext_set_pvdContext_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSimulationContext.prototype, 'pvdContext', { get: PxVehiclePhysXSimulationContext.prototype.get_pvdContext, set: PxVehiclePhysXSimulationContext.prototype.set_pvdContext });

// Interface: PxVehiclePhysXSteerState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehiclePhysXSteerState() { throw "cannot construct a PxVehiclePhysXSteerState, no constructor in IDL" }
PxVehiclePhysXSteerState.prototype = Object.create(WrapperObject.prototype);
PxVehiclePhysXSteerState.prototype.constructor = PxVehiclePhysXSteerState;
PxVehiclePhysXSteerState.prototype.__class__ = PxVehiclePhysXSteerState;
PxVehiclePhysXSteerState.__cache__ = {};
Module['PxVehiclePhysXSteerState'] = PxVehiclePhysXSteerState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSteerState.prototype['setToDefault'] = PxVehiclePhysXSteerState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehiclePhysXSteerState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSteerState.prototype['get_previousSteerCommand'] = PxVehiclePhysXSteerState.prototype.get_previousSteerCommand = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehiclePhysXSteerState_get_previousSteerCommand_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSteerState.prototype['set_previousSteerCommand'] = PxVehiclePhysXSteerState.prototype.set_previousSteerCommand = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSteerState_set_previousSteerCommand_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSteerState.prototype, 'previousSteerCommand', { get: PxVehiclePhysXSteerState.prototype.get_previousSteerCommand, set: PxVehiclePhysXSteerState.prototype.set_previousSteerCommand });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSteerState.prototype['__destroy__'] = PxVehiclePhysXSteerState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehiclePhysXSteerState___destroy___0(self);
};

// Interface: PxVehiclePhysXSuspensionLimitConstraintParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehiclePhysXSuspensionLimitConstraintParams() { throw "cannot construct a PxVehiclePhysXSuspensionLimitConstraintParams, no constructor in IDL" }
PxVehiclePhysXSuspensionLimitConstraintParams.prototype = Object.create(WrapperObject.prototype);
PxVehiclePhysXSuspensionLimitConstraintParams.prototype.constructor = PxVehiclePhysXSuspensionLimitConstraintParams;
PxVehiclePhysXSuspensionLimitConstraintParams.prototype.__class__ = PxVehiclePhysXSuspensionLimitConstraintParams;
PxVehiclePhysXSuspensionLimitConstraintParams.__cache__ = {};
Module['PxVehiclePhysXSuspensionLimitConstraintParams'] = PxVehiclePhysXSuspensionLimitConstraintParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSuspensionLimitConstraintParams.prototype['transformAndScale'] = PxVehiclePhysXSuspensionLimitConstraintParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehiclePhysXSuspensionLimitConstraintParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSuspensionLimitConstraintParams.prototype['isValid'] = PxVehiclePhysXSuspensionLimitConstraintParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSuspensionLimitConstraintParams.prototype['get_restitution'] = PxVehiclePhysXSuspensionLimitConstraintParams.prototype.get_restitution = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_restitution_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSuspensionLimitConstraintParams.prototype['set_restitution'] = PxVehiclePhysXSuspensionLimitConstraintParams.prototype.set_restitution = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_restitution_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSuspensionLimitConstraintParams.prototype, 'restitution', { get: PxVehiclePhysXSuspensionLimitConstraintParams.prototype.get_restitution, set: PxVehiclePhysXSuspensionLimitConstraintParams.prototype.set_restitution });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSuspensionLimitConstraintParams.prototype['get_directionForSuspensionLimitConstraint'] = PxVehiclePhysXSuspensionLimitConstraintParams.prototype.get_directionForSuspensionLimitConstraint = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_get_directionForSuspensionLimitConstraint_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSuspensionLimitConstraintParams.prototype['set_directionForSuspensionLimitConstraint'] = PxVehiclePhysXSuspensionLimitConstraintParams.prototype.set_directionForSuspensionLimitConstraint = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams_set_directionForSuspensionLimitConstraint_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehiclePhysXSuspensionLimitConstraintParams.prototype, 'directionForSuspensionLimitConstraint', { get: PxVehiclePhysXSuspensionLimitConstraintParams.prototype.get_directionForSuspensionLimitConstraint, set: PxVehiclePhysXSuspensionLimitConstraintParams.prototype.set_directionForSuspensionLimitConstraint });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehiclePhysXSuspensionLimitConstraintParams.prototype['__destroy__'] = PxVehiclePhysXSuspensionLimitConstraintParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehiclePhysXSuspensionLimitConstraintParams___destroy___0(self);
};

// Interface: PxVehiclePvdContext

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehiclePvdContext() { throw "cannot construct a PxVehiclePvdContext, no constructor in IDL" }
PxVehiclePvdContext.prototype = Object.create(WrapperObject.prototype);
PxVehiclePvdContext.prototype.constructor = PxVehiclePvdContext;
PxVehiclePvdContext.prototype.__class__ = PxVehiclePvdContext;
PxVehiclePvdContext.__cache__ = {};
Module['PxVehiclePvdContext'] = PxVehiclePvdContext;

// Interface: PxVehicleRigidBodyParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleRigidBodyParams() {
  this.ptr = _emscripten_bind_PxVehicleRigidBodyParams_PxVehicleRigidBodyParams_0();
  getCache(PxVehicleRigidBodyParams)[this.ptr] = this;
};

PxVehicleRigidBodyParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleRigidBodyParams.prototype.constructor = PxVehicleRigidBodyParams;
PxVehicleRigidBodyParams.prototype.__class__ = PxVehicleRigidBodyParams;
PxVehicleRigidBodyParams.__cache__ = {};
Module['PxVehicleRigidBodyParams'] = PxVehicleRigidBodyParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyParams.prototype['transformAndScale'] = PxVehicleRigidBodyParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleRigidBodyParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleRigidBodyParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyParams.prototype['isValid'] = PxVehicleRigidBodyParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleRigidBodyParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyParams.prototype['get_mass'] = PxVehicleRigidBodyParams.prototype.get_mass = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleRigidBodyParams_get_mass_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyParams.prototype['set_mass'] = PxVehicleRigidBodyParams.prototype.set_mass = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleRigidBodyParams_set_mass_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleRigidBodyParams.prototype, 'mass', { get: PxVehicleRigidBodyParams.prototype.get_mass, set: PxVehicleRigidBodyParams.prototype.set_mass });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyParams.prototype['get_moi'] = PxVehicleRigidBodyParams.prototype.get_moi = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleRigidBodyParams_get_moi_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyParams.prototype['set_moi'] = PxVehicleRigidBodyParams.prototype.set_moi = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleRigidBodyParams_set_moi_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleRigidBodyParams.prototype, 'moi', { get: PxVehicleRigidBodyParams.prototype.get_moi, set: PxVehicleRigidBodyParams.prototype.set_moi });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyParams.prototype['__destroy__'] = PxVehicleRigidBodyParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleRigidBodyParams___destroy___0(self);
};

// Interface: PxVehicleRigidBodyState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleRigidBodyState() {
  this.ptr = _emscripten_bind_PxVehicleRigidBodyState_PxVehicleRigidBodyState_0();
  getCache(PxVehicleRigidBodyState)[this.ptr] = this;
};

PxVehicleRigidBodyState.prototype = Object.create(WrapperObject.prototype);
PxVehicleRigidBodyState.prototype.constructor = PxVehicleRigidBodyState;
PxVehicleRigidBodyState.prototype.__class__ = PxVehicleRigidBodyState;
PxVehicleRigidBodyState.__cache__ = {};
Module['PxVehicleRigidBodyState'] = PxVehicleRigidBodyState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['setToDefault'] = PxVehicleRigidBodyState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleRigidBodyState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['getVerticalSpeed'] = PxVehicleRigidBodyState.prototype.getVerticalSpeed = function(frame) {
  var self = this.ptr;
  if (frame && typeof frame === 'object') frame = frame.ptr;
  return _emscripten_bind_PxVehicleRigidBodyState_getVerticalSpeed_1(self, frame);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['getLateralSpeed'] = PxVehicleRigidBodyState.prototype.getLateralSpeed = function(frame) {
  var self = this.ptr;
  if (frame && typeof frame === 'object') frame = frame.ptr;
  return _emscripten_bind_PxVehicleRigidBodyState_getLateralSpeed_1(self, frame);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['getLongitudinalSpeed'] = PxVehicleRigidBodyState.prototype.getLongitudinalSpeed = function(frame) {
  var self = this.ptr;
  if (frame && typeof frame === 'object') frame = frame.ptr;
  return _emscripten_bind_PxVehicleRigidBodyState_getLongitudinalSpeed_1(self, frame);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['get_pose'] = PxVehicleRigidBodyState.prototype.get_pose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleRigidBodyState_get_pose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['set_pose'] = PxVehicleRigidBodyState.prototype.set_pose = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleRigidBodyState_set_pose_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleRigidBodyState.prototype, 'pose', { get: PxVehicleRigidBodyState.prototype.get_pose, set: PxVehicleRigidBodyState.prototype.set_pose });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['get_linearVelocity'] = PxVehicleRigidBodyState.prototype.get_linearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleRigidBodyState_get_linearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['set_linearVelocity'] = PxVehicleRigidBodyState.prototype.set_linearVelocity = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleRigidBodyState_set_linearVelocity_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleRigidBodyState.prototype, 'linearVelocity', { get: PxVehicleRigidBodyState.prototype.get_linearVelocity, set: PxVehicleRigidBodyState.prototype.set_linearVelocity });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['get_angularVelocity'] = PxVehicleRigidBodyState.prototype.get_angularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleRigidBodyState_get_angularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['set_angularVelocity'] = PxVehicleRigidBodyState.prototype.set_angularVelocity = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleRigidBodyState_set_angularVelocity_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleRigidBodyState.prototype, 'angularVelocity', { get: PxVehicleRigidBodyState.prototype.get_angularVelocity, set: PxVehicleRigidBodyState.prototype.set_angularVelocity });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['get_previousLinearVelocity'] = PxVehicleRigidBodyState.prototype.get_previousLinearVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleRigidBodyState_get_previousLinearVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['set_previousLinearVelocity'] = PxVehicleRigidBodyState.prototype.set_previousLinearVelocity = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleRigidBodyState_set_previousLinearVelocity_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleRigidBodyState.prototype, 'previousLinearVelocity', { get: PxVehicleRigidBodyState.prototype.get_previousLinearVelocity, set: PxVehicleRigidBodyState.prototype.set_previousLinearVelocity });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['get_previousAngularVelocity'] = PxVehicleRigidBodyState.prototype.get_previousAngularVelocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleRigidBodyState_get_previousAngularVelocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['set_previousAngularVelocity'] = PxVehicleRigidBodyState.prototype.set_previousAngularVelocity = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleRigidBodyState_set_previousAngularVelocity_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleRigidBodyState.prototype, 'previousAngularVelocity', { get: PxVehicleRigidBodyState.prototype.get_previousAngularVelocity, set: PxVehicleRigidBodyState.prototype.set_previousAngularVelocity });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['get_externalForce'] = PxVehicleRigidBodyState.prototype.get_externalForce = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleRigidBodyState_get_externalForce_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['set_externalForce'] = PxVehicleRigidBodyState.prototype.set_externalForce = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleRigidBodyState_set_externalForce_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleRigidBodyState.prototype, 'externalForce', { get: PxVehicleRigidBodyState.prototype.get_externalForce, set: PxVehicleRigidBodyState.prototype.set_externalForce });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['get_externalTorque'] = PxVehicleRigidBodyState.prototype.get_externalTorque = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleRigidBodyState_get_externalTorque_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['set_externalTorque'] = PxVehicleRigidBodyState.prototype.set_externalTorque = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleRigidBodyState_set_externalTorque_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleRigidBodyState.prototype, 'externalTorque', { get: PxVehicleRigidBodyState.prototype.get_externalTorque, set: PxVehicleRigidBodyState.prototype.set_externalTorque });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRigidBodyState.prototype['__destroy__'] = PxVehicleRigidBodyState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleRigidBodyState___destroy___0(self);
};

// Interface: PxVehicleRoadGeometryState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleRoadGeometryState() {
  this.ptr = _emscripten_bind_PxVehicleRoadGeometryState_PxVehicleRoadGeometryState_0();
  getCache(PxVehicleRoadGeometryState)[this.ptr] = this;
};

PxVehicleRoadGeometryState.prototype = Object.create(WrapperObject.prototype);
PxVehicleRoadGeometryState.prototype.constructor = PxVehicleRoadGeometryState;
PxVehicleRoadGeometryState.prototype.__class__ = PxVehicleRoadGeometryState;
PxVehicleRoadGeometryState.__cache__ = {};
Module['PxVehicleRoadGeometryState'] = PxVehicleRoadGeometryState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRoadGeometryState.prototype['setToDefault'] = PxVehicleRoadGeometryState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleRoadGeometryState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRoadGeometryState.prototype['get_plane'] = PxVehicleRoadGeometryState.prototype.get_plane = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleRoadGeometryState_get_plane_0(self), PxPlane);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRoadGeometryState.prototype['set_plane'] = PxVehicleRoadGeometryState.prototype.set_plane = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleRoadGeometryState_set_plane_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleRoadGeometryState.prototype, 'plane', { get: PxVehicleRoadGeometryState.prototype.get_plane, set: PxVehicleRoadGeometryState.prototype.set_plane });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRoadGeometryState.prototype['get_friction'] = PxVehicleRoadGeometryState.prototype.get_friction = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleRoadGeometryState_get_friction_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRoadGeometryState.prototype['set_friction'] = PxVehicleRoadGeometryState.prototype.set_friction = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleRoadGeometryState_set_friction_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleRoadGeometryState.prototype, 'friction', { get: PxVehicleRoadGeometryState.prototype.get_friction, set: PxVehicleRoadGeometryState.prototype.set_friction });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRoadGeometryState.prototype['get_velocity'] = PxVehicleRoadGeometryState.prototype.get_velocity = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleRoadGeometryState_get_velocity_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRoadGeometryState.prototype['set_velocity'] = PxVehicleRoadGeometryState.prototype.set_velocity = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleRoadGeometryState_set_velocity_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleRoadGeometryState.prototype, 'velocity', { get: PxVehicleRoadGeometryState.prototype.get_velocity, set: PxVehicleRoadGeometryState.prototype.set_velocity });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRoadGeometryState.prototype['get_hitState'] = PxVehicleRoadGeometryState.prototype.get_hitState = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleRoadGeometryState_get_hitState_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRoadGeometryState.prototype['set_hitState'] = PxVehicleRoadGeometryState.prototype.set_hitState = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleRoadGeometryState_set_hitState_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleRoadGeometryState.prototype, 'hitState', { get: PxVehicleRoadGeometryState.prototype.get_hitState, set: PxVehicleRoadGeometryState.prototype.set_hitState });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleRoadGeometryState.prototype['__destroy__'] = PxVehicleRoadGeometryState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleRoadGeometryState___destroy___0(self);
};

// Interface: PxVehicleScale

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleScale() {
  this.ptr = _emscripten_bind_PxVehicleScale_PxVehicleScale_0();
  getCache(PxVehicleScale)[this.ptr] = this;
};

PxVehicleScale.prototype = Object.create(WrapperObject.prototype);
PxVehicleScale.prototype.constructor = PxVehicleScale;
PxVehicleScale.prototype.__class__ = PxVehicleScale;
PxVehicleScale.__cache__ = {};
Module['PxVehicleScale'] = PxVehicleScale;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleScale.prototype['setToDefault'] = PxVehicleScale.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleScale_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleScale.prototype['isValid'] = PxVehicleScale.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleScale_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleScale.prototype['get_scale'] = PxVehicleScale.prototype.get_scale = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleScale_get_scale_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleScale.prototype['set_scale'] = PxVehicleScale.prototype.set_scale = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleScale_set_scale_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleScale.prototype, 'scale', { get: PxVehicleScale.prototype.get_scale, set: PxVehicleScale.prototype.set_scale });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleScale.prototype['__destroy__'] = PxVehicleScale.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleScale___destroy___0(self);
};

// Interface: PxVehicleSteerCommandResponseParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleSteerCommandResponseParams() {
  this.ptr = _emscripten_bind_PxVehicleSteerCommandResponseParams_PxVehicleSteerCommandResponseParams_0();
  getCache(PxVehicleSteerCommandResponseParams)[this.ptr] = this;
};

PxVehicleSteerCommandResponseParams.prototype = Object.create(PxVehicleCommandResponseParams.prototype);
PxVehicleSteerCommandResponseParams.prototype.constructor = PxVehicleSteerCommandResponseParams;
PxVehicleSteerCommandResponseParams.prototype.__class__ = PxVehicleSteerCommandResponseParams;
PxVehicleSteerCommandResponseParams.__cache__ = {};
Module['PxVehicleSteerCommandResponseParams'] = PxVehicleSteerCommandResponseParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSteerCommandResponseParams.prototype['transformAndScale'] = PxVehicleSteerCommandResponseParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSteerCommandResponseParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleSteerCommandResponseParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSteerCommandResponseParams.prototype['isValid'] = PxVehicleSteerCommandResponseParams.prototype.isValid = function(axleDesc) {
  var self = this.ptr;
  if (axleDesc && typeof axleDesc === 'object') axleDesc = axleDesc.ptr;
  return !!(_emscripten_bind_PxVehicleSteerCommandResponseParams_isValid_1(self, axleDesc));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSteerCommandResponseParams.prototype['get_nonlinearResponse'] = PxVehicleSteerCommandResponseParams.prototype.get_nonlinearResponse = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSteerCommandResponseParams_get_nonlinearResponse_0(self), PxVehicleCommandNonLinearResponseParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSteerCommandResponseParams.prototype['set_nonlinearResponse'] = PxVehicleSteerCommandResponseParams.prototype.set_nonlinearResponse = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSteerCommandResponseParams_set_nonlinearResponse_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSteerCommandResponseParams.prototype, 'nonlinearResponse', { get: PxVehicleSteerCommandResponseParams.prototype.get_nonlinearResponse, set: PxVehicleSteerCommandResponseParams.prototype.set_nonlinearResponse });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSteerCommandResponseParams.prototype['get_wheelResponseMultipliers'] = PxVehicleSteerCommandResponseParams.prototype.get_wheelResponseMultipliers = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleSteerCommandResponseParams_get_wheelResponseMultipliers_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSteerCommandResponseParams.prototype['set_wheelResponseMultipliers'] = PxVehicleSteerCommandResponseParams.prototype.set_wheelResponseMultipliers = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleSteerCommandResponseParams_set_wheelResponseMultipliers_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSteerCommandResponseParams.prototype, 'wheelResponseMultipliers', { get: PxVehicleSteerCommandResponseParams.prototype.get_wheelResponseMultipliers, set: PxVehicleSteerCommandResponseParams.prototype.set_wheelResponseMultipliers });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSteerCommandResponseParams.prototype['get_maxResponse'] = PxVehicleSteerCommandResponseParams.prototype.get_maxResponse = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleSteerCommandResponseParams_get_maxResponse_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSteerCommandResponseParams.prototype['set_maxResponse'] = PxVehicleSteerCommandResponseParams.prototype.set_maxResponse = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSteerCommandResponseParams_set_maxResponse_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSteerCommandResponseParams.prototype, 'maxResponse', { get: PxVehicleSteerCommandResponseParams.prototype.get_maxResponse, set: PxVehicleSteerCommandResponseParams.prototype.set_maxResponse });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSteerCommandResponseParams.prototype['__destroy__'] = PxVehicleSteerCommandResponseParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleSteerCommandResponseParams___destroy___0(self);
};

// Interface: PxVehicleSuspensionComplianceParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleSuspensionComplianceParams() {
  this.ptr = _emscripten_bind_PxVehicleSuspensionComplianceParams_PxVehicleSuspensionComplianceParams_0();
  getCache(PxVehicleSuspensionComplianceParams)[this.ptr] = this;
};

PxVehicleSuspensionComplianceParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleSuspensionComplianceParams.prototype.constructor = PxVehicleSuspensionComplianceParams;
PxVehicleSuspensionComplianceParams.prototype.__class__ = PxVehicleSuspensionComplianceParams;
PxVehicleSuspensionComplianceParams.__cache__ = {};
Module['PxVehicleSuspensionComplianceParams'] = PxVehicleSuspensionComplianceParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceParams.prototype['transformAndScale'] = PxVehicleSuspensionComplianceParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionComplianceParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleSuspensionComplianceParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceParams.prototype['isValid'] = PxVehicleSuspensionComplianceParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleSuspensionComplianceParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceParams.prototype['get_wheelToeAngle'] = PxVehicleSuspensionComplianceParams.prototype.get_wheelToeAngle = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelToeAngle_0(self), PxVehicleFixedSizeLookupTableFloat_3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceParams.prototype['set_wheelToeAngle'] = PxVehicleSuspensionComplianceParams.prototype.set_wheelToeAngle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelToeAngle_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionComplianceParams.prototype, 'wheelToeAngle', { get: PxVehicleSuspensionComplianceParams.prototype.get_wheelToeAngle, set: PxVehicleSuspensionComplianceParams.prototype.set_wheelToeAngle });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceParams.prototype['get_wheelCamberAngle'] = PxVehicleSuspensionComplianceParams.prototype.get_wheelCamberAngle = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionComplianceParams_get_wheelCamberAngle_0(self), PxVehicleFixedSizeLookupTableFloat_3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceParams.prototype['set_wheelCamberAngle'] = PxVehicleSuspensionComplianceParams.prototype.set_wheelCamberAngle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionComplianceParams_set_wheelCamberAngle_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionComplianceParams.prototype, 'wheelCamberAngle', { get: PxVehicleSuspensionComplianceParams.prototype.get_wheelCamberAngle, set: PxVehicleSuspensionComplianceParams.prototype.set_wheelCamberAngle });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceParams.prototype['get_suspForceAppPoint'] = PxVehicleSuspensionComplianceParams.prototype.get_suspForceAppPoint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionComplianceParams_get_suspForceAppPoint_0(self), PxVehicleFixedSizeLookupTableVec3_3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceParams.prototype['set_suspForceAppPoint'] = PxVehicleSuspensionComplianceParams.prototype.set_suspForceAppPoint = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionComplianceParams_set_suspForceAppPoint_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionComplianceParams.prototype, 'suspForceAppPoint', { get: PxVehicleSuspensionComplianceParams.prototype.get_suspForceAppPoint, set: PxVehicleSuspensionComplianceParams.prototype.set_suspForceAppPoint });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceParams.prototype['get_tireForceAppPoint'] = PxVehicleSuspensionComplianceParams.prototype.get_tireForceAppPoint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionComplianceParams_get_tireForceAppPoint_0(self), PxVehicleFixedSizeLookupTableVec3_3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceParams.prototype['set_tireForceAppPoint'] = PxVehicleSuspensionComplianceParams.prototype.set_tireForceAppPoint = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionComplianceParams_set_tireForceAppPoint_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionComplianceParams.prototype, 'tireForceAppPoint', { get: PxVehicleSuspensionComplianceParams.prototype.get_tireForceAppPoint, set: PxVehicleSuspensionComplianceParams.prototype.set_tireForceAppPoint });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceParams.prototype['__destroy__'] = PxVehicleSuspensionComplianceParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleSuspensionComplianceParams___destroy___0(self);
};

// Interface: PxVehicleSuspensionComplianceState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleSuspensionComplianceState() {
  this.ptr = _emscripten_bind_PxVehicleSuspensionComplianceState_PxVehicleSuspensionComplianceState_0();
  getCache(PxVehicleSuspensionComplianceState)[this.ptr] = this;
};

PxVehicleSuspensionComplianceState.prototype = Object.create(WrapperObject.prototype);
PxVehicleSuspensionComplianceState.prototype.constructor = PxVehicleSuspensionComplianceState;
PxVehicleSuspensionComplianceState.prototype.__class__ = PxVehicleSuspensionComplianceState;
PxVehicleSuspensionComplianceState.__cache__ = {};
Module['PxVehicleSuspensionComplianceState'] = PxVehicleSuspensionComplianceState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceState.prototype['setToDefault'] = PxVehicleSuspensionComplianceState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleSuspensionComplianceState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceState.prototype['get_toe'] = PxVehicleSuspensionComplianceState.prototype.get_toe = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleSuspensionComplianceState_get_toe_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceState.prototype['set_toe'] = PxVehicleSuspensionComplianceState.prototype.set_toe = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionComplianceState_set_toe_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionComplianceState.prototype, 'toe', { get: PxVehicleSuspensionComplianceState.prototype.get_toe, set: PxVehicleSuspensionComplianceState.prototype.set_toe });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceState.prototype['get_camber'] = PxVehicleSuspensionComplianceState.prototype.get_camber = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleSuspensionComplianceState_get_camber_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceState.prototype['set_camber'] = PxVehicleSuspensionComplianceState.prototype.set_camber = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionComplianceState_set_camber_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionComplianceState.prototype, 'camber', { get: PxVehicleSuspensionComplianceState.prototype.get_camber, set: PxVehicleSuspensionComplianceState.prototype.set_camber });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceState.prototype['get_tireForceAppPoint'] = PxVehicleSuspensionComplianceState.prototype.get_tireForceAppPoint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionComplianceState_get_tireForceAppPoint_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceState.prototype['set_tireForceAppPoint'] = PxVehicleSuspensionComplianceState.prototype.set_tireForceAppPoint = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionComplianceState_set_tireForceAppPoint_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionComplianceState.prototype, 'tireForceAppPoint', { get: PxVehicleSuspensionComplianceState.prototype.get_tireForceAppPoint, set: PxVehicleSuspensionComplianceState.prototype.set_tireForceAppPoint });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceState.prototype['get_suspForceAppPoint'] = PxVehicleSuspensionComplianceState.prototype.get_suspForceAppPoint = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionComplianceState_get_suspForceAppPoint_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceState.prototype['set_suspForceAppPoint'] = PxVehicleSuspensionComplianceState.prototype.set_suspForceAppPoint = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionComplianceState_set_suspForceAppPoint_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionComplianceState.prototype, 'suspForceAppPoint', { get: PxVehicleSuspensionComplianceState.prototype.get_suspForceAppPoint, set: PxVehicleSuspensionComplianceState.prototype.set_suspForceAppPoint });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionComplianceState.prototype['__destroy__'] = PxVehicleSuspensionComplianceState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleSuspensionComplianceState___destroy___0(self);
};

// Interface: PxVehicleSuspensionForce

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleSuspensionForce() {
  this.ptr = _emscripten_bind_PxVehicleSuspensionForce_PxVehicleSuspensionForce_0();
  getCache(PxVehicleSuspensionForce)[this.ptr] = this;
};

PxVehicleSuspensionForce.prototype = Object.create(WrapperObject.prototype);
PxVehicleSuspensionForce.prototype.constructor = PxVehicleSuspensionForce;
PxVehicleSuspensionForce.prototype.__class__ = PxVehicleSuspensionForce;
PxVehicleSuspensionForce.__cache__ = {};
Module['PxVehicleSuspensionForce'] = PxVehicleSuspensionForce;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForce.prototype['setToDefault'] = PxVehicleSuspensionForce.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleSuspensionForce_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForce.prototype['get_force'] = PxVehicleSuspensionForce.prototype.get_force = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionForce_get_force_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForce.prototype['set_force'] = PxVehicleSuspensionForce.prototype.set_force = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionForce_set_force_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionForce.prototype, 'force', { get: PxVehicleSuspensionForce.prototype.get_force, set: PxVehicleSuspensionForce.prototype.set_force });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForce.prototype['get_torque'] = PxVehicleSuspensionForce.prototype.get_torque = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionForce_get_torque_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForce.prototype['set_torque'] = PxVehicleSuspensionForce.prototype.set_torque = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionForce_set_torque_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionForce.prototype, 'torque', { get: PxVehicleSuspensionForce.prototype.get_torque, set: PxVehicleSuspensionForce.prototype.set_torque });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForce.prototype['get_normalForce'] = PxVehicleSuspensionForce.prototype.get_normalForce = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleSuspensionForce_get_normalForce_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForce.prototype['set_normalForce'] = PxVehicleSuspensionForce.prototype.set_normalForce = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionForce_set_normalForce_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionForce.prototype, 'normalForce', { get: PxVehicleSuspensionForce.prototype.get_normalForce, set: PxVehicleSuspensionForce.prototype.set_normalForce });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForce.prototype['__destroy__'] = PxVehicleSuspensionForce.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleSuspensionForce___destroy___0(self);
};

// Interface: PxVehicleSuspensionForceParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleSuspensionForceParams() {
  this.ptr = _emscripten_bind_PxVehicleSuspensionForceParams_PxVehicleSuspensionForceParams_0();
  getCache(PxVehicleSuspensionForceParams)[this.ptr] = this;
};

PxVehicleSuspensionForceParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleSuspensionForceParams.prototype.constructor = PxVehicleSuspensionForceParams;
PxVehicleSuspensionForceParams.prototype.__class__ = PxVehicleSuspensionForceParams;
PxVehicleSuspensionForceParams.__cache__ = {};
Module['PxVehicleSuspensionForceParams'] = PxVehicleSuspensionForceParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForceParams.prototype['transformAndScale'] = PxVehicleSuspensionForceParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionForceParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleSuspensionForceParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForceParams.prototype['isValid'] = PxVehicleSuspensionForceParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleSuspensionForceParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForceParams.prototype['get_stiffness'] = PxVehicleSuspensionForceParams.prototype.get_stiffness = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleSuspensionForceParams_get_stiffness_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForceParams.prototype['set_stiffness'] = PxVehicleSuspensionForceParams.prototype.set_stiffness = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionForceParams_set_stiffness_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionForceParams.prototype, 'stiffness', { get: PxVehicleSuspensionForceParams.prototype.get_stiffness, set: PxVehicleSuspensionForceParams.prototype.set_stiffness });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForceParams.prototype['get_damping'] = PxVehicleSuspensionForceParams.prototype.get_damping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleSuspensionForceParams_get_damping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForceParams.prototype['set_damping'] = PxVehicleSuspensionForceParams.prototype.set_damping = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionForceParams_set_damping_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionForceParams.prototype, 'damping', { get: PxVehicleSuspensionForceParams.prototype.get_damping, set: PxVehicleSuspensionForceParams.prototype.set_damping });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForceParams.prototype['get_sprungMass'] = PxVehicleSuspensionForceParams.prototype.get_sprungMass = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleSuspensionForceParams_get_sprungMass_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForceParams.prototype['set_sprungMass'] = PxVehicleSuspensionForceParams.prototype.set_sprungMass = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionForceParams_set_sprungMass_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionForceParams.prototype, 'sprungMass', { get: PxVehicleSuspensionForceParams.prototype.get_sprungMass, set: PxVehicleSuspensionForceParams.prototype.set_sprungMass });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionForceParams.prototype['__destroy__'] = PxVehicleSuspensionForceParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleSuspensionForceParams___destroy___0(self);
};

// Interface: PxVehicleSuspensionParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleSuspensionParams() {
  this.ptr = _emscripten_bind_PxVehicleSuspensionParams_PxVehicleSuspensionParams_0();
  getCache(PxVehicleSuspensionParams)[this.ptr] = this;
};

PxVehicleSuspensionParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleSuspensionParams.prototype.constructor = PxVehicleSuspensionParams;
PxVehicleSuspensionParams.prototype.__class__ = PxVehicleSuspensionParams;
PxVehicleSuspensionParams.__cache__ = {};
Module['PxVehicleSuspensionParams'] = PxVehicleSuspensionParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionParams.prototype['transformAndScale'] = PxVehicleSuspensionParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleSuspensionParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionParams.prototype['isValid'] = PxVehicleSuspensionParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleSuspensionParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionParams.prototype['get_suspensionAttachment'] = PxVehicleSuspensionParams.prototype.get_suspensionAttachment = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionParams_get_suspensionAttachment_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionParams.prototype['set_suspensionAttachment'] = PxVehicleSuspensionParams.prototype.set_suspensionAttachment = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionParams_set_suspensionAttachment_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionParams.prototype, 'suspensionAttachment', { get: PxVehicleSuspensionParams.prototype.get_suspensionAttachment, set: PxVehicleSuspensionParams.prototype.set_suspensionAttachment });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionParams.prototype['get_suspensionTravelDir'] = PxVehicleSuspensionParams.prototype.get_suspensionTravelDir = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDir_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionParams.prototype['set_suspensionTravelDir'] = PxVehicleSuspensionParams.prototype.set_suspensionTravelDir = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDir_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionParams.prototype, 'suspensionTravelDir', { get: PxVehicleSuspensionParams.prototype.get_suspensionTravelDir, set: PxVehicleSuspensionParams.prototype.set_suspensionTravelDir });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionParams.prototype['get_suspensionTravelDist'] = PxVehicleSuspensionParams.prototype.get_suspensionTravelDist = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleSuspensionParams_get_suspensionTravelDist_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionParams.prototype['set_suspensionTravelDist'] = PxVehicleSuspensionParams.prototype.set_suspensionTravelDist = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionParams_set_suspensionTravelDist_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionParams.prototype, 'suspensionTravelDist', { get: PxVehicleSuspensionParams.prototype.get_suspensionTravelDist, set: PxVehicleSuspensionParams.prototype.set_suspensionTravelDist });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionParams.prototype['get_wheelAttachment'] = PxVehicleSuspensionParams.prototype.get_wheelAttachment = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionParams_get_wheelAttachment_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionParams.prototype['set_wheelAttachment'] = PxVehicleSuspensionParams.prototype.set_wheelAttachment = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionParams_set_wheelAttachment_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionParams.prototype, 'wheelAttachment', { get: PxVehicleSuspensionParams.prototype.get_wheelAttachment, set: PxVehicleSuspensionParams.prototype.set_wheelAttachment });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionParams.prototype['__destroy__'] = PxVehicleSuspensionParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleSuspensionParams___destroy___0(self);
};

// Interface: PxVehicleSuspensionState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleSuspensionState() {
  this.ptr = _emscripten_bind_PxVehicleSuspensionState_PxVehicleSuspensionState_0();
  getCache(PxVehicleSuspensionState)[this.ptr] = this;
};

PxVehicleSuspensionState.prototype = Object.create(WrapperObject.prototype);
PxVehicleSuspensionState.prototype.constructor = PxVehicleSuspensionState;
PxVehicleSuspensionState.prototype.__class__ = PxVehicleSuspensionState;
PxVehicleSuspensionState.__cache__ = {};
Module['PxVehicleSuspensionState'] = PxVehicleSuspensionState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionState.prototype['setToDefault'] = PxVehicleSuspensionState.prototype.setToDefault = function(jounce, separation) {
  var self = this.ptr;
  if (jounce && typeof jounce === 'object') jounce = jounce.ptr;
  if (separation && typeof separation === 'object') separation = separation.ptr;
  _emscripten_bind_PxVehicleSuspensionState_setToDefault_2(self, jounce, separation);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionState.prototype['get_jounce'] = PxVehicleSuspensionState.prototype.get_jounce = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleSuspensionState_get_jounce_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionState.prototype['set_jounce'] = PxVehicleSuspensionState.prototype.set_jounce = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionState_set_jounce_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionState.prototype, 'jounce', { get: PxVehicleSuspensionState.prototype.get_jounce, set: PxVehicleSuspensionState.prototype.set_jounce });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionState.prototype['get_jounceSpeed'] = PxVehicleSuspensionState.prototype.get_jounceSpeed = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleSuspensionState_get_jounceSpeed_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionState.prototype['set_jounceSpeed'] = PxVehicleSuspensionState.prototype.set_jounceSpeed = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionState_set_jounceSpeed_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionState.prototype, 'jounceSpeed', { get: PxVehicleSuspensionState.prototype.get_jounceSpeed, set: PxVehicleSuspensionState.prototype.set_jounceSpeed });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionState.prototype['get_separation'] = PxVehicleSuspensionState.prototype.get_separation = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleSuspensionState_get_separation_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionState.prototype['set_separation'] = PxVehicleSuspensionState.prototype.set_separation = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionState_set_separation_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionState.prototype, 'separation', { get: PxVehicleSuspensionState.prototype.get_separation, set: PxVehicleSuspensionState.prototype.set_separation });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionState.prototype['__destroy__'] = PxVehicleSuspensionState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleSuspensionState___destroy___0(self);
};

// Interface: PxVehicleSuspensionStateCalculationParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleSuspensionStateCalculationParams() {
  this.ptr = _emscripten_bind_PxVehicleSuspensionStateCalculationParams_PxVehicleSuspensionStateCalculationParams_0();
  getCache(PxVehicleSuspensionStateCalculationParams)[this.ptr] = this;
};

PxVehicleSuspensionStateCalculationParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleSuspensionStateCalculationParams.prototype.constructor = PxVehicleSuspensionStateCalculationParams;
PxVehicleSuspensionStateCalculationParams.prototype.__class__ = PxVehicleSuspensionStateCalculationParams;
PxVehicleSuspensionStateCalculationParams.__cache__ = {};
Module['PxVehicleSuspensionStateCalculationParams'] = PxVehicleSuspensionStateCalculationParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionStateCalculationParams.prototype['transformAndScale'] = PxVehicleSuspensionStateCalculationParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleSuspensionStateCalculationParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleSuspensionStateCalculationParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionStateCalculationParams.prototype['isValid'] = PxVehicleSuspensionStateCalculationParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleSuspensionStateCalculationParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionStateCalculationParams.prototype['get_suspensionJounceCalculationType'] = PxVehicleSuspensionStateCalculationParams.prototype.get_suspensionJounceCalculationType = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_suspensionJounceCalculationType_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionStateCalculationParams.prototype['set_suspensionJounceCalculationType'] = PxVehicleSuspensionStateCalculationParams.prototype.set_suspensionJounceCalculationType = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_suspensionJounceCalculationType_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionStateCalculationParams.prototype, 'suspensionJounceCalculationType', { get: PxVehicleSuspensionStateCalculationParams.prototype.get_suspensionJounceCalculationType, set: PxVehicleSuspensionStateCalculationParams.prototype.set_suspensionJounceCalculationType });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionStateCalculationParams.prototype['get_limitSuspensionExpansionVelocity'] = PxVehicleSuspensionStateCalculationParams.prototype.get_limitSuspensionExpansionVelocity = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleSuspensionStateCalculationParams_get_limitSuspensionExpansionVelocity_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionStateCalculationParams.prototype['set_limitSuspensionExpansionVelocity'] = PxVehicleSuspensionStateCalculationParams.prototype.set_limitSuspensionExpansionVelocity = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleSuspensionStateCalculationParams_set_limitSuspensionExpansionVelocity_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleSuspensionStateCalculationParams.prototype, 'limitSuspensionExpansionVelocity', { get: PxVehicleSuspensionStateCalculationParams.prototype.get_limitSuspensionExpansionVelocity, set: PxVehicleSuspensionStateCalculationParams.prototype.set_limitSuspensionExpansionVelocity });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleSuspensionStateCalculationParams.prototype['__destroy__'] = PxVehicleSuspensionStateCalculationParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleSuspensionStateCalculationParams___destroy___0(self);
};

// Interface: PxVehicleTankDriveDifferentialParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTankDriveDifferentialParams() {
  this.ptr = _emscripten_bind_PxVehicleTankDriveDifferentialParams_PxVehicleTankDriveDifferentialParams_0();
  getCache(PxVehicleTankDriveDifferentialParams)[this.ptr] = this;
};

PxVehicleTankDriveDifferentialParams.prototype = Object.create(PxVehicleMultiWheelDriveDifferentialParams.prototype);
PxVehicleTankDriveDifferentialParams.prototype.constructor = PxVehicleTankDriveDifferentialParams;
PxVehicleTankDriveDifferentialParams.prototype.__class__ = PxVehicleTankDriveDifferentialParams;
PxVehicleTankDriveDifferentialParams.__cache__ = {};
Module['PxVehicleTankDriveDifferentialParams'] = PxVehicleTankDriveDifferentialParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['setToDefault'] = PxVehicleTankDriveDifferentialParams.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['getNbWheelsInTrack'] = PxVehicleTankDriveDifferentialParams.prototype.getNbWheelsInTrack = function(i) {
  var self = this.ptr;
  if (i && typeof i === 'object') i = i.ptr;
  return _emscripten_bind_PxVehicleTankDriveDifferentialParams_getNbWheelsInTrack_1(self, i);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['getWheelsInTrack'] = PxVehicleTankDriveDifferentialParams.prototype.getWheelsInTrack = function(i) {
  var self = this.ptr;
  if (i && typeof i === 'object') i = i.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelsInTrack_1(self, i), PxU32ConstPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['getWheelInTrack'] = PxVehicleTankDriveDifferentialParams.prototype.getWheelInTrack = function(j, i) {
  var self = this.ptr;
  if (j && typeof j === 'object') j = j.ptr;
  if (i && typeof i === 'object') i = i.ptr;
  return _emscripten_bind_PxVehicleTankDriveDifferentialParams_getWheelInTrack_2(self, j, i);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['getThrustControllerIndex'] = PxVehicleTankDriveDifferentialParams.prototype.getThrustControllerIndex = function(i) {
  var self = this.ptr;
  if (i && typeof i === 'object') i = i.ptr;
  return _emscripten_bind_PxVehicleTankDriveDifferentialParams_getThrustControllerIndex_1(self, i);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['transformAndScale'] = PxVehicleTankDriveDifferentialParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleTankDriveDifferentialParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleTankDriveDifferentialParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['isValid'] = PxVehicleTankDriveDifferentialParams.prototype.isValid = function(axleDesc) {
  var self = this.ptr;
  if (axleDesc && typeof axleDesc === 'object') axleDesc = axleDesc.ptr;
  return !!(_emscripten_bind_PxVehicleTankDriveDifferentialParams_isValid_1(self, axleDesc));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['get_nbTracks'] = PxVehicleTankDriveDifferentialParams.prototype.get_nbTracks = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbTracks_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['set_nbTracks'] = PxVehicleTankDriveDifferentialParams.prototype.set_nbTracks = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbTracks_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTankDriveDifferentialParams.prototype, 'nbTracks', { get: PxVehicleTankDriveDifferentialParams.prototype.get_nbTracks, set: PxVehicleTankDriveDifferentialParams.prototype.set_nbTracks });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['get_thrustIdPerTrack'] = PxVehicleTankDriveDifferentialParams.prototype.get_thrustIdPerTrack = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_thrustIdPerTrack_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['set_thrustIdPerTrack'] = PxVehicleTankDriveDifferentialParams.prototype.set_thrustIdPerTrack = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_thrustIdPerTrack_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTankDriveDifferentialParams.prototype, 'thrustIdPerTrack', { get: PxVehicleTankDriveDifferentialParams.prototype.get_thrustIdPerTrack, set: PxVehicleTankDriveDifferentialParams.prototype.set_thrustIdPerTrack });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['get_nbWheelsPerTrack'] = PxVehicleTankDriveDifferentialParams.prototype.get_nbWheelsPerTrack = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_nbWheelsPerTrack_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['set_nbWheelsPerTrack'] = PxVehicleTankDriveDifferentialParams.prototype.set_nbWheelsPerTrack = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_nbWheelsPerTrack_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTankDriveDifferentialParams.prototype, 'nbWheelsPerTrack', { get: PxVehicleTankDriveDifferentialParams.prototype.get_nbWheelsPerTrack, set: PxVehicleTankDriveDifferentialParams.prototype.set_nbWheelsPerTrack });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['get_trackToWheelIds'] = PxVehicleTankDriveDifferentialParams.prototype.get_trackToWheelIds = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_trackToWheelIds_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['set_trackToWheelIds'] = PxVehicleTankDriveDifferentialParams.prototype.set_trackToWheelIds = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_trackToWheelIds_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTankDriveDifferentialParams.prototype, 'trackToWheelIds', { get: PxVehicleTankDriveDifferentialParams.prototype.get_trackToWheelIds, set: PxVehicleTankDriveDifferentialParams.prototype.set_trackToWheelIds });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['get_wheelIdsInTrackOrder'] = PxVehicleTankDriveDifferentialParams.prototype.get_wheelIdsInTrackOrder = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_wheelIdsInTrackOrder_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['set_wheelIdsInTrackOrder'] = PxVehicleTankDriveDifferentialParams.prototype.set_wheelIdsInTrackOrder = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_wheelIdsInTrackOrder_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTankDriveDifferentialParams.prototype, 'wheelIdsInTrackOrder', { get: PxVehicleTankDriveDifferentialParams.prototype.get_wheelIdsInTrackOrder, set: PxVehicleTankDriveDifferentialParams.prototype.set_wheelIdsInTrackOrder });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['get_torqueRatios'] = PxVehicleTankDriveDifferentialParams.prototype.get_torqueRatios = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_torqueRatios_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['set_torqueRatios'] = PxVehicleTankDriveDifferentialParams.prototype.set_torqueRatios = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_torqueRatios_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTankDriveDifferentialParams.prototype, 'torqueRatios', { get: PxVehicleTankDriveDifferentialParams.prototype.get_torqueRatios, set: PxVehicleTankDriveDifferentialParams.prototype.set_torqueRatios });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['get_aveWheelSpeedRatios'] = PxVehicleTankDriveDifferentialParams.prototype.get_aveWheelSpeedRatios = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleTankDriveDifferentialParams_get_aveWheelSpeedRatios_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['set_aveWheelSpeedRatios'] = PxVehicleTankDriveDifferentialParams.prototype.set_aveWheelSpeedRatios = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTankDriveDifferentialParams_set_aveWheelSpeedRatios_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTankDriveDifferentialParams.prototype, 'aveWheelSpeedRatios', { get: PxVehicleTankDriveDifferentialParams.prototype.get_aveWheelSpeedRatios, set: PxVehicleTankDriveDifferentialParams.prototype.set_aveWheelSpeedRatios });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveDifferentialParams.prototype['__destroy__'] = PxVehicleTankDriveDifferentialParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTankDriveDifferentialParams___destroy___0(self);
};

// Interface: PxVehicleTankDriveTransmissionCommandState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTankDriveTransmissionCommandState() {
  this.ptr = _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_PxVehicleTankDriveTransmissionCommandState_0();
  getCache(PxVehicleTankDriveTransmissionCommandState)[this.ptr] = this;
};

PxVehicleTankDriveTransmissionCommandState.prototype = Object.create(PxVehicleEngineDriveTransmissionCommandState.prototype);
PxVehicleTankDriveTransmissionCommandState.prototype.constructor = PxVehicleTankDriveTransmissionCommandState;
PxVehicleTankDriveTransmissionCommandState.prototype.__class__ = PxVehicleTankDriveTransmissionCommandState;
PxVehicleTankDriveTransmissionCommandState.__cache__ = {};
Module['PxVehicleTankDriveTransmissionCommandState'] = PxVehicleTankDriveTransmissionCommandState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveTransmissionCommandState.prototype['setToDefault'] = PxVehicleTankDriveTransmissionCommandState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveTransmissionCommandState.prototype['get_thrusts'] = PxVehicleTankDriveTransmissionCommandState.prototype.get_thrusts = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_thrusts_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveTransmissionCommandState.prototype['set_thrusts'] = PxVehicleTankDriveTransmissionCommandState.prototype.set_thrusts = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_thrusts_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTankDriveTransmissionCommandState.prototype, 'thrusts', { get: PxVehicleTankDriveTransmissionCommandState.prototype.get_thrusts, set: PxVehicleTankDriveTransmissionCommandState.prototype.set_thrusts });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveTransmissionCommandState.prototype['get_clutch'] = PxVehicleTankDriveTransmissionCommandState.prototype.get_clutch = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_clutch_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveTransmissionCommandState.prototype['set_clutch'] = PxVehicleTankDriveTransmissionCommandState.prototype.set_clutch = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_clutch_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTankDriveTransmissionCommandState.prototype, 'clutch', { get: PxVehicleTankDriveTransmissionCommandState.prototype.get_clutch, set: PxVehicleTankDriveTransmissionCommandState.prototype.set_clutch });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveTransmissionCommandState.prototype['get_targetGear'] = PxVehicleTankDriveTransmissionCommandState.prototype.get_targetGear = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_get_targetGear_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveTransmissionCommandState.prototype['set_targetGear'] = PxVehicleTankDriveTransmissionCommandState.prototype.set_targetGear = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTankDriveTransmissionCommandState_set_targetGear_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTankDriveTransmissionCommandState.prototype, 'targetGear', { get: PxVehicleTankDriveTransmissionCommandState.prototype.get_targetGear, set: PxVehicleTankDriveTransmissionCommandState.prototype.set_targetGear });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTankDriveTransmissionCommandState.prototype['__destroy__'] = PxVehicleTankDriveTransmissionCommandState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTankDriveTransmissionCommandState___destroy___0(self);
};

// Interface: PxVehicleTireAxisStickyParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTireAxisStickyParams() {
  this.ptr = _emscripten_bind_PxVehicleTireAxisStickyParams_PxVehicleTireAxisStickyParams_0();
  getCache(PxVehicleTireAxisStickyParams)[this.ptr] = this;
};

PxVehicleTireAxisStickyParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleTireAxisStickyParams.prototype.constructor = PxVehicleTireAxisStickyParams;
PxVehicleTireAxisStickyParams.prototype.__class__ = PxVehicleTireAxisStickyParams;
PxVehicleTireAxisStickyParams.__cache__ = {};
Module['PxVehicleTireAxisStickyParams'] = PxVehicleTireAxisStickyParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireAxisStickyParams.prototype['transformAndScale'] = PxVehicleTireAxisStickyParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleTireAxisStickyParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleTireAxisStickyParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireAxisStickyParams.prototype['isValid'] = PxVehicleTireAxisStickyParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleTireAxisStickyParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireAxisStickyParams.prototype['get_thresholdSpeed'] = PxVehicleTireAxisStickyParams.prototype.get_thresholdSpeed = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdSpeed_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireAxisStickyParams.prototype['set_thresholdSpeed'] = PxVehicleTireAxisStickyParams.prototype.set_thresholdSpeed = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdSpeed_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireAxisStickyParams.prototype, 'thresholdSpeed', { get: PxVehicleTireAxisStickyParams.prototype.get_thresholdSpeed, set: PxVehicleTireAxisStickyParams.prototype.set_thresholdSpeed });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireAxisStickyParams.prototype['get_thresholdTime'] = PxVehicleTireAxisStickyParams.prototype.get_thresholdTime = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireAxisStickyParams_get_thresholdTime_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireAxisStickyParams.prototype['set_thresholdTime'] = PxVehicleTireAxisStickyParams.prototype.set_thresholdTime = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireAxisStickyParams_set_thresholdTime_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireAxisStickyParams.prototype, 'thresholdTime', { get: PxVehicleTireAxisStickyParams.prototype.get_thresholdTime, set: PxVehicleTireAxisStickyParams.prototype.set_thresholdTime });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireAxisStickyParams.prototype['get_damping'] = PxVehicleTireAxisStickyParams.prototype.get_damping = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireAxisStickyParams_get_damping_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireAxisStickyParams.prototype['set_damping'] = PxVehicleTireAxisStickyParams.prototype.set_damping = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireAxisStickyParams_set_damping_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireAxisStickyParams.prototype, 'damping', { get: PxVehicleTireAxisStickyParams.prototype.get_damping, set: PxVehicleTireAxisStickyParams.prototype.set_damping });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireAxisStickyParams.prototype['__destroy__'] = PxVehicleTireAxisStickyParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireAxisStickyParams___destroy___0(self);
};

// Interface: PxVehicleTireCamberAngleState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTireCamberAngleState() {
  this.ptr = _emscripten_bind_PxVehicleTireCamberAngleState_PxVehicleTireCamberAngleState_0();
  getCache(PxVehicleTireCamberAngleState)[this.ptr] = this;
};

PxVehicleTireCamberAngleState.prototype = Object.create(WrapperObject.prototype);
PxVehicleTireCamberAngleState.prototype.constructor = PxVehicleTireCamberAngleState;
PxVehicleTireCamberAngleState.prototype.__class__ = PxVehicleTireCamberAngleState;
PxVehicleTireCamberAngleState.__cache__ = {};
Module['PxVehicleTireCamberAngleState'] = PxVehicleTireCamberAngleState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireCamberAngleState.prototype['setToDefault'] = PxVehicleTireCamberAngleState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireCamberAngleState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireCamberAngleState.prototype['get_camberAngle'] = PxVehicleTireCamberAngleState.prototype.get_camberAngle = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireCamberAngleState_get_camberAngle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireCamberAngleState.prototype['set_camberAngle'] = PxVehicleTireCamberAngleState.prototype.set_camberAngle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireCamberAngleState_set_camberAngle_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireCamberAngleState.prototype, 'camberAngle', { get: PxVehicleTireCamberAngleState.prototype.get_camberAngle, set: PxVehicleTireCamberAngleState.prototype.set_camberAngle });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireCamberAngleState.prototype['__destroy__'] = PxVehicleTireCamberAngleState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireCamberAngleState___destroy___0(self);
};

// Interface: PxVehicleTireDirectionState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTireDirectionState() {
  this.ptr = _emscripten_bind_PxVehicleTireDirectionState_PxVehicleTireDirectionState_0();
  getCache(PxVehicleTireDirectionState)[this.ptr] = this;
};

PxVehicleTireDirectionState.prototype = Object.create(WrapperObject.prototype);
PxVehicleTireDirectionState.prototype.constructor = PxVehicleTireDirectionState;
PxVehicleTireDirectionState.prototype.__class__ = PxVehicleTireDirectionState;
PxVehicleTireDirectionState.__cache__ = {};
Module['PxVehicleTireDirectionState'] = PxVehicleTireDirectionState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireDirectionState.prototype['setToDefault'] = PxVehicleTireDirectionState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireDirectionState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireDirectionState.prototype['get_directions'] = PxVehicleTireDirectionState.prototype.get_directions = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleTireDirectionState_get_directions_1(self, arg0), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireDirectionState.prototype['set_directions'] = PxVehicleTireDirectionState.prototype.set_directions = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTireDirectionState_set_directions_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireDirectionState.prototype, 'directions', { get: PxVehicleTireDirectionState.prototype.get_directions, set: PxVehicleTireDirectionState.prototype.set_directions });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireDirectionState.prototype['__destroy__'] = PxVehicleTireDirectionState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireDirectionState___destroy___0(self);
};

// Interface: PxVehicleTireForce

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTireForce() {
  this.ptr = _emscripten_bind_PxVehicleTireForce_PxVehicleTireForce_0();
  getCache(PxVehicleTireForce)[this.ptr] = this;
};

PxVehicleTireForce.prototype = Object.create(WrapperObject.prototype);
PxVehicleTireForce.prototype.constructor = PxVehicleTireForce;
PxVehicleTireForce.prototype.__class__ = PxVehicleTireForce;
PxVehicleTireForce.__cache__ = {};
Module['PxVehicleTireForce'] = PxVehicleTireForce;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForce.prototype['setToDefault'] = PxVehicleTireForce.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireForce_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForce.prototype['get_forces'] = PxVehicleTireForce.prototype.get_forces = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleTireForce_get_forces_1(self, arg0), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForce.prototype['set_forces'] = PxVehicleTireForce.prototype.set_forces = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTireForce_set_forces_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireForce.prototype, 'forces', { get: PxVehicleTireForce.prototype.get_forces, set: PxVehicleTireForce.prototype.set_forces });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForce.prototype['get_torques'] = PxVehicleTireForce.prototype.get_torques = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleTireForce_get_torques_1(self, arg0), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForce.prototype['set_torques'] = PxVehicleTireForce.prototype.set_torques = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTireForce_set_torques_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireForce.prototype, 'torques', { get: PxVehicleTireForce.prototype.get_torques, set: PxVehicleTireForce.prototype.set_torques });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForce.prototype['get_aligningMoment'] = PxVehicleTireForce.prototype.get_aligningMoment = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireForce_get_aligningMoment_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForce.prototype['set_aligningMoment'] = PxVehicleTireForce.prototype.set_aligningMoment = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireForce_set_aligningMoment_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireForce.prototype, 'aligningMoment', { get: PxVehicleTireForce.prototype.get_aligningMoment, set: PxVehicleTireForce.prototype.set_aligningMoment });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForce.prototype['get_wheelTorque'] = PxVehicleTireForce.prototype.get_wheelTorque = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireForce_get_wheelTorque_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForce.prototype['set_wheelTorque'] = PxVehicleTireForce.prototype.set_wheelTorque = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireForce_set_wheelTorque_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireForce.prototype, 'wheelTorque', { get: PxVehicleTireForce.prototype.get_wheelTorque, set: PxVehicleTireForce.prototype.set_wheelTorque });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForce.prototype['__destroy__'] = PxVehicleTireForce.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireForce___destroy___0(self);
};

// Interface: PxVehicleTireForceParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTireForceParams() {
  this.ptr = _emscripten_bind_PxVehicleTireForceParams_PxVehicleTireForceParams_0();
  getCache(PxVehicleTireForceParams)[this.ptr] = this;
};

PxVehicleTireForceParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleTireForceParams.prototype.constructor = PxVehicleTireForceParams;
PxVehicleTireForceParams.prototype.__class__ = PxVehicleTireForceParams;
PxVehicleTireForceParams.__cache__ = {};
Module['PxVehicleTireForceParams'] = PxVehicleTireForceParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParams.prototype['transformAndScale'] = PxVehicleTireForceParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleTireForceParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleTireForceParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParams.prototype['isValid'] = PxVehicleTireForceParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleTireForceParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParams.prototype['get_latStiffX'] = PxVehicleTireForceParams.prototype.get_latStiffX = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireForceParams_get_latStiffX_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParams.prototype['set_latStiffX'] = PxVehicleTireForceParams.prototype.set_latStiffX = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireForceParams_set_latStiffX_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireForceParams.prototype, 'latStiffX', { get: PxVehicleTireForceParams.prototype.get_latStiffX, set: PxVehicleTireForceParams.prototype.set_latStiffX });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParams.prototype['get_latStiffY'] = PxVehicleTireForceParams.prototype.get_latStiffY = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireForceParams_get_latStiffY_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParams.prototype['set_latStiffY'] = PxVehicleTireForceParams.prototype.set_latStiffY = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireForceParams_set_latStiffY_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireForceParams.prototype, 'latStiffY', { get: PxVehicleTireForceParams.prototype.get_latStiffY, set: PxVehicleTireForceParams.prototype.set_latStiffY });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParams.prototype['get_longStiff'] = PxVehicleTireForceParams.prototype.get_longStiff = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireForceParams_get_longStiff_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParams.prototype['set_longStiff'] = PxVehicleTireForceParams.prototype.set_longStiff = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireForceParams_set_longStiff_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireForceParams.prototype, 'longStiff', { get: PxVehicleTireForceParams.prototype.get_longStiff, set: PxVehicleTireForceParams.prototype.set_longStiff });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParams.prototype['get_camberStiff'] = PxVehicleTireForceParams.prototype.get_camberStiff = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireForceParams_get_camberStiff_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParams.prototype['set_camberStiff'] = PxVehicleTireForceParams.prototype.set_camberStiff = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireForceParams_set_camberStiff_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireForceParams.prototype, 'camberStiff', { get: PxVehicleTireForceParams.prototype.get_camberStiff, set: PxVehicleTireForceParams.prototype.set_camberStiff });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParams.prototype['get_restLoad'] = PxVehicleTireForceParams.prototype.get_restLoad = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireForceParams_get_restLoad_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParams.prototype['set_restLoad'] = PxVehicleTireForceParams.prototype.set_restLoad = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireForceParams_set_restLoad_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireForceParams.prototype, 'restLoad', { get: PxVehicleTireForceParams.prototype.get_restLoad, set: PxVehicleTireForceParams.prototype.set_restLoad });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParams.prototype['__destroy__'] = PxVehicleTireForceParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireForceParams___destroy___0(self);
};

// Interface: PxVehicleTireForceParamsExt

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTireForceParamsExt() { throw "cannot construct a PxVehicleTireForceParamsExt, no constructor in IDL" }
PxVehicleTireForceParamsExt.prototype = Object.create(WrapperObject.prototype);
PxVehicleTireForceParamsExt.prototype.constructor = PxVehicleTireForceParamsExt;
PxVehicleTireForceParamsExt.prototype.__class__ = PxVehicleTireForceParamsExt;
PxVehicleTireForceParamsExt.__cache__ = {};
Module['PxVehicleTireForceParamsExt'] = PxVehicleTireForceParamsExt;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParamsExt.prototype['setFrictionVsSlip'] = PxVehicleTireForceParamsExt.prototype.setFrictionVsSlip = function(tireForceParams, i, j, value) {
  if (tireForceParams && typeof tireForceParams === 'object') tireForceParams = tireForceParams.ptr;
  if (i && typeof i === 'object') i = i.ptr;
  if (j && typeof j === 'object') j = j.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxVehicleTireForceParamsExt_setFrictionVsSlip_4(tireForceParams, i, j, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireForceParamsExt.prototype['setLoadFilter'] = PxVehicleTireForceParamsExt.prototype.setLoadFilter = function(tireForceParams, i, j, value) {
  if (tireForceParams && typeof tireForceParams === 'object') tireForceParams = tireForceParams.ptr;
  if (i && typeof i === 'object') i = i.ptr;
  if (j && typeof j === 'object') j = j.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_PxVehicleTireForceParamsExt_setLoadFilter_4(tireForceParams, i, j, value);
};


// Interface: PxVehicleTireGripState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTireGripState() { throw "cannot construct a PxVehicleTireGripState, no constructor in IDL" }
PxVehicleTireGripState.prototype = Object.create(WrapperObject.prototype);
PxVehicleTireGripState.prototype.constructor = PxVehicleTireGripState;
PxVehicleTireGripState.prototype.__class__ = PxVehicleTireGripState;
PxVehicleTireGripState.__cache__ = {};
Module['PxVehicleTireGripState'] = PxVehicleTireGripState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireGripState.prototype['setToDefault'] = PxVehicleTireGripState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireGripState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireGripState.prototype['get_load'] = PxVehicleTireGripState.prototype.get_load = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireGripState_get_load_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireGripState.prototype['set_load'] = PxVehicleTireGripState.prototype.set_load = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireGripState_set_load_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireGripState.prototype, 'load', { get: PxVehicleTireGripState.prototype.get_load, set: PxVehicleTireGripState.prototype.set_load });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireGripState.prototype['get_friction'] = PxVehicleTireGripState.prototype.get_friction = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireGripState_get_friction_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireGripState.prototype['set_friction'] = PxVehicleTireGripState.prototype.set_friction = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireGripState_set_friction_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireGripState.prototype, 'friction', { get: PxVehicleTireGripState.prototype.get_friction, set: PxVehicleTireGripState.prototype.set_friction });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireGripState.prototype['__destroy__'] = PxVehicleTireGripState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireGripState___destroy___0(self);
};

// Interface: PxVehicleTireSlipParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTireSlipParams() {
  this.ptr = _emscripten_bind_PxVehicleTireSlipParams_PxVehicleTireSlipParams_0();
  getCache(PxVehicleTireSlipParams)[this.ptr] = this;
};

PxVehicleTireSlipParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleTireSlipParams.prototype.constructor = PxVehicleTireSlipParams;
PxVehicleTireSlipParams.prototype.__class__ = PxVehicleTireSlipParams;
PxVehicleTireSlipParams.__cache__ = {};
Module['PxVehicleTireSlipParams'] = PxVehicleTireSlipParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSlipParams.prototype['setToDefault'] = PxVehicleTireSlipParams.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireSlipParams_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSlipParams.prototype['transformAndScale'] = PxVehicleTireSlipParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleTireSlipParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleTireSlipParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSlipParams.prototype['isValid'] = PxVehicleTireSlipParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleTireSlipParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSlipParams.prototype['get_minLatSlipDenominator'] = PxVehicleTireSlipParams.prototype.get_minLatSlipDenominator = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireSlipParams_get_minLatSlipDenominator_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSlipParams.prototype['set_minLatSlipDenominator'] = PxVehicleTireSlipParams.prototype.set_minLatSlipDenominator = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireSlipParams_set_minLatSlipDenominator_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireSlipParams.prototype, 'minLatSlipDenominator', { get: PxVehicleTireSlipParams.prototype.get_minLatSlipDenominator, set: PxVehicleTireSlipParams.prototype.set_minLatSlipDenominator });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSlipParams.prototype['get_minPassiveLongSlipDenominator'] = PxVehicleTireSlipParams.prototype.get_minPassiveLongSlipDenominator = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireSlipParams_get_minPassiveLongSlipDenominator_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSlipParams.prototype['set_minPassiveLongSlipDenominator'] = PxVehicleTireSlipParams.prototype.set_minPassiveLongSlipDenominator = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireSlipParams_set_minPassiveLongSlipDenominator_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireSlipParams.prototype, 'minPassiveLongSlipDenominator', { get: PxVehicleTireSlipParams.prototype.get_minPassiveLongSlipDenominator, set: PxVehicleTireSlipParams.prototype.set_minPassiveLongSlipDenominator });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSlipParams.prototype['get_minActiveLongSlipDenominator'] = PxVehicleTireSlipParams.prototype.get_minActiveLongSlipDenominator = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTireSlipParams_get_minActiveLongSlipDenominator_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSlipParams.prototype['set_minActiveLongSlipDenominator'] = PxVehicleTireSlipParams.prototype.set_minActiveLongSlipDenominator = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleTireSlipParams_set_minActiveLongSlipDenominator_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireSlipParams.prototype, 'minActiveLongSlipDenominator', { get: PxVehicleTireSlipParams.prototype.get_minActiveLongSlipDenominator, set: PxVehicleTireSlipParams.prototype.set_minActiveLongSlipDenominator });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSlipParams.prototype['__destroy__'] = PxVehicleTireSlipParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireSlipParams___destroy___0(self);
};

// Interface: PxVehicleTireSlipState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTireSlipState() {
  this.ptr = _emscripten_bind_PxVehicleTireSlipState_PxVehicleTireSlipState_0();
  getCache(PxVehicleTireSlipState)[this.ptr] = this;
};

PxVehicleTireSlipState.prototype = Object.create(WrapperObject.prototype);
PxVehicleTireSlipState.prototype.constructor = PxVehicleTireSlipState;
PxVehicleTireSlipState.prototype.__class__ = PxVehicleTireSlipState;
PxVehicleTireSlipState.__cache__ = {};
Module['PxVehicleTireSlipState'] = PxVehicleTireSlipState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSlipState.prototype['setToDefault'] = PxVehicleTireSlipState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireSlipState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSlipState.prototype['get_slips'] = PxVehicleTireSlipState.prototype.get_slips = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleTireSlipState_get_slips_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSlipState.prototype['set_slips'] = PxVehicleTireSlipState.prototype.set_slips = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTireSlipState_set_slips_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireSlipState.prototype, 'slips', { get: PxVehicleTireSlipState.prototype.get_slips, set: PxVehicleTireSlipState.prototype.set_slips });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSlipState.prototype['__destroy__'] = PxVehicleTireSlipState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireSlipState___destroy___0(self);
};

// Interface: PxVehicleTireSpeedState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTireSpeedState() {
  this.ptr = _emscripten_bind_PxVehicleTireSpeedState_PxVehicleTireSpeedState_0();
  getCache(PxVehicleTireSpeedState)[this.ptr] = this;
};

PxVehicleTireSpeedState.prototype = Object.create(WrapperObject.prototype);
PxVehicleTireSpeedState.prototype.constructor = PxVehicleTireSpeedState;
PxVehicleTireSpeedState.prototype.__class__ = PxVehicleTireSpeedState;
PxVehicleTireSpeedState.__cache__ = {};
Module['PxVehicleTireSpeedState'] = PxVehicleTireSpeedState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSpeedState.prototype['setToDefault'] = PxVehicleTireSpeedState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireSpeedState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSpeedState.prototype['get_speedStates'] = PxVehicleTireSpeedState.prototype.get_speedStates = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleTireSpeedState_get_speedStates_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSpeedState.prototype['set_speedStates'] = PxVehicleTireSpeedState.prototype.set_speedStates = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTireSpeedState_set_speedStates_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireSpeedState.prototype, 'speedStates', { get: PxVehicleTireSpeedState.prototype.get_speedStates, set: PxVehicleTireSpeedState.prototype.set_speedStates });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireSpeedState.prototype['__destroy__'] = PxVehicleTireSpeedState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireSpeedState___destroy___0(self);
};

// Interface: PxVehicleTireStickyParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTireStickyParams() {
  this.ptr = _emscripten_bind_PxVehicleTireStickyParams_PxVehicleTireStickyParams_0();
  getCache(PxVehicleTireStickyParams)[this.ptr] = this;
};

PxVehicleTireStickyParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleTireStickyParams.prototype.constructor = PxVehicleTireStickyParams;
PxVehicleTireStickyParams.prototype.__class__ = PxVehicleTireStickyParams;
PxVehicleTireStickyParams.__cache__ = {};
Module['PxVehicleTireStickyParams'] = PxVehicleTireStickyParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireStickyParams.prototype['setToDefault'] = PxVehicleTireStickyParams.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireStickyParams_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireStickyParams.prototype['transformAndScale'] = PxVehicleTireStickyParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleTireStickyParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleTireStickyParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireStickyParams.prototype['isValid'] = PxVehicleTireStickyParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleTireStickyParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireStickyParams.prototype['get_stickyParams'] = PxVehicleTireStickyParams.prototype.get_stickyParams = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleTireStickyParams_get_stickyParams_1(self, arg0), PxVehicleTireAxisStickyParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireStickyParams.prototype['set_stickyParams'] = PxVehicleTireStickyParams.prototype.set_stickyParams = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTireStickyParams_set_stickyParams_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireStickyParams.prototype, 'stickyParams', { get: PxVehicleTireStickyParams.prototype.get_stickyParams, set: PxVehicleTireStickyParams.prototype.set_stickyParams });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireStickyParams.prototype['__destroy__'] = PxVehicleTireStickyParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireStickyParams___destroy___0(self);
};

// Interface: PxVehicleTireStickyState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTireStickyState() {
  this.ptr = _emscripten_bind_PxVehicleTireStickyState_PxVehicleTireStickyState_0();
  getCache(PxVehicleTireStickyState)[this.ptr] = this;
};

PxVehicleTireStickyState.prototype = Object.create(WrapperObject.prototype);
PxVehicleTireStickyState.prototype.constructor = PxVehicleTireStickyState;
PxVehicleTireStickyState.prototype.__class__ = PxVehicleTireStickyState;
PxVehicleTireStickyState.__cache__ = {};
Module['PxVehicleTireStickyState'] = PxVehicleTireStickyState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireStickyState.prototype['setToDefault'] = PxVehicleTireStickyState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireStickyState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireStickyState.prototype['get_lowSpeedTime'] = PxVehicleTireStickyState.prototype.get_lowSpeedTime = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleTireStickyState_get_lowSpeedTime_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireStickyState.prototype['set_lowSpeedTime'] = PxVehicleTireStickyState.prototype.set_lowSpeedTime = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTireStickyState_set_lowSpeedTime_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireStickyState.prototype, 'lowSpeedTime', { get: PxVehicleTireStickyState.prototype.get_lowSpeedTime, set: PxVehicleTireStickyState.prototype.set_lowSpeedTime });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireStickyState.prototype['get_activeStatus'] = PxVehicleTireStickyState.prototype.get_activeStatus = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return !!(_emscripten_bind_PxVehicleTireStickyState_get_activeStatus_1(self, arg0));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireStickyState.prototype['set_activeStatus'] = PxVehicleTireStickyState.prototype.set_activeStatus = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleTireStickyState_set_activeStatus_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTireStickyState.prototype, 'activeStatus', { get: PxVehicleTireStickyState.prototype.get_activeStatus, set: PxVehicleTireStickyState.prototype.set_activeStatus });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTireStickyState.prototype['__destroy__'] = PxVehicleTireStickyState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTireStickyState___destroy___0(self);
};

// Interface: PxVehicleTopLevelFunctions

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTopLevelFunctions() { throw "cannot construct a PxVehicleTopLevelFunctions, no constructor in IDL" }
PxVehicleTopLevelFunctions.prototype = Object.create(WrapperObject.prototype);
PxVehicleTopLevelFunctions.prototype.constructor = PxVehicleTopLevelFunctions;
PxVehicleTopLevelFunctions.prototype.__class__ = PxVehicleTopLevelFunctions;
PxVehicleTopLevelFunctions.__cache__ = {};
Module['PxVehicleTopLevelFunctions'] = PxVehicleTopLevelFunctions;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTopLevelFunctions.prototype['InitVehicleExtension'] = PxVehicleTopLevelFunctions.prototype.InitVehicleExtension = function(foundation) {
  if (foundation && typeof foundation === 'object') foundation = foundation.ptr;
  return !!(_emscripten_bind_PxVehicleTopLevelFunctions_InitVehicleExtension_1(foundation));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTopLevelFunctions.prototype['CloseVehicleExtension'] = PxVehicleTopLevelFunctions.prototype.CloseVehicleExtension = function() {
  _emscripten_bind_PxVehicleTopLevelFunctions_CloseVehicleExtension_0();
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTopLevelFunctions.prototype['VehicleComputeSprungMasses'] = PxVehicleTopLevelFunctions.prototype.VehicleComputeSprungMasses = function(nbSprungMasses, sprungMassCoordinates, totalMass, gravityDirection, sprungMasses) {
  if (nbSprungMasses && typeof nbSprungMasses === 'object') nbSprungMasses = nbSprungMasses.ptr;
  if (sprungMassCoordinates && typeof sprungMassCoordinates === 'object') sprungMassCoordinates = sprungMassCoordinates.ptr;
  if (totalMass && typeof totalMass === 'object') totalMass = totalMass.ptr;
  if (gravityDirection && typeof gravityDirection === 'object') gravityDirection = gravityDirection.ptr;
  if (sprungMasses && typeof sprungMasses === 'object') sprungMasses = sprungMasses.ptr;
  return !!(_emscripten_bind_PxVehicleTopLevelFunctions_VehicleComputeSprungMasses_5(nbSprungMasses, sprungMassCoordinates, totalMass, gravityDirection, sprungMasses));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTopLevelFunctions.prototype['VehicleUnitCylinderSweepMeshCreate'] = PxVehicleTopLevelFunctions.prototype.VehicleUnitCylinderSweepMeshCreate = function(vehicleFrame, physics, params) {
  if (vehicleFrame && typeof vehicleFrame === 'object') vehicleFrame = vehicleFrame.ptr;
  if (physics && typeof physics === 'object') physics = physics.ptr;
  if (params && typeof params === 'object') params = params.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshCreate_3(vehicleFrame, physics, params), PxConvexMesh);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTopLevelFunctions.prototype['VehicleUnitCylinderSweepMeshDestroy'] = PxVehicleTopLevelFunctions.prototype.VehicleUnitCylinderSweepMeshDestroy = function(mesh) {
  if (mesh && typeof mesh === 'object') mesh = mesh.ptr;
  _emscripten_bind_PxVehicleTopLevelFunctions_VehicleUnitCylinderSweepMeshDestroy_1(mesh);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTopLevelFunctions.prototype['get_MAX_NB_ENGINE_TORQUE_CURVE_ENTRIES'] = PxVehicleTopLevelFunctions.prototype.get_MAX_NB_ENGINE_TORQUE_CURVE_ENTRIES = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleTopLevelFunctions_get_MAX_NB_ENGINE_TORQUE_CURVE_ENTRIES_0(self);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleTopLevelFunctions.prototype, 'MAX_NB_ENGINE_TORQUE_CURVE_ENTRIES', { get: PxVehicleTopLevelFunctions.prototype.get_MAX_NB_ENGINE_TORQUE_CURVE_ENTRIES });

// Interface: PxVehicleTorqueCurveLookupTable

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleTorqueCurveLookupTable() {
  this.ptr = _emscripten_bind_PxVehicleTorqueCurveLookupTable_PxVehicleTorqueCurveLookupTable_0();
  getCache(PxVehicleTorqueCurveLookupTable)[this.ptr] = this;
};

PxVehicleTorqueCurveLookupTable.prototype = Object.create(WrapperObject.prototype);
PxVehicleTorqueCurveLookupTable.prototype.constructor = PxVehicleTorqueCurveLookupTable;
PxVehicleTorqueCurveLookupTable.prototype.__class__ = PxVehicleTorqueCurveLookupTable;
PxVehicleTorqueCurveLookupTable.__cache__ = {};
Module['PxVehicleTorqueCurveLookupTable'] = PxVehicleTorqueCurveLookupTable;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTorqueCurveLookupTable.prototype['addPair'] = PxVehicleTorqueCurveLookupTable.prototype.addPair = function(x, y) {
  var self = this.ptr;
  if (x && typeof x === 'object') x = x.ptr;
  if (y && typeof y === 'object') y = y.ptr;
  return !!(_emscripten_bind_PxVehicleTorqueCurveLookupTable_addPair_2(self, x, y));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTorqueCurveLookupTable.prototype['interpolate'] = PxVehicleTorqueCurveLookupTable.prototype.interpolate = function(x) {
  var self = this.ptr;
  if (x && typeof x === 'object') x = x.ptr;
  return _emscripten_bind_PxVehicleTorqueCurveLookupTable_interpolate_1(self, x);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTorqueCurveLookupTable.prototype['clear'] = PxVehicleTorqueCurveLookupTable.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTorqueCurveLookupTable_clear_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTorqueCurveLookupTable.prototype['isValid'] = PxVehicleTorqueCurveLookupTable.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleTorqueCurveLookupTable_isValid_0(self));
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleTorqueCurveLookupTable.prototype['__destroy__'] = PxVehicleTorqueCurveLookupTable.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleTorqueCurveLookupTable___destroy___0(self);
};

// Interface: PxVehicleWheelActuationState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleWheelActuationState() {
  this.ptr = _emscripten_bind_PxVehicleWheelActuationState_PxVehicleWheelActuationState_0();
  getCache(PxVehicleWheelActuationState)[this.ptr] = this;
};

PxVehicleWheelActuationState.prototype = Object.create(WrapperObject.prototype);
PxVehicleWheelActuationState.prototype.constructor = PxVehicleWheelActuationState;
PxVehicleWheelActuationState.prototype.__class__ = PxVehicleWheelActuationState;
PxVehicleWheelActuationState.__cache__ = {};
Module['PxVehicleWheelActuationState'] = PxVehicleWheelActuationState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelActuationState.prototype['setToDefault'] = PxVehicleWheelActuationState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleWheelActuationState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelActuationState.prototype['get_isBrakeApplied'] = PxVehicleWheelActuationState.prototype.get_isBrakeApplied = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleWheelActuationState_get_isBrakeApplied_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelActuationState.prototype['set_isBrakeApplied'] = PxVehicleWheelActuationState.prototype.set_isBrakeApplied = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleWheelActuationState_set_isBrakeApplied_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelActuationState.prototype, 'isBrakeApplied', { get: PxVehicleWheelActuationState.prototype.get_isBrakeApplied, set: PxVehicleWheelActuationState.prototype.set_isBrakeApplied });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelActuationState.prototype['get_isDriveApplied'] = PxVehicleWheelActuationState.prototype.get_isDriveApplied = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleWheelActuationState_get_isDriveApplied_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelActuationState.prototype['set_isDriveApplied'] = PxVehicleWheelActuationState.prototype.set_isDriveApplied = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleWheelActuationState_set_isDriveApplied_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelActuationState.prototype, 'isDriveApplied', { get: PxVehicleWheelActuationState.prototype.get_isDriveApplied, set: PxVehicleWheelActuationState.prototype.set_isDriveApplied });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelActuationState.prototype['__destroy__'] = PxVehicleWheelActuationState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleWheelActuationState___destroy___0(self);
};

// Interface: PxVehicleWheelConstraintGroupState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleWheelConstraintGroupState() {
  this.ptr = _emscripten_bind_PxVehicleWheelConstraintGroupState_PxVehicleWheelConstraintGroupState_0();
  getCache(PxVehicleWheelConstraintGroupState)[this.ptr] = this;
};

PxVehicleWheelConstraintGroupState.prototype = Object.create(WrapperObject.prototype);
PxVehicleWheelConstraintGroupState.prototype.constructor = PxVehicleWheelConstraintGroupState;
PxVehicleWheelConstraintGroupState.prototype.__class__ = PxVehicleWheelConstraintGroupState;
PxVehicleWheelConstraintGroupState.__cache__ = {};
Module['PxVehicleWheelConstraintGroupState'] = PxVehicleWheelConstraintGroupState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['setToDefault'] = PxVehicleWheelConstraintGroupState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleWheelConstraintGroupState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['getNbConstraintGroups'] = PxVehicleWheelConstraintGroupState.prototype.getNbConstraintGroups = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleWheelConstraintGroupState_getNbConstraintGroups_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['getNbWheelsInConstraintGroup'] = PxVehicleWheelConstraintGroupState.prototype.getNbWheelsInConstraintGroup = function(i) {
  var self = this.ptr;
  if (i && typeof i === 'object') i = i.ptr;
  return _emscripten_bind_PxVehicleWheelConstraintGroupState_getNbWheelsInConstraintGroup_1(self, i);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['getWheelInConstraintGroup'] = PxVehicleWheelConstraintGroupState.prototype.getWheelInConstraintGroup = function(j, i) {
  var self = this.ptr;
  if (j && typeof j === 'object') j = j.ptr;
  if (i && typeof i === 'object') i = i.ptr;
  return _emscripten_bind_PxVehicleWheelConstraintGroupState_getWheelInConstraintGroup_2(self, j, i);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['getMultiplierInConstraintGroup'] = PxVehicleWheelConstraintGroupState.prototype.getMultiplierInConstraintGroup = function(j, i) {
  var self = this.ptr;
  if (j && typeof j === 'object') j = j.ptr;
  if (i && typeof i === 'object') i = i.ptr;
  return _emscripten_bind_PxVehicleWheelConstraintGroupState_getMultiplierInConstraintGroup_2(self, j, i);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['get_nbGroups'] = PxVehicleWheelConstraintGroupState.prototype.get_nbGroups = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbGroups_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['set_nbGroups'] = PxVehicleWheelConstraintGroupState.prototype.set_nbGroups = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbGroups_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelConstraintGroupState.prototype, 'nbGroups', { get: PxVehicleWheelConstraintGroupState.prototype.get_nbGroups, set: PxVehicleWheelConstraintGroupState.prototype.set_nbGroups });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['get_nbWheelsPerGroup'] = PxVehicleWheelConstraintGroupState.prototype.get_nbWheelsPerGroup = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsPerGroup_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['set_nbWheelsPerGroup'] = PxVehicleWheelConstraintGroupState.prototype.set_nbWheelsPerGroup = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsPerGroup_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelConstraintGroupState.prototype, 'nbWheelsPerGroup', { get: PxVehicleWheelConstraintGroupState.prototype.get_nbWheelsPerGroup, set: PxVehicleWheelConstraintGroupState.prototype.set_nbWheelsPerGroup });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['get_groupToWheelIds'] = PxVehicleWheelConstraintGroupState.prototype.get_groupToWheelIds = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleWheelConstraintGroupState_get_groupToWheelIds_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['set_groupToWheelIds'] = PxVehicleWheelConstraintGroupState.prototype.set_groupToWheelIds = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleWheelConstraintGroupState_set_groupToWheelIds_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelConstraintGroupState.prototype, 'groupToWheelIds', { get: PxVehicleWheelConstraintGroupState.prototype.get_groupToWheelIds, set: PxVehicleWheelConstraintGroupState.prototype.set_groupToWheelIds });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['get_wheelIdsInGroupOrder'] = PxVehicleWheelConstraintGroupState.prototype.get_wheelIdsInGroupOrder = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelIdsInGroupOrder_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['set_wheelIdsInGroupOrder'] = PxVehicleWheelConstraintGroupState.prototype.set_wheelIdsInGroupOrder = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelIdsInGroupOrder_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelConstraintGroupState.prototype, 'wheelIdsInGroupOrder', { get: PxVehicleWheelConstraintGroupState.prototype.get_wheelIdsInGroupOrder, set: PxVehicleWheelConstraintGroupState.prototype.set_wheelIdsInGroupOrder });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['get_wheelMultipliersInGroupOrder'] = PxVehicleWheelConstraintGroupState.prototype.get_wheelMultipliersInGroupOrder = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  return _emscripten_bind_PxVehicleWheelConstraintGroupState_get_wheelMultipliersInGroupOrder_1(self, arg0);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['set_wheelMultipliersInGroupOrder'] = PxVehicleWheelConstraintGroupState.prototype.set_wheelMultipliersInGroupOrder = function(arg0, arg1) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
  _emscripten_bind_PxVehicleWheelConstraintGroupState_set_wheelMultipliersInGroupOrder_2(self, arg0, arg1);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelConstraintGroupState.prototype, 'wheelMultipliersInGroupOrder', { get: PxVehicleWheelConstraintGroupState.prototype.get_wheelMultipliersInGroupOrder, set: PxVehicleWheelConstraintGroupState.prototype.set_wheelMultipliersInGroupOrder });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['get_nbWheelsInGroups'] = PxVehicleWheelConstraintGroupState.prototype.get_nbWheelsInGroups = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleWheelConstraintGroupState_get_nbWheelsInGroups_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['set_nbWheelsInGroups'] = PxVehicleWheelConstraintGroupState.prototype.set_nbWheelsInGroups = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleWheelConstraintGroupState_set_nbWheelsInGroups_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelConstraintGroupState.prototype, 'nbWheelsInGroups', { get: PxVehicleWheelConstraintGroupState.prototype.get_nbWheelsInGroups, set: PxVehicleWheelConstraintGroupState.prototype.set_nbWheelsInGroups });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelConstraintGroupState.prototype['__destroy__'] = PxVehicleWheelConstraintGroupState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleWheelConstraintGroupState___destroy___0(self);
};

// Interface: PxVehicleWheelLocalPose

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleWheelLocalPose() {
  this.ptr = _emscripten_bind_PxVehicleWheelLocalPose_PxVehicleWheelLocalPose_0();
  getCache(PxVehicleWheelLocalPose)[this.ptr] = this;
};

PxVehicleWheelLocalPose.prototype = Object.create(WrapperObject.prototype);
PxVehicleWheelLocalPose.prototype.constructor = PxVehicleWheelLocalPose;
PxVehicleWheelLocalPose.prototype.__class__ = PxVehicleWheelLocalPose;
PxVehicleWheelLocalPose.__cache__ = {};
Module['PxVehicleWheelLocalPose'] = PxVehicleWheelLocalPose;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelLocalPose.prototype['setToDefault'] = PxVehicleWheelLocalPose.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleWheelLocalPose_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelLocalPose.prototype['get_localPose'] = PxVehicleWheelLocalPose.prototype.get_localPose = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleWheelLocalPose_get_localPose_0(self), PxTransform);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelLocalPose.prototype['set_localPose'] = PxVehicleWheelLocalPose.prototype.set_localPose = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleWheelLocalPose_set_localPose_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelLocalPose.prototype, 'localPose', { get: PxVehicleWheelLocalPose.prototype.get_localPose, set: PxVehicleWheelLocalPose.prototype.set_localPose });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelLocalPose.prototype['__destroy__'] = PxVehicleWheelLocalPose.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleWheelLocalPose___destroy___0(self);
};

// Interface: PxVehicleWheelParams

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleWheelParams() {
  this.ptr = _emscripten_bind_PxVehicleWheelParams_PxVehicleWheelParams_0();
  getCache(PxVehicleWheelParams)[this.ptr] = this;
};

PxVehicleWheelParams.prototype = Object.create(WrapperObject.prototype);
PxVehicleWheelParams.prototype.constructor = PxVehicleWheelParams;
PxVehicleWheelParams.prototype.__class__ = PxVehicleWheelParams;
PxVehicleWheelParams.__cache__ = {};
Module['PxVehicleWheelParams'] = PxVehicleWheelParams;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelParams.prototype['transformAndScale'] = PxVehicleWheelParams.prototype.transformAndScale = function(srcFrame, trgFrame, srcScale, trgScale) {
  var self = this.ptr;
  if (srcFrame && typeof srcFrame === 'object') srcFrame = srcFrame.ptr;
  if (trgFrame && typeof trgFrame === 'object') trgFrame = trgFrame.ptr;
  if (srcScale && typeof srcScale === 'object') srcScale = srcScale.ptr;
  if (trgScale && typeof trgScale === 'object') trgScale = trgScale.ptr;
  return wrapPointer(_emscripten_bind_PxVehicleWheelParams_transformAndScale_4(self, srcFrame, trgFrame, srcScale, trgScale), PxVehicleWheelParams);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelParams.prototype['isValid'] = PxVehicleWheelParams.prototype.isValid = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_PxVehicleWheelParams_isValid_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelParams.prototype['get_radius'] = PxVehicleWheelParams.prototype.get_radius = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleWheelParams_get_radius_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelParams.prototype['set_radius'] = PxVehicleWheelParams.prototype.set_radius = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleWheelParams_set_radius_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelParams.prototype, 'radius', { get: PxVehicleWheelParams.prototype.get_radius, set: PxVehicleWheelParams.prototype.set_radius });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelParams.prototype['get_halfWidth'] = PxVehicleWheelParams.prototype.get_halfWidth = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleWheelParams_get_halfWidth_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelParams.prototype['set_halfWidth'] = PxVehicleWheelParams.prototype.set_halfWidth = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleWheelParams_set_halfWidth_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelParams.prototype, 'halfWidth', { get: PxVehicleWheelParams.prototype.get_halfWidth, set: PxVehicleWheelParams.prototype.set_halfWidth });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelParams.prototype['get_mass'] = PxVehicleWheelParams.prototype.get_mass = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleWheelParams_get_mass_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelParams.prototype['set_mass'] = PxVehicleWheelParams.prototype.set_mass = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleWheelParams_set_mass_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelParams.prototype, 'mass', { get: PxVehicleWheelParams.prototype.get_mass, set: PxVehicleWheelParams.prototype.set_mass });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelParams.prototype['get_moi'] = PxVehicleWheelParams.prototype.get_moi = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleWheelParams_get_moi_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelParams.prototype['set_moi'] = PxVehicleWheelParams.prototype.set_moi = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleWheelParams_set_moi_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelParams.prototype, 'moi', { get: PxVehicleWheelParams.prototype.get_moi, set: PxVehicleWheelParams.prototype.set_moi });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelParams.prototype['get_dampingRate'] = PxVehicleWheelParams.prototype.get_dampingRate = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleWheelParams_get_dampingRate_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelParams.prototype['set_dampingRate'] = PxVehicleWheelParams.prototype.set_dampingRate = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleWheelParams_set_dampingRate_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelParams.prototype, 'dampingRate', { get: PxVehicleWheelParams.prototype.get_dampingRate, set: PxVehicleWheelParams.prototype.set_dampingRate });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelParams.prototype['__destroy__'] = PxVehicleWheelParams.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleWheelParams___destroy___0(self);
};

// Interface: PxVehicleWheelRigidBody1dState

/** @suppress {undefinedVars, duplicate} @this{Object} */
function PxVehicleWheelRigidBody1dState() {
  this.ptr = _emscripten_bind_PxVehicleWheelRigidBody1dState_PxVehicleWheelRigidBody1dState_0();
  getCache(PxVehicleWheelRigidBody1dState)[this.ptr] = this;
};

PxVehicleWheelRigidBody1dState.prototype = Object.create(WrapperObject.prototype);
PxVehicleWheelRigidBody1dState.prototype.constructor = PxVehicleWheelRigidBody1dState;
PxVehicleWheelRigidBody1dState.prototype.__class__ = PxVehicleWheelRigidBody1dState;
PxVehicleWheelRigidBody1dState.__cache__ = {};
Module['PxVehicleWheelRigidBody1dState'] = PxVehicleWheelRigidBody1dState;
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelRigidBody1dState.prototype['setToDefault'] = PxVehicleWheelRigidBody1dState.prototype.setToDefault = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleWheelRigidBody1dState_setToDefault_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelRigidBody1dState.prototype['get_rotationSpeed'] = PxVehicleWheelRigidBody1dState.prototype.get_rotationSpeed = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationSpeed_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelRigidBody1dState.prototype['set_rotationSpeed'] = PxVehicleWheelRigidBody1dState.prototype.set_rotationSpeed = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationSpeed_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelRigidBody1dState.prototype, 'rotationSpeed', { get: PxVehicleWheelRigidBody1dState.prototype.get_rotationSpeed, set: PxVehicleWheelRigidBody1dState.prototype.set_rotationSpeed });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelRigidBody1dState.prototype['get_correctedRotationSpeed'] = PxVehicleWheelRigidBody1dState.prototype.get_correctedRotationSpeed = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleWheelRigidBody1dState_get_correctedRotationSpeed_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelRigidBody1dState.prototype['set_correctedRotationSpeed'] = PxVehicleWheelRigidBody1dState.prototype.set_correctedRotationSpeed = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleWheelRigidBody1dState_set_correctedRotationSpeed_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelRigidBody1dState.prototype, 'correctedRotationSpeed', { get: PxVehicleWheelRigidBody1dState.prototype.get_correctedRotationSpeed, set: PxVehicleWheelRigidBody1dState.prototype.set_correctedRotationSpeed });
/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelRigidBody1dState.prototype['get_rotationAngle'] = PxVehicleWheelRigidBody1dState.prototype.get_rotationAngle = function() {
  var self = this.ptr;
  return _emscripten_bind_PxVehicleWheelRigidBody1dState_get_rotationAngle_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelRigidBody1dState.prototype['set_rotationAngle'] = PxVehicleWheelRigidBody1dState.prototype.set_rotationAngle = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_PxVehicleWheelRigidBody1dState_set_rotationAngle_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(PxVehicleWheelRigidBody1dState.prototype, 'rotationAngle', { get: PxVehicleWheelRigidBody1dState.prototype.get_rotationAngle, set: PxVehicleWheelRigidBody1dState.prototype.set_rotationAngle });

/** @suppress {undefinedVars, duplicate} @this{Object} */
PxVehicleWheelRigidBody1dState.prototype['__destroy__'] = PxVehicleWheelRigidBody1dState.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_PxVehicleWheelRigidBody1dState___destroy___0(self);
};

// Interface: SimplPvdTransportImpl

/** @suppress {undefinedVars, duplicate} @this{Object} */
function SimplPvdTransportImpl() {
  this.ptr = _emscripten_bind_SimplPvdTransportImpl_SimplPvdTransportImpl_0();
  getCache(SimplPvdTransportImpl)[this.ptr] = this;
};

SimplPvdTransportImpl.prototype = Object.create(SimplePvdTransport.prototype);
SimplPvdTransportImpl.prototype.constructor = SimplPvdTransportImpl;
SimplPvdTransportImpl.prototype.__class__ = SimplPvdTransportImpl;
SimplPvdTransportImpl.__cache__ = {};
Module['SimplPvdTransportImpl'] = SimplPvdTransportImpl;
/** @suppress {undefinedVars, duplicate} @this{Object} */
SimplPvdTransportImpl.prototype['connect'] = SimplPvdTransportImpl.prototype.connect = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_SimplPvdTransportImpl_connect_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimplPvdTransportImpl.prototype['isConnected'] = SimplPvdTransportImpl.prototype.isConnected = function() {
  var self = this.ptr;
  return !!(_emscripten_bind_SimplPvdTransportImpl_isConnected_0(self));
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimplPvdTransportImpl.prototype['disconnect'] = SimplPvdTransportImpl.prototype.disconnect = function() {
  var self = this.ptr;
  _emscripten_bind_SimplPvdTransportImpl_disconnect_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimplPvdTransportImpl.prototype['send'] = SimplPvdTransportImpl.prototype.send = function(inBytes, inLength) {
  var self = this.ptr;
  if (inBytes && typeof inBytes === 'object') inBytes = inBytes.ptr;
  if (inLength && typeof inLength === 'object') inLength = inLength.ptr;
  _emscripten_bind_SimplPvdTransportImpl_send_2(self, inBytes, inLength);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SimplPvdTransportImpl.prototype['flush'] = SimplPvdTransportImpl.prototype.flush = function() {
  var self = this.ptr;
  _emscripten_bind_SimplPvdTransportImpl_flush_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
SimplPvdTransportImpl.prototype['__destroy__'] = SimplPvdTransportImpl.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_SimplPvdTransportImpl___destroy___0(self);
};

// Interface: SphereSupport

/** @suppress {undefinedVars, duplicate} @this{Object} */
function SphereSupport(radius) {
  if (radius && typeof radius === 'object') radius = radius.ptr;
  this.ptr = _emscripten_bind_SphereSupport_SphereSupport_1(radius);
  getCache(SphereSupport)[this.ptr] = this;
};

SphereSupport.prototype = Object.create(Support.prototype);
SphereSupport.prototype.constructor = SphereSupport;
SphereSupport.prototype.__class__ = SphereSupport;
SphereSupport.__cache__ = {};
Module['SphereSupport'] = SphereSupport;
/** @suppress {undefinedVars, duplicate} @this{Object} */
SphereSupport.prototype['getMargin'] = SphereSupport.prototype.getMargin = function() {
  var self = this.ptr;
  return _emscripten_bind_SphereSupport_getMargin_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SphereSupport.prototype['supportLocal'] = SphereSupport.prototype.supportLocal = function(dir) {
  var self = this.ptr;
  if (dir && typeof dir === 'object') dir = dir.ptr;
  return wrapPointer(_emscripten_bind_SphereSupport_supportLocal_1(self, dir), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SphereSupport.prototype['get_radius'] = SphereSupport.prototype.get_radius = function() {
  var self = this.ptr;
  return _emscripten_bind_SphereSupport_get_radius_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SphereSupport.prototype['set_radius'] = SphereSupport.prototype.set_radius = function(arg0) {
  var self = this.ptr;
  if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
  _emscripten_bind_SphereSupport_set_radius_1(self, arg0);
};

/** @suppress {checkTypes} */
Object.defineProperty(SphereSupport.prototype, 'radius', { get: SphereSupport.prototype.get_radius, set: SphereSupport.prototype.set_radius });

/** @suppress {undefinedVars, duplicate} @this{Object} */
SphereSupport.prototype['__destroy__'] = SphereSupport.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_SphereSupport___destroy___0(self);
};

// Interface: SupportFunctions

/** @suppress {undefinedVars, duplicate} @this{Object} */
function SupportFunctions() { throw "cannot construct a SupportFunctions, no constructor in IDL" }
SupportFunctions.prototype = Object.create(WrapperObject.prototype);
SupportFunctions.prototype.constructor = SupportFunctions;
SupportFunctions.prototype.__class__ = SupportFunctions;
SupportFunctions.__cache__ = {};
Module['SupportFunctions'] = SupportFunctions;
/** @suppress {undefinedVars, duplicate} @this{Object} */
SupportFunctions.prototype['PxActor_getShape'] = SupportFunctions.prototype.PxActor_getShape = function(actor, index) {
  if (actor && typeof actor === 'object') actor = actor.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_SupportFunctions_PxActor_getShape_2(actor, index), PxShape);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SupportFunctions.prototype['PxScene_getActiveActors'] = SupportFunctions.prototype.PxScene_getActiveActors = function(scene) {
  if (scene && typeof scene === 'object') scene = scene.ptr;
  return wrapPointer(_emscripten_bind_SupportFunctions_PxScene_getActiveActors_1(scene), PxArray_PxActorPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SupportFunctions.prototype['PxArticulationReducedCoordinate_getMinSolverPositionIterations'] = SupportFunctions.prototype.PxArticulationReducedCoordinate_getMinSolverPositionIterations = function(articulation) {
  if (articulation && typeof articulation === 'object') articulation = articulation.ptr;
  return _emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverPositionIterations_1(articulation);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
SupportFunctions.prototype['PxArticulationReducedCoordinate_getMinSolverVelocityIterations'] = SupportFunctions.prototype.PxArticulationReducedCoordinate_getMinSolverVelocityIterations = function(articulation) {
  if (articulation && typeof articulation === 'object') articulation = articulation.ptr;
  return _emscripten_bind_SupportFunctions_PxArticulationReducedCoordinate_getMinSolverVelocityIterations_1(articulation);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
SupportFunctions.prototype['__destroy__'] = SupportFunctions.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_SupportFunctions___destroy___0(self);
};

// Interface: Vector_PxActorPtr

/** @suppress {undefinedVars, duplicate} @this{Object} */
function Vector_PxActorPtr(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_0(); getCache(Vector_PxActorPtr)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_Vector_PxActorPtr_Vector_PxActorPtr_1(size);
  getCache(Vector_PxActorPtr)[this.ptr] = this;
};

Vector_PxActorPtr.prototype = Object.create(WrapperObject.prototype);
Vector_PxActorPtr.prototype.constructor = Vector_PxActorPtr;
Vector_PxActorPtr.prototype.__class__ = Vector_PxActorPtr;
Vector_PxActorPtr.__cache__ = {};
Module['Vector_PxActorPtr'] = Vector_PxActorPtr;
/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxActorPtr.prototype['at'] = Vector_PxActorPtr.prototype.at = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxActorPtr_at_1(self, index), PxActor);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxActorPtr.prototype['data'] = Vector_PxActorPtr.prototype.data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxActorPtr_data_0(self), PxActorPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxActorPtr.prototype['size'] = Vector_PxActorPtr.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_Vector_PxActorPtr_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxActorPtr.prototype['push_back'] = Vector_PxActorPtr.prototype.push_back = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_Vector_PxActorPtr_push_back_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxActorPtr.prototype['clear'] = Vector_PxActorPtr.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxActorPtr_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxActorPtr.prototype['__destroy__'] = Vector_PxActorPtr.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxActorPtr___destroy___0(self);
};

// Interface: Vector_PxContactPairPoint

/** @suppress {undefinedVars, duplicate} @this{Object} */
function Vector_PxContactPairPoint(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_0(); getCache(Vector_PxContactPairPoint)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_Vector_PxContactPairPoint_Vector_PxContactPairPoint_1(size);
  getCache(Vector_PxContactPairPoint)[this.ptr] = this;
};

Vector_PxContactPairPoint.prototype = Object.create(WrapperObject.prototype);
Vector_PxContactPairPoint.prototype.constructor = Vector_PxContactPairPoint;
Vector_PxContactPairPoint.prototype.__class__ = Vector_PxContactPairPoint;
Vector_PxContactPairPoint.__cache__ = {};
Module['Vector_PxContactPairPoint'] = Vector_PxContactPairPoint;
/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxContactPairPoint.prototype['at'] = Vector_PxContactPairPoint.prototype.at = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxContactPairPoint_at_1(self, index), PxContactPairPoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxContactPairPoint.prototype['data'] = Vector_PxContactPairPoint.prototype.data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxContactPairPoint_data_0(self), PxContactPairPoint);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxContactPairPoint.prototype['size'] = Vector_PxContactPairPoint.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_Vector_PxContactPairPoint_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxContactPairPoint.prototype['push_back'] = Vector_PxContactPairPoint.prototype.push_back = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_Vector_PxContactPairPoint_push_back_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxContactPairPoint.prototype['clear'] = Vector_PxContactPairPoint.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxContactPairPoint_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxContactPairPoint.prototype['__destroy__'] = Vector_PxContactPairPoint.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxContactPairPoint___destroy___0(self);
};

// Interface: Vector_PxHeightFieldSample

/** @suppress {undefinedVars, duplicate} @this{Object} */
function Vector_PxHeightFieldSample(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_0(); getCache(Vector_PxHeightFieldSample)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_Vector_PxHeightFieldSample_Vector_PxHeightFieldSample_1(size);
  getCache(Vector_PxHeightFieldSample)[this.ptr] = this;
};

Vector_PxHeightFieldSample.prototype = Object.create(WrapperObject.prototype);
Vector_PxHeightFieldSample.prototype.constructor = Vector_PxHeightFieldSample;
Vector_PxHeightFieldSample.prototype.__class__ = Vector_PxHeightFieldSample;
Vector_PxHeightFieldSample.__cache__ = {};
Module['Vector_PxHeightFieldSample'] = Vector_PxHeightFieldSample;
/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxHeightFieldSample.prototype['at'] = Vector_PxHeightFieldSample.prototype.at = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxHeightFieldSample_at_1(self, index), PxHeightFieldSample);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxHeightFieldSample.prototype['data'] = Vector_PxHeightFieldSample.prototype.data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxHeightFieldSample_data_0(self), PxHeightFieldSample);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxHeightFieldSample.prototype['size'] = Vector_PxHeightFieldSample.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_Vector_PxHeightFieldSample_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxHeightFieldSample.prototype['push_back'] = Vector_PxHeightFieldSample.prototype.push_back = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_Vector_PxHeightFieldSample_push_back_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxHeightFieldSample.prototype['clear'] = Vector_PxHeightFieldSample.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxHeightFieldSample_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxHeightFieldSample.prototype['__destroy__'] = Vector_PxHeightFieldSample.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxHeightFieldSample___destroy___0(self);
};

// Interface: Vector_PxMaterialConst

/** @suppress {undefinedVars, duplicate} @this{Object} */
function Vector_PxMaterialConst(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_0(); getCache(Vector_PxMaterialConst)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_Vector_PxMaterialConst_Vector_PxMaterialConst_1(size);
  getCache(Vector_PxMaterialConst)[this.ptr] = this;
};

Vector_PxMaterialConst.prototype = Object.create(WrapperObject.prototype);
Vector_PxMaterialConst.prototype.constructor = Vector_PxMaterialConst;
Vector_PxMaterialConst.prototype.__class__ = Vector_PxMaterialConst;
Vector_PxMaterialConst.__cache__ = {};
Module['Vector_PxMaterialConst'] = Vector_PxMaterialConst;
/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxMaterialConst.prototype['at'] = Vector_PxMaterialConst.prototype.at = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxMaterialConst_at_1(self, index), PxMaterial);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxMaterialConst.prototype['data'] = Vector_PxMaterialConst.prototype.data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxMaterialConst_data_0(self), PxMaterialConstPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxMaterialConst.prototype['size'] = Vector_PxMaterialConst.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_Vector_PxMaterialConst_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxMaterialConst.prototype['push_back'] = Vector_PxMaterialConst.prototype.push_back = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_Vector_PxMaterialConst_push_back_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxMaterialConst.prototype['clear'] = Vector_PxMaterialConst.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxMaterialConst_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxMaterialConst.prototype['__destroy__'] = Vector_PxMaterialConst.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxMaterialConst___destroy___0(self);
};

// Interface: Vector_PxRaycastHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function Vector_PxRaycastHit(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_0(); getCache(Vector_PxRaycastHit)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_Vector_PxRaycastHit_Vector_PxRaycastHit_1(size);
  getCache(Vector_PxRaycastHit)[this.ptr] = this;
};

Vector_PxRaycastHit.prototype = Object.create(WrapperObject.prototype);
Vector_PxRaycastHit.prototype.constructor = Vector_PxRaycastHit;
Vector_PxRaycastHit.prototype.__class__ = Vector_PxRaycastHit;
Vector_PxRaycastHit.__cache__ = {};
Module['Vector_PxRaycastHit'] = Vector_PxRaycastHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxRaycastHit.prototype['at'] = Vector_PxRaycastHit.prototype.at = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxRaycastHit_at_1(self, index), PxRaycastHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxRaycastHit.prototype['data'] = Vector_PxRaycastHit.prototype.data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxRaycastHit_data_0(self), PxRaycastHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxRaycastHit.prototype['size'] = Vector_PxRaycastHit.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_Vector_PxRaycastHit_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxRaycastHit.prototype['push_back'] = Vector_PxRaycastHit.prototype.push_back = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_Vector_PxRaycastHit_push_back_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxRaycastHit.prototype['clear'] = Vector_PxRaycastHit.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxRaycastHit_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxRaycastHit.prototype['__destroy__'] = Vector_PxRaycastHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxRaycastHit___destroy___0(self);
};

// Interface: Vector_PxReal

/** @suppress {undefinedVars, duplicate} @this{Object} */
function Vector_PxReal(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_Vector_PxReal_Vector_PxReal_0(); getCache(Vector_PxReal)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_Vector_PxReal_Vector_PxReal_1(size);
  getCache(Vector_PxReal)[this.ptr] = this;
};

Vector_PxReal.prototype = Object.create(WrapperObject.prototype);
Vector_PxReal.prototype.constructor = Vector_PxReal;
Vector_PxReal.prototype.__class__ = Vector_PxReal;
Vector_PxReal.__cache__ = {};
Module['Vector_PxReal'] = Vector_PxReal;
/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxReal.prototype['at'] = Vector_PxReal.prototype.at = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return _emscripten_bind_Vector_PxReal_at_1(self, index);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxReal.prototype['data'] = Vector_PxReal.prototype.data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxReal_data_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxReal.prototype['size'] = Vector_PxReal.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_Vector_PxReal_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxReal.prototype['push_back'] = Vector_PxReal.prototype.push_back = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_Vector_PxReal_push_back_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxReal.prototype['clear'] = Vector_PxReal.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxReal_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxReal.prototype['__destroy__'] = Vector_PxReal.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxReal___destroy___0(self);
};

// Interface: Vector_PxSweepHit

/** @suppress {undefinedVars, duplicate} @this{Object} */
function Vector_PxSweepHit(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_0(); getCache(Vector_PxSweepHit)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_Vector_PxSweepHit_Vector_PxSweepHit_1(size);
  getCache(Vector_PxSweepHit)[this.ptr] = this;
};

Vector_PxSweepHit.prototype = Object.create(WrapperObject.prototype);
Vector_PxSweepHit.prototype.constructor = Vector_PxSweepHit;
Vector_PxSweepHit.prototype.__class__ = Vector_PxSweepHit;
Vector_PxSweepHit.__cache__ = {};
Module['Vector_PxSweepHit'] = Vector_PxSweepHit;
/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxSweepHit.prototype['at'] = Vector_PxSweepHit.prototype.at = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxSweepHit_at_1(self, index), PxSweepHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxSweepHit.prototype['data'] = Vector_PxSweepHit.prototype.data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxSweepHit_data_0(self), PxSweepHit);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxSweepHit.prototype['size'] = Vector_PxSweepHit.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_Vector_PxSweepHit_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxSweepHit.prototype['push_back'] = Vector_PxSweepHit.prototype.push_back = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_Vector_PxSweepHit_push_back_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxSweepHit.prototype['clear'] = Vector_PxSweepHit.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxSweepHit_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxSweepHit.prototype['__destroy__'] = Vector_PxSweepHit.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxSweepHit___destroy___0(self);
};

// Interface: Vector_PxU16

/** @suppress {undefinedVars, duplicate} @this{Object} */
function Vector_PxU16(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_Vector_PxU16_Vector_PxU16_0(); getCache(Vector_PxU16)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_Vector_PxU16_Vector_PxU16_1(size);
  getCache(Vector_PxU16)[this.ptr] = this;
};

Vector_PxU16.prototype = Object.create(WrapperObject.prototype);
Vector_PxU16.prototype.constructor = Vector_PxU16;
Vector_PxU16.prototype.__class__ = Vector_PxU16;
Vector_PxU16.__cache__ = {};
Module['Vector_PxU16'] = Vector_PxU16;
/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU16.prototype['at'] = Vector_PxU16.prototype.at = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return _emscripten_bind_Vector_PxU16_at_1(self, index);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU16.prototype['data'] = Vector_PxU16.prototype.data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxU16_data_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU16.prototype['size'] = Vector_PxU16.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_Vector_PxU16_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU16.prototype['push_back'] = Vector_PxU16.prototype.push_back = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_Vector_PxU16_push_back_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU16.prototype['clear'] = Vector_PxU16.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxU16_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU16.prototype['__destroy__'] = Vector_PxU16.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxU16___destroy___0(self);
};

// Interface: Vector_PxU32

/** @suppress {undefinedVars, duplicate} @this{Object} */
function Vector_PxU32(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_Vector_PxU32_Vector_PxU32_0(); getCache(Vector_PxU32)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_Vector_PxU32_Vector_PxU32_1(size);
  getCache(Vector_PxU32)[this.ptr] = this;
};

Vector_PxU32.prototype = Object.create(WrapperObject.prototype);
Vector_PxU32.prototype.constructor = Vector_PxU32;
Vector_PxU32.prototype.__class__ = Vector_PxU32;
Vector_PxU32.__cache__ = {};
Module['Vector_PxU32'] = Vector_PxU32;
/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU32.prototype['at'] = Vector_PxU32.prototype.at = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return _emscripten_bind_Vector_PxU32_at_1(self, index);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU32.prototype['data'] = Vector_PxU32.prototype.data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxU32_data_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU32.prototype['size'] = Vector_PxU32.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_Vector_PxU32_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU32.prototype['push_back'] = Vector_PxU32.prototype.push_back = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_Vector_PxU32_push_back_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU32.prototype['clear'] = Vector_PxU32.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxU32_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU32.prototype['__destroy__'] = Vector_PxU32.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxU32___destroy___0(self);
};

// Interface: Vector_PxU8

/** @suppress {undefinedVars, duplicate} @this{Object} */
function Vector_PxU8(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_Vector_PxU8_Vector_PxU8_0(); getCache(Vector_PxU8)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_Vector_PxU8_Vector_PxU8_1(size);
  getCache(Vector_PxU8)[this.ptr] = this;
};

Vector_PxU8.prototype = Object.create(WrapperObject.prototype);
Vector_PxU8.prototype.constructor = Vector_PxU8;
Vector_PxU8.prototype.__class__ = Vector_PxU8;
Vector_PxU8.__cache__ = {};
Module['Vector_PxU8'] = Vector_PxU8;
/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU8.prototype['at'] = Vector_PxU8.prototype.at = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return _emscripten_bind_Vector_PxU8_at_1(self, index);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU8.prototype['data'] = Vector_PxU8.prototype.data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxU8_data_0(self), VoidPtr);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU8.prototype['size'] = Vector_PxU8.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_Vector_PxU8_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU8.prototype['push_back'] = Vector_PxU8.prototype.push_back = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_Vector_PxU8_push_back_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU8.prototype['clear'] = Vector_PxU8.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxU8_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxU8.prototype['__destroy__'] = Vector_PxU8.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxU8___destroy___0(self);
};

// Interface: Vector_PxVec3

/** @suppress {undefinedVars, duplicate} @this{Object} */
function Vector_PxVec3(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_Vector_PxVec3_Vector_PxVec3_0(); getCache(Vector_PxVec3)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_Vector_PxVec3_Vector_PxVec3_1(size);
  getCache(Vector_PxVec3)[this.ptr] = this;
};

Vector_PxVec3.prototype = Object.create(WrapperObject.prototype);
Vector_PxVec3.prototype.constructor = Vector_PxVec3;
Vector_PxVec3.prototype.__class__ = Vector_PxVec3;
Vector_PxVec3.__cache__ = {};
Module['Vector_PxVec3'] = Vector_PxVec3;
/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxVec3.prototype['at'] = Vector_PxVec3.prototype.at = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxVec3_at_1(self, index), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxVec3.prototype['data'] = Vector_PxVec3.prototype.data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxVec3_data_0(self), PxVec3);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxVec3.prototype['size'] = Vector_PxVec3.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_Vector_PxVec3_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxVec3.prototype['push_back'] = Vector_PxVec3.prototype.push_back = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_Vector_PxVec3_push_back_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxVec3.prototype['clear'] = Vector_PxVec3.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxVec3_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxVec3.prototype['__destroy__'] = Vector_PxVec3.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxVec3___destroy___0(self);
};

// Interface: Vector_PxVec4

/** @suppress {undefinedVars, duplicate} @this{Object} */
function Vector_PxVec4(size) {
  if (size && typeof size === 'object') size = size.ptr;
  if (size === undefined) { this.ptr = _emscripten_bind_Vector_PxVec4_Vector_PxVec4_0(); getCache(Vector_PxVec4)[this.ptr] = this;return }
  this.ptr = _emscripten_bind_Vector_PxVec4_Vector_PxVec4_1(size);
  getCache(Vector_PxVec4)[this.ptr] = this;
};

Vector_PxVec4.prototype = Object.create(WrapperObject.prototype);
Vector_PxVec4.prototype.constructor = Vector_PxVec4;
Vector_PxVec4.prototype.__class__ = Vector_PxVec4;
Vector_PxVec4.__cache__ = {};
Module['Vector_PxVec4'] = Vector_PxVec4;
/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxVec4.prototype['at'] = Vector_PxVec4.prototype.at = function(index) {
  var self = this.ptr;
  if (index && typeof index === 'object') index = index.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxVec4_at_1(self, index), PxVec4);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxVec4.prototype['data'] = Vector_PxVec4.prototype.data = function() {
  var self = this.ptr;
  return wrapPointer(_emscripten_bind_Vector_PxVec4_data_0(self), PxVec4);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxVec4.prototype['size'] = Vector_PxVec4.prototype.size = function() {
  var self = this.ptr;
  return _emscripten_bind_Vector_PxVec4_size_0(self);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxVec4.prototype['push_back'] = Vector_PxVec4.prototype.push_back = function(value) {
  var self = this.ptr;
  if (value && typeof value === 'object') value = value.ptr;
  _emscripten_bind_Vector_PxVec4_push_back_1(self, value);
};

/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxVec4.prototype['clear'] = Vector_PxVec4.prototype.clear = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxVec4_clear_0(self);
};


/** @suppress {undefinedVars, duplicate} @this{Object} */
Vector_PxVec4.prototype['__destroy__'] = Vector_PxVec4.prototype.__destroy__ = function() {
  var self = this.ptr;
  _emscripten_bind_Vector_PxVec4___destroy___0(self);
};

(function() {
  function setupEnums() {
    
// $EngineDriveVehicleEnum

    Module['eDIFFTYPE_FOURWHEELDRIVE'] = _emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_FOURWHEELDRIVE();

    Module['eDIFFTYPE_MULTIWHEELDRIVE'] = _emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_MULTIWHEELDRIVE();

    Module['eDIFFTYPE_TANKDRIVE'] = _emscripten_enum_EngineDriveVehicleEnum_eDIFFTYPE_TANKDRIVE();

    
// $PxActorFlagEnum

    Module['eVISUALIZATION'] = _emscripten_enum_PxActorFlagEnum_eVISUALIZATION();

    Module['eDISABLE_GRAVITY'] = _emscripten_enum_PxActorFlagEnum_eDISABLE_GRAVITY();

    Module['eSEND_SLEEP_NOTIFIES'] = _emscripten_enum_PxActorFlagEnum_eSEND_SLEEP_NOTIFIES();

    Module['eDISABLE_SIMULATION'] = _emscripten_enum_PxActorFlagEnum_eDISABLE_SIMULATION();

    
// $PxActorTypeEnum

    Module['eRIGID_STATIC'] = _emscripten_enum_PxActorTypeEnum_eRIGID_STATIC();

    Module['eRIGID_DYNAMIC'] = _emscripten_enum_PxActorTypeEnum_eRIGID_DYNAMIC();

    Module['eARTICULATION_LINK'] = _emscripten_enum_PxActorTypeEnum_eARTICULATION_LINK();

    Module['eDEFORMABLE_SURFACE'] = _emscripten_enum_PxActorTypeEnum_eDEFORMABLE_SURFACE();

    Module['eDEFORMABLE_VOLUME'] = _emscripten_enum_PxActorTypeEnum_eDEFORMABLE_VOLUME();

    Module['eSOFTBODY'] = _emscripten_enum_PxActorTypeEnum_eSOFTBODY();

    Module['ePBD_PARTICLESYSTEM'] = _emscripten_enum_PxActorTypeEnum_ePBD_PARTICLESYSTEM();

    
// $PxActorTypeFlagEnum

    Module['eRIGID_STATIC'] = _emscripten_enum_PxActorTypeFlagEnum_eRIGID_STATIC();

    Module['eRIGID_DYNAMIC'] = _emscripten_enum_PxActorTypeFlagEnum_eRIGID_DYNAMIC();

    
// $PxArticulationAxisEnum

    Module['eTWIST'] = _emscripten_enum_PxArticulationAxisEnum_eTWIST();

    Module['eSWING1'] = _emscripten_enum_PxArticulationAxisEnum_eSWING1();

    Module['eSWING2'] = _emscripten_enum_PxArticulationAxisEnum_eSWING2();

    Module['eX'] = _emscripten_enum_PxArticulationAxisEnum_eX();

    Module['eY'] = _emscripten_enum_PxArticulationAxisEnum_eY();

    Module['eZ'] = _emscripten_enum_PxArticulationAxisEnum_eZ();

    
// $PxArticulationCacheFlagEnum

    Module['eVELOCITY'] = _emscripten_enum_PxArticulationCacheFlagEnum_eVELOCITY();

    Module['eACCELERATION'] = _emscripten_enum_PxArticulationCacheFlagEnum_eACCELERATION();

    Module['ePOSITION'] = _emscripten_enum_PxArticulationCacheFlagEnum_ePOSITION();

    Module['eFORCE'] = _emscripten_enum_PxArticulationCacheFlagEnum_eFORCE();

    Module['eLINK_VELOCITY'] = _emscripten_enum_PxArticulationCacheFlagEnum_eLINK_VELOCITY();

    Module['eLINK_ACCELERATION'] = _emscripten_enum_PxArticulationCacheFlagEnum_eLINK_ACCELERATION();

    Module['eROOT_TRANSFORM'] = _emscripten_enum_PxArticulationCacheFlagEnum_eROOT_TRANSFORM();

    Module['eROOT_VELOCITIES'] = _emscripten_enum_PxArticulationCacheFlagEnum_eROOT_VELOCITIES();

    Module['eLINK_INCOMING_JOINT_FORCE'] = _emscripten_enum_PxArticulationCacheFlagEnum_eLINK_INCOMING_JOINT_FORCE();

    Module['eJOINT_TARGET_POSITIONS'] = _emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_POSITIONS();

    Module['eJOINT_TARGET_VELOCITIES'] = _emscripten_enum_PxArticulationCacheFlagEnum_eJOINT_TARGET_VELOCITIES();

    Module['eALL'] = _emscripten_enum_PxArticulationCacheFlagEnum_eALL();

    
// $PxArticulationDriveTypeEnum

    Module['eFORCE'] = _emscripten_enum_PxArticulationDriveTypeEnum_eFORCE();

    Module['eACCELERATION'] = _emscripten_enum_PxArticulationDriveTypeEnum_eACCELERATION();

    Module['eNONE'] = _emscripten_enum_PxArticulationDriveTypeEnum_eNONE();

    
// $PxArticulationFlagEnum

    Module['eFIX_BASE'] = _emscripten_enum_PxArticulationFlagEnum_eFIX_BASE();

    Module['eDRIVE_LIMITS_ARE_FORCES'] = _emscripten_enum_PxArticulationFlagEnum_eDRIVE_LIMITS_ARE_FORCES();

    Module['eDISABLE_SELF_COLLISION'] = _emscripten_enum_PxArticulationFlagEnum_eDISABLE_SELF_COLLISION();

    
// $PxArticulationJointTypeEnum

    Module['eFIX'] = _emscripten_enum_PxArticulationJointTypeEnum_eFIX();

    Module['ePRISMATIC'] = _emscripten_enum_PxArticulationJointTypeEnum_ePRISMATIC();

    Module['eREVOLUTE'] = _emscripten_enum_PxArticulationJointTypeEnum_eREVOLUTE();

    Module['eSPHERICAL'] = _emscripten_enum_PxArticulationJointTypeEnum_eSPHERICAL();

    Module['eUNDEFINED'] = _emscripten_enum_PxArticulationJointTypeEnum_eUNDEFINED();

    
// $PxArticulationKinematicFlagEnum

    Module['ePOSITION'] = _emscripten_enum_PxArticulationKinematicFlagEnum_ePOSITION();

    Module['eVELOCITY'] = _emscripten_enum_PxArticulationKinematicFlagEnum_eVELOCITY();

    
// $PxArticulationMotionEnum

    Module['eLOCKED'] = _emscripten_enum_PxArticulationMotionEnum_eLOCKED();

    Module['eLIMITED'] = _emscripten_enum_PxArticulationMotionEnum_eLIMITED();

    Module['eFREE'] = _emscripten_enum_PxArticulationMotionEnum_eFREE();

    
// $PxBVHBuildStrategyEnum

    Module['eFAST'] = _emscripten_enum_PxBVHBuildStrategyEnum_eFAST();

    Module['eDEFAULT'] = _emscripten_enum_PxBVHBuildStrategyEnum_eDEFAULT();

    Module['eSAH'] = _emscripten_enum_PxBVHBuildStrategyEnum_eSAH();

    
// $PxBaseFlagEnum

    Module['eOWNS_MEMORY'] = _emscripten_enum_PxBaseFlagEnum_eOWNS_MEMORY();

    Module['eIS_RELEASABLE'] = _emscripten_enum_PxBaseFlagEnum_eIS_RELEASABLE();

    
// $PxBroadPhaseTypeEnum

    Module['eSAP'] = _emscripten_enum_PxBroadPhaseTypeEnum_eSAP();

    Module['eMBP'] = _emscripten_enum_PxBroadPhaseTypeEnum_eMBP();

    Module['eABP'] = _emscripten_enum_PxBroadPhaseTypeEnum_eABP();

    Module['ePABP'] = _emscripten_enum_PxBroadPhaseTypeEnum_ePABP();

    Module['eGPU'] = _emscripten_enum_PxBroadPhaseTypeEnum_eGPU();

    
// $PxCapsuleClimbingModeEnum

    Module['eEASY'] = _emscripten_enum_PxCapsuleClimbingModeEnum_eEASY();

    Module['eCONSTRAINED'] = _emscripten_enum_PxCapsuleClimbingModeEnum_eCONSTRAINED();

    
// $PxCombineModeEnum

    Module['eAVERAGE'] = _emscripten_enum_PxCombineModeEnum_eAVERAGE();

    Module['eMIN'] = _emscripten_enum_PxCombineModeEnum_eMIN();

    Module['eMULTIPLY'] = _emscripten_enum_PxCombineModeEnum_eMULTIPLY();

    Module['eMAX'] = _emscripten_enum_PxCombineModeEnum_eMAX();

    
// $PxConstraintFlagEnum

    Module['eBROKEN'] = _emscripten_enum_PxConstraintFlagEnum_eBROKEN();

    Module['eCOLLISION_ENABLED'] = _emscripten_enum_PxConstraintFlagEnum_eCOLLISION_ENABLED();

    Module['eVISUALIZATION'] = _emscripten_enum_PxConstraintFlagEnum_eVISUALIZATION();

    Module['eDRIVE_LIMITS_ARE_FORCES'] = _emscripten_enum_PxConstraintFlagEnum_eDRIVE_LIMITS_ARE_FORCES();

    Module['eIMPROVED_SLERP'] = _emscripten_enum_PxConstraintFlagEnum_eIMPROVED_SLERP();

    Module['eDISABLE_PREPROCESSING'] = _emscripten_enum_PxConstraintFlagEnum_eDISABLE_PREPROCESSING();

    Module['eENABLE_EXTENDED_LIMITS'] = _emscripten_enum_PxConstraintFlagEnum_eENABLE_EXTENDED_LIMITS();

    Module['eGPU_COMPATIBLE'] = _emscripten_enum_PxConstraintFlagEnum_eGPU_COMPATIBLE();

    Module['eALWAYS_UPDATE'] = _emscripten_enum_PxConstraintFlagEnum_eALWAYS_UPDATE();

    Module['eDISABLE_CONSTRAINT'] = _emscripten_enum_PxConstraintFlagEnum_eDISABLE_CONSTRAINT();

    
// $PxContactPairFlagEnum

    Module['eREMOVED_SHAPE_0'] = _emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_0();

    Module['eREMOVED_SHAPE_1'] = _emscripten_enum_PxContactPairFlagEnum_eREMOVED_SHAPE_1();

    Module['eACTOR_PAIR_HAS_FIRST_TOUCH'] = _emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_HAS_FIRST_TOUCH();

    Module['eACTOR_PAIR_LOST_TOUCH'] = _emscripten_enum_PxContactPairFlagEnum_eACTOR_PAIR_LOST_TOUCH();

    Module['eINTERNAL_HAS_IMPULSES'] = _emscripten_enum_PxContactPairFlagEnum_eINTERNAL_HAS_IMPULSES();

    Module['eINTERNAL_CONTACTS_ARE_FLIPPED'] = _emscripten_enum_PxContactPairFlagEnum_eINTERNAL_CONTACTS_ARE_FLIPPED();

    
// $PxContactPairHeaderFlagEnum

    Module['eREMOVED_ACTOR_0'] = _emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_0();

    Module['eREMOVED_ACTOR_1'] = _emscripten_enum_PxContactPairHeaderFlagEnum_eREMOVED_ACTOR_1();

    
// $PxControllerBehaviorFlagEnum

    Module['eCCT_CAN_RIDE_ON_OBJECT'] = _emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_CAN_RIDE_ON_OBJECT();

    Module['eCCT_SLIDE'] = _emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_SLIDE();

    Module['eCCT_USER_DEFINED_RIDE'] = _emscripten_enum_PxControllerBehaviorFlagEnum_eCCT_USER_DEFINED_RIDE();

    
// $PxControllerCollisionFlagEnum

    Module['eCOLLISION_SIDES'] = _emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_SIDES();

    Module['eCOLLISION_UP'] = _emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_UP();

    Module['eCOLLISION_DOWN'] = _emscripten_enum_PxControllerCollisionFlagEnum_eCOLLISION_DOWN();

    
// $PxControllerNonWalkableModeEnum

    Module['ePREVENT_CLIMBING'] = _emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING();

    Module['ePREVENT_CLIMBING_AND_FORCE_SLIDING'] = _emscripten_enum_PxControllerNonWalkableModeEnum_ePREVENT_CLIMBING_AND_FORCE_SLIDING();

    
// $PxControllerShapeTypeEnum

    Module['eBOX'] = _emscripten_enum_PxControllerShapeTypeEnum_eBOX();

    Module['eCAPSULE'] = _emscripten_enum_PxControllerShapeTypeEnum_eCAPSULE();

    
// $PxConvexCoreTypeEnum

    Module['ePOINT'] = _emscripten_enum_PxConvexCoreTypeEnum_ePOINT();

    Module['eSEGMENT'] = _emscripten_enum_PxConvexCoreTypeEnum_eSEGMENT();

    Module['eBOX'] = _emscripten_enum_PxConvexCoreTypeEnum_eBOX();

    Module['eELLIPSOID'] = _emscripten_enum_PxConvexCoreTypeEnum_eELLIPSOID();

    Module['eCYLINDER'] = _emscripten_enum_PxConvexCoreTypeEnum_eCYLINDER();

    Module['eCONE'] = _emscripten_enum_PxConvexCoreTypeEnum_eCONE();

    
// $PxConvexFlagEnum

    Module['e16_BIT_INDICES'] = _emscripten_enum_PxConvexFlagEnum_e16_BIT_INDICES();

    Module['eCOMPUTE_CONVEX'] = _emscripten_enum_PxConvexFlagEnum_eCOMPUTE_CONVEX();

    Module['eCHECK_ZERO_AREA_TRIANGLES'] = _emscripten_enum_PxConvexFlagEnum_eCHECK_ZERO_AREA_TRIANGLES();

    Module['eQUANTIZE_INPUT'] = _emscripten_enum_PxConvexFlagEnum_eQUANTIZE_INPUT();

    Module['eDISABLE_MESH_VALIDATION'] = _emscripten_enum_PxConvexFlagEnum_eDISABLE_MESH_VALIDATION();

    Module['ePLANE_SHIFTING'] = _emscripten_enum_PxConvexFlagEnum_ePLANE_SHIFTING();

    Module['eFAST_INERTIA_COMPUTATION'] = _emscripten_enum_PxConvexFlagEnum_eFAST_INERTIA_COMPUTATION();

    Module['eSHIFT_VERTICES'] = _emscripten_enum_PxConvexFlagEnum_eSHIFT_VERTICES();

    
// $PxConvexMeshCookingTypeEnum

    Module['eQUICKHULL'] = _emscripten_enum_PxConvexMeshCookingTypeEnum_eQUICKHULL();

    
// $PxConvexMeshGeometryFlagEnum

    Module['eTIGHT_BOUNDS'] = _emscripten_enum_PxConvexMeshGeometryFlagEnum_eTIGHT_BOUNDS();

    
// $PxD6AngularDriveConfigEnum

    Module['eSWING_TWIST'] = _emscripten_enum_PxD6AngularDriveConfigEnum_eSWING_TWIST();

    Module['eSLERP'] = _emscripten_enum_PxD6AngularDriveConfigEnum_eSLERP();

    Module['eLEGACY'] = _emscripten_enum_PxD6AngularDriveConfigEnum_eLEGACY();

    
// $PxD6AxisEnum

    Module['eX'] = _emscripten_enum_PxD6AxisEnum_eX();

    Module['eY'] = _emscripten_enum_PxD6AxisEnum_eY();

    Module['eZ'] = _emscripten_enum_PxD6AxisEnum_eZ();

    Module['eTWIST'] = _emscripten_enum_PxD6AxisEnum_eTWIST();

    Module['eSWING1'] = _emscripten_enum_PxD6AxisEnum_eSWING1();

    Module['eSWING2'] = _emscripten_enum_PxD6AxisEnum_eSWING2();

    
// $PxD6DriveEnum

    Module['eX'] = _emscripten_enum_PxD6DriveEnum_eX();

    Module['eY'] = _emscripten_enum_PxD6DriveEnum_eY();

    Module['eZ'] = _emscripten_enum_PxD6DriveEnum_eZ();

    Module['eSWING'] = _emscripten_enum_PxD6DriveEnum_eSWING();

    Module['eTWIST'] = _emscripten_enum_PxD6DriveEnum_eTWIST();

    Module['eSLERP'] = _emscripten_enum_PxD6DriveEnum_eSLERP();

    Module['eSWING1'] = _emscripten_enum_PxD6DriveEnum_eSWING1();

    Module['eSWING2'] = _emscripten_enum_PxD6DriveEnum_eSWING2();

    
// $PxD6JointDriveFlagEnum

    Module['eACCELERATION'] = _emscripten_enum_PxD6JointDriveFlagEnum_eACCELERATION();

    
// $PxD6MotionEnum

    Module['eLOCKED'] = _emscripten_enum_PxD6MotionEnum_eLOCKED();

    Module['eLIMITED'] = _emscripten_enum_PxD6MotionEnum_eLIMITED();

    Module['eFREE'] = _emscripten_enum_PxD6MotionEnum_eFREE();

    
// $PxDebugColorEnum

    Module['eARGB_BLACK'] = _emscripten_enum_PxDebugColorEnum_eARGB_BLACK();

    Module['eARGB_RED'] = _emscripten_enum_PxDebugColorEnum_eARGB_RED();

    Module['eARGB_GREEN'] = _emscripten_enum_PxDebugColorEnum_eARGB_GREEN();

    Module['eARGB_BLUE'] = _emscripten_enum_PxDebugColorEnum_eARGB_BLUE();

    Module['eARGB_YELLOW'] = _emscripten_enum_PxDebugColorEnum_eARGB_YELLOW();

    Module['eARGB_MAGENTA'] = _emscripten_enum_PxDebugColorEnum_eARGB_MAGENTA();

    Module['eARGB_CYAN'] = _emscripten_enum_PxDebugColorEnum_eARGB_CYAN();

    Module['eARGB_WHITE'] = _emscripten_enum_PxDebugColorEnum_eARGB_WHITE();

    Module['eARGB_GREY'] = _emscripten_enum_PxDebugColorEnum_eARGB_GREY();

    Module['eARGB_DARKRED'] = _emscripten_enum_PxDebugColorEnum_eARGB_DARKRED();

    Module['eARGB_DARKGREEN'] = _emscripten_enum_PxDebugColorEnum_eARGB_DARKGREEN();

    Module['eARGB_DARKBLUE'] = _emscripten_enum_PxDebugColorEnum_eARGB_DARKBLUE();

    
// $PxDistanceJointFlagEnum

    Module['eMAX_DISTANCE_ENABLED'] = _emscripten_enum_PxDistanceJointFlagEnum_eMAX_DISTANCE_ENABLED();

    Module['eMIN_DISTANCE_ENABLED'] = _emscripten_enum_PxDistanceJointFlagEnum_eMIN_DISTANCE_ENABLED();

    Module['eSPRING_ENABLED'] = _emscripten_enum_PxDistanceJointFlagEnum_eSPRING_ENABLED();

    
// $PxDynamicTreeSecondaryPrunerEnum

    Module['eNONE'] = _emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eNONE();

    Module['eBUCKET'] = _emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBUCKET();

    Module['eINCREMENTAL'] = _emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eINCREMENTAL();

    Module['eBVH'] = _emscripten_enum_PxDynamicTreeSecondaryPrunerEnum_eBVH();

    
// $PxErrorCodeEnum

    Module['eNO_ERROR'] = _emscripten_enum_PxErrorCodeEnum_eNO_ERROR();

    Module['eDEBUG_INFO'] = _emscripten_enum_PxErrorCodeEnum_eDEBUG_INFO();

    Module['eDEBUG_WARNING'] = _emscripten_enum_PxErrorCodeEnum_eDEBUG_WARNING();

    Module['eINVALID_PARAMETER'] = _emscripten_enum_PxErrorCodeEnum_eINVALID_PARAMETER();

    Module['eINVALID_OPERATION'] = _emscripten_enum_PxErrorCodeEnum_eINVALID_OPERATION();

    Module['eOUT_OF_MEMORY'] = _emscripten_enum_PxErrorCodeEnum_eOUT_OF_MEMORY();

    Module['eINTERNAL_ERROR'] = _emscripten_enum_PxErrorCodeEnum_eINTERNAL_ERROR();

    Module['eABORT'] = _emscripten_enum_PxErrorCodeEnum_eABORT();

    Module['ePERF_WARNING'] = _emscripten_enum_PxErrorCodeEnum_ePERF_WARNING();

    Module['eMASK_ALL'] = _emscripten_enum_PxErrorCodeEnum_eMASK_ALL();

    
// $PxFilterFlagEnum

    Module['eKILL'] = _emscripten_enum_PxFilterFlagEnum_eKILL();

    Module['eSUPPRESS'] = _emscripten_enum_PxFilterFlagEnum_eSUPPRESS();

    Module['eCALLBACK'] = _emscripten_enum_PxFilterFlagEnum_eCALLBACK();

    Module['eNOTIFY'] = _emscripten_enum_PxFilterFlagEnum_eNOTIFY();

    Module['eDEFAULT'] = _emscripten_enum_PxFilterFlagEnum_eDEFAULT();

    
// $PxFilterObjectFlagEnum

    Module['eKINEMATIC'] = _emscripten_enum_PxFilterObjectFlagEnum_eKINEMATIC();

    Module['eTRIGGER'] = _emscripten_enum_PxFilterObjectFlagEnum_eTRIGGER();

    
// $PxForceModeEnum

    Module['eFORCE'] = _emscripten_enum_PxForceModeEnum_eFORCE();

    Module['eIMPULSE'] = _emscripten_enum_PxForceModeEnum_eIMPULSE();

    Module['eVELOCITY_CHANGE'] = _emscripten_enum_PxForceModeEnum_eVELOCITY_CHANGE();

    Module['eACCELERATION'] = _emscripten_enum_PxForceModeEnum_eACCELERATION();

    
// $PxFrictionTypeEnum

    Module['ePATCH'] = _emscripten_enum_PxFrictionTypeEnum_ePATCH();

    Module['eFRICTION_COUNT'] = _emscripten_enum_PxFrictionTypeEnum_eFRICTION_COUNT();

    
// $PxGeometryTypeEnum

    Module['eSPHERE'] = _emscripten_enum_PxGeometryTypeEnum_eSPHERE();

    Module['ePLANE'] = _emscripten_enum_PxGeometryTypeEnum_ePLANE();

    Module['eCAPSULE'] = _emscripten_enum_PxGeometryTypeEnum_eCAPSULE();

    Module['eBOX'] = _emscripten_enum_PxGeometryTypeEnum_eBOX();

    Module['eCONVEXCORE'] = _emscripten_enum_PxGeometryTypeEnum_eCONVEXCORE();

    Module['eCONVEXMESH'] = _emscripten_enum_PxGeometryTypeEnum_eCONVEXMESH();

    Module['ePARTICLESYSTEM'] = _emscripten_enum_PxGeometryTypeEnum_ePARTICLESYSTEM();

    Module['eTETRAHEDRONMESH'] = _emscripten_enum_PxGeometryTypeEnum_eTETRAHEDRONMESH();

    Module['eTRIANGLEMESH'] = _emscripten_enum_PxGeometryTypeEnum_eTRIANGLEMESH();

    Module['eHEIGHTFIELD'] = _emscripten_enum_PxGeometryTypeEnum_eHEIGHTFIELD();

    Module['eCUSTOM'] = _emscripten_enum_PxGeometryTypeEnum_eCUSTOM();

    
// $PxHeightFieldFlagEnum

    Module['eNO_BOUNDARY_EDGES'] = _emscripten_enum_PxHeightFieldFlagEnum_eNO_BOUNDARY_EDGES();

    
// $PxHeightFieldFormatEnum

    Module['eS16_TM'] = _emscripten_enum_PxHeightFieldFormatEnum_eS16_TM();

    
// $PxHitFlagEnum

    Module['ePOSITION'] = _emscripten_enum_PxHitFlagEnum_ePOSITION();

    Module['eNORMAL'] = _emscripten_enum_PxHitFlagEnum_eNORMAL();

    Module['eUV'] = _emscripten_enum_PxHitFlagEnum_eUV();

    Module['eASSUME_NO_INITIAL_OVERLAP'] = _emscripten_enum_PxHitFlagEnum_eASSUME_NO_INITIAL_OVERLAP();

    Module['eANY_HIT'] = _emscripten_enum_PxHitFlagEnum_eANY_HIT();

    Module['eMESH_MULTIPLE'] = _emscripten_enum_PxHitFlagEnum_eMESH_MULTIPLE();

    Module['eMESH_BOTH_SIDES'] = _emscripten_enum_PxHitFlagEnum_eMESH_BOTH_SIDES();

    Module['ePRECISE_SWEEP'] = _emscripten_enum_PxHitFlagEnum_ePRECISE_SWEEP();

    Module['eMTD'] = _emscripten_enum_PxHitFlagEnum_eMTD();

    Module['eFACE_INDEX'] = _emscripten_enum_PxHitFlagEnum_eFACE_INDEX();

    Module['eDEFAULT'] = _emscripten_enum_PxHitFlagEnum_eDEFAULT();

    Module['eMODIFIABLE_FLAGS'] = _emscripten_enum_PxHitFlagEnum_eMODIFIABLE_FLAGS();

    
// $PxIDENTITYEnum

    Module['PxIdentity'] = _emscripten_enum_PxIDENTITYEnum_PxIdentity();

    
// $PxJointActorIndexEnum

    Module['eACTOR0'] = _emscripten_enum_PxJointActorIndexEnum_eACTOR0();

    Module['eACTOR1'] = _emscripten_enum_PxJointActorIndexEnum_eACTOR1();

    
// $PxMaterialFlagEnum

    Module['eDISABLE_FRICTION'] = _emscripten_enum_PxMaterialFlagEnum_eDISABLE_FRICTION();

    Module['eDISABLE_STRONG_FRICTION'] = _emscripten_enum_PxMaterialFlagEnum_eDISABLE_STRONG_FRICTION();

    Module['eCOMPLIANT_ACCELERATION_SPRING'] = _emscripten_enum_PxMaterialFlagEnum_eCOMPLIANT_ACCELERATION_SPRING();

    
// $PxMeshCookingHintEnum

    Module['eSIM_PERFORMANCE'] = _emscripten_enum_PxMeshCookingHintEnum_eSIM_PERFORMANCE();

    Module['eCOOKING_PERFORMANCE'] = _emscripten_enum_PxMeshCookingHintEnum_eCOOKING_PERFORMANCE();

    
// $PxMeshFlagEnum

    Module['eFLIPNORMALS'] = _emscripten_enum_PxMeshFlagEnum_eFLIPNORMALS();

    Module['e16_BIT_INDICES'] = _emscripten_enum_PxMeshFlagEnum_e16_BIT_INDICES();

    
// $PxMeshGeometryFlagEnum

    Module['eDOUBLE_SIDED'] = _emscripten_enum_PxMeshGeometryFlagEnum_eDOUBLE_SIDED();

    
// $PxMeshMidPhaseEnum

    Module['eBVH33'] = _emscripten_enum_PxMeshMidPhaseEnum_eBVH33();

    Module['eBVH34'] = _emscripten_enum_PxMeshMidPhaseEnum_eBVH34();

    
// $PxMeshPreprocessingFlagEnum

    Module['eWELD_VERTICES'] = _emscripten_enum_PxMeshPreprocessingFlagEnum_eWELD_VERTICES();

    Module['eDISABLE_CLEAN_MESH'] = _emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_CLEAN_MESH();

    Module['eDISABLE_ACTIVE_EDGES_PRECOMPUTE'] = _emscripten_enum_PxMeshPreprocessingFlagEnum_eDISABLE_ACTIVE_EDGES_PRECOMPUTE();

    Module['eFORCE_32BIT_INDICES'] = _emscripten_enum_PxMeshPreprocessingFlagEnum_eFORCE_32BIT_INDICES();

    Module['eENABLE_INERTIA'] = _emscripten_enum_PxMeshPreprocessingFlagEnum_eENABLE_INERTIA();

    
// $PxPairFilteringModeEnum

    Module['eKEEP'] = _emscripten_enum_PxPairFilteringModeEnum_eKEEP();

    Module['eSUPPRESS'] = _emscripten_enum_PxPairFilteringModeEnum_eSUPPRESS();

    Module['eKILL'] = _emscripten_enum_PxPairFilteringModeEnum_eKILL();

    Module['eDEFAULT'] = _emscripten_enum_PxPairFilteringModeEnum_eDEFAULT();

    
// $PxPairFlagEnum

    Module['eSOLVE_CONTACT'] = _emscripten_enum_PxPairFlagEnum_eSOLVE_CONTACT();

    Module['eMODIFY_CONTACTS'] = _emscripten_enum_PxPairFlagEnum_eMODIFY_CONTACTS();

    Module['eNOTIFY_TOUCH_FOUND'] = _emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_FOUND();

    Module['eNOTIFY_TOUCH_PERSISTS'] = _emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_PERSISTS();

    Module['eNOTIFY_TOUCH_LOST'] = _emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_LOST();

    Module['eNOTIFY_TOUCH_CCD'] = _emscripten_enum_PxPairFlagEnum_eNOTIFY_TOUCH_CCD();

    Module['eNOTIFY_THRESHOLD_FORCE_FOUND'] = _emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_FOUND();

    Module['eNOTIFY_THRESHOLD_FORCE_PERSISTS'] = _emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_PERSISTS();

    Module['eNOTIFY_THRESHOLD_FORCE_LOST'] = _emscripten_enum_PxPairFlagEnum_eNOTIFY_THRESHOLD_FORCE_LOST();

    Module['eNOTIFY_CONTACT_POINTS'] = _emscripten_enum_PxPairFlagEnum_eNOTIFY_CONTACT_POINTS();

    Module['eDETECT_DISCRETE_CONTACT'] = _emscripten_enum_PxPairFlagEnum_eDETECT_DISCRETE_CONTACT();

    Module['eDETECT_CCD_CONTACT'] = _emscripten_enum_PxPairFlagEnum_eDETECT_CCD_CONTACT();

    Module['ePRE_SOLVER_VELOCITY'] = _emscripten_enum_PxPairFlagEnum_ePRE_SOLVER_VELOCITY();

    Module['ePOST_SOLVER_VELOCITY'] = _emscripten_enum_PxPairFlagEnum_ePOST_SOLVER_VELOCITY();

    Module['eCONTACT_EVENT_POSE'] = _emscripten_enum_PxPairFlagEnum_eCONTACT_EVENT_POSE();

    Module['eNEXT_FREE'] = _emscripten_enum_PxPairFlagEnum_eNEXT_FREE();

    Module['eCONTACT_DEFAULT'] = _emscripten_enum_PxPairFlagEnum_eCONTACT_DEFAULT();

    Module['eTRIGGER_DEFAULT'] = _emscripten_enum_PxPairFlagEnum_eTRIGGER_DEFAULT();

    
// $PxPrismaticJointFlagEnum

    Module['eLIMIT_ENABLED'] = _emscripten_enum_PxPrismaticJointFlagEnum_eLIMIT_ENABLED();

    
// $PxPruningStructureTypeEnum

    Module['eNONE'] = _emscripten_enum_PxPruningStructureTypeEnum_eNONE();

    Module['eDYNAMIC_AABB_TREE'] = _emscripten_enum_PxPruningStructureTypeEnum_eDYNAMIC_AABB_TREE();

    Module['eSTATIC_AABB_TREE'] = _emscripten_enum_PxPruningStructureTypeEnum_eSTATIC_AABB_TREE();

    
// $PxPvdInstrumentationFlagEnum

    Module['eDEBUG'] = _emscripten_enum_PxPvdInstrumentationFlagEnum_eDEBUG();

    Module['ePROFILE'] = _emscripten_enum_PxPvdInstrumentationFlagEnum_ePROFILE();

    Module['eMEMORY'] = _emscripten_enum_PxPvdInstrumentationFlagEnum_eMEMORY();

    Module['eALL'] = _emscripten_enum_PxPvdInstrumentationFlagEnum_eALL();

    
// $PxPvdSceneFlagEnum

    Module['eTRANSMIT_CONTACTS'] = _emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONTACTS();

    Module['eTRANSMIT_SCENEQUERIES'] = _emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_SCENEQUERIES();

    Module['eTRANSMIT_CONSTRAINTS'] = _emscripten_enum_PxPvdSceneFlagEnum_eTRANSMIT_CONSTRAINTS();

    
// $PxQueryFlagEnum

    Module['eSTATIC'] = _emscripten_enum_PxQueryFlagEnum_eSTATIC();

    Module['eDYNAMIC'] = _emscripten_enum_PxQueryFlagEnum_eDYNAMIC();

    Module['ePREFILTER'] = _emscripten_enum_PxQueryFlagEnum_ePREFILTER();

    Module['ePOSTFILTER'] = _emscripten_enum_PxQueryFlagEnum_ePOSTFILTER();

    Module['eANY_HIT'] = _emscripten_enum_PxQueryFlagEnum_eANY_HIT();

    Module['eNO_BLOCK'] = _emscripten_enum_PxQueryFlagEnum_eNO_BLOCK();

    
// $PxQueryHitType

    Module['eNONE'] = _emscripten_enum_PxQueryHitType_eNONE();

    Module['eBLOCK'] = _emscripten_enum_PxQueryHitType_eBLOCK();

    Module['eTOUCH'] = _emscripten_enum_PxQueryHitType_eTOUCH();

    
// $PxRevoluteJointFlagEnum

    Module['eLIMIT_ENABLED'] = _emscripten_enum_PxRevoluteJointFlagEnum_eLIMIT_ENABLED();

    Module['eDRIVE_ENABLED'] = _emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_ENABLED();

    Module['eDRIVE_FREESPIN'] = _emscripten_enum_PxRevoluteJointFlagEnum_eDRIVE_FREESPIN();

    
// $PxRigidBodyFlagEnum

    Module['eKINEMATIC'] = _emscripten_enum_PxRigidBodyFlagEnum_eKINEMATIC();

    Module['eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES'] = _emscripten_enum_PxRigidBodyFlagEnum_eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES();

    Module['eENABLE_CCD'] = _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD();

    Module['eENABLE_CCD_FRICTION'] = _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_FRICTION();

    Module['eENABLE_POSE_INTEGRATION_PREVIEW'] = _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_POSE_INTEGRATION_PREVIEW();

    Module['eENABLE_SPECULATIVE_CCD'] = _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_SPECULATIVE_CCD();

    Module['eENABLE_CCD_MAX_CONTACT_IMPULSE'] = _emscripten_enum_PxRigidBodyFlagEnum_eENABLE_CCD_MAX_CONTACT_IMPULSE();

    Module['eRETAIN_ACCELERATIONS'] = _emscripten_enum_PxRigidBodyFlagEnum_eRETAIN_ACCELERATIONS();

    
// $PxRigidDynamicLockFlagEnum

    Module['eLOCK_LINEAR_X'] = _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_X();

    Module['eLOCK_LINEAR_Y'] = _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Y();

    Module['eLOCK_LINEAR_Z'] = _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_LINEAR_Z();

    Module['eLOCK_ANGULAR_X'] = _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_X();

    Module['eLOCK_ANGULAR_Y'] = _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Y();

    Module['eLOCK_ANGULAR_Z'] = _emscripten_enum_PxRigidDynamicLockFlagEnum_eLOCK_ANGULAR_Z();

    
// $PxSceneFlagEnum

    Module['eENABLE_ACTIVE_ACTORS'] = _emscripten_enum_PxSceneFlagEnum_eENABLE_ACTIVE_ACTORS();

    Module['eENABLE_CCD'] = _emscripten_enum_PxSceneFlagEnum_eENABLE_CCD();

    Module['eDISABLE_CCD_RESWEEP'] = _emscripten_enum_PxSceneFlagEnum_eDISABLE_CCD_RESWEEP();

    Module['eENABLE_PCM'] = _emscripten_enum_PxSceneFlagEnum_eENABLE_PCM();

    Module['eDISABLE_CONTACT_REPORT_BUFFER_RESIZE'] = _emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_REPORT_BUFFER_RESIZE();

    Module['eDISABLE_CONTACT_CACHE'] = _emscripten_enum_PxSceneFlagEnum_eDISABLE_CONTACT_CACHE();

    Module['eREQUIRE_RW_LOCK'] = _emscripten_enum_PxSceneFlagEnum_eREQUIRE_RW_LOCK();

    Module['eENABLE_STABILIZATION'] = _emscripten_enum_PxSceneFlagEnum_eENABLE_STABILIZATION();

    Module['eENABLE_AVERAGE_POINT'] = _emscripten_enum_PxSceneFlagEnum_eENABLE_AVERAGE_POINT();

    Module['eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS'] = _emscripten_enum_PxSceneFlagEnum_eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS();

    Module['eENABLE_GPU_DYNAMICS'] = _emscripten_enum_PxSceneFlagEnum_eENABLE_GPU_DYNAMICS();

    Module['eENABLE_ENHANCED_DETERMINISM'] = _emscripten_enum_PxSceneFlagEnum_eENABLE_ENHANCED_DETERMINISM();

    Module['eENABLE_FRICTION_EVERY_ITERATION'] = _emscripten_enum_PxSceneFlagEnum_eENABLE_FRICTION_EVERY_ITERATION();

    Module['eENABLE_DIRECT_GPU_API'] = _emscripten_enum_PxSceneFlagEnum_eENABLE_DIRECT_GPU_API();

    Module['eMUTABLE_FLAGS'] = _emscripten_enum_PxSceneFlagEnum_eMUTABLE_FLAGS();

    
// $PxSceneQueryUpdateModeEnum

    Module['eBUILD_ENABLED_COMMIT_ENABLED'] = _emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_ENABLED();

    Module['eBUILD_ENABLED_COMMIT_DISABLED'] = _emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_ENABLED_COMMIT_DISABLED();

    Module['eBUILD_DISABLED_COMMIT_DISABLED'] = _emscripten_enum_PxSceneQueryUpdateModeEnum_eBUILD_DISABLED_COMMIT_DISABLED();

    
// $PxSdfBitsPerSubgridPixelEnum

    Module['e8_BIT_PER_PIXEL'] = _emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e8_BIT_PER_PIXEL();

    Module['e16_BIT_PER_PIXEL'] = _emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e16_BIT_PER_PIXEL();

    Module['e32_BIT_PER_PIXEL'] = _emscripten_enum_PxSdfBitsPerSubgridPixelEnum_e32_BIT_PER_PIXEL();

    
// $PxShapeFlagEnum

    Module['eSIMULATION_SHAPE'] = _emscripten_enum_PxShapeFlagEnum_eSIMULATION_SHAPE();

    Module['eSCENE_QUERY_SHAPE'] = _emscripten_enum_PxShapeFlagEnum_eSCENE_QUERY_SHAPE();

    Module['eTRIGGER_SHAPE'] = _emscripten_enum_PxShapeFlagEnum_eTRIGGER_SHAPE();

    Module['eVISUALIZATION'] = _emscripten_enum_PxShapeFlagEnum_eVISUALIZATION();

    
// $PxSolverTypeEnum

    Module['ePGS'] = _emscripten_enum_PxSolverTypeEnum_ePGS();

    Module['eTGS'] = _emscripten_enum_PxSolverTypeEnum_eTGS();

    
// $PxSphericalJointFlagEnum

    Module['eLIMIT_ENABLED'] = _emscripten_enum_PxSphericalJointFlagEnum_eLIMIT_ENABLED();

    
// $PxTetrahedronMeshAnalysisResultEnum

    Module['eVALID'] = _emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eVALID();

    Module['eDEGENERATE_TETRAHEDRON'] = _emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eDEGENERATE_TETRAHEDRON();

    Module['eMESH_IS_PROBLEMATIC'] = _emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC();

    Module['eMESH_IS_INVALID'] = _emscripten_enum_PxTetrahedronMeshAnalysisResultEnum_eMESH_IS_INVALID();

    
// $PxTetrahedronMeshFlagEnum

    Module['e16_BIT_INDICES'] = _emscripten_enum_PxTetrahedronMeshFlagEnum_e16_BIT_INDICES();

    
// $PxTetrahedronMeshFormatEnum

    Module['eTET_MESH'] = _emscripten_enum_PxTetrahedronMeshFormatEnum_eTET_MESH();

    Module['eHEX_MESH'] = _emscripten_enum_PxTetrahedronMeshFormatEnum_eHEX_MESH();

    
// $PxTriangleMeshAnalysisResultEnum

    Module['eVALID'] = _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eVALID();

    Module['eZERO_VOLUME'] = _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eZERO_VOLUME();

    Module['eOPEN_BOUNDARIES'] = _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eOPEN_BOUNDARIES();

    Module['eSELF_INTERSECTIONS'] = _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eSELF_INTERSECTIONS();

    Module['eINCONSISTENT_TRIANGLE_ORIENTATION'] = _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eINCONSISTENT_TRIANGLE_ORIENTATION();

    Module['eCONTAINS_ACUTE_ANGLED_TRIANGLES'] = _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_ACUTE_ANGLED_TRIANGLES();

    Module['eEDGE_SHARED_BY_MORE_THAN_TWO_TRIANGLES'] = _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eEDGE_SHARED_BY_MORE_THAN_TWO_TRIANGLES();

    Module['eCONTAINS_DUPLICATE_POINTS'] = _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_DUPLICATE_POINTS();

    Module['eCONTAINS_INVALID_POINTS'] = _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eCONTAINS_INVALID_POINTS();

    Module['eREQUIRES_32BIT_INDEX_BUFFER'] = _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eREQUIRES_32BIT_INDEX_BUFFER();

    Module['eTRIANGLE_INDEX_OUT_OF_RANGE'] = _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eTRIANGLE_INDEX_OUT_OF_RANGE();

    Module['eMESH_IS_PROBLEMATIC'] = _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_PROBLEMATIC();

    Module['eMESH_IS_INVALID'] = _emscripten_enum_PxTriangleMeshAnalysisResultEnum_eMESH_IS_INVALID();

    
// $PxTriangleMeshFlagEnum

    Module['e16_BIT_INDICES'] = _emscripten_enum_PxTriangleMeshFlagEnum_e16_BIT_INDICES();

    Module['eADJACENCY_INFO'] = _emscripten_enum_PxTriangleMeshFlagEnum_eADJACENCY_INFO();

    
// $PxTriggerPairFlagEnum

    Module['eREMOVED_SHAPE_TRIGGER'] = _emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_TRIGGER();

    Module['eREMOVED_SHAPE_OTHER'] = _emscripten_enum_PxTriggerPairFlagEnum_eREMOVED_SHAPE_OTHER();

    Module['eNEXT_FREE'] = _emscripten_enum_PxTriggerPairFlagEnum_eNEXT_FREE();

    
// $PxVehicleAxesEnum

    Module['ePosX'] = _emscripten_enum_PxVehicleAxesEnum_ePosX();

    Module['eNegX'] = _emscripten_enum_PxVehicleAxesEnum_eNegX();

    Module['ePosY'] = _emscripten_enum_PxVehicleAxesEnum_ePosY();

    Module['eNegY'] = _emscripten_enum_PxVehicleAxesEnum_eNegY();

    Module['ePosZ'] = _emscripten_enum_PxVehicleAxesEnum_ePosZ();

    Module['eNegZ'] = _emscripten_enum_PxVehicleAxesEnum_eNegZ();

    
// $PxVehicleClutchAccuracyModeEnum

    Module['eESTIMATE'] = _emscripten_enum_PxVehicleClutchAccuracyModeEnum_eESTIMATE();

    Module['eBEST_POSSIBLE'] = _emscripten_enum_PxVehicleClutchAccuracyModeEnum_eBEST_POSSIBLE();

    
// $PxVehicleCommandNonLinearResponseParamsEnum

    Module['eMAX_NB_COMMAND_VALUES'] = _emscripten_enum_PxVehicleCommandNonLinearResponseParamsEnum_eMAX_NB_COMMAND_VALUES();

    
// $PxVehicleCommandValueResponseTableEnum

    Module['eMAX_NB_SPEED_RESPONSES'] = _emscripten_enum_PxVehicleCommandValueResponseTableEnum_eMAX_NB_SPEED_RESPONSES();

    
// $PxVehicleDirectDriveTransmissionCommandStateEnum

    Module['eREVERSE'] = _emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eREVERSE();

    Module['eNEUTRAL'] = _emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eNEUTRAL();

    Module['eFORWARD'] = _emscripten_enum_PxVehicleDirectDriveTransmissionCommandStateEnum_eFORWARD();

    
// $PxVehicleEngineDriveTransmissionCommandStateEnum

    Module['eAUTOMATIC_GEAR'] = _emscripten_enum_PxVehicleEngineDriveTransmissionCommandStateEnum_eAUTOMATIC_GEAR();

    
// $PxVehicleGearboxParamsEnum

    Module['eMAX_NB_GEARS'] = _emscripten_enum_PxVehicleGearboxParamsEnum_eMAX_NB_GEARS();

    
// $PxVehicleLimitsEnum

    Module['eMAX_NB_WHEELS'] = _emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_WHEELS();

    Module['eMAX_NB_AXLES'] = _emscripten_enum_PxVehicleLimitsEnum_eMAX_NB_AXLES();

    
// $PxVehiclePhysXActorUpdateModeEnum

    Module['eAPPLY_VELOCITY'] = _emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_VELOCITY();

    Module['eAPPLY_ACCELERATION'] = _emscripten_enum_PxVehiclePhysXActorUpdateModeEnum_eAPPLY_ACCELERATION();

    
// $PxVehiclePhysXConstraintLimitsEnum

    Module['eNB_DOFS_PER_PXCONSTRAINT'] = _emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_PXCONSTRAINT();

    Module['eNB_DOFS_PER_WHEEL'] = _emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_DOFS_PER_WHEEL();

    Module['eNB_WHEELS_PER_PXCONSTRAINT'] = _emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_WHEELS_PER_PXCONSTRAINT();

    Module['eNB_CONSTRAINTS_PER_VEHICLE'] = _emscripten_enum_PxVehiclePhysXConstraintLimitsEnum_eNB_CONSTRAINTS_PER_VEHICLE();

    
// $PxVehiclePhysXRoadGeometryQueryTypeEnum

    Module['eNONE'] = _emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eNONE();

    Module['eRAYCAST'] = _emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eRAYCAST();

    Module['eSWEEP'] = _emscripten_enum_PxVehiclePhysXRoadGeometryQueryTypeEnum_eSWEEP();

    
// $PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum

    Module['eSUSPENSION'] = _emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eSUSPENSION();

    Module['eROAD_GEOMETRY_NORMAL'] = _emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eROAD_GEOMETRY_NORMAL();

    Module['eNONE'] = _emscripten_enum_PxVehiclePhysXSuspensionLimitConstraintParamsDirectionSpecifierEnum_eNONE();

    
// $PxVehicleSimulationContextTypeEnum

    Module['eDEFAULT'] = _emscripten_enum_PxVehicleSimulationContextTypeEnum_eDEFAULT();

    Module['ePHYSX'] = _emscripten_enum_PxVehicleSimulationContextTypeEnum_ePHYSX();

    
// $PxVehicleSuspensionJounceCalculationTypeEnum

    Module['eRAYCAST'] = _emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eRAYCAST();

    Module['eSWEEP'] = _emscripten_enum_PxVehicleSuspensionJounceCalculationTypeEnum_eSWEEP();

    
// $PxVehicleTireDirectionModesEnum

    Module['eLONGITUDINAL'] = _emscripten_enum_PxVehicleTireDirectionModesEnum_eLONGITUDINAL();

    Module['eLATERAL'] = _emscripten_enum_PxVehicleTireDirectionModesEnum_eLATERAL();

    
// $PxVisualizationParameterEnum

    Module['eSCALE'] = _emscripten_enum_PxVisualizationParameterEnum_eSCALE();

    Module['eWORLD_AXES'] = _emscripten_enum_PxVisualizationParameterEnum_eWORLD_AXES();

    Module['eBODY_AXES'] = _emscripten_enum_PxVisualizationParameterEnum_eBODY_AXES();

    Module['eBODY_MASS_AXES'] = _emscripten_enum_PxVisualizationParameterEnum_eBODY_MASS_AXES();

    Module['eBODY_LIN_VELOCITY'] = _emscripten_enum_PxVisualizationParameterEnum_eBODY_LIN_VELOCITY();

    Module['eBODY_ANG_VELOCITY'] = _emscripten_enum_PxVisualizationParameterEnum_eBODY_ANG_VELOCITY();

    Module['eCONTACT_POINT'] = _emscripten_enum_PxVisualizationParameterEnum_eCONTACT_POINT();

    Module['eCONTACT_NORMAL'] = _emscripten_enum_PxVisualizationParameterEnum_eCONTACT_NORMAL();

    Module['eCONTACT_ERROR'] = _emscripten_enum_PxVisualizationParameterEnum_eCONTACT_ERROR();

    Module['eCONTACT_FORCE'] = _emscripten_enum_PxVisualizationParameterEnum_eCONTACT_FORCE();

    Module['eACTOR_AXES'] = _emscripten_enum_PxVisualizationParameterEnum_eACTOR_AXES();

    Module['eCOLLISION_AABBS'] = _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AABBS();

    Module['eCOLLISION_SHAPES'] = _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_SHAPES();

    Module['eCOLLISION_AXES'] = _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_AXES();

    Module['eCOLLISION_COMPOUNDS'] = _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_COMPOUNDS();

    Module['eCOLLISION_FNORMALS'] = _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_FNORMALS();

    Module['eCOLLISION_EDGES'] = _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_EDGES();

    Module['eCOLLISION_STATIC'] = _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_STATIC();

    Module['eCOLLISION_DYNAMIC'] = _emscripten_enum_PxVisualizationParameterEnum_eCOLLISION_DYNAMIC();

    Module['eJOINT_LOCAL_FRAMES'] = _emscripten_enum_PxVisualizationParameterEnum_eJOINT_LOCAL_FRAMES();

    Module['eJOINT_LIMITS'] = _emscripten_enum_PxVisualizationParameterEnum_eJOINT_LIMITS();

    Module['eCULL_BOX'] = _emscripten_enum_PxVisualizationParameterEnum_eCULL_BOX();

    Module['eMBP_REGIONS'] = _emscripten_enum_PxVisualizationParameterEnum_eMBP_REGIONS();

    Module['eSIMULATION_MESH'] = _emscripten_enum_PxVisualizationParameterEnum_eSIMULATION_MESH();

    Module['eSDF'] = _emscripten_enum_PxVisualizationParameterEnum_eSDF();

    Module['eNUM_VALUES'] = _emscripten_enum_PxVisualizationParameterEnum_eNUM_VALUES();

    Module['eFORCE_DWORD'] = _emscripten_enum_PxVisualizationParameterEnum_eFORCE_DWORD();

  }
  if (runtimeInitialized) setupEnums();
  else addOnInit(setupEnums);
})();
// end include: glue.js

// include: /src/PhysX/physx/source/webidlbindings/src/wasm/onload.js
/**
 * Makes the API a little less verbose
 */
Object.defineProperty(Module, 'PHYSICS_VERSION', { get() { return Module.PxTopLevelFunctions.prototype.PHYSICS_VERSION; }});

//Move PxTopLevelFunctions to PhysX object
for(const prop in Module.PxTopLevelFunctions.prototype) {
    if(prop !== 'constructor' && !prop.startsWith('get_') && !prop.startsWith('__')) {
        Object.defineProperty(Module, prop, { get() { return Module.PxTopLevelFunctions.prototype[prop]; }});
    }
}

//Move NativeArrayHelpers to PhysX object
for(const prop in Module.NativeArrayHelpers.prototype) {
    if(prop !== 'constructor' && !prop.startsWith('get_') && !prop.startsWith('__')) {
        Object.defineProperty(Module, prop, { get() { return Module.NativeArrayHelpers.prototype[prop]; }});
    }
}

//Group enums
const regex = /_emscripten_enum_(.*?)_(.*)/;
const enums = Object.keys(Module).filter(key => key.includes('_emscripten_enum_')).map(emscript => emscript.match(regex));

for (const [emscript, enumName, entryName] of enums) {
    Module[enumName] ??= {};
    Object.defineProperty(Module[enumName], entryName, { get() { return Module[emscript](); }});
}// end include: /src/PhysX/physx/source/webidlbindings/src/wasm/onload.js

// include: postamble_modularize.js
// In MODULARIZE mode we wrap the generated code in a factory function
// and return either the Module itself, or a promise of the module.
//
// We assign to the `moduleRtn` global here and configure closure to see
// this as and extern so it won't get minified.

if (runtimeInitialized)  {
  moduleRtn = Module;
} else {
  // Set up the promise that indicates the Module is initialized
  moduleRtn = new Promise((resolve, reject) => {
    readyPromiseResolve = resolve;
    readyPromiseReject = reject;
  });
}

// Assertion for attempting to access module properties on the incoming
// moduleArg.  In the past we used this object as the prototype of the module
// and assigned properties to it, but now we return a distinct object.  This
// keeps the instance private until it is ready (i.e the promise has been
// resolved).
for (const prop of Object.keys(Module)) {
  if (!(prop in moduleArg)) {
    Object.defineProperty(moduleArg, prop, {
      configurable: true,
      get() {
        abort(`Access to module property ('${prop}') is no longer possible via the module constructor argument; Instead, use the result of the module constructor.`)
      }
    });
  }
}
// end include: postamble_modularize.js



  return moduleRtn;
}

// Export using a UMD style export, or ES6 exports if selected
export default PhysX;