@galacean/engine-physics-physx 0.9.19 → 0.9.21

package/dist/browser.js

@@ -1,1383 +1,1316 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@galacean/engine')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@galacean/engine'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.Galacean = global.Galacean || {}, global.Galacean.PhysicsPhysX = {}), global.Galacean));
-})(this, (function (exports, engine) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@swc/helpers/src/_instanceof.mjs'), require('@swc/helpers/src/_ts_decorate.mjs'), require('@swc/helpers/src/_inherits.mjs'), require('@galacean/engine')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@swc/helpers/src/_instanceof.mjs', '@swc/helpers/src/_ts_decorate.mjs', '@swc/helpers/src/_inherits.mjs', '@galacean/engine'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.Galacean = global.Galacean || {}, global.Galacean.PhysicsPhysX = {}), global._instanceof, global._ts_decorate, global._inherits, global.Galacean));
+}(this, (function (exports, _instanceof, _ts_decorate, _inherits, engine) { 'use strict';
 
-    function _instanceof(left, right) {
-        if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-            return !!right[Symbol.hasInstance](left);
-        } else return left instanceof right;
-    }
+  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    function __decorate(decorators, target, key, desc) {
-        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-        return c > 3 && r && Object.defineProperty(target, key, r), r;
-    }
+  var _instanceof__default = /*#__PURE__*/_interopDefaultLegacy(_instanceof);
+  var _ts_decorate__default = /*#__PURE__*/_interopDefaultLegacy(_ts_decorate);
+  var _inherits__default = /*#__PURE__*/_interopDefaultLegacy(_inherits);
 
-    /**
-     * PhysX runtime mode.
-     */ exports.PhysXRuntimeMode = void 0;
-    (function(PhysXRuntimeMode) {
-        PhysXRuntimeMode[PhysXRuntimeMode[/** Use webAssembly mode first, if WebAssembly mode is not supported, roll back to JavaScript mode.  */ "Auto"] = 0] = "Auto";
-        PhysXRuntimeMode[PhysXRuntimeMode[/** WebAssembly mode. */ "WebAssembly"] = 1] = "WebAssembly";
-        PhysXRuntimeMode[PhysXRuntimeMode[/** JavaScript mode. */ "JavaScript"] = 2] = "JavaScript";
-    })(exports.PhysXRuntimeMode || (exports.PhysXRuntimeMode = {}));
+  (function(PhysXRuntimeMode) {
+      PhysXRuntimeMode[PhysXRuntimeMode[/** Use webAssembly mode first, if WebAssembly mode is not supported, roll back to JavaScript mode.  */ "Auto"] = 0] = "Auto";
+      PhysXRuntimeMode[PhysXRuntimeMode[/** WebAssembly mode. */ "WebAssembly"] = 1] = "WebAssembly";
+      PhysXRuntimeMode[PhysXRuntimeMode[/** JavaScript mode. */ "JavaScript"] = 2] = "JavaScript";
+  })(exports.PhysXRuntimeMode || (exports.PhysXRuntimeMode = {}));
 
-    function _set_prototype_of(o, p) {
-        _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
-            o.__proto__ = p;
+  /**
+   * a base interface providing common functionality for PhysX joints
+   */ var PhysXJoint = /*#__PURE__*/ function() {
+      function PhysXJoint() {
+          this._connectedAnchor = new engine.Vector3();
+          this._breakForce = Number.MAX_VALUE;
+          this._breakTorque = Number.MAX_VALUE;
+      }
+      var _proto = PhysXJoint.prototype;
+      /**
+     * {@inheritDoc IJoint.setConnectedCollider }
+     */ _proto.setConnectedCollider = function setConnectedCollider(value) {
+          var _this__collider;
+          this._pxJoint.setActors((value == null ? void 0 : value._pxActor) || null, ((_this__collider = this._collider) == null ? void 0 : _this__collider._pxActor) || null);
+      };
+      /**
+     * {@inheritDoc IJoint.setConnectedAnchor }
+     */ _proto.setConnectedAnchor = function setConnectedAnchor(value) {
+          this._connectedAnchor.copyFrom(value);
+          this._setLocalPose(0, value, PhysXJoint._defaultQuat);
+      };
+      /**
+     * {@inheritDoc IJoint.setConnectedMassScale }
+     */ _proto.setConnectedMassScale = function setConnectedMassScale(value) {
+          this._pxJoint.setInvMassScale0(1 / value);
+      };
+      /**
+     * {@inheritDoc IJoint.setConnectedInertiaScale }
+     */ _proto.setConnectedInertiaScale = function setConnectedInertiaScale(value) {
+          this._pxJoint.setInvInertiaScale0(1 / value);
+      };
+      /**
+     * {@inheritDoc IJoint.setMassScale }
+     */ _proto.setMassScale = function setMassScale(value) {
+          this._pxJoint.setInvMassScale1(1 / value);
+      };
+      /**
+     * {@inheritDoc IJoint.setInertiaScale }
+     */ _proto.setInertiaScale = function setInertiaScale(value) {
+          this._pxJoint.setInvInertiaScale1(1 / value);
+      };
+      /**
+     * {@inheritDoc IJoint.setBreakForce }
+     */ _proto.setBreakForce = function setBreakForce(value) {
+          this._breakForce = value;
+          this._pxJoint.setBreakForce(this._breakForce, this._breakTorque);
+      };
+      /**
+     * {@inheritDoc IJoint.setBreakTorque }
+     */ _proto.setBreakTorque = function setBreakTorque(value) {
+          this._breakTorque = value;
+          this._pxJoint.setBreakForce(this._breakForce, this._breakTorque);
+      };
+      /**
+     * Set the joint local pose for an actor.
+     * @param actor 0 for the first actor, 1 for the second actor.
+     * @param position the local position for the actor this joint
+     * @param rotation the local rotation for the actor this joint
+     */ _proto._setLocalPose = function _setLocalPose(actor, position, rotation) {
+          this._pxJoint.setLocalPose(actor, position, rotation);
+      };
+      return PhysXJoint;
+  }();
+  PhysXJoint._xAxis = new engine.Vector3(1, 0, 0);
+  PhysXJoint._defaultVec = new engine.Vector3();
+  PhysXJoint._defaultQuat = new engine.Quaternion();
 
-            return o;
-        };
+  /**
+   * A fixed joint permits no relative movement between two colliders. ie the bodies are glued together.
+   */ var PhysXFixedJoint = /*#__PURE__*/ function(PhysXJoint1) {
+      _inherits__default['default'](PhysXFixedJoint, PhysXJoint1);
+      function PhysXFixedJoint(collider) {
+          var _this;
+          _this = PhysXJoint1.call(this) || this;
+          _this._collider = collider;
+          _this._pxJoint = exports.PhysXPhysics._pxPhysics.createFixedJoint(null, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat);
+          return _this;
+      }
+      return PhysXFixedJoint;
+  }(PhysXJoint);
 
-        return _set_prototype_of(o, p);
-    }
+  /**
+   * A joint which behaves in a similar way to a hinge or axle.
+   */ var PhysXHingeJoint = /*#__PURE__*/ function(PhysXJoint1) {
+      _inherits__default['default'](PhysXHingeJoint, PhysXJoint1);
+      function PhysXHingeJoint(collider) {
+          var _this;
+          _this = PhysXJoint1.call(this) || this;
+          _this._axisRotationQuaternion = new engine.Quaternion();
+          _this._swingOffset = new engine.Vector3();
+          _this._velocity = new engine.Vector3();
+          _this._collider = collider;
+          _this._pxJoint = exports.PhysXPhysics._pxPhysics.createRevoluteJoint(null, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat);
+          return _this;
+      }
+      var _proto = PhysXHingeJoint.prototype;
+      /**
+     * {@inheritDoc IHingeJoint.setAxis }
+     */ _proto.setAxis = function setAxis(value) {
+          var xAxis = PhysXJoint._xAxis;
+          var axisRotationQuaternion = this._axisRotationQuaternion;
+          xAxis.set(1, 0, 0);
+          value.normalize();
+          var angle = Math.acos(engine.Vector3.dot(xAxis, value));
+          engine.Vector3.cross(xAxis, value, xAxis);
+          engine.Quaternion.rotationAxisAngle(xAxis, angle, axisRotationQuaternion);
+          this._setLocalPose(0, this._swingOffset, axisRotationQuaternion);
+      };
+      /**
+     * {@inheritDoc IHingeJoint.setSwingOffset }
+     */ _proto.setSwingOffset = function setSwingOffset(value) {
+          this._swingOffset.copyFrom(value);
+          this._setLocalPose(1, this._swingOffset, this._axisRotationQuaternion);
+      };
+      /**
+     * {@inheritDoc IHingeJoint.getAngle }
+     */ _proto.getAngle = function getAngle() {
+          return this._pxJoint.getAngle();
+      };
+      /**
+     * {@inheritDoc IHingeJoint.getVelocity }
+     */ _proto.getVelocity = function getVelocity() {
+          var velocity = this._velocity;
+          velocity.copyFrom(this._pxJoint.getVelocity());
+          return velocity;
+      };
+      /**
+     * {@inheritDoc IHingeJoint.setHardLimitCone }
+     */ _proto.setHardLimit = function setHardLimit(lowerLimit, upperLimit, contactDist) {
+          this._pxJoint.setHardLimit(lowerLimit, upperLimit, contactDist);
+      };
+      /**
+     * {@inheritDoc IHingeJoint.setHardLimitCone }
+     */ _proto.setSoftLimit = function setSoftLimit(lowerLimit, upperLimit, stiffness, damping) {
+          this._pxJoint.setSoftLimit(lowerLimit, upperLimit, stiffness, damping);
+      };
+      /**
+     * {@inheritDoc IHingeJoint.setDriveVelocity }
+     */ _proto.setDriveVelocity = function setDriveVelocity(velocity) {
+          this._pxJoint.setDriveVelocity(velocity);
+      };
+      /**
+     * {@inheritDoc IHingeJoint.setDriveForceLimit }
+     */ _proto.setDriveForceLimit = function setDriveForceLimit(limit) {
+          this._pxJoint.setDriveForceLimit(limit);
+      };
+      /**
+     * {@inheritDoc IHingeJoint.setDriveGearRatio }
+     */ _proto.setDriveGearRatio = function setDriveGearRatio(ratio) {
+          this._pxJoint.setDriveGearRatio(ratio);
+      };
+      /**
+     * {@inheritDoc IHingeJoint.setHingeJointFlag }
+     */ _proto.setHingeJointFlag = function setHingeJointFlag(flag, value) {
+          this._pxJoint.setRevoluteJointFlag(flag, value);
+      };
+      return PhysXHingeJoint;
+  }(PhysXJoint);
 
-    function _inherits(subClass, superClass) {
-        if (typeof superClass !== "function" && superClass !== null) {
-            throw new TypeError("Super expression must either be null or a function");
-        }
+  /**
+   * a joint that maintains an upper or lower bound (or both) on the distance between two points on different objects
+   */ var PhysXSpringJoint = /*#__PURE__*/ function(PhysXJoint1) {
+      _inherits__default['default'](PhysXSpringJoint, PhysXJoint1);
+      function PhysXSpringJoint(collider) {
+          var _this;
+          _this = PhysXJoint1.call(this) || this;
+          _this._swingOffset = new engine.Vector3();
+          _this._collider = collider;
+          _this._pxJoint = exports.PhysXPhysics._pxPhysics.createDistanceJoint(null, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat);
+          _this._pxJoint.setDistanceJointFlag(2, true); // enable max distance;
+          _this._pxJoint.setDistanceJointFlag(4, true); // enable min distance;
+          _this._pxJoint.setDistanceJointFlag(8, true); // enable spring;
+          return _this;
+      }
+      var _proto = PhysXSpringJoint.prototype;
+      /**
+     * {@inheritDoc ISpringJoint.setSwingOffset }
+     */ _proto.setSwingOffset = function setSwingOffset(value) {
+          this._swingOffset.copyFrom(value);
+          this._setLocalPose(1, value, PhysXJoint._defaultQuat);
+      };
+      /**
+     * {@inheritDoc ISpringJoint.setMinDistance }
+     */ _proto.setMinDistance = function setMinDistance(distance) {
+          this._pxJoint.setMinDistance(distance);
+      };
+      /**
+     * {@inheritDoc ISpringJoint.setMaxDistance }
+     */ _proto.setMaxDistance = function setMaxDistance(distance) {
+          this._pxJoint.setMaxDistance(distance);
+      };
+      /**
+     * {@inheritDoc ISpringJoint.setTolerance }
+     */ _proto.setTolerance = function setTolerance(tolerance) {
+          this._pxJoint.setTolerance(tolerance);
+      };
+      /**
+     * {@inheritDoc ISpringJoint.setStiffness }
+     */ _proto.setStiffness = function setStiffness(stiffness) {
+          this._pxJoint.setStiffness(stiffness);
+      };
+      /**
+     * {@inheritDoc ISpringJoint.setDamping }
+     */ _proto.setDamping = function setDamping(damping) {
+          this._pxJoint.setDamping(damping);
+      };
+      return PhysXSpringJoint;
+  }(PhysXJoint);
 
-        subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+  /**
+   * High-performance unordered array, delete uses exchange method to improve performance, internal capacity only increases.
+   */ var DisorderedArray = /*#__PURE__*/ function() {
+      function DisorderedArray(count) {
+          if (count === void 0) count = 0;
+          this.length = 0;
+          this._elements = new Array(count);
+      }
+      var _proto = DisorderedArray.prototype;
+      _proto.add = function add(element) {
+          if (this.length === this._elements.length) this._elements.push(element);
+          else this._elements[this.length] = element;
+          this.length++;
+      };
+      _proto.delete = function _delete(element) {
+          //TODO: It can be optimized for custom binary search and other algorithms, currently this._elements>=this.length wastes performance.
+          var index = this._elements.indexOf(element);
+          this.deleteByIndex(index);
+      };
+      _proto.get = function get(index) {
+          if (index >= this.length) {
+              throw "Index is out of range.";
+          }
+          return this._elements[index];
+      };
+      /**
+     *
+     * @param index
+     * @returns The replaced item is used to reset its index.
+     */ _proto.deleteByIndex = function deleteByIndex(index) {
+          var elements = this._elements;
+          var end = null;
+          var lastIndex = this.length - 1;
+          if (index !== lastIndex) {
+              end = elements[lastIndex];
+              elements[index] = end;
+          }
+          this.length--;
+          return end;
+      };
+      _proto.garbageCollection = function garbageCollection() {
+          this._elements.length = this.length;
+      };
+      return DisorderedArray;
+  }();
 
-        if (superClass) _set_prototype_of(subClass, superClass);
-    }
+  var ShapeFlag;
+  (function(ShapeFlag) {
+      ShapeFlag[ShapeFlag[/** The shape will partake in collision in the physical simulation. */ "SIMULATION_SHAPE"] = 1] = "SIMULATION_SHAPE";
+      ShapeFlag[ShapeFlag[/** The shape will partake in scene queries (ray casts, overlap tests, sweeps, ...). */ "SCENE_QUERY_SHAPE"] = 2] = "SCENE_QUERY_SHAPE";
+      ShapeFlag[ShapeFlag[/** The shape is a trigger which can send reports whenever other shapes enter/leave its volume. */ "TRIGGER_SHAPE"] = 4] = "TRIGGER_SHAPE";
+  })(ShapeFlag || (ShapeFlag = {}));
+  /**
+   * Abstract class for collider shapes.
+   */ var PhysXColliderShape = /*#__PURE__*/ function() {
+      function PhysXColliderShape() {
+          /** @internal */ this._controllers = new DisorderedArray();
+          this._scale = new engine.Vector3(1, 1, 1);
+          this._position = new engine.Vector3();
+          this._rotation = null;
+          this._axis = null;
+          this._physxRotation = new engine.Quaternion();
+          this._shapeFlags = 2 | 1;
+          /** @internal */ this._pxMaterials = new Array(1);
+      }
+      var _proto = PhysXColliderShape.prototype;
+      /**
+     * {@inheritDoc IColliderShape.setRotation }
+     */ _proto.setRotation = function setRotation(value) {
+          this._rotation = value;
+          engine.Quaternion.rotationYawPitchRoll(value.x, value.y, value.z, this._physxRotation);
+          this._axis && engine.Quaternion.multiply(this._physxRotation, this._axis, this._physxRotation);
+          this._physxRotation.normalize();
+          this._setLocalPose();
+      };
+      /**
+     * {@inheritDoc IColliderShape.setPosition }
+     */ _proto.setPosition = function setPosition(value) {
+          if (value !== this._position) {
+              this._position.copyFrom(value);
+          }
+          this._setLocalPose();
+      };
+      /**
+     * {@inheritDoc IColliderShape.setContactOffset }
+     * @default 0.02f * PxTolerancesScale::length
+     */ _proto.setContactOffset = function setContactOffset(offset) {
+          this._pxShape.setContactOffset(offset);
+          var controllers = this._controllers;
+          for(var i = 0, n = controllers.length; i < n; i++){
+              controllers.get(i)._pxController.setContactOffset(offset);
+          }
+      };
+      /**
+     * {@inheritDoc IColliderShape.setMaterial }
+     */ _proto.setMaterial = function setMaterial(value) {
+          this._pxMaterials[0] = value._pxMaterial;
+          this._pxShape.setMaterials(this._pxMaterials);
+      };
+      /**
+     * {@inheritDoc IColliderShape.setIsTrigger }
+     */ _proto.setIsTrigger = function setIsTrigger(value) {
+          this._modifyFlag(1, !value);
+          this._modifyFlag(4, value);
+          this._setShapeFlags(this._shapeFlags);
+      };
+      /**
+     * {@inheritDoc IColliderShape.destroy }
+     */ _proto.destroy = function destroy() {
+          this._pxShape.release();
+      };
+      /**
+     *  @internal
+     */ _proto._setShapeFlags = function _setShapeFlags(flags) {
+          this._shapeFlags = flags;
+          this._pxShape.setFlags(new exports.PhysXPhysics._physX.PxShapeFlags(this._shapeFlags));
+      };
+      _proto._setLocalPose = function _setLocalPose() {
+          var transform = PhysXColliderShape.transform;
+          engine.Vector3.multiply(this._position, this._scale, transform.translation);
+          transform.rotation = this._physxRotation;
+          this._pxShape.setLocalPose(transform);
+      };
+      _proto._initialize = function _initialize(material, id) {
+          this._id = id;
+          this._pxMaterials[0] = material._pxMaterial;
+          this._pxShape = exports.PhysXPhysics._pxPhysics.createShape(this._pxGeometry, material._pxMaterial, true, new exports.PhysXPhysics._physX.PxShapeFlags(this._shapeFlags));
+          this._pxShape.setQueryFilterData(new exports.PhysXPhysics._physX.PxFilterData(id, 0, 0, 0));
+      };
+      _proto._modifyFlag = function _modifyFlag(flag, value) {
+          this._shapeFlags = value ? this._shapeFlags | flag : this._shapeFlags & ~flag;
+      };
+      return PhysXColliderShape;
+  }();
+  PhysXColliderShape.halfSqrt = 0.70710678118655;
+  PhysXColliderShape.transform = {
+      translation: new engine.Vector3(),
+      rotation: null
+  };
 
-    /**
-     * a base interface providing common functionality for PhysX joints
-     */ var PhysXJoint = /*#__PURE__*/ function() {
-        function PhysXJoint() {
-            this._connectedAnchor = new engine.Vector3();
-            this._breakForce = Number.MAX_VALUE;
-            this._breakTorque = Number.MAX_VALUE;
-        }
-        var _proto = PhysXJoint.prototype;
-        /**
-       * {@inheritDoc IJoint.setConnectedCollider }
-       */ _proto.setConnectedCollider = function setConnectedCollider(value) {
-            var _this__collider;
-            this._pxJoint.setActors((value == null ? void 0 : value._pxActor) || null, ((_this__collider = this._collider) == null ? void 0 : _this__collider._pxActor) || null);
-        };
-        /**
-       * {@inheritDoc IJoint.setConnectedAnchor }
-       */ _proto.setConnectedAnchor = function setConnectedAnchor(value) {
-            this._connectedAnchor.copyFrom(value);
-            this._setLocalPose(0, value, PhysXJoint._defaultQuat);
-        };
-        /**
-       * {@inheritDoc IJoint.setConnectedMassScale }
-       */ _proto.setConnectedMassScale = function setConnectedMassScale(value) {
-            this._pxJoint.setInvMassScale0(1 / value);
-        };
-        /**
-       * {@inheritDoc IJoint.setConnectedInertiaScale }
-       */ _proto.setConnectedInertiaScale = function setConnectedInertiaScale(value) {
-            this._pxJoint.setInvInertiaScale0(1 / value);
-        };
-        /**
-       * {@inheritDoc IJoint.setMassScale }
-       */ _proto.setMassScale = function setMassScale(value) {
-            this._pxJoint.setInvMassScale1(1 / value);
-        };
-        /**
-       * {@inheritDoc IJoint.setInertiaScale }
-       */ _proto.setInertiaScale = function setInertiaScale(value) {
-            this._pxJoint.setInvInertiaScale1(1 / value);
-        };
-        /**
-       * {@inheritDoc IJoint.setBreakForce }
-       */ _proto.setBreakForce = function setBreakForce(value) {
-            this._breakForce = value;
-            this._pxJoint.setBreakForce(this._breakForce, this._breakTorque);
-        };
-        /**
-       * {@inheritDoc IJoint.setBreakTorque }
-       */ _proto.setBreakTorque = function setBreakTorque(value) {
-            this._breakTorque = value;
-            this._pxJoint.setBreakForce(this._breakForce, this._breakTorque);
-        };
-        /**
-       * Set the joint local pose for an actor.
-       * @param actor 0 for the first actor, 1 for the second actor.
-       * @param position the local position for the actor this joint
-       * @param rotation the local rotation for the actor this joint
-       */ _proto._setLocalPose = function _setLocalPose(actor, position, rotation) {
-            this._pxJoint.setLocalPose(actor, position, rotation);
-        };
-        return PhysXJoint;
-    }();
-    (function() {
-        PhysXJoint._xAxis = new engine.Vector3(1, 0, 0);
-    })();
-    (function() {
-        PhysXJoint._defaultVec = new engine.Vector3();
-    })();
-    (function() {
-        PhysXJoint._defaultQuat = new engine.Quaternion();
-    })();
+  /**
+   * Box collider shape in PhysX.
+   */ var PhysXBoxColliderShape = /*#__PURE__*/ function(PhysXColliderShape) {
+      _inherits__default['default'](PhysXBoxColliderShape, PhysXColliderShape);
+      function PhysXBoxColliderShape(uniqueID, size, material) {
+          var _this;
+          _this = PhysXColliderShape.call(this) || this;
+          /** @internal */ _this._halfSize = new engine.Vector3();
+          _this._halfSize.set(size.x * 0.5, size.y * 0.5, size.z * 0.5);
+          _this._pxGeometry = new exports.PhysXPhysics._physX.PxBoxGeometry(_this._halfSize.x * _this._scale.x, _this._halfSize.y * _this._scale.y, _this._halfSize.z * _this._scale.z);
+          _this._initialize(material, uniqueID);
+          _this._setLocalPose();
+          return _this;
+      }
+      var _proto = PhysXBoxColliderShape.prototype;
+      /**
+     * {@inheritDoc IBoxColliderShape.setSize }
+     */ _proto.setSize = function setSize(value) {
+          this._halfSize.set(value.x * 0.5, value.y * 0.5, value.z * 0.5);
+          engine.Vector3.multiply(this._halfSize, this._scale, PhysXBoxColliderShape._tempHalfExtents);
+          this._pxGeometry.halfExtents = PhysXBoxColliderShape._tempHalfExtents;
+          this._pxShape.setGeometry(this._pxGeometry);
+          var controllers = this._controllers;
+          for(var i = 0, n = controllers.length; i < n; i++){
+              var pxController = controllers.get(i)._pxController;
+              pxController.setHalfHeight(this._halfSize.x);
+              pxController.setHalfSideExtent(this._halfSize.y);
+              pxController.setHalfForwardExtent(this._halfSize.z);
+          }
+      };
+      /**
+     * {@inheritDoc IColliderShape.setWorldScale }
+     */ _proto.setWorldScale = function setWorldScale(scale) {
+          this._scale.copyFrom(scale);
+          this._setLocalPose();
+          engine.Vector3.multiply(this._halfSize, this._scale, PhysXBoxColliderShape._tempHalfExtents);
+          this._pxGeometry.halfExtents = PhysXBoxColliderShape._tempHalfExtents;
+          this._pxShape.setGeometry(this._pxGeometry);
+      };
+      return PhysXBoxColliderShape;
+  }(PhysXColliderShape);
+  PhysXBoxColliderShape._tempHalfExtents = new engine.Vector3();
 
-    /**
-     * A fixed joint permits no relative movement between two colliders. ie the bodies are glued together.
-     */ var PhysXFixedJoint = /*#__PURE__*/ function(PhysXJoint1) {
-        _inherits(PhysXFixedJoint, PhysXJoint1);
-        function PhysXFixedJoint(collider) {
-            var _this;
-            _this = PhysXJoint1.call(this) || this;
-            _this._collider = collider;
-            _this._pxJoint = exports.PhysXPhysics._pxPhysics.createFixedJoint(null, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat);
-            return _this;
-        }
-        return PhysXFixedJoint;
-    }(PhysXJoint);
+  /**
+   * Capsule collider shape in PhysX.
+   */ var PhysXCapsuleColliderShape = /*#__PURE__*/ function(PhysXColliderShape1) {
+      _inherits__default['default'](PhysXCapsuleColliderShape, PhysXColliderShape1);
+      function PhysXCapsuleColliderShape(uniqueID, radius, height, material) {
+          var _this;
+          _this = PhysXColliderShape1.call(this) || this;
+          _this._upAxis = /** Up axis is Y. */ 1;
+          _this._radius = radius;
+          _this._halfHeight = height * 0.5;
+          _this._axis = new engine.Quaternion(0, 0, PhysXColliderShape.halfSqrt, PhysXColliderShape.halfSqrt);
+          _this._physxRotation.copyFrom(_this._axis);
+          _this._pxGeometry = new exports.PhysXPhysics._physX.PxCapsuleGeometry(_this._radius, _this._halfHeight);
+          _this._initialize(material, uniqueID);
+          _this._setLocalPose();
+          return _this;
+      }
+      var _proto = PhysXCapsuleColliderShape.prototype;
+      /**
+     * {@inheritDoc ICapsuleColliderShape.setRadius }
+     */ _proto.setRadius = function setRadius(value) {
+          this._radius = value;
+          switch(this._upAxis){
+              case /** Up axis is X. */ 0:
+                  this._pxGeometry.radius = this._radius * Math.max(this._scale.y, this._scale.z);
+                  break;
+              case 1:
+                  this._pxGeometry.radius = this._radius * Math.max(this._scale.x, this._scale.z);
+                  break;
+              case /** Up axis is Z. */ 2:
+                  this._pxGeometry.radius = this._radius * Math.max(this._scale.x, this._scale.y);
+                  break;
+          }
+          this._pxShape.setGeometry(this._pxGeometry);
+          var controllers = this._controllers;
+          for(var i = 0, n = controllers.length; i < n; i++){
+              controllers.get(i)._pxController.setRadius(value);
+          }
+      };
+      /**
+     * {@inheritDoc ICapsuleColliderShape.setHeight }
+     */ _proto.setHeight = function setHeight(value) {
+          this._halfHeight = value * 0.5;
+          switch(this._upAxis){
+              case 0:
+                  this._pxGeometry.halfHeight = this._halfHeight * this._scale.x;
+                  break;
+              case 1:
+                  this._pxGeometry.halfHeight = this._halfHeight * this._scale.y;
+                  break;
+              case 2:
+                  this._pxGeometry.halfHeight = this._halfHeight * this._scale.z;
+                  break;
+          }
+          this._pxShape.setGeometry(this._pxGeometry);
+          var controllers = this._controllers;
+          for(var i = 0, n = controllers.length; i < n; i++){
+              controllers.get(i)._pxController.setHeight(value);
+          }
+      };
+      /**
+     * {@inheritDoc ICapsuleColliderShape.setUpAxis }
+     */ _proto.setUpAxis = function setUpAxis(upAxis) {
+          var _this = this, rotation = _this._rotation, axis = _this._axis, physxRotation = _this._physxRotation;
+          this._upAxis = upAxis;
+          switch(this._upAxis){
+              case 0:
+                  axis.set(0, 0, 0, 1);
+                  break;
+              case 1:
+                  axis.set(0, 0, PhysXColliderShape.halfSqrt, PhysXColliderShape.halfSqrt);
+                  break;
+              case 2:
+                  axis.set(0, PhysXColliderShape.halfSqrt, 0, PhysXColliderShape.halfSqrt);
+                  break;
+          }
+          if (rotation) {
+              engine.Quaternion.rotationYawPitchRoll(rotation.x, rotation.y, rotation.z, physxRotation);
+              engine.Quaternion.multiply(physxRotation, axis, physxRotation);
+          } else {
+              physxRotation.copyFrom(axis);
+          }
+          this._setLocalPose();
+      };
+      /**
+     * {@inheritDoc IColliderShape.setWorldScale }
+     */ _proto.setWorldScale = function setWorldScale(scale) {
+          this._scale.copyFrom(scale);
+          this._setLocalPose();
+          switch(this._upAxis){
+              case 0:
+                  this._pxGeometry.radius = this._radius * Math.max(scale.y, scale.z);
+                  this._pxGeometry.halfHeight = this._halfHeight * scale.x;
+                  break;
+              case 1:
+                  this._pxGeometry.radius = this._radius * Math.max(scale.x, scale.z);
+                  this._pxGeometry.halfHeight = this._halfHeight * scale.y;
+                  break;
+              case 2:
+                  this._pxGeometry.radius = this._radius * Math.max(scale.x, scale.y);
+                  this._pxGeometry.halfHeight = this._halfHeight * scale.z;
+                  break;
+          }
+          this._pxShape.setGeometry(this._pxGeometry);
+      };
+      return PhysXCapsuleColliderShape;
+  }(PhysXColliderShape);
+  var /**
+   * The up axis of the collider shape.
+   */ ColliderShapeUpAxis;
+  (function(ColliderShapeUpAxis) {
+      ColliderShapeUpAxis[ColliderShapeUpAxis["X"] = 0] = "X";
+      ColliderShapeUpAxis[ColliderShapeUpAxis["Y"] = 1] = "Y";
+      ColliderShapeUpAxis[ColliderShapeUpAxis["Z"] = 2] = "Z";
+  })(ColliderShapeUpAxis || (ColliderShapeUpAxis = {}));
 
-    /**
-     * A joint which behaves in a similar way to a hinge or axle.
-     */ var PhysXHingeJoint = /*#__PURE__*/ function(PhysXJoint1) {
-        _inherits(PhysXHingeJoint, PhysXJoint1);
-        function PhysXHingeJoint(collider) {
-            var _this;
-            _this = PhysXJoint1.call(this) || this;
-            _this._axisRotationQuaternion = new engine.Quaternion();
-            _this._swingOffset = new engine.Vector3();
-            _this._velocity = new engine.Vector3();
-            _this._collider = collider;
-            _this._pxJoint = exports.PhysXPhysics._pxPhysics.createRevoluteJoint(null, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat);
-            return _this;
-        }
-        var _proto = PhysXHingeJoint.prototype;
-        /**
-       * {@inheritDoc IHingeJoint.setAxis }
-       */ _proto.setAxis = function setAxis(value) {
-            var xAxis = PhysXJoint._xAxis;
-            var axisRotationQuaternion = this._axisRotationQuaternion;
-            xAxis.set(1, 0, 0);
-            value.normalize();
-            var angle = Math.acos(engine.Vector3.dot(xAxis, value));
-            engine.Vector3.cross(xAxis, value, xAxis);
-            engine.Quaternion.rotationAxisAngle(xAxis, angle, axisRotationQuaternion);
-            this._setLocalPose(0, this._swingOffset, axisRotationQuaternion);
-        };
-        /**
-       * {@inheritDoc IHingeJoint.setSwingOffset }
-       */ _proto.setSwingOffset = function setSwingOffset(value) {
-            this._swingOffset.copyFrom(value);
-            this._setLocalPose(1, this._swingOffset, this._axisRotationQuaternion);
-        };
-        /**
-       * {@inheritDoc IHingeJoint.getAngle }
-       */ _proto.getAngle = function getAngle() {
-            return this._pxJoint.getAngle();
-        };
-        /**
-       * {@inheritDoc IHingeJoint.getVelocity }
-       */ _proto.getVelocity = function getVelocity() {
-            var velocity = this._velocity;
-            velocity.copyFrom(this._pxJoint.getVelocity());
-            return velocity;
-        };
-        /**
-       * {@inheritDoc IHingeJoint.setHardLimitCone }
-       */ _proto.setHardLimit = function setHardLimit(lowerLimit, upperLimit, contactDist) {
-            this._pxJoint.setHardLimit(lowerLimit, upperLimit, contactDist);
-        };
-        /**
-       * {@inheritDoc IHingeJoint.setHardLimitCone }
-       */ _proto.setSoftLimit = function setSoftLimit(lowerLimit, upperLimit, stiffness, damping) {
-            this._pxJoint.setSoftLimit(lowerLimit, upperLimit, stiffness, damping);
-        };
-        /**
-       * {@inheritDoc IHingeJoint.setDriveVelocity }
-       */ _proto.setDriveVelocity = function setDriveVelocity(velocity) {
-            this._pxJoint.setDriveVelocity(velocity);
-        };
-        /**
-       * {@inheritDoc IHingeJoint.setDriveForceLimit }
-       */ _proto.setDriveForceLimit = function setDriveForceLimit(limit) {
-            this._pxJoint.setDriveForceLimit(limit);
-        };
-        /**
-       * {@inheritDoc IHingeJoint.setDriveGearRatio }
-       */ _proto.setDriveGearRatio = function setDriveGearRatio(ratio) {
-            this._pxJoint.setDriveGearRatio(ratio);
-        };
-        /**
-       * {@inheritDoc IHingeJoint.setHingeJointFlag }
-       */ _proto.setHingeJointFlag = function setHingeJointFlag(flag, value) {
-            this._pxJoint.setRevoluteJointFlag(flag, value);
-        };
-        return PhysXHingeJoint;
-    }(PhysXJoint);
+  /**
+   * Base class for character controllers.
+   */ var PhysXCharacterController = /*#__PURE__*/ function() {
+      function PhysXCharacterController() {}
+      var _proto = PhysXCharacterController.prototype;
+      /**
+     * {@inheritDoc ICharacterController.move }
+     */ _proto.move = function move(disp, minDist, elapsedTime) {
+          return this._pxController.move(disp, minDist, elapsedTime);
+      };
+      /**
+     * {@inheritDoc ICharacterController.setWorldPosition }
+     */ _proto.setWorldPosition = function setWorldPosition(position) {
+          this._pxController && this._pxController.setPosition(position);
+      };
+      /**
+     * {@inheritDoc ICharacterController.getWorldPosition }
+     */ _proto.getWorldPosition = function getWorldPosition(position) {
+          position.copyFrom(this._pxController.getPosition());
+      };
+      /**
+     * {@inheritDoc ICharacterController.setStepOffset }
+     */ _proto.setStepOffset = function setStepOffset(offset) {
+          this._pxController.setStepOffset(offset);
+      };
+      /**
+     * {@inheritDoc ICharacterController.setNonWalkableMode }
+     */ _proto.setNonWalkableMode = function setNonWalkableMode(flag) {
+          this._pxController.setNonWalkableMode(flag);
+      };
+      /**
+     * {@inheritDoc ICharacterController.setUpDirection }
+     */ _proto.setUpDirection = function setUpDirection(up) {
+          this._pxController.setUpDirection(up);
+      };
+      /**
+     * {@inheritDoc ICharacterController.setSlopeLimit }
+     */ _proto.setSlopeLimit = function setSlopeLimit(slopeLimit) {
+          this._pxController.setSlopeLimit(slopeLimit);
+      };
+      /**
+     * {@inheritDoc ICharacterController.addShape }
+     */ _proto.addShape = function addShape(shape) {
+          this._pxManager && this._createPXController(this._pxManager, shape);
+          this._shape = shape;
+          shape._controllers.add(this);
+      };
+      /**
+     * {@inheritDoc ICharacterController.removeShape }
+     */ _proto.removeShape = function removeShape(shape) {
+          this._destroyPXController();
+          this._shape = null;
+          shape._controllers.delete(this);
+      };
+      /**
+     * {@inheritDoc ICharacterController.destroy }
+     */ _proto.destroy = function destroy() {
+          this._destroyPXController();
+      };
+      /**
+     * @internal
+     */ _proto._createPXController = function _createPXController(pxManager, shape) {
+          var desc;
+          if (_instanceof__default['default'](shape, PhysXBoxColliderShape)) {
+              desc = new exports.PhysXPhysics._physX.PxBoxControllerDesc();
+              desc.halfHeight = shape._halfSize.x;
+              desc.halfSideExtent = shape._halfSize.y;
+              desc.halfForwardExtent = shape._halfSize.z;
+          } else if (_instanceof__default['default'](shape, PhysXCapsuleColliderShape)) {
+              desc = new exports.PhysXPhysics._physX.PxCapsuleControllerDesc();
+              desc.radius = shape._radius;
+              desc.height = shape._halfHeight * 2;
+              desc.climbingMode = 1; // constraint mode
+          } else {
+              throw "unsupported shape type";
+          }
+          desc.setMaterial(shape._pxMaterials[0]);
+          this._pxController = pxManager._getControllerManager().createController(desc);
+          this._pxController.setQueryFilterData(new exports.PhysXPhysics._physX.PxFilterData(shape._id, 0, 0, 0));
+      };
+      /**
+     * @internal
+     */ _proto._destroyPXController = function _destroyPXController() {
+          if (this._pxController) {
+              this._pxController.release();
+              this._pxController = null;
+          }
+      };
+      return PhysXCharacterController;
+  }();
 
-    /**
-     * a joint that maintains an upper or lower bound (or both) on the distance between two points on different objects
-     */ var PhysXSpringJoint = /*#__PURE__*/ function(PhysXJoint1) {
-        _inherits(PhysXSpringJoint, PhysXJoint1);
-        function PhysXSpringJoint(collider) {
-            var _this;
-            _this = PhysXJoint1.call(this) || this;
-            _this._swingOffset = new engine.Vector3();
-            _this._collider = collider;
-            _this._pxJoint = exports.PhysXPhysics._pxPhysics.createDistanceJoint(null, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat);
-            _this._pxJoint.setDistanceJointFlag(2, true); // enable max distance;
-            _this._pxJoint.setDistanceJointFlag(4, true); // enable min distance;
-            _this._pxJoint.setDistanceJointFlag(8, true); // enable spring;
-            return _this;
-        }
-        var _proto = PhysXSpringJoint.prototype;
-        /**
-       * {@inheritDoc ISpringJoint.setSwingOffset }
-       */ _proto.setSwingOffset = function setSwingOffset(value) {
-            this._swingOffset.copyFrom(value);
-            this._setLocalPose(1, value, PhysXJoint._defaultQuat);
-        };
-        /**
-       * {@inheritDoc ISpringJoint.setMinDistance }
-       */ _proto.setMinDistance = function setMinDistance(distance) {
-            this._pxJoint.setMinDistance(distance);
-        };
-        /**
-       * {@inheritDoc ISpringJoint.setMaxDistance }
-       */ _proto.setMaxDistance = function setMaxDistance(distance) {
-            this._pxJoint.setMaxDistance(distance);
-        };
-        /**
-       * {@inheritDoc ISpringJoint.setTolerance }
-       */ _proto.setTolerance = function setTolerance(tolerance) {
-            this._pxJoint.setTolerance(tolerance);
-        };
-        /**
-       * {@inheritDoc ISpringJoint.setStiffness }
-       */ _proto.setStiffness = function setStiffness(stiffness) {
-            this._pxJoint.setStiffness(stiffness);
-        };
-        /**
-       * {@inheritDoc ISpringJoint.setDamping }
-       */ _proto.setDamping = function setDamping(damping) {
-            this._pxJoint.setDamping(damping);
-        };
-        return PhysXSpringJoint;
-    }(PhysXJoint);
+  /**
+   * Abstract class of physical collider.
+   */ var PhysXCollider = /*#__PURE__*/ function() {
+      function PhysXCollider() {}
+      var _proto = PhysXCollider.prototype;
+      /**
+     * {@inheritDoc ICollider.addShape }
+     */ _proto.addShape = function addShape(shape) {
+          this._pxActor.attachShape(shape._pxShape);
+      };
+      /**
+     * {@inheritDoc ICollider.removeShape }
+     */ _proto.removeShape = function removeShape(shape) {
+          this._pxActor.detachShape(shape._pxShape, true);
+      };
+      /**
+     * {@inheritDoc ICollider.setWorldTransform }
+     */ _proto.setWorldTransform = function setWorldTransform(position, rotation) {
+          this._pxActor.setGlobalPose(this._transform(position, rotation), true);
+      };
+      /**
+     * {@inheritDoc ICollider.getWorldTransform }
+     */ _proto.getWorldTransform = function getWorldTransform(outPosition, outRotation) {
+          var transform = this._pxActor.getGlobalPose();
+          outPosition.set(transform.translation.x, transform.translation.y, transform.translation.z);
+          outRotation.set(transform.rotation.x, transform.rotation.y, transform.rotation.z, transform.rotation.w);
+      };
+      /**
+     * {@inheritDoc ICollider.destroy }
+     */ _proto.destroy = function destroy() {
+          this._pxActor.release();
+      };
+      /**
+     * @internal
+     */ _proto._transform = function _transform(pos, rot) {
+          var transform = PhysXCollider._tempTransform;
+          transform.translation = pos;
+          transform.rotation = rot.normalize();
+          return transform;
+      };
+      return PhysXCollider;
+  }();
+  PhysXCollider._tempTransform = {
+      translation: null,
+      rotation: null
+  };
 
-    /**
-     * High-performance unordered array, delete uses exchange method to improve performance, internal capacity only increases.
-     */ var DisorderedArray = /*#__PURE__*/ function() {
-        function DisorderedArray(count) {
-            if (count === void 0) count = 0;
-            this.length = 0;
-            this._elements = new Array(count);
-        }
-        var _proto = DisorderedArray.prototype;
-        _proto.add = function add(element) {
-            if (this.length === this._elements.length) this._elements.push(element);
-            else this._elements[this.length] = element;
-            this.length++;
-        };
-        _proto.delete = function _delete(element) {
-            //TODO: It can be optimized for custom binary search and other algorithms, currently this._elements>=this.length wastes performance.
-            var index = this._elements.indexOf(element);
-            this.deleteByIndex(index);
-        };
-        _proto.get = function get(index) {
-            if (index >= this.length) {
-                throw "Index is out of range.";
-            }
-            return this._elements[index];
-        };
-        /**
-       *
-       * @param index
-       * @returns The replaced item is used to reset its index.
-       */ _proto.deleteByIndex = function deleteByIndex(index) {
-            var elements = this._elements;
-            var end = null;
-            var lastIndex = this.length - 1;
-            if (index !== lastIndex) {
-                end = elements[lastIndex];
-                elements[index] = end;
-            }
-            this.length--;
-            return end;
-        };
-        _proto.garbageCollection = function garbageCollection() {
-            this._elements.length = this.length;
-        };
-        return DisorderedArray;
-    }();
+  var CollisionDetectionMode;
+  (function(CollisionDetectionMode) {
+      CollisionDetectionMode[CollisionDetectionMode[/** Continuous collision detection is off for this dynamic collider. */ "Discrete"] = 0] = "Discrete";
+      CollisionDetectionMode[CollisionDetectionMode[/** Continuous collision detection is on for colliding with static mesh geometry. */ "Continuous"] = 1] = "Continuous";
+      CollisionDetectionMode[CollisionDetectionMode[/** Continuous collision detection is on for colliding with static and dynamic geometry. */ "ContinuousDynamic"] = 2] = "ContinuousDynamic";
+      CollisionDetectionMode[CollisionDetectionMode[/** Speculative continuous collision detection is on for static and dynamic geometries */ "ContinuousSpeculative"] = 3] = "ContinuousSpeculative";
+  })(CollisionDetectionMode || (CollisionDetectionMode = {}));
+  /**
+   * A dynamic collider can act with self-defined movement or physical force
+   */ var PhysXDynamicCollider = /*#__PURE__*/ function(PhysXCollider) {
+      _inherits__default['default'](PhysXDynamicCollider, PhysXCollider);
+      function PhysXDynamicCollider(position, rotation) {
+          var _this;
+          _this = PhysXCollider.call(this) || this;
+          var transform = _this._transform(position, rotation);
+          _this._pxActor = exports.PhysXPhysics._pxPhysics.createRigidDynamic(transform);
+          return _this;
+      }
+      var _proto = PhysXDynamicCollider.prototype;
+      /**
+     * {@inheritDoc IDynamicCollider.setLinearDamping }
+     */ _proto.setLinearDamping = function setLinearDamping(value) {
+          this._pxActor.setLinearDamping(value);
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.setAngularDamping }
+     */ _proto.setAngularDamping = function setAngularDamping(value) {
+          this._pxActor.setAngularDamping(value);
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.setLinearVelocity }
+     */ _proto.setLinearVelocity = function setLinearVelocity(value) {
+          this._pxActor.setLinearVelocity(value, true);
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.setAngularVelocity }
+     */ _proto.setAngularVelocity = function setAngularVelocity(value) {
+          this._pxActor.setAngularVelocity(value, true);
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.setMass }
+     */ _proto.setMass = function setMass(value) {
+          this._pxActor.setMass(value);
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.setCenterOfMass }
+     */ _proto.setCenterOfMass = function setCenterOfMass(position) {
+          this._pxActor.setCMassLocalPose(position);
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.setInertiaTensor }
+     */ _proto.setInertiaTensor = function setInertiaTensor(value) {
+          this._pxActor.setMassSpaceInertiaTensor(value);
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.setMaxAngularVelocity }
+     */ _proto.setMaxAngularVelocity = function setMaxAngularVelocity(value) {
+          this._pxActor.setMaxAngularVelocity(value);
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.setMaxDepenetrationVelocity }
+     */ _proto.setMaxDepenetrationVelocity = function setMaxDepenetrationVelocity(value) {
+          this._pxActor.setMaxDepenetrationVelocity(value);
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.setSleepThreshold }
+     * @default 1e-5f * PxTolerancesScale::speed * PxTolerancesScale::speed
+     */ _proto.setSleepThreshold = function setSleepThreshold(value) {
+          this._pxActor.setSleepThreshold(value);
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.setSolverIterations }
+     */ _proto.setSolverIterations = function setSolverIterations(value) {
+          this._pxActor.setSolverIterationCounts(value, 1);
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.setCollisionDetectionMode }
+     */ _proto.setCollisionDetectionMode = function setCollisionDetectionMode(value) {
+          switch(value){
+              case 1:
+                  this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD, true);
+                  break;
+              case 2:
+                  this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, true);
+                  break;
+              case 3:
+                  this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, true);
+                  break;
+              case 0:
+                  this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD, false);
+                  this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, false);
+                  this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, false);
+                  break;
+          }
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.setIsKinematic }
+     */ _proto.setIsKinematic = function setIsKinematic(value) {
+          if (value) {
+              this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, true);
+          } else {
+              this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, false);
+          }
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.setConstraints }
+     */ _proto.setConstraints = function setConstraints(flags) {
+          this._pxActor.setRigidDynamicLockFlags(flags);
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.addForce }
+     */ _proto.addForce = function addForce(force) {
+          this._pxActor.addForce({
+              x: force.x,
+              y: force.y,
+              z: force.z
+          });
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.addTorque }
+     */ _proto.addTorque = function addTorque(torque) {
+          this._pxActor.addTorque({
+              x: torque.x,
+              y: torque.y,
+              z: torque.z
+          });
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.move }
+     */ _proto.move = function move(positionOrRotation, rotation) {
+          if (rotation) {
+              this._pxActor.setKinematicTarget(positionOrRotation, rotation);
+              return;
+          }
+          var tempTranslation = PhysXDynamicCollider._tempTranslation;
+          var tempRotation = PhysXDynamicCollider._tempRotation;
+          this.getWorldTransform(tempTranslation, tempRotation);
+          if (_instanceof__default['default'](positionOrRotation, engine.Vector3)) {
+              this._pxActor.setKinematicTarget(positionOrRotation, tempRotation);
+          } else {
+              this._pxActor.setKinematicTarget(tempTranslation, positionOrRotation);
+          }
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.sleep }
+     */ _proto.sleep = function sleep() {
+          return this._pxActor.putToSleep();
+      };
+      /**
+     * {@inheritDoc IDynamicCollider.wakeUp }
+     */ _proto.wakeUp = function wakeUp() {
+          return this._pxActor.wakeUp();
+      };
+      return PhysXDynamicCollider;
+  }(PhysXCollider);
+  PhysXDynamicCollider._tempTranslation = new engine.Vector3();
+  PhysXDynamicCollider._tempRotation = new engine.Quaternion();
 
-    var ShapeFlag;
-    (function(ShapeFlag) {
-        ShapeFlag[ShapeFlag[/** The shape will partake in collision in the physical simulation. */ "SIMULATION_SHAPE"] = 1] = "SIMULATION_SHAPE";
-        ShapeFlag[ShapeFlag[/** The shape will partake in scene queries (ray casts, overlap tests, sweeps, ...). */ "SCENE_QUERY_SHAPE"] = 2] = "SCENE_QUERY_SHAPE";
-        ShapeFlag[ShapeFlag[/** The shape is a trigger which can send reports whenever other shapes enter/leave its volume. */ "TRIGGER_SHAPE"] = 4] = "TRIGGER_SHAPE";
-    })(ShapeFlag || (ShapeFlag = {}));
-    /**
-     * Abstract class for collider shapes.
-     */ var PhysXColliderShape = /*#__PURE__*/ function() {
-        function PhysXColliderShape() {
-            /** @internal */ this._controllers = new DisorderedArray();
-            this._scale = new engine.Vector3(1, 1, 1);
-            this._position = new engine.Vector3();
-            this._rotation = null;
-            this._axis = null;
-            this._physxRotation = new engine.Quaternion();
-            this._shapeFlags = 2 | 1;
-            /** @internal */ this._pxMaterials = new Array(1);
-        }
-        var _proto = PhysXColliderShape.prototype;
-        /**
-       * {@inheritDoc IColliderShape.setRotation }
-       */ _proto.setRotation = function setRotation(value) {
-            this._rotation = value;
-            engine.Quaternion.rotationYawPitchRoll(value.x, value.y, value.z, this._physxRotation);
-            this._axis && engine.Quaternion.multiply(this._physxRotation, this._axis, this._physxRotation);
-            this._physxRotation.normalize();
-            this._setLocalPose();
-        };
-        /**
-       * {@inheritDoc IColliderShape.setPosition }
-       */ _proto.setPosition = function setPosition(value) {
-            if (value !== this._position) {
-                this._position.copyFrom(value);
-            }
-            this._setLocalPose();
-        };
-        /**
-       * {@inheritDoc IColliderShape.setContactOffset }
-       * @default 0.02f * PxTolerancesScale::length
-       */ _proto.setContactOffset = function setContactOffset(offset) {
-            this._pxShape.setContactOffset(offset);
-            var controllers = this._controllers;
-            for(var i = 0, n = controllers.length; i < n; i++){
-                controllers.get(i)._pxController.setContactOffset(offset);
-            }
-        };
-        /**
-       * {@inheritDoc IColliderShape.setMaterial }
-       */ _proto.setMaterial = function setMaterial(value) {
-            this._pxMaterials[0] = value._pxMaterial;
-            this._pxShape.setMaterials(this._pxMaterials);
-        };
-        /**
-       * {@inheritDoc IColliderShape.setIsTrigger }
-       */ _proto.setIsTrigger = function setIsTrigger(value) {
-            this._modifyFlag(1, !value);
-            this._modifyFlag(4, value);
-            this._setShapeFlags(this._shapeFlags);
-        };
-        /**
-       * {@inheritDoc IColliderShape.destroy }
-       */ _proto.destroy = function destroy() {
-            this._pxShape.release();
-        };
-        /**
-       *  @internal
-       */ _proto._setShapeFlags = function _setShapeFlags(flags) {
-            this._shapeFlags = flags;
-            this._pxShape.setFlags(new exports.PhysXPhysics._physX.PxShapeFlags(this._shapeFlags));
-        };
-        _proto._setLocalPose = function _setLocalPose() {
-            var transform = PhysXColliderShape.transform;
-            engine.Vector3.multiply(this._position, this._scale, transform.translation);
-            transform.rotation = this._physxRotation;
-            this._pxShape.setLocalPose(transform);
-        };
-        _proto._initialize = function _initialize(material, id) {
-            this._id = id;
-            this._pxMaterials[0] = material._pxMaterial;
-            this._pxShape = exports.PhysXPhysics._pxPhysics.createShape(this._pxGeometry, material._pxMaterial, true, new exports.PhysXPhysics._physX.PxShapeFlags(this._shapeFlags));
-            this._pxShape.setQueryFilterData(new exports.PhysXPhysics._physX.PxFilterData(id, 0, 0, 0));
-        };
-        _proto._modifyFlag = function _modifyFlag(flag, value) {
-            this._shapeFlags = value ? this._shapeFlags | flag : this._shapeFlags & ~flag;
-        };
-        return PhysXColliderShape;
-    }();
-    (function() {
-        PhysXColliderShape.halfSqrt = 0.70710678118655;
-    })();
-    (function() {
-        PhysXColliderShape.transform = {
-            translation: new engine.Vector3(),
-            rotation: null
-        };
-    })();
+  /**
+   * A manager is a collection of colliders and constraints which can interact.
+   */ var PhysXPhysicsManager = /*#__PURE__*/ function() {
+      function PhysXPhysicsManager(onContactEnter, onContactExit, onContactStay, onTriggerEnter, onTriggerExit, onTriggerStay) {
+          var _this = this;
+          /** @internal */ this._pxControllerManager = null;
+          this._currentEvents = new DisorderedArray();
+          this._eventMap = {};
+          this._eventPool = [];
+          this._onContactEnter = onContactEnter;
+          this._onContactExit = onContactExit;
+          this._onContactStay = onContactStay;
+          this._onTriggerEnter = onTriggerEnter;
+          this._onTriggerExit = onTriggerExit;
+          this._onTriggerStay = onTriggerStay;
+          var triggerCallback = {
+              onContactBegin: function(obj1, obj2) {
+                  var index1 = obj1.getQueryFilterData().word0;
+                  var index2 = obj2.getQueryFilterData().word0;
+                  _this._onContactEnter(index1, index2);
+              },
+              onContactEnd: function(obj1, obj2) {
+                  var index1 = obj1.getQueryFilterData().word0;
+                  var index2 = obj2.getQueryFilterData().word0;
+                  _this._onContactExit(index1, index2);
+              },
+              onContactPersist: function(obj1, obj2) {
+                  var index1 = obj1.getQueryFilterData().word0;
+                  var index2 = obj2.getQueryFilterData().word0;
+                  _this._onContactStay(index1, index2);
+              },
+              onTriggerBegin: function(obj1, obj2) {
+                  var index1 = obj1.getQueryFilterData().word0;
+                  var index2 = obj2.getQueryFilterData().word0;
+                  var event = index1 < index2 ? _this._getTrigger(index1, index2) : _this._getTrigger(index2, index1);
+                  event.state = 0;
+                  _this._currentEvents.add(event);
+              },
+              onTriggerEnd: function(obj1, obj2) {
+                  var index1 = obj1.getQueryFilterData().word0;
+                  var index2 = obj2.getQueryFilterData().word0;
+                  var event;
+                  if (index1 < index2) {
+                      var subMap = _this._eventMap[index1];
+                      event = subMap[index2];
+                      subMap[index2] = undefined;
+                  } else {
+                      var subMap1 = _this._eventMap[index2];
+                      event = subMap1[index1];
+                      subMap1[index1] = undefined;
+                  }
+                  event.state = 2;
+              }
+          };
+          var PHYSXSimulationCallbackInstance = exports.PhysXPhysics._physX.PxSimulationEventCallback.implement(triggerCallback);
+          var sceneDesc = exports.PhysXPhysics._physX.getDefaultSceneDesc(exports.PhysXPhysics._pxPhysics.getTolerancesScale(), 0, PHYSXSimulationCallbackInstance);
+          this._pxScene = exports.PhysXPhysics._pxPhysics.createScene(sceneDesc);
+      }
+      var _proto = PhysXPhysicsManager.prototype;
+      /**
+     * {@inheritDoc IPhysicsManager.setGravity }
+     */ _proto.setGravity = function setGravity(value) {
+          this._pxScene.setGravity(value);
+      };
+      /**
+     * {@inheritDoc IPhysicsManager.addColliderShape }
+     */ _proto.addColliderShape = function addColliderShape(colliderShape) {
+          this._eventMap[colliderShape._id] = {};
+      };
+      /**
+     * {@inheritDoc IPhysicsManager.removeColliderShape }
+     */ _proto.removeColliderShape = function removeColliderShape(colliderShape) {
+          var _this = this, eventPool = _this._eventPool, currentEvents = _this._currentEvents;
+          var shapeID = colliderShape._id;
+          for(var i = currentEvents.length - 1; i >= 0; i--){
+              var event = currentEvents.get(i);
+              if (event.index1 == shapeID || event.index2 == shapeID) {
+                  currentEvents.deleteByIndex(i);
+                  eventPool.push(event);
+              }
+          }
+          delete this._eventMap[shapeID];
+      };
+      /**
+     * {@inheritDoc IPhysicsManager.addCollider }
+     */ _proto.addCollider = function addCollider(collider) {
+          this._pxScene.addActor(collider._pxActor, null);
+      };
+      /**
+     * {@inheritDoc IPhysicsManager.removeCollider }
+     */ _proto.removeCollider = function removeCollider(collider) {
+          this._pxScene.removeActor(collider._pxActor, true);
+      };
+      /**
+     * {@inheritDoc IPhysicsManager.addCharacterController }
+     */ _proto.addCharacterController = function addCharacterController(characterController) {
+          // Physx have no API to remove/readd cct into scene.
+          if (!characterController._pxController) {
+              var shape = characterController._shape;
+              if (shape) {
+                  var lastPXManager = characterController._pxManager;
+                  if (lastPXManager !== this) {
+                      lastPXManager && characterController._destroyPXController();
+                      characterController._createPXController(this, shape);
+                  }
+              }
+          }
+          characterController._pxManager = this;
+      };
+      /**
+     * {@inheritDoc IPhysicsManager.removeCharacterController }
+     */ _proto.removeCharacterController = function removeCharacterController(characterController) {
+          characterController._pxManager = null;
+      };
+      /**
+     * {@inheritDoc IPhysicsManager.update }
+     */ _proto.update = function update(elapsedTime) {
+          this._simulate(elapsedTime);
+          this._fetchResults();
+          this._fireEvent();
+      };
+      /**
+     * {@inheritDoc IPhysicsManager.raycast }
+     */ _proto.raycast = function raycast(ray, distance, onRaycast, hit) {
+          var pxHitResult = PhysXPhysicsManager._pxRaycastHit;
+          distance = Math.min(distance, 3.4e38); // float32 max value limit in physx raycast.
+          var raycastCallback = {
+              preFilter: function(filterData, shape, actor) {
+                  var index = shape.getQueryFilterData().word0;
+                  if (onRaycast(index)) {
+                      return 2; // eBLOCK
+                  } else {
+                      return 0; // eNONE
+                  }
+              },
+              postFilter: function(filterData, hit) {}
+          };
+          var result = this._pxScene.raycastSingle(ray.origin, ray.direction, distance, pxHitResult, PhysXPhysicsManager._pxFilterData, exports.PhysXPhysics._physX.PxQueryFilterCallback.implement(raycastCallback));
+          if (result && hit != undefined) {
+              var position = PhysXPhysicsManager._tempPosition, normal = PhysXPhysicsManager._tempNormal;
+              var pxPosition = pxHitResult.position, pxNormal = pxHitResult.normal;
+              position.set(pxPosition.x, pxPosition.y, pxPosition.z);
+              normal.set(pxNormal.x, pxNormal.y, pxNormal.z);
+              hit(pxHitResult.getShape().getQueryFilterData().word0, pxHitResult.distance, position, normal);
+          }
+          return result;
+      };
+      /**
+     * @internal
+     */ _proto._getControllerManager = function _getControllerManager() {
+          var pxControllerManager = this._pxControllerManager;
+          if (pxControllerManager === null) {
+              this._pxControllerManager = pxControllerManager = this._pxScene.createControllerManager();
+          }
+          return pxControllerManager;
+      };
+      _proto._simulate = function _simulate(elapsedTime) {
+          this._pxScene.simulate(elapsedTime, true);
+      };
+      _proto._fetchResults = function _fetchResults(block) {
+          if (block === void 0) block = true;
+          this._pxScene.fetchResults(block);
+      };
+      _proto._getTrigger = function _getTrigger(index1, index2) {
+          var event;
+          if (this._eventPool.length) {
+              event = this._eventPool.pop();
+              event.index1 = index1;
+              event.index2 = index2;
+          } else {
+              event = new TriggerEvent(index1, index2);
+          }
+          this._eventMap[index1][index2] = event;
+          return event;
+      };
+      _proto._fireEvent = function _fireEvent() {
+          var _this = this, eventPool = _this._eventPool, currentEvents = _this._currentEvents;
+          for(var i = currentEvents.length - 1; i >= 0; i--){
+              var event = currentEvents.get(i);
+              if (event.state == 0) {
+                  this._onTriggerEnter(event.index1, event.index2);
+                  event.state = 1;
+              } else if (event.state == 1) {
+                  this._onTriggerStay(event.index1, event.index2);
+              } else if (event.state == 2) {
+                  this._onTriggerExit(event.index1, event.index2);
+                  currentEvents.deleteByIndex(i);
+                  eventPool.push(event);
+              }
+          }
+      };
+      PhysXPhysicsManager._init = function _init() {
+          PhysXPhysicsManager._pxRaycastHit = new exports.PhysXPhysics._physX.PxRaycastHit();
+          PhysXPhysicsManager._pxFilterData = new exports.PhysXPhysics._physX.PxQueryFilterData();
+          PhysXPhysicsManager._pxFilterData.flags = new exports.PhysXPhysics._physX.PxQueryFlags(1 | 2 | 4);
+      };
+      return PhysXPhysicsManager;
+  }();
+  PhysXPhysicsManager._tempPosition = new engine.Vector3();
+  PhysXPhysicsManager._tempNormal = new engine.Vector3();
+  var /**
+   * Filtering flags for scene queries.
+   */ QueryFlag;
+  (function(QueryFlag) {
+      QueryFlag[QueryFlag["STATIC"] = 1] = "STATIC";
+      QueryFlag[QueryFlag["DYNAMIC"] = 2] = "DYNAMIC";
+      QueryFlag[QueryFlag["PRE_FILTER"] = 4] = "PRE_FILTER";
+      QueryFlag[QueryFlag["POST_FILTER"] = 8] = "POST_FILTER";
+      QueryFlag[QueryFlag["ANY_HIT"] = 16] = "ANY_HIT";
+      QueryFlag[QueryFlag["NO_BLOCK"] = 32] = "NO_BLOCK";
+  })(QueryFlag || (QueryFlag = {}));
+  var /**
+   * Physics state
+   */ TriggerEventState;
+  (function(TriggerEventState) {
+      TriggerEventState[TriggerEventState["Enter"] = 0] = "Enter";
+      TriggerEventState[TriggerEventState["Stay"] = 1] = "Stay";
+      TriggerEventState[TriggerEventState["Exit"] = 2] = "Exit";
+  })(TriggerEventState || (TriggerEventState = {}));
+  /**
+   * Trigger event to store interactive object ids and state.
+   */ var TriggerEvent = function TriggerEvent(index1, index2) {
+      this.index1 = index1;
+      this.index2 = index2;
+  };
 
-    /**
-     * Box collider shape in PhysX.
-     */ var PhysXBoxColliderShape = /*#__PURE__*/ function(PhysXColliderShape) {
-        _inherits(PhysXBoxColliderShape, PhysXColliderShape);
-        function PhysXBoxColliderShape(uniqueID, size, material) {
-            var _this;
-            _this = PhysXColliderShape.call(this) || this;
-            /** @internal */ _this._halfSize = new engine.Vector3();
-            _this._halfSize.set(size.x * 0.5, size.y * 0.5, size.z * 0.5);
-            _this._pxGeometry = new exports.PhysXPhysics._physX.PxBoxGeometry(_this._halfSize.x * _this._scale.x, _this._halfSize.y * _this._scale.y, _this._halfSize.z * _this._scale.z);
-            _this._initialize(material, uniqueID);
-            _this._setLocalPose();
-            return _this;
-        }
-        var _proto = PhysXBoxColliderShape.prototype;
-        /**
-       * {@inheritDoc IBoxColliderShape.setSize }
-       */ _proto.setSize = function setSize(value) {
-            this._halfSize.set(value.x * 0.5, value.y * 0.5, value.z * 0.5);
-            engine.Vector3.multiply(this._halfSize, this._scale, PhysXBoxColliderShape._tempHalfExtents);
-            this._pxGeometry.halfExtents = PhysXBoxColliderShape._tempHalfExtents;
-            this._pxShape.setGeometry(this._pxGeometry);
-            var controllers = this._controllers;
-            for(var i = 0, n = controllers.length; i < n; i++){
-                var pxController = controllers.get(i)._pxController;
-                pxController.setHalfHeight(this._halfSize.x);
-                pxController.setHalfSideExtent(this._halfSize.y);
-                pxController.setHalfForwardExtent(this._halfSize.z);
-            }
-        };
-        /**
-       * {@inheritDoc IColliderShape.setWorldScale }
-       */ _proto.setWorldScale = function setWorldScale(scale) {
-            this._scale.copyFrom(scale);
-            this._setLocalPose();
-            engine.Vector3.multiply(this._halfSize, this._scale, PhysXBoxColliderShape._tempHalfExtents);
-            this._pxGeometry.halfExtents = PhysXBoxColliderShape._tempHalfExtents;
-            this._pxShape.setGeometry(this._pxGeometry);
-        };
-        return PhysXBoxColliderShape;
-    }(PhysXColliderShape);
-    (function() {
-        PhysXBoxColliderShape._tempHalfExtents = new engine.Vector3();
-    })();
+  /**
+   * Physics material describes how to handle colliding objects (friction, bounciness).
+   */ var PhysXPhysicsMaterial = /*#__PURE__*/ function() {
+      function PhysXPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine) {
+          var pxMaterial = exports.PhysXPhysics._pxPhysics.createMaterial(staticFriction, dynamicFriction, bounciness);
+          pxMaterial.setFrictionCombineMode(frictionCombine);
+          pxMaterial.setRestitutionCombineMode(bounceCombine);
+          this._pxMaterial = pxMaterial;
+      }
+      var _proto = PhysXPhysicsMaterial.prototype;
+      /**
+     * {@inheritDoc IPhysicsMaterial.setBounciness }
+     */ _proto.setBounciness = function setBounciness(value) {
+          this._pxMaterial.setRestitution(value);
+      };
+      /**
+     * {@inheritDoc IPhysicsMaterial.setDynamicFriction }
+     */ _proto.setDynamicFriction = function setDynamicFriction(value) {
+          this._pxMaterial.setDynamicFriction(value);
+      };
+      /**
+     * {@inheritDoc IPhysicsMaterial.setStaticFriction }
+     */ _proto.setStaticFriction = function setStaticFriction(value) {
+          this._pxMaterial.setStaticFriction(value);
+      };
+      /**
+     * {@inheritDoc IPhysicsMaterial.setBounceCombine }
+     */ _proto.setBounceCombine = function setBounceCombine(value) {
+          this._pxMaterial.setRestitutionCombineMode(value);
+      };
+      /**
+     * {@inheritDoc IPhysicsMaterial.setFrictionCombine }
+     */ _proto.setFrictionCombine = function setFrictionCombine(value) {
+          this._pxMaterial.setFrictionCombineMode(value);
+      };
+      /**
+     * {@inheritDoc IPhysicsMaterial.destroy }
+     */ _proto.destroy = function destroy() {
+          this._pxMaterial.release();
+      };
+      return PhysXPhysicsMaterial;
+  }();
+  var /**
+   * Describes how physics materials of the colliding objects are combined.
+   */ CombineMode;
+  (function(CombineMode) {
+      CombineMode[CombineMode[/** Averages the friction/bounce of the two colliding materials. */ "Average"] = 0] = "Average";
+      CombineMode[CombineMode[/** Uses the smaller friction/bounce of the two colliding materials. */ "Minimum"] = 1] = "Minimum";
+      CombineMode[CombineMode[/** Multiplies the friction/bounce of the two colliding materials. */ "Multiply"] = 2] = "Multiply";
+      CombineMode[CombineMode[/** Uses the larger friction/bounce of the two colliding materials. */ "Maximum"] = 3] = "Maximum";
+  })(CombineMode || (CombineMode = {}));
 
-    /**
-     * Capsule collider shape in PhysX.
-     */ var PhysXCapsuleColliderShape = /*#__PURE__*/ function(PhysXColliderShape1) {
-        _inherits(PhysXCapsuleColliderShape, PhysXColliderShape1);
-        function PhysXCapsuleColliderShape(uniqueID, radius, height, material) {
-            var _this;
-            _this = PhysXColliderShape1.call(this) || this;
-            _this._upAxis = /** Up axis is Y. */ 1;
-            _this._radius = radius;
-            _this._halfHeight = height * 0.5;
-            _this._axis = new engine.Quaternion(0, 0, PhysXColliderShape.halfSqrt, PhysXColliderShape.halfSqrt);
-            _this._physxRotation.copyFrom(_this._axis);
-            _this._pxGeometry = new exports.PhysXPhysics._physX.PxCapsuleGeometry(_this._radius, _this._halfHeight);
-            _this._initialize(material, uniqueID);
-            _this._setLocalPose();
-            return _this;
-        }
-        var _proto = PhysXCapsuleColliderShape.prototype;
-        /**
-       * {@inheritDoc ICapsuleColliderShape.setRadius }
-       */ _proto.setRadius = function setRadius(value) {
-            this._radius = value;
-            switch(this._upAxis){
-                case /** Up axis is X. */ 0:
-                    this._pxGeometry.radius = this._radius * Math.max(this._scale.y, this._scale.z);
-                    break;
-                case 1:
-                    this._pxGeometry.radius = this._radius * Math.max(this._scale.x, this._scale.z);
-                    break;
-                case /** Up axis is Z. */ 2:
-                    this._pxGeometry.radius = this._radius * Math.max(this._scale.x, this._scale.y);
-                    break;
-            }
-            this._pxShape.setGeometry(this._pxGeometry);
-            var controllers = this._controllers;
-            for(var i = 0, n = controllers.length; i < n; i++){
-                controllers.get(i)._pxController.setRadius(value);
-            }
-        };
-        /**
-       * {@inheritDoc ICapsuleColliderShape.setHeight }
-       */ _proto.setHeight = function setHeight(value) {
-            this._halfHeight = value * 0.5;
-            switch(this._upAxis){
-                case 0:
-                    this._pxGeometry.halfHeight = this._halfHeight * this._scale.x;
-                    break;
-                case 1:
-                    this._pxGeometry.halfHeight = this._halfHeight * this._scale.y;
-                    break;
-                case 2:
-                    this._pxGeometry.halfHeight = this._halfHeight * this._scale.z;
-                    break;
-            }
-            this._pxShape.setGeometry(this._pxGeometry);
-            var controllers = this._controllers;
-            for(var i = 0, n = controllers.length; i < n; i++){
-                controllers.get(i)._pxController.setHeight(value);
-            }
-        };
-        /**
-       * {@inheritDoc ICapsuleColliderShape.setUpAxis }
-       */ _proto.setUpAxis = function setUpAxis(upAxis) {
-            var _this = this, rotation = _this._rotation, axis = _this._axis, physxRotation = _this._physxRotation;
-            this._upAxis = upAxis;
-            switch(this._upAxis){
-                case 0:
-                    axis.set(0, 0, 0, 1);
-                    break;
-                case 1:
-                    axis.set(0, 0, PhysXColliderShape.halfSqrt, PhysXColliderShape.halfSqrt);
-                    break;
-                case 2:
-                    axis.set(0, PhysXColliderShape.halfSqrt, 0, PhysXColliderShape.halfSqrt);
-                    break;
-            }
-            if (rotation) {
-                engine.Quaternion.rotationYawPitchRoll(rotation.x, rotation.y, rotation.z, physxRotation);
-                engine.Quaternion.multiply(physxRotation, axis, physxRotation);
-            } else {
-                physxRotation.copyFrom(axis);
-            }
-            this._setLocalPose();
-        };
-        /**
-       * {@inheritDoc IColliderShape.setWorldScale }
-       */ _proto.setWorldScale = function setWorldScale(scale) {
-            this._scale.copyFrom(scale);
-            this._setLocalPose();
-            switch(this._upAxis){
-                case 0:
-                    this._pxGeometry.radius = this._radius * Math.max(scale.y, scale.z);
-                    this._pxGeometry.halfHeight = this._halfHeight * scale.x;
-                    break;
-                case 1:
-                    this._pxGeometry.radius = this._radius * Math.max(scale.x, scale.z);
-                    this._pxGeometry.halfHeight = this._halfHeight * scale.y;
-                    break;
-                case 2:
-                    this._pxGeometry.radius = this._radius * Math.max(scale.x, scale.y);
-                    this._pxGeometry.halfHeight = this._halfHeight * scale.z;
-                    break;
-            }
-            this._pxShape.setGeometry(this._pxGeometry);
-        };
-        return PhysXCapsuleColliderShape;
-    }(PhysXColliderShape);
-    var /**
-     * The up axis of the collider shape.
-     */ ColliderShapeUpAxis;
-    (function(ColliderShapeUpAxis) {
-        ColliderShapeUpAxis[ColliderShapeUpAxis["X"] = 0] = "X";
-        ColliderShapeUpAxis[ColliderShapeUpAxis["Y"] = 1] = "Y";
-        ColliderShapeUpAxis[ColliderShapeUpAxis["Z"] = 2] = "Z";
-    })(ColliderShapeUpAxis || (ColliderShapeUpAxis = {}));
+  /**
+   * A static collider component that will not move.
+   * @remarks Mostly used for object which always stays at the same place and never moves around.
+   */ var PhysXStaticCollider = /*#__PURE__*/ function(PhysXCollider) {
+      _inherits__default['default'](PhysXStaticCollider, PhysXCollider);
+      function PhysXStaticCollider(position, rotation) {
+          var _this;
+          _this = PhysXCollider.call(this) || this;
+          _this._pxActor = exports.PhysXPhysics._pxPhysics.createRigidStatic(_this._transform(position, rotation));
+          return _this;
+      }
+      return PhysXStaticCollider;
+  }(PhysXCollider);
 
-    /**
-     * Base class for character controllers.
-     */ var PhysXCharacterController = /*#__PURE__*/ function() {
-        function PhysXCharacterController() {}
-        var _proto = PhysXCharacterController.prototype;
-        /**
-       * {@inheritDoc ICharacterController.move }
-       */ _proto.move = function move(disp, minDist, elapsedTime) {
-            return this._pxController.move(disp, minDist, elapsedTime);
-        };
-        /**
-       * {@inheritDoc ICharacterController.setWorldPosition }
-       */ _proto.setWorldPosition = function setWorldPosition(position) {
-            this._pxController && this._pxController.setPosition(position);
-        };
-        /**
-       * {@inheritDoc ICharacterController.getWorldPosition }
-       */ _proto.getWorldPosition = function getWorldPosition(position) {
-            position.copyFrom(this._pxController.getPosition());
-        };
-        /**
-       * {@inheritDoc ICharacterController.setStepOffset }
-       */ _proto.setStepOffset = function setStepOffset(offset) {
-            this._pxController.setStepOffset(offset);
-        };
-        /**
-       * {@inheritDoc ICharacterController.setNonWalkableMode }
-       */ _proto.setNonWalkableMode = function setNonWalkableMode(flag) {
-            this._pxController.setNonWalkableMode(flag);
-        };
-        /**
-       * {@inheritDoc ICharacterController.setUpDirection }
-       */ _proto.setUpDirection = function setUpDirection(up) {
-            this._pxController.setUpDirection(up);
-        };
-        /**
-       * {@inheritDoc ICharacterController.setSlopeLimit }
-       */ _proto.setSlopeLimit = function setSlopeLimit(slopeLimit) {
-            this._pxController.setSlopeLimit(slopeLimit);
-        };
-        /**
-       * {@inheritDoc ICharacterController.addShape }
-       */ _proto.addShape = function addShape(shape) {
-            this._pxManager && this._createPXController(this._pxManager, shape);
-            this._shape = shape;
-            shape._controllers.add(this);
-        };
-        /**
-       * {@inheritDoc ICharacterController.removeShape }
-       */ _proto.removeShape = function removeShape(shape) {
-            this._destroyPXController();
-            this._shape = null;
-            shape._controllers.delete(this);
-        };
-        /**
-       * {@inheritDoc ICharacterController.destroy }
-       */ _proto.destroy = function destroy() {
-            this._destroyPXController();
-        };
-        /**
-       * @internal
-       */ _proto._createPXController = function _createPXController(pxManager, shape) {
-            var desc;
-            if (_instanceof(shape, PhysXBoxColliderShape)) {
-                desc = new exports.PhysXPhysics._physX.PxBoxControllerDesc();
-                desc.halfHeight = shape._halfSize.x;
-                desc.halfSideExtent = shape._halfSize.y;
-                desc.halfForwardExtent = shape._halfSize.z;
-            } else if (_instanceof(shape, PhysXCapsuleColliderShape)) {
-                desc = new exports.PhysXPhysics._physX.PxCapsuleControllerDesc();
-                desc.radius = shape._radius;
-                desc.height = shape._halfHeight * 2;
-                desc.climbingMode = 1; // constraint mode
-            } else {
-                throw "unsupported shape type";
-            }
-            desc.setMaterial(shape._pxMaterials[0]);
-            this._pxController = pxManager._getControllerManager().createController(desc);
-            this._pxController.setQueryFilterData(new exports.PhysXPhysics._physX.PxFilterData(shape._id, 0, 0, 0));
-        };
-        /**
-       * @internal
-       */ _proto._destroyPXController = function _destroyPXController() {
-            if (this._pxController) {
-                this._pxController.release();
-                this._pxController = null;
-            }
-        };
-        return PhysXCharacterController;
-    }();
+  /**
+   * Plane collider shape in PhysX.
+   */ var PhysXPlaneColliderShape = /*#__PURE__*/ function(PhysXColliderShape1) {
+      _inherits__default['default'](PhysXPlaneColliderShape, PhysXColliderShape1);
+      function PhysXPlaneColliderShape(uniqueID, material) {
+          var _this;
+          _this = PhysXColliderShape1.call(this) || this;
+          _this._axis = new engine.Quaternion(0, 0, PhysXColliderShape.halfSqrt, PhysXColliderShape.halfSqrt);
+          _this._physxRotation.copyFrom(_this._axis);
+          _this._pxGeometry = new exports.PhysXPhysics._physX.PxPlaneGeometry();
+          _this._initialize(material, uniqueID);
+          _this._setLocalPose();
+          return _this;
+      }
+      var _proto = PhysXPlaneColliderShape.prototype;
+      /**
+     * {@inheritDoc IColliderShape.setWorldScale }
+     */ _proto.setWorldScale = function setWorldScale(scale) {
+          this._scale.copyFrom(scale);
+          this._setLocalPose();
+      };
+      return PhysXPlaneColliderShape;
+  }(PhysXColliderShape);
 
-    /**
-     * Abstract class of physical collider.
-     */ var PhysXCollider = /*#__PURE__*/ function() {
-        function PhysXCollider() {}
-        var _proto = PhysXCollider.prototype;
-        /**
-       * {@inheritDoc ICollider.addShape }
-       */ _proto.addShape = function addShape(shape) {
-            this._pxActor.attachShape(shape._pxShape);
-        };
-        /**
-       * {@inheritDoc ICollider.removeShape }
-       */ _proto.removeShape = function removeShape(shape) {
-            this._pxActor.detachShape(shape._pxShape, true);
-        };
-        /**
-       * {@inheritDoc ICollider.setWorldTransform }
-       */ _proto.setWorldTransform = function setWorldTransform(position, rotation) {
-            this._pxActor.setGlobalPose(this._transform(position, rotation), true);
-        };
-        /**
-       * {@inheritDoc ICollider.getWorldTransform }
-       */ _proto.getWorldTransform = function getWorldTransform(outPosition, outRotation) {
-            var transform = this._pxActor.getGlobalPose();
-            outPosition.set(transform.translation.x, transform.translation.y, transform.translation.z);
-            outRotation.set(transform.rotation.x, transform.rotation.y, transform.rotation.z, transform.rotation.w);
-        };
-        /**
-       * {@inheritDoc ICollider.destroy }
-       */ _proto.destroy = function destroy() {
-            this._pxActor.release();
-        };
-        /**
-       * @internal
-       */ _proto._transform = function _transform(pos, rot) {
-            var transform = PhysXCollider._tempTransform;
-            transform.translation = pos;
-            transform.rotation = rot.normalize();
-            return transform;
-        };
-        return PhysXCollider;
-    }();
-    (function() {
-        PhysXCollider._tempTransform = {
-            translation: null,
-            rotation: null
-        };
-    })();
+  /**
+   * Sphere collider shape in PhysX.
+   */ var PhysXSphereColliderShape = /*#__PURE__*/ function(PhysXColliderShape) {
+      _inherits__default['default'](PhysXSphereColliderShape, PhysXColliderShape);
+      function PhysXSphereColliderShape(uniqueID, radius, material) {
+          var _this;
+          _this = PhysXColliderShape.call(this) || this;
+          _this._maxScale = 1;
+          _this._radius = radius;
+          _this._pxGeometry = new exports.PhysXPhysics._physX.PxSphereGeometry(_this._radius * _this._maxScale);
+          _this._initialize(material, uniqueID);
+          _this._setLocalPose();
+          return _this;
+      }
+      var _proto = PhysXSphereColliderShape.prototype;
+      /**
+     * {@inheritDoc ISphereColliderShape.setRadius }
+     */ _proto.setRadius = function setRadius(value) {
+          this._radius = value;
+          this._pxGeometry.radius = value * this._maxScale;
+          this._pxShape.setGeometry(this._pxGeometry);
+      };
+      /**
+     * {@inheritDoc IColliderShape.setWorldScale }
+     */ _proto.setWorldScale = function setWorldScale(scale) {
+          this._scale.copyFrom(scale);
+          this._setLocalPose();
+          this._maxScale = Math.max(scale.x, Math.max(scale.x, scale.y));
+          this._pxGeometry.radius = this._radius * this._maxScale;
+          this._pxShape.setGeometry(this._pxGeometry);
+      };
+      return PhysXSphereColliderShape;
+  }(PhysXColliderShape);
 
-    var CollisionDetectionMode;
-    (function(CollisionDetectionMode) {
-        CollisionDetectionMode[CollisionDetectionMode[/** Continuous collision detection is off for this dynamic collider. */ "Discrete"] = 0] = "Discrete";
-        CollisionDetectionMode[CollisionDetectionMode[/** Continuous collision detection is on for colliding with static mesh geometry. */ "Continuous"] = 1] = "Continuous";
-        CollisionDetectionMode[CollisionDetectionMode[/** Continuous collision detection is on for colliding with static and dynamic geometry. */ "ContinuousDynamic"] = 2] = "ContinuousDynamic";
-        CollisionDetectionMode[CollisionDetectionMode[/** Speculative continuous collision detection is on for static and dynamic geometries */ "ContinuousSpeculative"] = 3] = "ContinuousSpeculative";
-    })(CollisionDetectionMode || (CollisionDetectionMode = {}));
-    /**
-     * A dynamic collider can act with self-defined movement or physical force
-     */ var PhysXDynamicCollider = /*#__PURE__*/ function(PhysXCollider) {
-        _inherits(PhysXDynamicCollider, PhysXCollider);
-        function PhysXDynamicCollider(position, rotation) {
-            var _this;
-            _this = PhysXCollider.call(this) || this;
-            var transform = _this._transform(position, rotation);
-            _this._pxActor = exports.PhysXPhysics._pxPhysics.createRigidDynamic(transform);
-            return _this;
-        }
-        var _proto = PhysXDynamicCollider.prototype;
-        /**
-       * {@inheritDoc IDynamicCollider.setLinearDamping }
-       */ _proto.setLinearDamping = function setLinearDamping(value) {
-            this._pxActor.setLinearDamping(value);
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.setAngularDamping }
-       */ _proto.setAngularDamping = function setAngularDamping(value) {
-            this._pxActor.setAngularDamping(value);
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.setLinearVelocity }
-       */ _proto.setLinearVelocity = function setLinearVelocity(value) {
-            this._pxActor.setLinearVelocity(value, true);
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.setAngularVelocity }
-       */ _proto.setAngularVelocity = function setAngularVelocity(value) {
-            this._pxActor.setAngularVelocity(value, true);
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.setMass }
-       */ _proto.setMass = function setMass(value) {
-            this._pxActor.setMass(value);
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.setCenterOfMass }
-       */ _proto.setCenterOfMass = function setCenterOfMass(position) {
-            this._pxActor.setCMassLocalPose(position);
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.setInertiaTensor }
-       */ _proto.setInertiaTensor = function setInertiaTensor(value) {
-            this._pxActor.setMassSpaceInertiaTensor(value);
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.setMaxAngularVelocity }
-       */ _proto.setMaxAngularVelocity = function setMaxAngularVelocity(value) {
-            this._pxActor.setMaxAngularVelocity(value);
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.setMaxDepenetrationVelocity }
-       */ _proto.setMaxDepenetrationVelocity = function setMaxDepenetrationVelocity(value) {
-            this._pxActor.setMaxDepenetrationVelocity(value);
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.setSleepThreshold }
-       * @default 1e-5f * PxTolerancesScale::speed * PxTolerancesScale::speed
-       */ _proto.setSleepThreshold = function setSleepThreshold(value) {
-            this._pxActor.setSleepThreshold(value);
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.setSolverIterations }
-       */ _proto.setSolverIterations = function setSolverIterations(value) {
-            this._pxActor.setSolverIterationCounts(value, 1);
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.setCollisionDetectionMode }
-       */ _proto.setCollisionDetectionMode = function setCollisionDetectionMode(value) {
-            switch(value){
-                case 1:
-                    this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD, true);
-                    break;
-                case 2:
-                    this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, true);
-                    break;
-                case 3:
-                    this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, true);
-                    break;
-                case 0:
-                    this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD, false);
-                    this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, false);
-                    this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, false);
-                    break;
-            }
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.setIsKinematic }
-       */ _proto.setIsKinematic = function setIsKinematic(value) {
-            if (value) {
-                this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, true);
-            } else {
-                this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, false);
-            }
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.setConstraints }
-       */ _proto.setConstraints = function setConstraints(flags) {
-            this._pxActor.setRigidDynamicLockFlags(flags);
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.addForce }
-       */ _proto.addForce = function addForce(force) {
-            this._pxActor.addForce({
-                x: force.x,
-                y: force.y,
-                z: force.z
-            });
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.addTorque }
-       */ _proto.addTorque = function addTorque(torque) {
-            this._pxActor.addTorque({
-                x: torque.x,
-                y: torque.y,
-                z: torque.z
-            });
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.move }
-       */ _proto.move = function move(positionOrRotation, rotation) {
-            if (rotation) {
-                this._pxActor.setKinematicTarget(positionOrRotation, rotation);
-                return;
-            }
-            var tempTranslation = PhysXDynamicCollider._tempTranslation;
-            var tempRotation = PhysXDynamicCollider._tempRotation;
-            this.getWorldTransform(tempTranslation, tempRotation);
-            if (_instanceof(positionOrRotation, engine.Vector3)) {
-                this._pxActor.setKinematicTarget(positionOrRotation, tempRotation);
-            } else {
-                this._pxActor.setKinematicTarget(tempTranslation, positionOrRotation);
-            }
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.sleep }
-       */ _proto.sleep = function sleep() {
-            return this._pxActor.putToSleep();
-        };
-        /**
-       * {@inheritDoc IDynamicCollider.wakeUp }
-       */ _proto.wakeUp = function wakeUp() {
-            return this._pxActor.wakeUp();
-        };
-        return PhysXDynamicCollider;
-    }(PhysXCollider);
-    (function() {
-        PhysXDynamicCollider._tempTranslation = new engine.Vector3();
-    })();
-    (function() {
-        PhysXDynamicCollider._tempRotation = new engine.Quaternion();
-    })();
+  /**
+   *  Static interface implement decorator.
+   *  https://stackoverflow.com/questions/13955157/how-to-define-static-property-in-typescript-interface
+   */ function StaticInterfaceImplement() {
+      return function(constructor) {
+      };
+  }
 
-    /**
-     * A manager is a collection of colliders and constraints which can interact.
-     */ var PhysXPhysicsManager = /*#__PURE__*/ function() {
-        function PhysXPhysicsManager(onContactEnter, onContactExit, onContactStay, onTriggerEnter, onTriggerExit, onTriggerStay) {
-            var _this = this;
-            /** @internal */ this._pxControllerManager = null;
-            this._currentEvents = new DisorderedArray();
-            this._eventMap = {};
-            this._eventPool = [];
-            this._onContactEnter = onContactEnter;
-            this._onContactExit = onContactExit;
-            this._onContactStay = onContactStay;
-            this._onTriggerEnter = onTriggerEnter;
-            this._onTriggerExit = onTriggerExit;
-            this._onTriggerStay = onTriggerStay;
-            var triggerCallback = {
-                onContactBegin: function(obj1, obj2) {
-                    var index1 = obj1.getQueryFilterData().word0;
-                    var index2 = obj2.getQueryFilterData().word0;
-                    _this._onContactEnter(index1, index2);
-                },
-                onContactEnd: function(obj1, obj2) {
-                    var index1 = obj1.getQueryFilterData().word0;
-                    var index2 = obj2.getQueryFilterData().word0;
-                    _this._onContactExit(index1, index2);
-                },
-                onContactPersist: function(obj1, obj2) {
-                    var index1 = obj1.getQueryFilterData().word0;
-                    var index2 = obj2.getQueryFilterData().word0;
-                    _this._onContactStay(index1, index2);
-                },
-                onTriggerBegin: function(obj1, obj2) {
-                    var index1 = obj1.getQueryFilterData().word0;
-                    var index2 = obj2.getQueryFilterData().word0;
-                    var event = index1 < index2 ? _this._getTrigger(index1, index2) : _this._getTrigger(index2, index1);
-                    event.state = 0;
-                    _this._currentEvents.add(event);
-                },
-                onTriggerEnd: function(obj1, obj2) {
-                    var index1 = obj1.getQueryFilterData().word0;
-                    var index2 = obj2.getQueryFilterData().word0;
-                    var event;
-                    if (index1 < index2) {
-                        var subMap = _this._eventMap[index1];
-                        event = subMap[index2];
-                        subMap[index2] = undefined;
-                    } else {
-                        var subMap1 = _this._eventMap[index2];
-                        event = subMap1[index1];
-                        subMap1[index1] = undefined;
-                    }
-                    event.state = 2;
-                }
-            };
-            var PHYSXSimulationCallbackInstance = exports.PhysXPhysics._physX.PxSimulationEventCallback.implement(triggerCallback);
-            var sceneDesc = exports.PhysXPhysics._physX.getDefaultSceneDesc(exports.PhysXPhysics._pxPhysics.getTolerancesScale(), 0, PHYSXSimulationCallbackInstance);
-            this._pxScene = exports.PhysXPhysics._pxPhysics.createScene(sceneDesc);
-        }
-        var _proto = PhysXPhysicsManager.prototype;
-        /**
-       * {@inheritDoc IPhysicsManager.setGravity }
-       */ _proto.setGravity = function setGravity(value) {
-            this._pxScene.setGravity(value);
-        };
-        /**
-       * {@inheritDoc IPhysicsManager.addColliderShape }
-       */ _proto.addColliderShape = function addColliderShape(colliderShape) {
-            this._eventMap[colliderShape._id] = {};
-        };
-        /**
-       * {@inheritDoc IPhysicsManager.removeColliderShape }
-       */ _proto.removeColliderShape = function removeColliderShape(colliderShape) {
-            var _this = this, eventPool = _this._eventPool, currentEvents = _this._currentEvents;
-            var shapeID = colliderShape._id;
-            for(var i = currentEvents.length - 1; i >= 0; i--){
-                var event = currentEvents.get(i);
-                if (event.index1 == shapeID || event.index2 == shapeID) {
-                    currentEvents.deleteByIndex(i);
-                    eventPool.push(event);
-                }
-            }
-            delete this._eventMap[shapeID];
-        };
-        /**
-       * {@inheritDoc IPhysicsManager.addCollider }
-       */ _proto.addCollider = function addCollider(collider) {
-            this._pxScene.addActor(collider._pxActor, null);
-        };
-        /**
-       * {@inheritDoc IPhysicsManager.removeCollider }
-       */ _proto.removeCollider = function removeCollider(collider) {
-            this._pxScene.removeActor(collider._pxActor, true);
-        };
-        /**
-       * {@inheritDoc IPhysicsManager.addCharacterController }
-       */ _proto.addCharacterController = function addCharacterController(characterController) {
-            // Physx have no API to remove/readd cct into scene.
-            if (!characterController._pxController) {
-                var shape = characterController._shape;
-                if (shape) {
-                    var lastPXManager = characterController._pxManager;
-                    if (lastPXManager !== this) {
-                        lastPXManager && characterController._destroyPXController();
-                        characterController._createPXController(this, shape);
-                    }
-                }
-            }
-            characterController._pxManager = this;
-        };
-        /**
-       * {@inheritDoc IPhysicsManager.removeCharacterController }
-       */ _proto.removeCharacterController = function removeCharacterController(characterController) {
-            characterController._pxManager = null;
-        };
-        /**
-       * {@inheritDoc IPhysicsManager.update }
-       */ _proto.update = function update(elapsedTime) {
-            this._simulate(elapsedTime);
-            this._fetchResults();
-            this._fireEvent();
-        };
-        /**
-       * {@inheritDoc IPhysicsManager.raycast }
-       */ _proto.raycast = function raycast(ray, distance, onRaycast, hit) {
-            var pxHitResult = PhysXPhysicsManager._pxRaycastHit;
-            distance = Math.min(distance, 3.4e38); // float32 max value limit in physx raycast.
-            var raycastCallback = {
-                preFilter: function(filterData, shape, actor) {
-                    var index = shape.getQueryFilterData().word0;
-                    if (onRaycast(index)) {
-                        return 2; // eBLOCK
-                    } else {
-                        return 0; // eNONE
-                    }
-                },
-                postFilter: function(filterData, hit) {}
-            };
-            var result = this._pxScene.raycastSingle(ray.origin, ray.direction, distance, pxHitResult, PhysXPhysicsManager._pxFilterData, exports.PhysXPhysics._physX.PxQueryFilterCallback.implement(raycastCallback));
-            if (result && hit != undefined) {
-                var position = PhysXPhysicsManager._tempPosition, normal = PhysXPhysicsManager._tempNormal;
-                var pxPosition = pxHitResult.position, pxNormal = pxHitResult.normal;
-                position.set(pxPosition.x, pxPosition.y, pxPosition.z);
-                normal.set(pxNormal.x, pxNormal.y, pxNormal.z);
-                hit(pxHitResult.getShape().getQueryFilterData().word0, pxHitResult.distance, position, normal);
-            }
-            return result;
-        };
-        /**
-       * @internal
-       */ _proto._getControllerManager = function _getControllerManager() {
-            var pxControllerManager = this._pxControllerManager;
-            if (pxControllerManager === null) {
-                this._pxControllerManager = pxControllerManager = this._pxScene.createControllerManager();
-            }
-            return pxControllerManager;
-        };
-        _proto._simulate = function _simulate(elapsedTime) {
-            this._pxScene.simulate(elapsedTime, true);
-        };
-        _proto._fetchResults = function _fetchResults(block) {
-            if (block === void 0) block = true;
-            this._pxScene.fetchResults(block);
-        };
-        _proto._getTrigger = function _getTrigger(index1, index2) {
-            var event;
-            if (this._eventPool.length) {
-                event = this._eventPool.pop();
-                event.index1 = index1;
-                event.index2 = index2;
-            } else {
-                event = new TriggerEvent(index1, index2);
-            }
-            this._eventMap[index1][index2] = event;
-            return event;
-        };
-        _proto._fireEvent = function _fireEvent() {
-            var _this = this, eventPool = _this._eventPool, currentEvents = _this._currentEvents;
-            for(var i = currentEvents.length - 1; i >= 0; i--){
-                var event = currentEvents.get(i);
-                if (event.state == 0) {
-                    this._onTriggerEnter(event.index1, event.index2);
-                    event.state = 1;
-                } else if (event.state == 1) {
-                    this._onTriggerStay(event.index1, event.index2);
-                } else if (event.state == 2) {
-                    this._onTriggerExit(event.index1, event.index2);
-                    currentEvents.deleteByIndex(i);
-                    eventPool.push(event);
-                }
-            }
-        };
-        PhysXPhysicsManager._init = function _init() {
-            PhysXPhysicsManager._pxRaycastHit = new exports.PhysXPhysics._physX.PxRaycastHit();
-            PhysXPhysicsManager._pxFilterData = new exports.PhysXPhysics._physX.PxQueryFilterData();
-            PhysXPhysicsManager._pxFilterData.flags = new exports.PhysXPhysics._physX.PxQueryFlags(1 | 2 | 4);
-        };
-        return PhysXPhysicsManager;
-    }();
-    (function() {
-        PhysXPhysicsManager._tempPosition = new engine.Vector3();
-    })();
-    (function() {
-        PhysXPhysicsManager._tempNormal = new engine.Vector3();
-    })();
-    var /**
-     * Filtering flags for scene queries.
-     */ QueryFlag;
-    (function(QueryFlag) {
-        QueryFlag[QueryFlag["STATIC"] = 1] = "STATIC";
-        QueryFlag[QueryFlag["DYNAMIC"] = 2] = "DYNAMIC";
-        QueryFlag[QueryFlag["PRE_FILTER"] = 4] = "PRE_FILTER";
-        QueryFlag[QueryFlag["POST_FILTER"] = 8] = "POST_FILTER";
-        QueryFlag[QueryFlag["ANY_HIT"] = 16] = "ANY_HIT";
-        QueryFlag[QueryFlag["NO_BLOCK"] = 32] = "NO_BLOCK";
-    })(QueryFlag || (QueryFlag = {}));
-    var /**
-     * Physics state
-     */ TriggerEventState;
-    (function(TriggerEventState) {
-        TriggerEventState[TriggerEventState["Enter"] = 0] = "Enter";
-        TriggerEventState[TriggerEventState["Stay"] = 1] = "Stay";
-        TriggerEventState[TriggerEventState["Exit"] = 2] = "Exit";
-    })(TriggerEventState || (TriggerEventState = {}));
-    /**
-     * Trigger event to store interactive object ids and state.
-     */ var TriggerEvent = function TriggerEvent(index1, index2) {
-        this.index1 = index1;
-        this.index2 = index2;
-    };
+  exports.PhysXPhysics = /*#__PURE__*/ function() {
+      function PhysXPhysics1() {}
+      /**
+     * Initialize PhysXPhysics.
+     * @param runtimeMode - Runtime mode
+     * @returns Promise object
+     */ PhysXPhysics1.initialize = function initialize(runtimeMode) {
+          if (runtimeMode === void 0) runtimeMode = exports.PhysXRuntimeMode.Auto;
+          var scriptPromise = new Promise(function(resolve, reject) {
+              var script = document.createElement("script");
+              document.body.appendChild(script);
+              script.async = true;
+              script.onload = resolve;
+              script.onerror = reject;
+              if (runtimeMode == exports.PhysXRuntimeMode.Auto) {
+                  var supported = function() {
+                      try {
+                          if (typeof WebAssembly === "object" && typeof WebAssembly.instantiate === "function") {
+                              var module = new WebAssembly.Module(Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00));
+                              if (_instanceof__default['default'](module, WebAssembly.Module)) return _instanceof__default['default'](new WebAssembly.Instance(module), WebAssembly.Instance);
+                          }
+                      } catch (e) {}
+                      return false;
+                  }();
+                  if (supported) {
+                      runtimeMode = exports.PhysXRuntimeMode.WebAssembly;
+                  } else {
+                      runtimeMode = exports.PhysXRuntimeMode.JavaScript;
+                  }
+              }
+              if (runtimeMode == exports.PhysXRuntimeMode.JavaScript) {
+                  script.src = "https://gw.alipayobjects.com/os/lib/oasis-engine/physics-physx/0.9.0-beta.56/libs/physx.release.js.js";
+              } else if (runtimeMode == exports.PhysXRuntimeMode.WebAssembly) {
+                  script.src = "https://gw.alipayobjects.com/os/lib/oasis-engine/physics-physx/0.9.0-beta.56/libs/physx.release.js";
+              }
+          });
+          return new Promise(function(resolve, reject) {
+              scriptPromise.then(function() {
+                  return window.PHYSX().then(function(PHYSX) {
+                      exports.PhysXPhysics._init(PHYSX);
+                      console.log("PhysX loaded.");
+                      resolve();
+                  }, reject);
+              }, reject).catch(reject);
+          });
+      };
+      /**
+     * Destroy PhysXPhysics.
+     */ PhysXPhysics1.destroy = function destroy() {
+          this._pxFoundation.release();
+          this._pxPhysics.release();
+          this._physX = null;
+          this._pxFoundation = null;
+          this._pxPhysics = null;
+      };
+      /**
+     * {@inheritDoc IPhysics.createPhysicsManager }
+     */ PhysXPhysics1.createPhysicsManager = function createPhysicsManager(onContactBegin, onContactEnd, onContactStay, onTriggerBegin, onTriggerEnd, onTriggerStay) {
+          return new PhysXPhysicsManager(onContactBegin, onContactEnd, onContactStay, onTriggerBegin, onTriggerEnd, onTriggerStay);
+      };
+      /**
+     * {@inheritDoc IPhysics.createStaticCollider }
+     */ PhysXPhysics1.createStaticCollider = function createStaticCollider(position, rotation) {
+          return new PhysXStaticCollider(position, rotation);
+      };
+      /**
+     * {@inheritDoc IPhysics.createDynamicCollider }
+     */ PhysXPhysics1.createDynamicCollider = function createDynamicCollider(position, rotation) {
+          return new PhysXDynamicCollider(position, rotation);
+      };
+      /**
+     * {@inheritDoc IPhysics.createCharacterController }
+     */ PhysXPhysics1.createCharacterController = function createCharacterController() {
+          return new PhysXCharacterController();
+      };
+      /**
+     * {@inheritDoc IPhysics.createPhysicsMaterial }
+     */ PhysXPhysics1.createPhysicsMaterial = function createPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine) {
+          return new PhysXPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine);
+      };
+      /**
+     * {@inheritDoc IPhysics.createBoxColliderShape }
+     */ PhysXPhysics1.createBoxColliderShape = function createBoxColliderShape(uniqueID, size, material) {
+          return new PhysXBoxColliderShape(uniqueID, size, material);
+      };
+      /**
+     * {@inheritDoc IPhysics.createSphereColliderShape }
+     */ PhysXPhysics1.createSphereColliderShape = function createSphereColliderShape(uniqueID, radius, material) {
+          return new PhysXSphereColliderShape(uniqueID, radius, material);
+      };
+      /**
+     * {@inheritDoc IPhysics.createPlaneColliderShape }
+     */ PhysXPhysics1.createPlaneColliderShape = function createPlaneColliderShape(uniqueID, material) {
+          return new PhysXPlaneColliderShape(uniqueID, material);
+      };
+      /**
+     * {@inheritDoc IPhysics.createCapsuleColliderShape }
+     */ PhysXPhysics1.createCapsuleColliderShape = function createCapsuleColliderShape(uniqueID, radius, height, material) {
+          return new PhysXCapsuleColliderShape(uniqueID, radius, height, material);
+      };
+      /**
+     * {@inheritDoc IPhysics.createFixedJoint }
+     */ PhysXPhysics1.createFixedJoint = function createFixedJoint(collider) {
+          return new PhysXFixedJoint(collider);
+      };
+      /**
+     * {@inheritDoc IPhysics.createHingeJoint }
+     */ PhysXPhysics1.createHingeJoint = function createHingeJoint(collider) {
+          return new PhysXHingeJoint(collider);
+      };
+      /**
+     * {@inheritDoc IPhysics.createSpringJoint }
+     */ PhysXPhysics1.createSpringJoint = function createSpringJoint(collider) {
+          return new PhysXSpringJoint(collider);
+      };
+      PhysXPhysics1._init = function _init(physX) {
+          var version = physX.PX_PHYSICS_VERSION;
+          var defaultErrorCallback = new physX.PxDefaultErrorCallback();
+          var allocator = new physX.PxDefaultAllocator();
+          var pxFoundation = physX.PxCreateFoundation(version, allocator, defaultErrorCallback);
+          var pxPhysics = physX.PxCreatePhysics(version, pxFoundation, new physX.PxTolerancesScale(), false, null);
+          physX.PxInitExtensions(pxPhysics, null);
+          exports.PhysXPhysics._physX = physX;
+          exports.PhysXPhysics._pxFoundation = pxFoundation;
+          exports.PhysXPhysics._pxPhysics = pxPhysics;
+          PhysXPhysicsManager._init();
+      };
+      return PhysXPhysics1;
+  }();
+  exports.PhysXPhysics = _ts_decorate__default['default']([
+      StaticInterfaceImplement()
+  ], exports.PhysXPhysics);
 
-    /**
-     * Physics material describes how to handle colliding objects (friction, bounciness).
-     */ var PhysXPhysicsMaterial = /*#__PURE__*/ function() {
-        function PhysXPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine) {
-            var pxMaterial = exports.PhysXPhysics._pxPhysics.createMaterial(staticFriction, dynamicFriction, bounciness);
-            pxMaterial.setFrictionCombineMode(frictionCombine);
-            pxMaterial.setRestitutionCombineMode(bounceCombine);
-            this._pxMaterial = pxMaterial;
-        }
-        var _proto = PhysXPhysicsMaterial.prototype;
-        /**
-       * {@inheritDoc IPhysicsMaterial.setBounciness }
-       */ _proto.setBounciness = function setBounciness(value) {
-            this._pxMaterial.setRestitution(value);
-        };
-        /**
-       * {@inheritDoc IPhysicsMaterial.setDynamicFriction }
-       */ _proto.setDynamicFriction = function setDynamicFriction(value) {
-            this._pxMaterial.setDynamicFriction(value);
-        };
-        /**
-       * {@inheritDoc IPhysicsMaterial.setStaticFriction }
-       */ _proto.setStaticFriction = function setStaticFriction(value) {
-            this._pxMaterial.setStaticFriction(value);
-        };
-        /**
-       * {@inheritDoc IPhysicsMaterial.setBounceCombine }
-       */ _proto.setBounceCombine = function setBounceCombine(value) {
-            this._pxMaterial.setRestitutionCombineMode(value);
-        };
-        /**
-       * {@inheritDoc IPhysicsMaterial.setFrictionCombine }
-       */ _proto.setFrictionCombine = function setFrictionCombine(value) {
-            this._pxMaterial.setFrictionCombineMode(value);
-        };
-        /**
-       * {@inheritDoc IPhysicsMaterial.destroy }
-       */ _proto.destroy = function destroy() {
-            this._pxMaterial.release();
-        };
-        return PhysXPhysicsMaterial;
-    }();
-    var /**
-     * Describes how physics materials of the colliding objects are combined.
-     */ CombineMode;
-    (function(CombineMode) {
-        CombineMode[CombineMode[/** Averages the friction/bounce of the two colliding materials. */ "Average"] = 0] = "Average";
-        CombineMode[CombineMode[/** Uses the smaller friction/bounce of the two colliding materials. */ "Minimum"] = 1] = "Minimum";
-        CombineMode[CombineMode[/** Multiplies the friction/bounce of the two colliding materials. */ "Multiply"] = 2] = "Multiply";
-        CombineMode[CombineMode[/** Uses the larger friction/bounce of the two colliding materials. */ "Maximum"] = 3] = "Maximum";
-    })(CombineMode || (CombineMode = {}));
+  Object.defineProperty(exports, '__esModule', { value: true });
 
-    /**
-     * A static collider component that will not move.
-     * @remarks Mostly used for object which always stays at the same place and never moves around.
-     */ var PhysXStaticCollider = /*#__PURE__*/ function(PhysXCollider) {
-        _inherits(PhysXStaticCollider, PhysXCollider);
-        function PhysXStaticCollider(position, rotation) {
-            var _this;
-            _this = PhysXCollider.call(this) || this;
-            _this._pxActor = exports.PhysXPhysics._pxPhysics.createRigidStatic(_this._transform(position, rotation));
-            return _this;
-        }
-        return PhysXStaticCollider;
-    }(PhysXCollider);
-
-    /**
-     * Plane collider shape in PhysX.
-     */ var PhysXPlaneColliderShape = /*#__PURE__*/ function(PhysXColliderShape1) {
-        _inherits(PhysXPlaneColliderShape, PhysXColliderShape1);
-        function PhysXPlaneColliderShape(uniqueID, material) {
-            var _this;
-            _this = PhysXColliderShape1.call(this) || this;
-            _this._axis = new engine.Quaternion(0, 0, PhysXColliderShape.halfSqrt, PhysXColliderShape.halfSqrt);
-            _this._physxRotation.copyFrom(_this._axis);
-            _this._pxGeometry = new exports.PhysXPhysics._physX.PxPlaneGeometry();
-            _this._initialize(material, uniqueID);
-            _this._setLocalPose();
-            return _this;
-        }
-        var _proto = PhysXPlaneColliderShape.prototype;
-        /**
-       * {@inheritDoc IColliderShape.setWorldScale }
-       */ _proto.setWorldScale = function setWorldScale(scale) {
-            this._scale.copyFrom(scale);
-            this._setLocalPose();
-        };
-        return PhysXPlaneColliderShape;
-    }(PhysXColliderShape);
-
-    /**
-     * Sphere collider shape in PhysX.
-     */ var PhysXSphereColliderShape = /*#__PURE__*/ function(PhysXColliderShape) {
-        _inherits(PhysXSphereColliderShape, PhysXColliderShape);
-        function PhysXSphereColliderShape(uniqueID, radius, material) {
-            var _this;
-            _this = PhysXColliderShape.call(this) || this;
-            _this._maxScale = 1;
-            _this._radius = radius;
-            _this._pxGeometry = new exports.PhysXPhysics._physX.PxSphereGeometry(_this._radius * _this._maxScale);
-            _this._initialize(material, uniqueID);
-            _this._setLocalPose();
-            return _this;
-        }
-        var _proto = PhysXSphereColliderShape.prototype;
-        /**
-       * {@inheritDoc ISphereColliderShape.setRadius }
-       */ _proto.setRadius = function setRadius(value) {
-            this._radius = value;
-            this._pxGeometry.radius = value * this._maxScale;
-            this._pxShape.setGeometry(this._pxGeometry);
-        };
-        /**
-       * {@inheritDoc IColliderShape.setWorldScale }
-       */ _proto.setWorldScale = function setWorldScale(scale) {
-            this._scale.copyFrom(scale);
-            this._setLocalPose();
-            this._maxScale = Math.max(scale.x, Math.max(scale.x, scale.y));
-            this._pxGeometry.radius = this._radius * this._maxScale;
-            this._pxShape.setGeometry(this._pxGeometry);
-        };
-        return PhysXSphereColliderShape;
-    }(PhysXColliderShape);
-
-    /**
-     *  Static interface implement decorator.
-     *  https://stackoverflow.com/questions/13955157/how-to-define-static-property-in-typescript-interface
-     */ function StaticInterfaceImplement() {
-        return function(constructor) {
-        };
-    }
-
-    exports.PhysXPhysics = /*#__PURE__*/ function() {
-        function PhysXPhysics1() {}
-        /**
-       * Initialize PhysXPhysics.
-       * @param runtimeMode - Runtime mode
-       * @returns Promise object
-       */ PhysXPhysics1.initialize = function initialize(runtimeMode) {
-            if (runtimeMode === void 0) runtimeMode = exports.PhysXRuntimeMode.Auto;
-            var scriptPromise = new Promise(function(resolve, reject) {
-                var script = document.createElement("script");
-                document.body.appendChild(script);
-                script.async = true;
-                script.onload = resolve;
-                script.onerror = reject;
-                if (runtimeMode == exports.PhysXRuntimeMode.Auto) {
-                    var supported = function() {
-                        try {
-                            if (typeof WebAssembly === "object" && typeof WebAssembly.instantiate === "function") {
-                                var module = new WebAssembly.Module(Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00));
-                                if (_instanceof(module, WebAssembly.Module)) return _instanceof(new WebAssembly.Instance(module), WebAssembly.Instance);
-                            }
-                        } catch (e) {}
-                        return false;
-                    }();
-                    if (supported) {
-                        runtimeMode = exports.PhysXRuntimeMode.WebAssembly;
-                    } else {
-                        runtimeMode = exports.PhysXRuntimeMode.JavaScript;
-                    }
-                }
-                if (runtimeMode == exports.PhysXRuntimeMode.JavaScript) {
-                    script.src = "https://gw.alipayobjects.com/os/lib/oasis-engine/physics-physx/0.9.0-beta.56/libs/physx.release.js.js";
-                } else if (runtimeMode == exports.PhysXRuntimeMode.WebAssembly) {
-                    script.src = "https://gw.alipayobjects.com/os/lib/oasis-engine/physics-physx/0.9.0-beta.56/libs/physx.release.js";
-                }
-            });
-            return new Promise(function(resolve, reject) {
-                scriptPromise.then(function() {
-                    return window.PHYSX().then(function(PHYSX) {
-                        exports.PhysXPhysics._init(PHYSX);
-                        console.log("PhysX loaded.");
-                        resolve();
-                    }, reject);
-                }, reject).catch(reject);
-            });
-        };
-        /**
-       * Destroy PhysXPhysics.
-       */ PhysXPhysics1.destroy = function destroy() {
-            this._pxFoundation.release();
-            this._pxPhysics.release();
-            this._physX = null;
-            this._pxFoundation = null;
-            this._pxPhysics = null;
-        };
-        /**
-       * {@inheritDoc IPhysics.createPhysicsManager }
-       */ PhysXPhysics1.createPhysicsManager = function createPhysicsManager(onContactBegin, onContactEnd, onContactStay, onTriggerBegin, onTriggerEnd, onTriggerStay) {
-            return new PhysXPhysicsManager(onContactBegin, onContactEnd, onContactStay, onTriggerBegin, onTriggerEnd, onTriggerStay);
-        };
-        /**
-       * {@inheritDoc IPhysics.createStaticCollider }
-       */ PhysXPhysics1.createStaticCollider = function createStaticCollider(position, rotation) {
-            return new PhysXStaticCollider(position, rotation);
-        };
-        /**
-       * {@inheritDoc IPhysics.createDynamicCollider }
-       */ PhysXPhysics1.createDynamicCollider = function createDynamicCollider(position, rotation) {
-            return new PhysXDynamicCollider(position, rotation);
-        };
-        /**
-       * {@inheritDoc IPhysics.createCharacterController }
-       */ PhysXPhysics1.createCharacterController = function createCharacterController() {
-            return new PhysXCharacterController();
-        };
-        /**
-       * {@inheritDoc IPhysics.createPhysicsMaterial }
-       */ PhysXPhysics1.createPhysicsMaterial = function createPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine) {
-            return new PhysXPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine);
-        };
-        /**
-       * {@inheritDoc IPhysics.createBoxColliderShape }
-       */ PhysXPhysics1.createBoxColliderShape = function createBoxColliderShape(uniqueID, size, material) {
-            return new PhysXBoxColliderShape(uniqueID, size, material);
-        };
-        /**
-       * {@inheritDoc IPhysics.createSphereColliderShape }
-       */ PhysXPhysics1.createSphereColliderShape = function createSphereColliderShape(uniqueID, radius, material) {
-            return new PhysXSphereColliderShape(uniqueID, radius, material);
-        };
-        /**
-       * {@inheritDoc IPhysics.createPlaneColliderShape }
-       */ PhysXPhysics1.createPlaneColliderShape = function createPlaneColliderShape(uniqueID, material) {
-            return new PhysXPlaneColliderShape(uniqueID, material);
-        };
-        /**
-       * {@inheritDoc IPhysics.createCapsuleColliderShape }
-       */ PhysXPhysics1.createCapsuleColliderShape = function createCapsuleColliderShape(uniqueID, radius, height, material) {
-            return new PhysXCapsuleColliderShape(uniqueID, radius, height, material);
-        };
-        /**
-       * {@inheritDoc IPhysics.createFixedJoint }
-       */ PhysXPhysics1.createFixedJoint = function createFixedJoint(collider) {
-            return new PhysXFixedJoint(collider);
-        };
-        /**
-       * {@inheritDoc IPhysics.createHingeJoint }
-       */ PhysXPhysics1.createHingeJoint = function createHingeJoint(collider) {
-            return new PhysXHingeJoint(collider);
-        };
-        /**
-       * {@inheritDoc IPhysics.createSpringJoint }
-       */ PhysXPhysics1.createSpringJoint = function createSpringJoint(collider) {
-            return new PhysXSpringJoint(collider);
-        };
-        PhysXPhysics1._init = function _init(physX) {
-            var version = physX.PX_PHYSICS_VERSION;
-            var defaultErrorCallback = new physX.PxDefaultErrorCallback();
-            var allocator = new physX.PxDefaultAllocator();
-            var pxFoundation = physX.PxCreateFoundation(version, allocator, defaultErrorCallback);
-            var pxPhysics = physX.PxCreatePhysics(version, pxFoundation, new physX.PxTolerancesScale(), false, null);
-            physX.PxInitExtensions(pxPhysics, null);
-            exports.PhysXPhysics._physX = physX;
-            exports.PhysXPhysics._pxFoundation = pxFoundation;
-            exports.PhysXPhysics._pxPhysics = pxPhysics;
-            PhysXPhysicsManager._init();
-        };
-        return PhysXPhysics1;
-    }();
-    exports.PhysXPhysics = __decorate([
-        StaticInterfaceImplement()
-    ], exports.PhysXPhysics);
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
+})));