@galacean/engine-physics-physx 0.0.0-experimental-backup.0 → 0.0.0-experimental-2.0-game

package/dist/browser.js

@@ -0,0 +1,1966 @@
+(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';
+
+    function _instanceof(left, right) {
+        if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+            return !!right[Symbol.hasInstance](left);
+        } else return left instanceof right;
+    }
+
+    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);
+    }
+
+    /**
+     * Flags which affect the behavior of Shapes.
+     */ var ShapeFlag = /*#__PURE__*/ function(ShapeFlag) {
+        /** The shape will partake in collision in the physical simulation. */ ShapeFlag[ShapeFlag["SIMULATION_SHAPE"] = 1] = "SIMULATION_SHAPE";
+        /** The shape will partake in scene queries (ray casts, overlap tests, sweeps, ...). */ ShapeFlag[ShapeFlag["SCENE_QUERY_SHAPE"] = 2] = "SCENE_QUERY_SHAPE";
+        /** The shape is a trigger which can send reports whenever other shapes enter/leave its volume. */ ShapeFlag[ShapeFlag["TRIGGER_SHAPE"] = 4] = "TRIGGER_SHAPE";
+        return ShapeFlag;
+    }({});
+    /**
+     * Abstract class for collider shapes.
+     */ var PhysXColliderShape = /*#__PURE__*/ function() {
+        function PhysXColliderShape(physXPhysics) {
+            /** @internal */ this._controllers = new engine.DisorderedArray();
+            /** @internal */ this._contractOffset = 0.02;
+            /** @internal */ this._worldScale = new engine.Vector3(1, 1, 1);
+            /** @internal */ this._position = new engine.Vector3();
+            /** @internal */ this._rotation = new engine.Vector3();
+            this._axis = null;
+            this._physXRotation = new engine.Quaternion();
+            this._shapeFlags = 2 | 1;
+            this._physXPhysics = physXPhysics;
+        }
+        var _proto = PhysXColliderShape.prototype;
+        /**
+       * {@inheritDoc IColliderShape.setRotation }
+       */ _proto.setRotation = function setRotation(value) {
+            var rotation = this._rotation.set(engine.MathUtil.degreeToRadian(value.x), engine.MathUtil.degreeToRadian(value.y), engine.MathUtil.degreeToRadian(value.z));
+            engine.Quaternion.rotationYawPitchRoll(rotation.y, rotation.x, rotation.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);
+            }
+            var controllers = this._controllers;
+            for(var i = 0, n = controllers.length; i < n; i++){
+                controllers.get(i)._updateShapePosition(this._position, this._worldScale);
+            }
+            this._setLocalPose();
+        };
+        /**
+       * {@inheritDoc IColliderShape.setWorldScale }
+       */ _proto.setWorldScale = function setWorldScale(scale) {
+            this._worldScale.set(Math.abs(scale.x), Math.abs(scale.y), Math.abs(scale.z));
+            this._setLocalPose();
+            var controllers = this._controllers;
+            for(var i = 0, n = controllers.length; i < n; i++){
+                controllers.get(i)._updateShapePosition(this._position, this._worldScale);
+            }
+        };
+        /**
+       * {@inheritDoc IColliderShape.setContactOffset }
+       * @default 0.02f * PxTolerancesScale::length
+       */ _proto.setContactOffset = function setContactOffset(offset) {
+            this._contractOffset = offset;
+            var controllers = this._controllers;
+            if (controllers.length) {
+                for(var i = 0, n = controllers.length; i < n; i++){
+                    var _controllers_get__pxController;
+                    (_controllers_get__pxController = controllers.get(i)._pxController) == null ? void 0 : _controllers_get__pxController.setContactOffset(offset);
+                }
+            } else {
+                this._pxShape.setContactOffset(offset);
+            }
+        };
+        /**
+       * {@inheritDoc IColliderShape.setMaterial }
+       */ _proto.setMaterial = function setMaterial(value) {
+            this._pxMaterial = value._pxMaterial;
+            this._pxShape.setMaterial(this._pxMaterial);
+        };
+        /**
+       * {@inheritDoc IColliderShape.setIsTrigger }
+       */ _proto.setIsTrigger = function setIsTrigger(value) {
+            this._modifyFlag(1, !value);
+            this._modifyFlag(4, value);
+            this._setShapeFlags(this._shapeFlags);
+        };
+        /**
+       * {@inheritDoc IColliderShape.pointDistance }
+       */ _proto.pointDistance = function pointDistance(point) {
+            var info = this._pxGeometry.pointDistance(this._pxShape.getGlobalPose(), point);
+            var closestPoint = info.closestPoint;
+            var res = PhysXColliderShape._tempVector4;
+            res.set(closestPoint.x, closestPoint.y, closestPoint.z, info.distance);
+            return res;
+        };
+        /**
+       * {@inheritDoc IColliderShape.destroy }
+       */ _proto.destroy = function destroy() {
+            var _this__pxGeometry;
+            this._pxShape.release();
+            (_this__pxGeometry = this._pxGeometry) == null ? void 0 : _this__pxGeometry.delete();
+        };
+        /**
+       *  @internal
+       */ _proto._setShapeFlags = function _setShapeFlags(flags) {
+            this._shapeFlags = flags;
+            var shapeFlags = new this._physXPhysics._physX.PxShapeFlags(this._shapeFlags);
+            this._pxShape.setFlags(shapeFlags);
+            shapeFlags.delete();
+        };
+        _proto._setLocalPose = function _setLocalPose() {
+            var transform = PhysXColliderShape.transform;
+            engine.Vector3.multiply(this._position, this._worldScale, transform.translation);
+            transform.rotation = this._physXRotation;
+            this._pxShape.setLocalPose(transform);
+        };
+        _proto._initialize = function _initialize(material, id) {
+            this._id = id;
+            this._pxMaterial = material._pxMaterial;
+            var shapeFlags = new this._physXPhysics._physX.PxShapeFlags(this._shapeFlags);
+            this._pxShape = this._physXPhysics._pxPhysics.createShape(this._pxGeometry, material._pxMaterial, true, shapeFlags);
+            shapeFlags.delete();
+            this._pxShape.setUUID(id);
+        };
+        _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
+    };
+    PhysXColliderShape._tempVector4 = new engine.Vector4();
+
+    /**
+     * Box collider shape in PhysX.
+     */ var PhysXBoxColliderShape = /*#__PURE__*/ function(PhysXColliderShape) {
+        _inherits(PhysXBoxColliderShape, PhysXColliderShape);
+        function PhysXBoxColliderShape(physXPhysics, uniqueID, size, material) {
+            var _this;
+            _this = PhysXColliderShape.call(this, physXPhysics) || this, /** @internal */ _this._halfSize = new engine.Vector3();
+            var halfSize = _this._halfSize;
+            halfSize.set(size.x * 0.5, size.y * 0.5, size.z * 0.5);
+            _this._pxGeometry = new physXPhysics._physX.PxBoxGeometry(halfSize.x, halfSize.y, halfSize.z);
+            _this._initialize(material, uniqueID);
+            _this._setLocalPose();
+            return _this;
+        }
+        var _proto = PhysXBoxColliderShape.prototype;
+        /**
+       * {@inheritDoc IBoxColliderShape.setSize }
+       */ _proto.setSize = function setSize(value) {
+            var halfSize = this._halfSize;
+            var tempExtents = PhysXBoxColliderShape._tempHalfExtents;
+            halfSize.set(value.x * 0.5, value.y * 0.5, value.z * 0.5);
+            engine.Vector3.multiply(halfSize, this._worldScale, tempExtents);
+            this._pxGeometry.halfExtents = tempExtents;
+            this._pxShape.setGeometry(this._pxGeometry);
+            this._updateController(tempExtents);
+        };
+        /**
+       * {@inheritDoc IColliderShape.setRotation }
+       */ _proto.setRotation = function setRotation(value) {
+            PhysXColliderShape.prototype.setRotation.call(this, value);
+            if (this._controllers.length > 0) {
+                console.warn("Box character controller `rotation` is not supported in PhysX and will be ignored");
+            }
+        };
+        /**
+       * {@inheritDoc IColliderShape.setWorldScale }
+       */ _proto.setWorldScale = function setWorldScale(scale) {
+            PhysXColliderShape.prototype.setWorldScale.call(this, scale);
+            var tempExtents = PhysXBoxColliderShape._tempHalfExtents;
+            engine.Vector3.multiply(this._halfSize, this._worldScale, tempExtents);
+            this._pxGeometry.halfExtents = tempExtents;
+            this._pxShape.setGeometry(this._pxGeometry);
+            this._updateController(tempExtents);
+        };
+        _proto._updateController = function _updateController(extents) {
+            var controllers = this._controllers;
+            for(var i = 0, n = controllers.length; i < n; i++){
+                var pxController = controllers.get(i)._pxController;
+                if (pxController) {
+                    pxController.setHalfHeight(extents.y);
+                    pxController.setHalfSideExtent(extents.x);
+                    pxController.setHalfForwardExtent(extents.z);
+                }
+            }
+        };
+        return PhysXBoxColliderShape;
+    }(PhysXColliderShape);
+    PhysXBoxColliderShape._tempHalfExtents = new engine.Vector3();
+
+    /**
+     * Capsule collider shape in PhysX.
+     */ var PhysXCapsuleColliderShape = /*#__PURE__*/ function(PhysXColliderShape1) {
+        _inherits(PhysXCapsuleColliderShape, PhysXColliderShape1);
+        function PhysXCapsuleColliderShape(physXPhysics, uniqueID, radius, height, material) {
+            var _this;
+            _this = PhysXColliderShape1.call(this, physXPhysics) || this, /** @internal */ _this._upAxis = 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 physXPhysics._physX.PxCapsuleGeometry(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;
+            var sizeScale = this._worldScale;
+            switch(this._upAxis){
+                case 0:
+                    this._pxGeometry.radius = this._radius * Math.max(sizeScale.y, sizeScale.z);
+                    break;
+                case 1:
+                    this._pxGeometry.radius = this._radius * Math.max(sizeScale.x, sizeScale.z);
+                    break;
+                case 2:
+                    this._pxGeometry.radius = this._radius * Math.max(sizeScale.x, sizeScale.y);
+                    break;
+            }
+            this._pxShape.setGeometry(this._pxGeometry);
+            var radius = this._pxGeometry.radius;
+            var controllers = this._controllers;
+            for(var i = 0, n = controllers.length; i < n; i++){
+                var _controllers_get__pxController;
+                (_controllers_get__pxController = controllers.get(i)._pxController) == null ? void 0 : _controllers_get__pxController.setRadius(radius);
+            }
+        };
+        /**
+       * {@inheritDoc ICapsuleColliderShape.setHeight }
+       */ _proto.setHeight = function setHeight(value) {
+            this._halfHeight = value * 0.5;
+            var sizeScale = this._worldScale;
+            switch(this._upAxis){
+                case 0:
+                    this._pxGeometry.halfHeight = this._halfHeight * sizeScale.x;
+                    break;
+                case 1:
+                    this._pxGeometry.halfHeight = this._halfHeight * sizeScale.y;
+                    break;
+                case 2:
+                    this._pxGeometry.halfHeight = this._halfHeight * sizeScale.z;
+                    break;
+            }
+            this._pxShape.setGeometry(this._pxGeometry);
+            var height = this._pxGeometry.halfHeight * 2;
+            var controllers = this._controllers;
+            for(var i = 0, n = controllers.length; i < n; i++){
+                var _controllers_get__pxController;
+                (_controllers_get__pxController = controllers.get(i)._pxController) == null ? void 0 : _controllers_get__pxController.setHeight(height);
+            }
+        };
+        /**
+       * {@inheritDoc ICapsuleColliderShape.setRotation }
+       */ _proto.setRotation = function setRotation(value) {
+            PhysXColliderShape1.prototype.setRotation.call(this, value);
+            if (this._controllers.length > 0) {
+                console.warn("Capsule character controller `rotation` is not supported in PhysX and will be ignored");
+            }
+        };
+        /**
+       * {@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.y, rotation.x, rotation.z, physXRotation);
+                engine.Quaternion.multiply(physXRotation, axis, physXRotation);
+            } else {
+                physXRotation.copyFrom(axis);
+            }
+            this._setLocalPose();
+            if (this._controllers.length > 0) {
+                console.warn("Capsule character controller `upAxis` is not supported in PhysX and will be ignored");
+            }
+        };
+        /**
+       * {@inheritDoc IColliderShape.setWorldScale }
+       */ _proto.setWorldScale = function setWorldScale(scale) {
+            PhysXColliderShape1.prototype.setWorldScale.call(this, scale);
+            var sizeScale = this._worldScale;
+            var geometry = this._pxGeometry;
+            switch(this._upAxis){
+                case 0:
+                    geometry.radius = this._radius * Math.max(sizeScale.y, sizeScale.z);
+                    geometry.halfHeight = this._halfHeight * sizeScale.x;
+                    break;
+                case 1:
+                    geometry.radius = this._radius * Math.max(sizeScale.x, sizeScale.z);
+                    geometry.halfHeight = this._halfHeight * sizeScale.y;
+                    break;
+                case 2:
+                    geometry.radius = this._radius * Math.max(sizeScale.x, sizeScale.y);
+                    geometry.halfHeight = this._halfHeight * sizeScale.z;
+                    break;
+            }
+            this._pxShape.setGeometry(geometry);
+            var radius = geometry.radius;
+            var height = geometry.halfHeight * 2;
+            var controllers = this._controllers;
+            for(var i = 0, n = controllers.length; i < n; i++){
+                var pxController = controllers.get(i)._pxController;
+                if (pxController) {
+                    pxController.setRadius(radius);
+                    pxController.setHeight(height);
+                }
+            }
+        };
+        return PhysXCapsuleColliderShape;
+    }(PhysXColliderShape);
+    /**
+     * The up axis of the collider shape.
+     */ var ColliderShapeUpAxis = /*#__PURE__*/ function(ColliderShapeUpAxis) {
+        /** Up axis is X. */ ColliderShapeUpAxis[ColliderShapeUpAxis["X"] = 0] = "X";
+        /** Up axis is Y. */ ColliderShapeUpAxis[ColliderShapeUpAxis["Y"] = 1] = "Y";
+        /** Up axis is Z. */ ColliderShapeUpAxis[ColliderShapeUpAxis["Z"] = 2] = "Z";
+        return ColliderShapeUpAxis;
+    }({});
+
+    /**
+     * Base class for character controllers.
+     */ var PhysXCharacterController = /*#__PURE__*/ function() {
+        function PhysXCharacterController(physXPhysics) {
+            /** @internal  */ this._scene = null;
+            this._shapeScaledPosition = new engine.Vector3();
+            this._worldPosition = null;
+            this._physXPhysics = physXPhysics;
+        }
+        var _proto = PhysXCharacterController.prototype;
+        /**
+       * {@inheritDoc ICharacterController.move }
+       */ _proto.move = function move(disp, minDist, elapsedTime) {
+            var _this__pxController;
+            var _this__pxController_move;
+            return (_this__pxController_move = (_this__pxController = this._pxController) == null ? void 0 : _this__pxController.move(disp, minDist, elapsedTime)) != null ? _this__pxController_move : 0;
+        };
+        /**
+       * {@inheritDoc ICharacterController.setWorldPosition }
+       */ _proto.setWorldPosition = function setWorldPosition(position) {
+            this._worldPosition = position;
+            this._updateNativePosition();
+        };
+        /**
+       * {@inheritDoc ICharacterController.getWorldPosition }
+       */ _proto.getWorldPosition = function getWorldPosition(position) {
+            if (this._pxController) {
+                position.copyFrom(this._pxController.getPosition());
+                position.subtract(this._shapeScaledPosition);
+            }
+        };
+        /**
+       * {@inheritDoc ICharacterController.setStepOffset }
+       */ _proto.setStepOffset = function setStepOffset(offset) {
+            var _this__pxController;
+            (_this__pxController = this._pxController) == null ? void 0 : _this__pxController.setStepOffset(offset);
+        };
+        /**
+       * {@inheritDoc ICharacterController.setNonWalkableMode }
+       */ _proto.setNonWalkableMode = function setNonWalkableMode(flag) {
+            var _this__pxController;
+            (_this__pxController = this._pxController) == null ? void 0 : _this__pxController.setNonWalkableMode(flag);
+        };
+        /**
+       * {@inheritDoc ICharacterController.setUpDirection }
+       */ _proto.setUpDirection = function setUpDirection(up) {
+            var _this__pxController;
+            (_this__pxController = this._pxController) == null ? void 0 : _this__pxController.setUpDirection(up);
+        };
+        /**
+       * {@inheritDoc ICharacterController.setSlopeLimit }
+       */ _proto.setSlopeLimit = function setSlopeLimit(slopeLimit) {
+            var _this__pxController;
+            (_this__pxController = this._pxController) == null ? void 0 : _this__pxController.setSlopeLimit(Math.cos(slopeLimit * Math.PI / 180));
+        };
+        /**
+       * {@inheritDoc ICharacterController.addShape }
+       */ _proto.addShape = function addShape(shape) {
+            var _this__pxController, _this__scene;
+            // Add shape should sync latest position and world scale to pxController
+            this._updateShapePosition(shape._position, shape._worldScale);
+            // When CharacterController is disabled, set shape property need check pxController whether exist because of this._pxManager is null and won't create pxController
+            this._pxManager && this._createPXController(this._pxManager, shape);
+            this._shape = shape;
+            shape._controllers.add(this);
+            (_this__pxController = this._pxController) == null ? void 0 : _this__pxController.setContactOffset(shape._contractOffset);
+            (_this__scene = this._scene) == null ? void 0 : _this__scene._addColliderShape(shape._id);
+        };
+        /**
+       * {@inheritDoc ICharacterController.removeShape }
+       */ _proto.removeShape = function removeShape(shape) {
+            var _this__scene;
+            this._destroyPXController();
+            this._shape = null;
+            shape._controllers.delete(this);
+            (_this__scene = this._scene) == null ? void 0 : _this__scene._removeColliderShape(shape._id);
+        };
+        /**
+       * {@inheritDoc ICollider.setCollisionLayer }
+       */ _proto.setCollisionLayer = function setCollisionLayer(layer) {
+            var _this__pxController;
+            var actor = (_this__pxController = this._pxController) == null ? void 0 : _this__pxController.getActor();
+            if (actor) {
+                this._physXPhysics._physX.setGroup(actor, layer);
+            }
+        };
+        /**
+       * {@inheritDoc ICharacterController.destroy }
+       */ _proto.destroy = function destroy() {
+            this._destroyPXController();
+        };
+        /**
+       * @internal
+       */ _proto._createPXController = function _createPXController(pxManager, shape) {
+            var desc;
+            if (_instanceof(shape, PhysXBoxColliderShape)) {
+                desc = new this._physXPhysics._physX.PxBoxControllerDesc();
+                desc.halfHeight = shape._halfSize.y;
+                desc.halfSideExtent = shape._halfSize.x;
+                desc.halfForwardExtent = shape._halfSize.z;
+                if (shape._rotation.lengthSquared() > 0) {
+                    console.warn("Box character controller `rotation` is not supported in PhysX and will be ignored");
+                }
+            } else if (_instanceof(shape, PhysXCapsuleColliderShape)) {
+                desc = new this._physXPhysics._physX.PxCapsuleControllerDesc();
+                desc.radius = shape._radius;
+                desc.height = shape._halfHeight * 2;
+                desc.climbingMode = 1; // constraint mode
+                if (shape._rotation.lengthSquared() > 0) {
+                    console.warn("Capsule character controller `rotation` is not supported in PhysX and will be ignored");
+                }
+                if (shape._upAxis !== ColliderShapeUpAxis.Y) {
+                    console.warn("Capsule character controller `upAxis` is not supported in PhysX and will be ignored");
+                }
+            } else {
+                throw "unsupported shape type";
+            }
+            desc.setMaterial(shape._pxMaterial);
+            this._pxController = pxManager._getControllerManager().createController(desc);
+            desc.delete();
+            this._pxController.setUUID(shape._id);
+            this._updateNativePosition();
+        };
+        /**
+       * @internal
+       */ _proto._destroyPXController = function _destroyPXController() {
+            if (this._pxController) {
+                this._pxController.release();
+                this._pxController = null;
+            }
+        };
+        /**
+       * @internal
+       */ _proto._updateShapePosition = function _updateShapePosition(shapePosition, worldScale) {
+            engine.Vector3.multiply(shapePosition, worldScale, this._shapeScaledPosition);
+            this._updateNativePosition();
+        };
+        _proto._updateNativePosition = function _updateNativePosition() {
+            var worldPosition = this._worldPosition;
+            if (this._pxController && worldPosition) {
+                engine.Vector3.add(worldPosition, this._shapeScaledPosition, PhysXCharacterController._tempVec);
+                this._pxController.setPosition(PhysXCharacterController._tempVec);
+            }
+        };
+        return PhysXCharacterController;
+    }();
+    PhysXCharacterController._tempVec = new engine.Vector3();
+
+    /**
+     * Abstract class of physical collider.
+     */ var PhysXCollider = /*#__PURE__*/ function() {
+        function PhysXCollider(physXPhysics) {
+            /** @internal  */ this._scene = null;
+            /** @internal */ this._shapes = new Array();
+            this._physXPhysics = physXPhysics;
+        }
+        var _proto = PhysXCollider.prototype;
+        /**
+       * {@inheritDoc ICollider.addShape }
+       */ _proto.addShape = function addShape(shape) {
+            var _this__scene;
+            this._pxActor.attachShape(shape._pxShape);
+            this._shapes.push(shape);
+            (_this__scene = this._scene) == null ? void 0 : _this__scene._addColliderShape(shape._id);
+        };
+        /**
+       * {@inheritDoc ICollider.removeShape }
+       */ _proto.removeShape = function removeShape(shape) {
+            var _this__scene;
+            this._pxActor.detachShape(shape._pxShape, true);
+            var shapes = this._shapes;
+            shapes.splice(shapes.indexOf(shape), 1);
+            (_this__scene = this._scene) == null ? void 0 : _this__scene._removeColliderShape(shape._id);
+        };
+        /**
+       * {@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.setCollisionLayer }
+       */ _proto.setCollisionLayer = function setCollisionLayer(layer) {
+            this._physXPhysics._physX.setGroup(this._pxActor, layer);
+        };
+        /**
+       * {@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
+    };
+
+    /**
+     * A dynamic collider can act with self-defined movement or physical force
+     */ var PhysXDynamicCollider = /*#__PURE__*/ function(PhysXCollider) {
+        _inherits(PhysXDynamicCollider, PhysXCollider);
+        function PhysXDynamicCollider(physXPhysics, position, rotation) {
+            var _this;
+            _this = PhysXCollider.call(this, physXPhysics) || 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.getLinearVelocity }
+       */ _proto.getLinearVelocity = function getLinearVelocity(out) {
+            var velocity = this._pxActor.getLinearVelocity();
+            return out.set(velocity.x, velocity.y, velocity.z);
+        };
+        /**
+       * {@inheritDoc IDynamicCollider.setLinearVelocity }
+       */ _proto.setLinearVelocity = function setLinearVelocity(value) {
+            this._pxActor.setLinearVelocity(value, true);
+        };
+        /**
+       * {@inheritDoc IDynamicCollider.getAngularVelocity }
+       */ _proto.getAngularVelocity = function getAngularVelocity(out) {
+            var velocity = this._pxActor.getAngularVelocity();
+            return out.set(engine.MathUtil.radianToDegree(velocity.x), engine.MathUtil.radianToDegree(velocity.y), engine.MathUtil.radianToDegree(velocity.z));
+        };
+        /**
+       * {@inheritDoc IDynamicCollider.setAngularVelocity }
+       */ _proto.setAngularVelocity = function setAngularVelocity(value) {
+            PhysXDynamicCollider._tempTranslation.set(engine.MathUtil.degreeToRadian(value.x), engine.MathUtil.degreeToRadian(value.y), engine.MathUtil.degreeToRadian(value.z));
+            this._pxActor.setAngularVelocity(PhysXDynamicCollider._tempTranslation, true);
+        };
+        /**
+       * {@inheritDoc IDynamicCollider.setMass }
+       */ _proto.setMass = function setMass(value) {
+            this._pxActor.setMass(value);
+        };
+        /**
+       * {@inheritDoc IDynamicCollider.getCenterOfMass }
+       */ _proto.getCenterOfMass = function getCenterOfMass(out) {
+            var translation = this._pxActor.getCMassLocalPose().translation;
+            return out.set(translation.x, translation.y, translation.z);
+        };
+        /**
+       * {@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.getInertiaTensor }
+       */ _proto.getInertiaTensor = function getInertiaTensor(out) {
+            var inertia = this._pxActor.getMassSpaceInertiaTensor();
+            return out.set(inertia.x, inertia.y, inertia.z);
+        };
+        /**
+       * {@inheritDoc IDynamicCollider.setMassAndUpdateInertia }
+       */ _proto.setMassAndUpdateInertia = function setMassAndUpdateInertia(mass) {
+            this._pxActor.setMassAndUpdateInertia(mass);
+        };
+        /**
+       * {@inheritDoc IDynamicCollider.setMaxAngularVelocity }
+       */ _proto.setMaxAngularVelocity = function setMaxAngularVelocity(value) {
+            this._pxActor.setMaxAngularVelocity(engine.MathUtil.degreeToRadian(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) {
+            var physX = this._physXPhysics._physX;
+            switch(value){
+                case 1:
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD, true);
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, false);
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, false);
+                    break;
+                case 2:
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD, true);
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, true);
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, false);
+                    break;
+                case 3:
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD, false);
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, false);
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, true);
+                    break;
+                case 0:
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD, false);
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, false);
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, false);
+                    break;
+            }
+        };
+        /**
+       * {@inheritDoc IDynamicCollider.setUseGravity }
+       */ _proto.setUseGravity = function setUseGravity(value) {
+            this._pxActor.setActorFlag(this._physXPhysics._physX.PxActorFlag.eDISABLE_GRAVITY, !value);
+        };
+        /**
+       * {@inheritDoc IDynamicCollider.setIsKinematic }
+       */ _proto.setIsKinematic = function setIsKinematic(value) {
+            if (value) {
+                this._pxActor.setRigidBodyFlag(this._physXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, true);
+            } else {
+                this._pxActor.setRigidBodyFlag(this._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.isSleeping }
+       */ _proto.isSleeping = function isSleeping() {
+            return this._pxActor.isSleeping();
+        };
+        /**
+       * {@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 PhysXPhysicsManager = function PhysXPhysicsManager() {
+        /** @internal */ this._eventMap = {};
+    };
+
+    /**
+     * Physics material describes how to handle colliding objects (friction, bounciness).
+     */ var PhysXPhysicsMaterial = /*#__PURE__*/ function() {
+        function PhysXPhysicsMaterial(physXPhysics, staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine) {
+            this._physXPhysics = physXPhysics;
+            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;
+    }();
+
+    function _defineProperties(target, props) {
+        for (var i = 0; i < props.length; i++) {
+            var descriptor = props[i];
+            descriptor.enumerable = descriptor.enumerable || false;
+            descriptor.configurable = true;
+
+            if ("value" in descriptor) descriptor.writable = true;
+
+            Object.defineProperty(target, descriptor.key, descriptor);
+        }
+    }
+    function _create_class(Constructor, protoProps, staticProps) {
+        if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+        if (staticProps) _defineProperties(Constructor, staticProps);
+
+        return Constructor;
+    }
+
+    /**
+     * A manager is a collection of colliders and constraints which can interact.
+     */ var PhysXPhysicsScene = /*#__PURE__*/ function() {
+        function PhysXPhysicsScene(physXPhysics, physicsManager) {
+            var _this = this;
+            /** @internal */ this._pxControllerManager = null;
+            // Cached geometry objects for reuse
+            this._boxGeometry = null;
+            this._sphereGeometry = null;
+            this._capsuleGeometry = null;
+            this._activeTriggers = new engine.DisorderedArray();
+            this._contactEvents = [];
+            this._contactEventCount = 0;
+            this._triggerEvents = [];
+            this._physicsEvents = {
+                contactEvents: [],
+                contactEventCount: 0,
+                triggerEvents: []
+            };
+            this._triggerEventPool = [];
+            this._physXPhysics = physXPhysics;
+            this._physXManager = physicsManager;
+            var physX = physXPhysics._physX;
+            this._pxRaycastHit = new physX.PxRaycastHit();
+            this._pxFilterData = new physX.PxQueryFilterData();
+            this._pxFilterData.flags = new physX.PxQueryFlags(1 | 2 | 4 | 8);
+            var triggerCallback = {
+                onContactBegin: function(collision) {
+                    _this._bufferContactEvent(collision, 0);
+                },
+                onContactEnd: function(collision) {
+                    _this._bufferContactEvent(collision, 2);
+                },
+                onContactPersist: function(collision) {
+                    _this._bufferContactEvent(collision, 1);
+                },
+                onTriggerBegin: function(index1, index2) {
+                    var event = index1 < index2 ? _this._getTrigger(index1, index2) : _this._getTrigger(index2, index1);
+                    event.state = 0;
+                    _this._activeTriggers.add(event);
+                },
+                onTriggerEnd: function(index1, index2) {
+                    var event;
+                    if (index1 < index2) {
+                        var subMap = _this._physXManager._eventMap[index1];
+                        event = subMap[index2];
+                        subMap[index2] = undefined;
+                    } else {
+                        var subMap1 = _this._physXManager._eventMap[index2];
+                        event = subMap1[index1];
+                        subMap1[index1] = undefined;
+                    }
+                    event.state = 2;
+                }
+            };
+            var pxPhysics = physXPhysics._pxPhysics;
+            this._physXSimulationCallbackInstance = physX.PxSimulationEventCallback.implement(triggerCallback);
+            var sceneDesc = physX.getDefaultSceneDesc(pxPhysics.getTolerancesScale(), 0, this._physXSimulationCallbackInstance);
+            this._pxScene = pxPhysics.createScene(sceneDesc);
+            sceneDesc.delete();
+        }
+        var _proto = PhysXPhysicsScene.prototype;
+        /**
+       * {@inheritDoc IPhysicsScene.setGravity }
+       */ _proto.setGravity = function setGravity(value) {
+            this._pxScene.setGravity(value);
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.addCollider }
+       */ _proto.addCollider = function addCollider(collider) {
+            collider._scene = this;
+            this._pxScene.addActor(collider._pxActor, null);
+            var shapes = collider._shapes;
+            for(var i = 0, n = shapes.length; i < n; i++){
+                this._addColliderShape(shapes[i]._id);
+            }
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.removeCollider }
+       */ _proto.removeCollider = function removeCollider(collider) {
+            collider._scene = null;
+            this._pxScene.removeActor(collider._pxActor, true);
+            var shapes = collider._shapes;
+            for(var i = 0, n = shapes.length; i < n; i++){
+                this._removeColliderShape(shapes[i]._id);
+            }
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.addCharacterController }
+       */ _proto.addCharacterController = function addCharacterController(characterController) {
+            characterController._scene = this;
+            // 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);
+                    }
+                    this._addColliderShape(shape._id);
+                }
+            }
+            characterController._pxManager = this;
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.removeCharacterController }
+       */ _proto.removeCharacterController = function removeCharacterController(characterController) {
+            characterController._scene = null;
+            characterController._pxManager = null;
+            characterController._destroyPXController();
+            var shape = characterController._shape;
+            shape && this._removeColliderShape(shape._id);
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.update }
+       */ _proto.update = function update(elapsedTime) {
+            this._contactEventCount = 0;
+            this._simulate(elapsedTime);
+            this._fetchResults();
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.updateEvents }
+       */ _proto.updateEvents = function updateEvents() {
+            var physicsEvents = this._physicsEvents;
+            // Collect trigger events: snapshot state for dispatch, then advance
+            var _this = this, triggerEventPool = _this._triggerEventPool, activeTriggers = _this._activeTriggers, triggerEvents = _this._triggerEvents;
+            triggerEvents.length = 0;
+            activeTriggers.forEach(function(event, i) {
+                event.dispatchState = event.state;
+                triggerEvents.push(event);
+                if (event.state === 0) {
+                    event.state = 1;
+                } else if (event.state === 2) {
+                    activeTriggers.deleteByIndex(i);
+                    triggerEventPool.push(event);
+                }
+            });
+            physicsEvents.contactEvents = this._contactEvents;
+            physicsEvents.contactEventCount = this._contactEventCount;
+            physicsEvents.triggerEvents = triggerEvents;
+            return physicsEvents;
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.raycast }
+       */ _proto.raycast = function raycast(ray, distance, onRaycast, hit) {
+            var _this = this, pxHitResult = _this._pxRaycastHit;
+            distance = Math.min(distance, 3.4e38); // float32 max value limit in physX raycast.
+            var raycastCallback = {
+                preFilter: function(filterData, index, actor) {
+                    if (onRaycast(index)) {
+                        return 2; // eBLOCK
+                    } else {
+                        return 0; // eNONE
+                    }
+                },
+                postFilter: function(filterData, distance) {
+                    if (distance <= 0) {
+                        return 0; // eNONE — skip initial overlap
+                    }
+                    return 2; // eBLOCK
+                }
+            };
+            var pxRaycastCallback = this._physXPhysics._physX.PxQueryFilterCallback.implement(raycastCallback);
+            var result = this._pxScene.raycastSingle(ray.origin, ray.direction, distance, pxHitResult, this._pxFilterData, pxRaycastCallback);
+            pxRaycastCallback.delete();
+            if (result && hit != undefined) {
+                var position = PhysXPhysicsScene._tempPosition, normal = PhysXPhysicsScene._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().getUUID(), pxHitResult.distance, position, normal);
+            }
+            return result;
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.boxCast }
+       */ _proto.boxCast = function boxCast(center, orientation, halfExtents, direction, distance, onSweep, outHitResult) {
+            if (!this._boxGeometry) {
+                this._boxGeometry = new this._physXPhysics._physX.PxBoxGeometry(halfExtents.x, halfExtents.y, halfExtents.z);
+            } else {
+                this._boxGeometry.halfExtents = halfExtents;
+            }
+            var pose = PhysXPhysicsScene._tempPose;
+            pose.translation.copyFrom(center);
+            pose.rotation.copyFrom(orientation);
+            return this._sweepSingle(this._boxGeometry, pose, direction, distance, onSweep, outHitResult);
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.sphereCast }
+       */ _proto.sphereCast = function sphereCast(center, radius, direction, distance, onSweep, outHitResult) {
+            if (!this._sphereGeometry) {
+                this._sphereGeometry = new this._physXPhysics._physX.PxSphereGeometry(radius);
+            } else {
+                this._sphereGeometry.radius = radius;
+            }
+            var tempQuat = PhysXPhysicsScene._tempQuaternion;
+            tempQuat.set(0, 0, 0, 1); // Identity quaternion
+            var pose = {
+                translation: center,
+                rotation: tempQuat
+            };
+            return this._sweepSingle(this._sphereGeometry, pose, direction, distance, onSweep, outHitResult);
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.capsuleCast }
+       */ _proto.capsuleCast = function capsuleCast(center, radius, height, orientation, direction, distance, onSweep, outHitResult) {
+            if (!this._capsuleGeometry) {
+                this._capsuleGeometry = new this._physXPhysics._physX.PxCapsuleGeometry(radius, height * 0.5);
+            } else {
+                this._capsuleGeometry.radius = radius;
+                this._capsuleGeometry.halfHeight = height * 0.5;
+            }
+            var pose = PhysXPhysicsScene._tempPose;
+            pose.translation.copyFrom(center);
+            pose.rotation.copyFrom(orientation);
+            return this._sweepSingle(this._capsuleGeometry, pose, direction, distance, onSweep, outHitResult);
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.overlapBoxAll }
+       */ _proto.overlapBoxAll = function overlapBoxAll(center, orientation, halfExtents, onOverlap) {
+            if (!this._boxGeometry) {
+                this._boxGeometry = new this._physXPhysics._physX.PxBoxGeometry(halfExtents.x, halfExtents.y, halfExtents.z);
+            } else {
+                this._boxGeometry.halfExtents = halfExtents;
+            }
+            var pose = PhysXPhysicsScene._tempPose;
+            pose.translation.copyFrom(center);
+            pose.rotation.copyFrom(orientation);
+            return this._overlapMultiple(this._boxGeometry, pose, onOverlap);
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.overlapSphereAll }
+       */ _proto.overlapSphereAll = function overlapSphereAll(center, radius, onOverlap) {
+            if (!this._sphereGeometry) {
+                this._sphereGeometry = new this._physXPhysics._physX.PxSphereGeometry(radius);
+            } else {
+                this._sphereGeometry.radius = radius;
+            }
+            var tempQuat = PhysXPhysicsScene._tempQuaternion;
+            tempQuat.set(0, 0, 0, 1);
+            var pose = {
+                translation: center,
+                rotation: tempQuat
+            };
+            return this._overlapMultiple(this._sphereGeometry, pose, onOverlap);
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.overlapCapsuleAll }
+       */ _proto.overlapCapsuleAll = function overlapCapsuleAll(center, radius, height, orientation, onOverlap) {
+            if (!this._capsuleGeometry) {
+                this._capsuleGeometry = new this._physXPhysics._physX.PxCapsuleGeometry(radius, height * 0.5);
+            } else {
+                this._capsuleGeometry.radius = radius;
+                this._capsuleGeometry.halfHeight = height * 0.5;
+            }
+            var pose = PhysXPhysicsScene._tempPose;
+            pose.translation.copyFrom(center);
+            pose.rotation.copyFrom(orientation);
+            return this._overlapMultiple(this._capsuleGeometry, pose, onOverlap);
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.gc }
+       */ _proto.gc = function gc() {
+            this._contactEvents.length = this._contactEventCount;
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.destroy }
+       */ _proto.destroy = function destroy() {
+            var _this__boxGeometry, _this__sphereGeometry, _this__capsuleGeometry, // Need to release the controller manager before release the scene.
+            _this__pxControllerManager;
+            (_this__boxGeometry = this._boxGeometry) == null ? void 0 : _this__boxGeometry.delete();
+            (_this__sphereGeometry = this._sphereGeometry) == null ? void 0 : _this__sphereGeometry.delete();
+            (_this__capsuleGeometry = this._capsuleGeometry) == null ? void 0 : _this__capsuleGeometry.delete();
+            this._physXSimulationCallbackInstance.delete();
+            this._pxRaycastHit.delete();
+            this._pxFilterData.flags.delete();
+            this._pxFilterData.delete();
+            (_this__pxControllerManager = this._pxControllerManager) == null ? void 0 : _this__pxControllerManager.release();
+            this._pxScene.release();
+        };
+        /**
+       * @internal
+       */ _proto._getControllerManager = function _getControllerManager() {
+            var pxControllerManager = this._pxControllerManager;
+            if (pxControllerManager === null) {
+                this._pxControllerManager = pxControllerManager = this._pxScene.createControllerManager();
+            }
+            return pxControllerManager;
+        };
+        /**
+       * @internal
+       */ _proto._addColliderShape = function _addColliderShape(id) {
+            this._physXManager._eventMap[id] = Object.create(null);
+        };
+        /**
+       * @internal
+       */ _proto._removeColliderShape = function _removeColliderShape(id) {
+            var _this = this, triggerEventPool = _this._triggerEventPool, activeTriggers = _this._activeTriggers;
+            var _this__physXManager = this._physXManager, eventMap = _this__physXManager._eventMap;
+            activeTriggers.forEach(function(event, i) {
+                if (event.index1 == id) {
+                    activeTriggers.deleteByIndex(i);
+                    triggerEventPool.push(event);
+                } else if (event.index2 == id) {
+                    activeTriggers.deleteByIndex(i);
+                    triggerEventPool.push(event);
+                    // If the shape is big index, should clear from the small index shape subMap
+                    eventMap[event.index1][id] = undefined;
+                }
+            });
+            delete eventMap[id];
+        };
+        _proto._sweepSingle = function _sweepSingle(geometry, pose, direction, distance, onSweep, outHitResult) {
+            distance = Math.min(distance, 3.4e38); // float32 max value limit in physx sweep
+            var sweepCallback = {
+                preFilter: function(filterData, index, actor) {
+                    if (onSweep(index)) {
+                        return 2; // eBLOCK
+                    } else {
+                        return 0; // eNONE
+                    }
+                },
+                postFilter: function(filterData, distance) {
+                    if (distance <= 0) {
+                        return 0; // eNONE — skip initial overlap
+                    }
+                    return 2; // eBLOCK
+                }
+            };
+            var pxSweepCallback = this._physXPhysics._physX.PxQueryFilterCallback.implement(sweepCallback);
+            var pxSweepHit = new this._physXPhysics._physX.PxSweepHit();
+            var result = this._pxScene.sweepSingle(geometry, pose, direction, distance, pxSweepHit, this._pxFilterData, pxSweepCallback);
+            if (result && outHitResult != undefined) {
+                var position = PhysXPhysicsScene._tempPosition, normal = PhysXPhysicsScene._tempNormal;
+                var pxPosition = pxSweepHit.position, pxNormal = pxSweepHit.normal;
+                position.set(pxPosition.x, pxPosition.y, pxPosition.z);
+                normal.set(pxNormal.x, pxNormal.y, pxNormal.z);
+                outHitResult(pxSweepHit.getShape().getUUID(), pxSweepHit.distance, position, normal);
+            }
+            pxSweepCallback.delete();
+            pxSweepHit.delete();
+            return result;
+        };
+        _proto._overlapMultiple = function _overlapMultiple(geometry, pose, onOverlap) {
+            var overlapCallback = {
+                preFilter: function(filterData, index, actor) {
+                    return onOverlap(index) ? 2 : 0;
+                }
+            };
+            var pxOverlapCallback = this._physXPhysics._physX.PxQueryFilterCallback.implement(overlapCallback);
+            var maxHits = 256;
+            var hits = this._pxScene.overlapMultiple(geometry, pose, maxHits, this._pxFilterData, pxOverlapCallback);
+            var result = PhysXPhysicsScene._tempShapeIDs;
+            result.length = 0;
+            if (hits) {
+                // PhysX overlapMultiple returns a collection with size() method
+                for(var i = 0, n = hits.size(); i < n; i++){
+                    result.push(hits.get(i).getShape().getUUID());
+                }
+            }
+            pxOverlapCallback.delete();
+            hits == null ? void 0 : hits.delete();
+            return result;
+        };
+        _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._triggerEventPool.length) {
+                event = this._triggerEventPool.pop();
+                event.index1 = index1;
+                event.index2 = index2;
+            } else {
+                event = new TriggerEvent(index1, index2);
+            }
+            this._physXManager._eventMap[index1][index2] = event;
+            return event;
+        };
+        _proto._bufferContactEvent = function _bufferContactEvent(collision, state) {
+            var _this__contactEvents, _index;
+            var index = this._contactEventCount++;
+            var event = (_this__contactEvents = this._contactEvents)[_index = index] || (_this__contactEvents[_index] = new ContactEvent());
+            event.shape0Id = collision.shape0Id;
+            event.shape1Id = collision.shape1Id;
+            event.state = state;
+            // Copy contact points from PhysX (the native data is only valid during fetchResults)
+            var nativeContacts = collision.getContacts();
+            var count = nativeContacts.size();
+            var bufferedContacts = event._bufferedContacts;
+            bufferedContacts.contactCount = count;
+            for(var i = 0; i < count; i++){
+                var _bufferedContacts_contacts, _i;
+                var src = nativeContacts.get(i);
+                var dst = (_bufferedContacts_contacts = bufferedContacts.contacts)[_i = i] || (_bufferedContacts_contacts[_i] = new BufferedContactPoint());
+                dst.position.copyFrom(src.position);
+                dst.normal.copyFrom(src.normal);
+                dst.impulse.copyFrom(src.impulse);
+                dst.separation = src.separation;
+            }
+        };
+        return PhysXPhysicsScene;
+    }();
+    PhysXPhysicsScene._tempPosition = new engine.Vector3();
+    PhysXPhysicsScene._tempQuaternion = new engine.Quaternion();
+    PhysXPhysicsScene._tempNormal = new engine.Vector3();
+    PhysXPhysicsScene._tempPose = {
+        translation: new engine.Vector3(),
+        rotation: new engine.Quaternion()
+    };
+    PhysXPhysicsScene._tempShapeIDs = [];
+    /**
+     * Trigger event to store interactive object ids and state.
+     */ var TriggerEvent = function TriggerEvent(index1, index2) {
+        this.index1 = index1;
+        this.index2 = index2;
+    };
+    /**
+     * Buffered contact point data, copied from PhysX during fetchResults.
+     */ var BufferedContactPoint = function BufferedContactPoint() {
+        this.position = new engine.Vector3();
+        this.normal = new engine.Vector3();
+        this.impulse = new engine.Vector3();
+        this.separation = 0;
+    };
+    /**
+     * Contact event buffered from PhysX fetchResults callback.
+     * Implements ICollision so it can be passed directly to the core layer.
+     */ var BufferedContacts = /*#__PURE__*/ function() {
+        function BufferedContacts() {
+            this.contactCount = 0;
+            this.contacts = [];
+        }
+        var _proto = BufferedContacts.prototype;
+        _proto.size = function size() {
+            return this.contactCount;
+        };
+        _proto.get = function get(index) {
+            return this.contacts[index];
+        };
+        return BufferedContacts;
+    }();
+    var ContactEvent = /*#__PURE__*/ function() {
+        function ContactEvent() {
+            /** @internal */ this._bufferedContacts = new BufferedContacts();
+        }
+        var _proto = ContactEvent.prototype;
+        _proto.getContacts = function getContacts() {
+            return this._bufferedContacts;
+        };
+        _create_class(ContactEvent, [
+            {
+                key: "contactCount",
+                get: function get() {
+                    return this._bufferedContacts.contactCount;
+                }
+            }
+        ]);
+        return ContactEvent;
+    }();
+
+    /**
+     * 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(physXPhysics, position, rotation) {
+            var _this;
+            _this = PhysXCollider.call(this, physXPhysics) || this;
+            _this._pxActor = physXPhysics._pxPhysics.createRigidStatic(_this._transform(position, rotation));
+            return _this;
+        }
+        return PhysXStaticCollider;
+    }(PhysXCollider);
+
+    /**
+     * PhysX runtime mode.
+     */ var PhysXRuntimeMode = /*#__PURE__*/ function(PhysXRuntimeMode) {
+        /** Use WebAssembly SIMD mode first, then WebAssembly as fallback. */ PhysXRuntimeMode[PhysXRuntimeMode["Auto"] = 0] = "Auto";
+        /** WebAssembly mode. */ PhysXRuntimeMode[PhysXRuntimeMode["WebAssembly"] = 1] = "WebAssembly";
+        /** WebAssembly SIMD mode. */ PhysXRuntimeMode[PhysXRuntimeMode["WebAssemblySIMD"] = 2] = "WebAssemblySIMD";
+        return PhysXRuntimeMode;
+    }({});
+
+    /**
+     * a base interface providing common functionality for PhysX joints
+     */ var PhysXJoint = /*#__PURE__*/ function() {
+        function PhysXJoint(physXPhysics) {
+            this._rotation = new engine.Quaternion();
+            this._breakForce = Number.MAX_VALUE;
+            this._breakTorque = Number.MAX_VALUE;
+            this._physXPhysics = physXPhysics;
+        }
+        var _proto = PhysXJoint.prototype;
+        /**
+       * {@inheritDoc IJoint.setConnectedCollider }
+       */ _proto.setConnectedCollider = function setConnectedCollider(value) {
+            var _this__collider;
+            this._pxJoint.setActors(((_this__collider = this._collider) == null ? void 0 : _this__collider._pxActor) || null, (value == null ? void 0 : value._pxActor) || null);
+        };
+        /**
+       * {@inheritDoc IJoint.setConnectedAnchor }
+       */ _proto.setAnchor = function setAnchor(value) {
+            this._setLocalPose(0, value, PhysXJoint._defaultQuat);
+            this._anchor = value;
+        };
+        /**
+       * {@inheritDoc IJoint.setConnectedAnchor }
+       */ _proto.setConnectedAnchor = function setConnectedAnchor(value) {
+            this._setLocalPose(1, value, this._rotation);
+            this._connectedAnchor = value;
+        };
+        _proto.setRotation = function setRotation(value) {
+            this._setLocalPose(1, this._connectedAnchor, value);
+            this._rotation.copyFrom(value);
+        };
+        /**
+       * {@inheritDoc IJoint.setMassScale }
+       */ _proto.setMassScale = function setMassScale(value) {
+            this._pxJoint.setInvMassScale0(1 / value);
+        };
+        /**
+       * {@inheritDoc IJoint.setConnectedMassScale }
+       */ _proto.setConnectedMassScale = function setConnectedMassScale(value) {
+            this._pxJoint.setInvMassScale1(1 / value);
+        };
+        /**
+       * {@inheritDoc IJoint.setInertiaScale }
+       */ _proto.setInertiaScale = function setInertiaScale(value) {
+            this._pxJoint.setInvInertiaScale0(value);
+        };
+        /**
+       * {@inheritDoc IJoint.setConnectedInertiaScale }
+       */ _proto.setConnectedInertiaScale = function setConnectedInertiaScale(value) {
+            this._pxJoint.setInvInertiaScale1(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);
+        };
+        /**
+       * {@inheritDoc IJoint.destroy }
+       */ _proto.destroy = function destroy() {
+            if (!this._pxJoint) return;
+            this._pxJoint.release();
+            this._collider = null;
+        };
+        /**
+       * 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._defaultVec = new engine.Vector3();
+    PhysXJoint._defaultQuat = new engine.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(physXPhysics, collider) {
+            var _this;
+            _this = PhysXJoint1.call(this, physXPhysics) || this;
+            _this._collider = collider;
+            _this._pxJoint = physXPhysics._pxPhysics.createFixedJoint(collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, null, 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(physXPhysics, collider) {
+            var _this;
+            _this = PhysXJoint1.call(this, physXPhysics) || this, _this._axisRotationQuaternion = new engine.Quaternion(), _this._connectedAxisRotationQuaternion = new engine.Quaternion();
+            _this._collider = collider;
+            _this._pxJoint = physXPhysics._pxPhysics.createRevoluteJoint(collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, null, PhysXJoint._defaultVec, PhysXJoint._defaultQuat);
+            return _this;
+        }
+        var _proto = PhysXHingeJoint.prototype;
+        _proto.setRotation = function setRotation(value) {
+            var axis = this._axis;
+            this._rotation.copyFrom(value);
+            axis && this.setAxis(axis);
+        };
+        /**
+       * {@inheritDoc IHingeJoint.setAxis }
+       */ _proto.setAxis = function setAxis(value) {
+            this._axis = value;
+            var xAxis = PhysXHingeJoint._xAxis;
+            var axisRotationQuaternion = this._axisRotationQuaternion;
+            xAxis.set(1, 0, 0);
+            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._anchor, axisRotationQuaternion);
+            var connectedAxisRotationQuaternion = this._connectedAxisRotationQuaternion;
+            engine.Quaternion.multiply(this._rotation, axisRotationQuaternion, connectedAxisRotationQuaternion);
+            this._setLocalPose(1, this._connectedAnchor, connectedAxisRotationQuaternion);
+        };
+        _proto.setAnchor = function setAnchor(value) {
+            this._setLocalPose(0, value, this._axisRotationQuaternion);
+            this._anchor = value;
+        };
+        /**
+       * {@inheritDoc IJoint.setConnectedAnchor }
+       */ _proto.setConnectedAnchor = function setConnectedAnchor(value) {
+            this._setLocalPose(1, value, this._connectedAxisRotationQuaternion);
+            this._connectedAnchor = value;
+        };
+        /**
+       * {@inheritDoc IHingeJoint.getAngle }
+       */ _proto.getAngle = function getAngle() {
+            return engine.MathUtil.radianToDegree(this._pxJoint.getAngle());
+        };
+        /**
+       * {@inheritDoc IHingeJoint.getVelocity }
+       */ _proto.getVelocity = function getVelocity() {
+            return this._pxJoint.getVelocity();
+        };
+        /**
+       * {@inheritDoc IHingeJoint.setHardLimitCone }
+       */ _proto.setHardLimit = function setHardLimit(lowerLimit, upperLimit, contactDist) {
+            this._pxJoint.setHardLimit(engine.MathUtil.degreeToRadian(lowerLimit), engine.MathUtil.degreeToRadian(upperLimit), contactDist);
+        };
+        /**
+       * {@inheritDoc IHingeJoint.setHardLimitCone }
+       */ _proto.setSoftLimit = function setSoftLimit(lowerLimit, upperLimit, stiffness, damping) {
+            this._pxJoint.setSoftLimit(engine.MathUtil.degreeToRadian(lowerLimit), engine.MathUtil.degreeToRadian(upperLimit), stiffness, damping);
+        };
+        /**
+       * {@inheritDoc IHingeJoint.setDriveVelocity }
+       */ _proto.setDriveVelocity = function setDriveVelocity(velocity, autowake) {
+            if (autowake === void 0) autowake = true;
+            this._pxJoint.setDriveVelocity(velocity, autowake);
+        };
+        /**
+       * {@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);
+    PhysXHingeJoint._xAxis = new engine.Vector3(1, 0, 0);
+
+    /**
+     * 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(physXPhysics, collider) {
+            var _this;
+            _this = PhysXJoint1.call(this, physXPhysics) || this;
+            _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.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);
+
+    function _assert_this_initialized(self) {
+        if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+
+        return self;
+    }
+
+    function _type_of(obj) {
+        "@swc/helpers - typeof";
+
+        return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+    }
+
+    function _possible_constructor_return(self, call) {
+        if (call && (_type_of(call) === "object" || typeof call === "function")) return call;
+
+        return _assert_this_initialized(self);
+    }
+
+    /**
+     * Mesh collider shape in PhysX.
+     */ var PhysXMeshColliderShape = /*#__PURE__*/ function(PhysXColliderShape) {
+        _inherits(PhysXMeshColliderShape, PhysXColliderShape);
+        function PhysXMeshColliderShape(physXPhysics, uniqueID, positions, indices, isConvex, material, cookingFlags) {
+            var _this;
+            _this = PhysXColliderShape.call(this, physXPhysics) || this, _this._pxMesh = null;
+            _this._isConvex = isConvex;
+            if (!_this._cookMesh(positions, indices, cookingFlags)) {
+                return _possible_constructor_return(_this);
+            }
+            var physX = physXPhysics._physX, physics = physXPhysics._pxPhysics;
+            var _this__worldScale = _this._worldScale, scaleX = _this__worldScale.x, scaleY = _this__worldScale.y, scaleZ = _this__worldScale.z;
+            var shapeFlags = ShapeFlag.SCENE_QUERY_SHAPE | ShapeFlag.SIMULATION_SHAPE;
+            var meshFlag = isConvex ? PhysXMeshColliderShape._tightBoundsFlag : 0;
+            var createShapeFn = isConvex ? physX.createConvexMeshShape : physX.createTriMeshShape;
+            _this._pxShape = createShapeFn(_this._pxMesh, scaleX, scaleY, scaleZ, meshFlag, shapeFlags, material._pxMaterial, physics);
+            _this._id = uniqueID;
+            _this._pxMaterial = material._pxMaterial;
+            _this._pxShape.setUUID(uniqueID);
+            _this._setLocalPose();
+            return _this;
+        }
+        var _proto = PhysXMeshColliderShape.prototype;
+        /**
+       * {@inheritDoc IMeshColliderShape.setMeshData }
+       */ _proto.setMeshData = function setMeshData(positions, indices, isConvex, cookingFlags) {
+            var _this__pxMesh, _this__pxGeometry;
+            (_this__pxMesh = this._pxMesh) == null ? void 0 : _this__pxMesh.release();
+            (_this__pxGeometry = this._pxGeometry) == null ? void 0 : _this__pxGeometry.delete();
+            this._pxMesh = null;
+            this._pxGeometry = null;
+            this._isConvex = isConvex;
+            if (!this._cookMesh(positions, indices, cookingFlags)) {
+                return false;
+            }
+            this._pxShape.setGeometry(this._pxGeometry);
+            return true;
+        };
+        /**
+       * {@inheritDoc IColliderShape.setWorldScale }
+       */ _proto.setWorldScale = function setWorldScale(scale) {
+            PhysXColliderShape.prototype.setWorldScale.call(this, scale);
+            this._updateGeometry();
+        };
+        /**
+       * {@inheritDoc IColliderShape.destroy }
+       */ _proto.destroy = function destroy() {
+            var _this__pxMesh;
+            (_this__pxMesh = this._pxMesh) == null ? void 0 : _this__pxMesh.release();
+            PhysXColliderShape.prototype.destroy.call(this);
+        };
+        _proto._cookMesh = function _cookMesh(positions, indices, cookingFlags) {
+            var _this__physXPhysics = this._physXPhysics, physX = _this__physXPhysics._physX, physics = _this__physXPhysics._pxPhysics, cooking = _this__physXPhysics._pxCooking, cookingParams = _this__physXPhysics._pxCookingParams;
+            // Apply per-shape cooking flags
+            var preprocessFlags = 0;
+            if (cookingFlags & engine.MeshColliderShapeCookingFlag.VertexWelding) {
+                preprocessFlags |= 1; // eWELD_VERTICES
+            }
+            if (!(cookingFlags & engine.MeshColliderShapeCookingFlag.Cleaning)) {
+                preprocessFlags |= 2; // eDISABLE_CLEAN_MESH
+            }
+            physX.setCookingMeshPreprocessParams(cookingParams, preprocessFlags);
+            cooking.setParams(cookingParams);
+            var verticesPtr = this._allocatePositions(positions);
+            if (this._isConvex) {
+                this._pxMesh = cooking.createConvexMesh(verticesPtr, positions.length, physics);
+                physX._free(verticesPtr);
+                if (!this._pxMesh) {
+                    this._logConvexCookingError(physX);
+                    return false;
+                }
+            } else {
+                if (!indices) {
+                    physX._free(verticesPtr);
+                    console.error("PhysXMeshColliderShape: Triangle mesh requires indices.");
+                    return false;
+                }
+                var isU32 = _instanceof(indices, Uint32Array);
+                var indicesPtr = this._allocateIndices(indices, isU32);
+                this._pxMesh = cooking.createTriMesh(verticesPtr, positions.length, indicesPtr, indices.length / 3, !isU32, physics);
+                physX._free(verticesPtr);
+                physX._free(indicesPtr);
+                if (!this._pxMesh) {
+                    this._logTriMeshCookingError(physX);
+                    return false;
+                }
+            }
+            var _this__worldScale = this._worldScale, scaleX = _this__worldScale.x, scaleY = _this__worldScale.y, scaleZ = _this__worldScale.z;
+            var meshFlag = this._isConvex ? PhysXMeshColliderShape._tightBoundsFlag : 0;
+            this._pxGeometry = this._isConvex ? physX.createConvexMeshGeometry(this._pxMesh, scaleX, scaleY, scaleZ, meshFlag) : physX.createTriMeshGeometry(this._pxMesh, scaleX, scaleY, scaleZ, meshFlag);
+            return true;
+        };
+        _proto._logConvexCookingError = function _logConvexCookingError(physX) {
+            switch(physX.getLastConvexCookingResult()){
+                case 1:
+                    console.error("PhysXMeshColliderShape: Failed to create convex mesh. Could not find 4 vertices that do not form a zero-area triangle.");
+                    break;
+                case 2:
+                    console.error("PhysXMeshColliderShape: Failed to create convex mesh within the maximum polygons limit (256). Consider simplifying the mesh.");
+                    break;
+                default:
+                    console.error("PhysXMeshColliderShape: Failed to create convex mesh. The input geometry may be invalid.");
+                    break;
+            }
+        };
+        _proto._logTriMeshCookingError = function _logTriMeshCookingError(physX) {
+            switch(physX.getLastTriMeshCookingResult()){
+                case 1:
+                    console.error("PhysXMeshColliderShape: Failed to create triangle mesh. One of the triangles is too large. Consider tessellating large triangles.");
+                    break;
+                default:
+                    console.error("PhysXMeshColliderShape: Failed to create triangle mesh. The input geometry may be invalid.");
+                    break;
+            }
+        };
+        _proto._allocatePositions = function _allocatePositions(positions) {
+            var physX = this._physXPhysics._physX;
+            var length = positions.length;
+            var ptr = physX._malloc(length * 3 * 4);
+            var view = new Float32Array(physX.HEAPF32.buffer, ptr, length * 3);
+            for(var i = 0, offset = 0; i < length; i++, offset += 3){
+                positions[i].copyToArray(view, offset);
+            }
+            return ptr;
+        };
+        _proto._allocateIndices = function _allocateIndices(indices, isU32) {
+            var physX = this._physXPhysics._physX;
+            // Uint8Array and Uint16Array both write as Uint16 (PhysX minimum index size)
+            var TypedArrayCtor = isU32 ? Uint32Array : Uint16Array;
+            var heap = isU32 ? physX.HEAPU32 : physX.HEAPU16;
+            var ptr = physX._malloc(indices.length * TypedArrayCtor.BYTES_PER_ELEMENT);
+            new TypedArrayCtor(heap.buffer, ptr, indices.length).set(indices);
+            return ptr;
+        };
+        _proto._updateGeometry = function _updateGeometry() {
+            if (!this._pxMesh) return;
+            var physX = this._physXPhysics._physX;
+            var _this__worldScale = this._worldScale, scaleX = _this__worldScale.x, scaleY = _this__worldScale.y, scaleZ = _this__worldScale.z;
+            var meshFlag = this._isConvex ? PhysXMeshColliderShape._tightBoundsFlag : 0;
+            var newGeometry = this._isConvex ? physX.createConvexMeshGeometry(this._pxMesh, scaleX, scaleY, scaleZ, meshFlag) : physX.createTriMeshGeometry(this._pxMesh, scaleX, scaleY, scaleZ, meshFlag);
+            this._pxGeometry.delete();
+            this._pxGeometry = newGeometry;
+            this._pxShape.setGeometry(this._pxGeometry);
+        };
+        return PhysXMeshColliderShape;
+    }(PhysXColliderShape);
+    PhysXMeshColliderShape._tightBoundsFlag = 1 // eTIGHT_BOUNDS = 1 (1<<0)
+    ;
+
+    /**
+     * Plane collider shape in PhysX.
+     */ var PhysXPlaneColliderShape = /*#__PURE__*/ function(PhysXColliderShape1) {
+        _inherits(PhysXPlaneColliderShape, PhysXColliderShape1);
+        function PhysXPlaneColliderShape(physXPhysics, uniqueID, material) {
+            var _this;
+            _this = PhysXColliderShape1.call(this, physXPhysics) || this;
+            _this._axis = new engine.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;
+        }
+        return PhysXPlaneColliderShape;
+    }(PhysXColliderShape);
+
+    /**
+     * Sphere collider shape in PhysX.
+     */ var PhysXSphereColliderShape = /*#__PURE__*/ function(PhysXColliderShape) {
+        _inherits(PhysXSphereColliderShape, PhysXColliderShape);
+        function PhysXSphereColliderShape(physXPhysics, uniqueID, radius, material) {
+            var _this;
+            _this = PhysXColliderShape.call(this, physXPhysics) || this, _this._maxScale = 1;
+            _this._radius = radius;
+            _this._pxGeometry = new physXPhysics._physX.PxSphereGeometry(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) {
+            PhysXColliderShape.prototype.setWorldScale.call(this, scale);
+            this._maxScale = Math.max(Math.abs(scale.x), Math.abs(scale.y), Math.abs(scale.z));
+            this._pxGeometry.radius = this._radius * this._maxScale;
+            this._pxShape.setGeometry(this._pxGeometry);
+        };
+        return PhysXSphereColliderShape;
+    }(PhysXColliderShape);
+
+    /**
+     * PhysX object creation.
+     */ var PhysXPhysics = /*#__PURE__*/ function() {
+        function PhysXPhysics(runtimeMode, runtimeUrls) {
+            if (runtimeMode === void 0) runtimeMode = PhysXRuntimeMode.Auto;
+            this._initializeState = 0;
+            this._runTimeMode = runtimeMode;
+            var _runtimeUrls_wasmSIMDModeUrl;
+            this._wasmSIMDModeUrl = (_runtimeUrls_wasmSIMDModeUrl = runtimeUrls == null ? void 0 : runtimeUrls.wasmSIMDModeUrl) != null ? _runtimeUrls_wasmSIMDModeUrl : "https://mdn.alipayobjects.com/rms/afts/file/A*iHrYQKBrgTAAAAAAQ4AAAAgAehQnAQ/physx.release.simd.js";
+            var _runtimeUrls_wasmModeUrl;
+            this._wasmModeUrl = (_runtimeUrls_wasmModeUrl = runtimeUrls == null ? void 0 : runtimeUrls.wasmModeUrl) != null ? _runtimeUrls_wasmModeUrl : "https://mdn.alipayobjects.com/rms/afts/file/A*DFuvR6Mv5C0AAAAAQ4AAAAgAehQnAQ/physx.release.js";
+        }
+        var _proto = PhysXPhysics.prototype;
+        /**
+       * Initialize PhysXPhysics.
+       * @param runtimeMode - Runtime mode
+       * @returns Promise object
+       */ _proto.initialize = function initialize() {
+            var _this = this;
+            if (this._initializeState === 2) {
+                return Promise.resolve();
+            } else if (this._initializeState === 1) {
+                return this._initializePromise;
+            }
+            this._initializeState = 1;
+            var runtimeMode = this._runTimeMode;
+            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) {
+                    runtimeMode = engine.SystemInfo._detectSIMDSupported() ? PhysXRuntimeMode.WebAssemblySIMD : PhysXRuntimeMode.WebAssembly;
+                }
+                if (runtimeMode == PhysXRuntimeMode.WebAssemblySIMD) {
+                    script.src = _this._wasmSIMDModeUrl;
+                } else {
+                    script.src = _this._wasmModeUrl;
+                }
+            });
+            var initializePromise = new Promise(function(resolve, reject) {
+                scriptPromise.then(function() {
+                    return window.PHYSX().then(function(PHYSX) {
+                        _this._runTimeMode = runtimeMode;
+                        _this._init(PHYSX);
+                        _this._initializeState = 2;
+                        _this._initializePromise = null;
+                        console.log("PhysX loaded.");
+                        resolve();
+                    }, reject);
+                }, reject).catch(reject);
+            });
+            this._initializePromise = initializePromise;
+            return initializePromise;
+        };
+        /**
+       * Destroy PhysXPhysics.
+       */ _proto.destroy = function destroy() {
+            this._pxCooking.release();
+            this._pxCookingParams.delete();
+            this._physX.PxCloseExtensions();
+            this._pxPhysics.release();
+            this._pxFoundation.release();
+            this._defaultErrorCallback.delete();
+            this._allocator.delete();
+            this._tolerancesScale.delete();
+        };
+        /**
+       * {@inheritDoc IPhysics.createPhysicsManager }
+       */ _proto.createPhysicsManager = function createPhysicsManager() {
+            return new PhysXPhysicsManager();
+        };
+        /**
+       * {@inheritDoc IPhysics.createPhysicsScene }
+       */ _proto.createPhysicsScene = function createPhysicsScene(physicsManager) {
+            var scene = new PhysXPhysicsScene(this, physicsManager);
+            return scene;
+        };
+        /**
+       * {@inheritDoc IPhysics.createStaticCollider }
+       */ _proto.createStaticCollider = function createStaticCollider(position, rotation) {
+            return new PhysXStaticCollider(this, position, rotation);
+        };
+        /**
+       * {@inheritDoc IPhysics.createDynamicCollider }
+       */ _proto.createDynamicCollider = function createDynamicCollider(position, rotation) {
+            return new PhysXDynamicCollider(this, position, rotation);
+        };
+        /**
+       * {@inheritDoc IPhysics.createCharacterController }
+       */ _proto.createCharacterController = function createCharacterController() {
+            return new PhysXCharacterController(this);
+        };
+        /**
+       * {@inheritDoc IPhysics.createPhysicsMaterial }
+       */ _proto.createPhysicsMaterial = function createPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine) {
+            return new PhysXPhysicsMaterial(this, staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine);
+        };
+        /**
+       * {@inheritDoc IPhysics.createBoxColliderShape }
+       */ _proto.createBoxColliderShape = function createBoxColliderShape(uniqueID, size, material) {
+            return new PhysXBoxColliderShape(this, uniqueID, size, material);
+        };
+        /**
+       * {@inheritDoc IPhysics.createSphereColliderShape }
+       */ _proto.createSphereColliderShape = function createSphereColliderShape(uniqueID, radius, material) {
+            return new PhysXSphereColliderShape(this, uniqueID, radius, material);
+        };
+        /**
+       * {@inheritDoc IPhysics.createPlaneColliderShape }
+       */ _proto.createPlaneColliderShape = function createPlaneColliderShape(uniqueID, material) {
+            return new PhysXPlaneColliderShape(this, uniqueID, material);
+        };
+        /**
+       * {@inheritDoc IPhysics.createCapsuleColliderShape }
+       */ _proto.createCapsuleColliderShape = function createCapsuleColliderShape(uniqueID, radius, height, material) {
+            return new PhysXCapsuleColliderShape(this, uniqueID, radius, height, material);
+        };
+        /**
+       * {@inheritDoc IPhysics.createMeshColliderShape }
+       */ _proto.createMeshColliderShape = function createMeshColliderShape(uniqueID, positions, indices, isConvex, material, cookingFlags) {
+            var shape = new PhysXMeshColliderShape(this, uniqueID, positions, indices, isConvex, material, cookingFlags);
+            return shape._pxShape ? shape : null;
+        };
+        /**
+       * {@inheritDoc IPhysics.createFixedJoint }
+       */ _proto.createFixedJoint = function createFixedJoint(collider) {
+            return new PhysXFixedJoint(this, collider);
+        };
+        /**
+       * {@inheritDoc IPhysics.createHingeJoint }
+       */ _proto.createHingeJoint = function createHingeJoint(collider) {
+            return new PhysXHingeJoint(this, collider);
+        };
+        /**
+       * {@inheritDoc IPhysics.createSpringJoint }
+       */ _proto.createSpringJoint = function createSpringJoint(collider) {
+            return new PhysXSpringJoint(this, collider);
+        };
+        /**
+       * {@inheritDoc IPhysics.getColliderLayerCollision }
+       */ _proto.getColliderLayerCollision = function getColliderLayerCollision(layer1, layer2) {
+            return this._physX.getGroupCollisionFlag(layer1, layer2);
+        };
+        /**
+       * {@inheritDoc IPhysics.setColliderLayerCollision }
+       */ _proto.setColliderLayerCollision = function setColliderLayerCollision(layer1, layer2, isCollide) {
+            this._physX.setGroupCollisionFlag(layer1, layer2, isCollide);
+        };
+        _proto._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 tolerancesScale = new physX.PxTolerancesScale();
+            var pxPhysics = physX.PxCreatePhysics(version, pxFoundation, tolerancesScale, false, null);
+            physX.PxInitExtensions(pxPhysics, null);
+            // Initialize cooking for mesh colliders
+            var cookingParams = new physX.PxCookingParams(tolerancesScale);
+            physX.setCookingMeshPreprocessParams(cookingParams, 1); // eWELD_VERTICES
+            cookingParams.meshWeldTolerance = 0.001;
+            // BVH34 midphase requires SSE2; SIMD WASM provides SSE2 via WASM SIMD
+            if (this._runTimeMode === PhysXRuntimeMode.WebAssemblySIMD) {
+                physX.setCookingMidphaseType(cookingParams, 1); // eBVH34
+            }
+            var pxCooking = physX.PxCreateCooking(version, pxFoundation, cookingParams);
+            this._physX = physX;
+            this._pxFoundation = pxFoundation;
+            this._pxPhysics = pxPhysics;
+            this._pxCooking = pxCooking;
+            this._pxCookingParams = cookingParams;
+            this._defaultErrorCallback = defaultErrorCallback;
+            this._allocator = allocator;
+            this._tolerancesScale = tolerancesScale;
+        };
+        return PhysXPhysics;
+    }();
+
+    //@ts-ignore
+    var version = "0.0.0-experimental-2.0-game";
+    console.log("Galacean Engine Physics PhysX Version: " + version);
+
+    exports.PhysXPhysics = PhysXPhysics;
+    exports.PhysXRuntimeMode = PhysXRuntimeMode;
+    exports.version = version;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=browser.js.map