@galacean/engine-physics-physx 0.0.0-experimental-animator-additive.1

package/dist/module.js

@@ -0,0 +1,1379 @@
+import { Vector3, Quaternion } from '@galacean/engine';
+
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
+
+/******************************************************************************
+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;
+}
+
+/**
+ * PhysX runtime mode.
+ */ var 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";
+})(PhysXRuntimeMode || (PhysXRuntimeMode = {}));
+
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+
+        return o;
+    };
+
+    return _set_prototype_of(o, p);
+}
+
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+
+    subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+
+/**
+ * a base interface providing common functionality for PhysX joints
+ */ var PhysXJoint = /*#__PURE__*/ function() {
+    function PhysXJoint() {
+        this._connectedAnchor = new 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 Vector3(1, 0, 0);
+})();
+(function() {
+    PhysXJoint._defaultVec = new Vector3();
+})();
+(function() {
+    PhysXJoint._defaultQuat = new Quaternion();
+})();
+
+/**
+ * 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 = PhysXPhysics._pxPhysics.createFixedJoint(null, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat);
+        return _this;
+    }
+    return PhysXFixedJoint;
+}(PhysXJoint);
+
+/**
+ * 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 Quaternion();
+        _this._swingOffset = new Vector3();
+        _this._velocity = new Vector3();
+        _this._collider = collider;
+        _this._pxJoint = 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(Vector3.dot(xAxis, value));
+        Vector3.cross(xAxis, value, xAxis);
+        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);
+
+/**
+ * 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 Vector3();
+        _this._collider = collider;
+        _this._pxJoint = 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);
+
+/**
+ * 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 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 Vector3(1, 1, 1);
+        this._position = new Vector3();
+        this._rotation = null;
+        this._axis = null;
+        this._physxRotation = new 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;
+        Quaternion.rotationYawPitchRoll(value.x, value.y, value.z, this._physxRotation);
+        this._axis && 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 PhysXPhysics._physX.PxShapeFlags(this._shapeFlags));
+    };
+    _proto._setLocalPose = function _setLocalPose() {
+        var transform = PhysXColliderShape.transform;
+        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 = PhysXPhysics._pxPhysics.createShape(this._pxGeometry, material._pxMaterial, true, new PhysXPhysics._physX.PxShapeFlags(this._shapeFlags));
+        this._pxShape.setQueryFilterData(new 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 Vector3(),
+        rotation: null
+    };
+})();
+
+/**
+ * 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 Vector3();
+        _this._halfSize.set(size.x * 0.5, size.y * 0.5, size.z * 0.5);
+        _this._pxGeometry = new 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);
+        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();
+        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 Vector3();
+})();
+
+/**
+ * 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 Quaternion(0, 0, PhysXColliderShape.halfSqrt, PhysXColliderShape.halfSqrt);
+        _this._physxRotation.copyFrom(_this._axis);
+        _this._pxGeometry = new 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) {
+            Quaternion.rotationYawPitchRoll(rotation.x, rotation.y, rotation.z, physxRotation);
+            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 = {}));
+
+/**
+ * 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 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 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 PhysXPhysics._physX.PxFilterData(shape._id, 0, 0, 0));
+    };
+    /**
+   * @internal
+   */ _proto._destroyPXController = function _destroyPXController() {
+        if (this._pxController) {
+            this._pxController.release();
+            this._pxController = null;
+        }
+    };
+    return PhysXCharacterController;
+}();
+
+/**
+ * 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
+    };
+})();
+
+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 = 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(PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD, true);
+                break;
+            case 2:
+                this._pxActor.setRigidBodyFlag(PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, true);
+                break;
+            case 3:
+                this._pxActor.setRigidBodyFlag(PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, true);
+                break;
+            case 0:
+                this._pxActor.setRigidBodyFlag(PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD, false);
+                this._pxActor.setRigidBodyFlag(PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, false);
+                this._pxActor.setRigidBodyFlag(PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, false);
+                break;
+        }
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setIsKinematic }
+   */ _proto.setIsKinematic = function setIsKinematic(value) {
+        if (value) {
+            this._pxActor.setRigidBodyFlag(PhysXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, true);
+        } else {
+            this._pxActor.setRigidBodyFlag(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, 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 Vector3();
+})();
+(function() {
+    PhysXDynamicCollider._tempRotation = new Quaternion();
+})();
+
+/**
+ * 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 = PhysXPhysics._physX.PxSimulationEventCallback.implement(triggerCallback);
+        var sceneDesc = PhysXPhysics._physX.getDefaultSceneDesc(PhysXPhysics._pxPhysics.getTolerancesScale(), 0, PHYSXSimulationCallbackInstance);
+        this._pxScene = 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) {
+        var lastPXManager = characterController._pxManager;
+        var shape = characterController._shape;
+        if (shape) {
+            if (lastPXManager !== this) {
+                lastPXManager && characterController._destroyPXController();
+                characterController._createPXController(this, shape);
+            }
+            this._pxScene.addController(characterController._pxController);
+        }
+        characterController._pxManager = this;
+    };
+    /**
+   * {@inheritDoc IPhysicsManager.removeCharacterController }
+   */ _proto.removeCharacterController = function removeCharacterController(characterController) {
+        if (characterController._shape) {
+            this._pxScene.removeController(characterController._pxController);
+        }
+        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, 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 PhysXPhysics._physX.PxRaycastHit();
+        PhysXPhysicsManager._pxFilterData = new PhysXPhysics._physX.PxQueryFilterData();
+        PhysXPhysicsManager._pxFilterData.flags = new PhysXPhysics._physX.PxQueryFlags(1 | 2 | 4);
+    };
+    return PhysXPhysicsManager;
+}();
+(function() {
+    PhysXPhysicsManager._tempPosition = new Vector3();
+})();
+(function() {
+    PhysXPhysicsManager._tempNormal = new 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;
+};
+
+/**
+ * Physics material describes how to handle colliding objects (friction, bounciness).
+ */ var PhysXPhysicsMaterial = /*#__PURE__*/ function() {
+    function PhysXPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine) {
+        var pxMaterial = 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 = {}));
+
+/**
+ * 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 = 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 Quaternion(0, 0, PhysXColliderShape.halfSqrt, PhysXColliderShape.halfSqrt);
+        _this._physxRotation.copyFrom(_this._axis);
+        _this._pxGeometry = new 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 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) {
+    };
+}
+
+var PhysXPhysics = /*#__PURE__*/ function() {
+    function PhysXPhysics1() {}
+    /**
+   * Initialize PhysXPhysics.
+   * @param runtimeMode - Runtime mode
+   * @returns Promise object
+   */ PhysXPhysics1.initialize = function initialize(runtimeMode) {
+        if (runtimeMode === void 0) runtimeMode = 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 == 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 = PhysXRuntimeMode.WebAssembly;
+                } else {
+                    runtimeMode = PhysXRuntimeMode.JavaScript;
+                }
+            }
+            if (runtimeMode == 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 == 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) {
+                    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);
+        PhysXPhysics._physX = physX;
+        PhysXPhysics._pxFoundation = pxFoundation;
+        PhysXPhysics._pxPhysics = pxPhysics;
+        PhysXPhysicsManager._init();
+    };
+    return PhysXPhysics1;
+}();
+PhysXPhysics = __decorate([
+    StaticInterfaceImplement()
+], PhysXPhysics);
+
+export { PhysXPhysics, PhysXRuntimeMode };
+//# sourceMappingURL=module.js.map