@babylonjs/core 7.12.0 → 7.13.1

package/Physics/v2/Plugins/havokPlugin.js

@@ -1,7 +1,6 @@
 import { Matrix, Quaternion, TmpVectors, Vector3 } from "../../../Maths/math.vector.js";
-import { PhysicsShapeType, PhysicsConstraintType, PhysicsMotionType, PhysicsConstraintMotorType, PhysicsConstraintAxis, PhysicsConstraintAxisLimitMode, PhysicsEventType, PhysicsActivationControl, } from "../IPhysicsEnginePlugin.js";
+import { PhysicsPrestepType, } from "../IPhysicsEnginePlugin.js";
 import { Logger } from "../../../Misc/logger.js";
-import { PhysicsMaterialCombineMode } from "../physicsMaterial.js";
 import { PhysicsShape } from "../physicsShape.js";
 import { BoundingBox } from "../../../Culling/boundingBox.js";
 import { Mesh } from "../../../Meshes/mesh.js";
@@ -688,13 +687,13 @@ export class HavokPlugin {
     }
     _internalSetMotionType(pluginData, motionType) {
         switch (motionType) {
-            case PhysicsMotionType.STATIC:
+            case 0 /* PhysicsMotionType.STATIC */:
                 this._hknp.HP_Body_SetMotionType(pluginData.hpBodyId, this._hknp.MotionType.STATIC);
                 break;
-            case PhysicsMotionType.ANIMATED:
+            case 1 /* PhysicsMotionType.ANIMATED */:
                 this._hknp.HP_Body_SetMotionType(pluginData.hpBodyId, this._hknp.MotionType.KINEMATIC);
                 break;
-            case PhysicsMotionType.DYNAMIC:
+            case 2 /* PhysicsMotionType.DYNAMIC */:
                 this._hknp.HP_Body_SetMotionType(pluginData.hpBodyId, this._hknp.MotionType.DYNAMIC);
                 break;
         }
@@ -721,11 +720,11 @@ export class HavokPlugin {
         const type = this._hknp.HP_Body_GetMotionType(pluginRef.hpBodyId)[1];
         switch (type) {
             case this._hknp.MotionType.STATIC:
-                return PhysicsMotionType.STATIC;
+                return 0 /* PhysicsMotionType.STATIC */;
             case this._hknp.MotionType.KINEMATIC:
-                return PhysicsMotionType.ANIMATED;
+                return 1 /* PhysicsMotionType.ANIMATED */;
             case this._hknp.MotionType.DYNAMIC:
-                return PhysicsMotionType.DYNAMIC;
+                return 2 /* PhysicsMotionType.DYNAMIC */;
         }
         throw new Error("Unknown motion type: " + type);
     }
@@ -736,13 +735,13 @@ export class HavokPlugin {
      */
     setActivationControl(body, controlMode) {
         switch (controlMode) {
-            case PhysicsActivationControl.ALWAYS_ACTIVE:
+            case 1 /* PhysicsActivationControl.ALWAYS_ACTIVE */:
                 this._hknp.HP_Body_SetActivationControl(body._pluginData.hpBodyId, this._hknp.ActivationControl.ALWAYS_ACTIVE);
                 break;
-            case PhysicsActivationControl.ALWAYS_INACTIVE:
+            case 2 /* PhysicsActivationControl.ALWAYS_INACTIVE */:
                 this._hknp.HP_Body_SetActivationControl(body._pluginData.hpBodyId, this._hknp.ActivationControl.ALWAYS_INACTIVE);
                 break;
-            case PhysicsActivationControl.SIMULATION_CONTROLLED:
+            case 0 /* PhysicsActivationControl.SIMULATION_CONTROLLED */:
                 this._hknp.HP_Body_SetActivationControl(body._pluginData.hpBodyId, this._hknp.ActivationControl.SIMULATION_CONTROLLED);
                 break;
         }
@@ -980,20 +979,28 @@ export class HavokPlugin {
      * same transformation.
      */
     setPhysicsBodyTransformation(body, node) {
-        const transformNode = body.transformNode;
-        if (body.numInstances > 0) {
-            // instances
-            const m = transformNode;
-            const matrixData = m._thinInstanceDataStorage.matrixData;
-            if (!matrixData) {
-                return; // TODO: error handling
+        if (body.getPrestepType() == PhysicsPrestepType.TELEPORT) {
+            const transformNode = body.transformNode;
+            if (body.numInstances > 0) {
+                // instances
+                const m = transformNode;
+                const matrixData = m._thinInstanceDataStorage.matrixData;
+                if (!matrixData) {
+                    return; // TODO: error handling
+                }
+                const instancesCount = body.numInstances;
+                this._createOrUpdateBodyInstances(body, body.getMotionType(), matrixData, 0, instancesCount, true);
             }
-            const instancesCount = body.numInstances;
-            this._createOrUpdateBodyInstances(body, body.getMotionType(), matrixData, 0, instancesCount, true);
+            else {
+                // regular
+                this._hknp.HP_Body_SetQTransform(body._pluginData.hpBodyId, this._getTransformInfos(node));
+            }
+        }
+        else if (body.getPrestepType() == PhysicsPrestepType.ACTION) {
+            this.setTargetTransform(body, node.absolutePosition, node.absoluteRotationQuaternion);
         }
         else {
-            // regular
-            this._hknp.HP_Body_SetQTransform(body._pluginData.hpBodyId, this._getTransformInfos(node));
+            Logger.Warn("Invalid prestep type set to physics body.");
         }
     }
     /**
@@ -1101,14 +1108,14 @@ export class HavokPlugin {
      */
     initShape(shape, type, options) {
         switch (type) {
-            case PhysicsShapeType.SPHERE:
+            case 0 /* PhysicsShapeType.SPHERE */:
                 {
                     const radius = options.radius || 1;
                     const center = options.center ? this._bVecToV3(options.center) : [0, 0, 0];
                     shape._pluginData = this._hknp.HP_Shape_CreateSphere(center, radius)[1];
                 }
                 break;
-            case PhysicsShapeType.BOX:
+            case 3 /* PhysicsShapeType.BOX */:
                 {
                     const rotation = options.rotation ? this._bQuatToV4(options.rotation) : [0, 0, 0, 1];
                     const extent = options.extents ? this._bVecToV3(options.extents) : [1, 1, 1];
@@ -1116,7 +1123,7 @@ export class HavokPlugin {
                     shape._pluginData = this._hknp.HP_Shape_CreateBox(center, rotation, extent)[1];
                 }
                 break;
-            case PhysicsShapeType.CAPSULE:
+            case 1 /* PhysicsShapeType.CAPSULE */:
                 {
                     const pointA = options.pointA ? this._bVecToV3(options.pointA) : [0, 0, 0];
                     const pointB = options.pointB ? this._bVecToV3(options.pointB) : [0, 1, 0];
@@ -1124,12 +1131,12 @@ export class HavokPlugin {
                     shape._pluginData = this._hknp.HP_Shape_CreateCapsule(pointA, pointB, radius)[1];
                 }
                 break;
-            case PhysicsShapeType.CONTAINER:
+            case 5 /* PhysicsShapeType.CONTAINER */:
                 {
                     shape._pluginData = this._hknp.HP_Shape_CreateContainer()[1];
                 }
                 break;
-            case PhysicsShapeType.CYLINDER:
+            case 2 /* PhysicsShapeType.CYLINDER */:
                 {
                     const pointA = options.pointA ? this._bVecToV3(options.pointA) : [0, 0, 0];
                     const pointB = options.pointB ? this._bVecToV3(options.pointB) : [0, 1, 0];
@@ -1137,18 +1144,18 @@ export class HavokPlugin {
                     shape._pluginData = this._hknp.HP_Shape_CreateCylinder(pointA, pointB, radius)[1];
                 }
                 break;
-            case PhysicsShapeType.CONVEX_HULL:
-            case PhysicsShapeType.MESH:
+            case 4 /* PhysicsShapeType.CONVEX_HULL */:
+            case 6 /* PhysicsShapeType.MESH */:
                 {
                     const mesh = options.mesh;
                     if (mesh) {
                         const includeChildMeshes = !!options.includeChildMeshes;
-                        const needIndices = type != PhysicsShapeType.CONVEX_HULL;
+                        const needIndices = type != 4 /* PhysicsShapeType.CONVEX_HULL */;
                         const accum = new MeshAccumulator(mesh, needIndices, mesh?.getScene());
                         accum.addNodeMeshes(mesh, includeChildMeshes);
                         const positions = accum.getVertices(this._hknp);
                         const numVec3s = positions.numObjects / 3;
-                        if (type == PhysicsShapeType.CONVEX_HULL) {
+                        if (type == 4 /* PhysicsShapeType.CONVEX_HULL */) {
                             shape._pluginData = this._hknp.HP_Shape_CreateConvexHull(positions.offset, numVec3s)[1];
                         }
                         else {
@@ -1164,7 +1171,7 @@ export class HavokPlugin {
                     }
                 }
                 break;
-            case PhysicsShapeType.HEIGHTFIELD:
+            case 7 /* PhysicsShapeType.HEIGHTFIELD */:
                 {
                     if (options.groundMesh) {
                         // update options with datas from groundMesh
@@ -1242,8 +1249,8 @@ export class HavokPlugin {
         const dynamicFriction = material.friction ?? 0.5;
         const staticFriction = material.staticFriction ?? dynamicFriction;
         const restitution = material.restitution ?? 0.0;
-        const frictionCombine = material.frictionCombine ?? PhysicsMaterialCombineMode.MINIMUM;
-        const restitutionCombine = material.restitutionCombine ?? PhysicsMaterialCombineMode.MAXIMUM;
+        const frictionCombine = material.frictionCombine ?? 1 /* PhysicsMaterialCombineMode.MINIMUM */;
+        const restitutionCombine = material.restitutionCombine ?? 2 /* PhysicsMaterialCombineMode.MAXIMUM */;
         const hpMaterial = [staticFriction, dynamicFriction, restitution, this._materialCombineToNative(frictionCombine), this._materialCombineToNative(restitutionCombine)];
         this._hknp.HP_Shape_SetMaterial(shape._pluginData, hpMaterial);
     }
@@ -1485,7 +1492,7 @@ export class HavokPlugin {
                 pivotB: new Vector3(pivotB[0], pivotB[1], pivotB[2]),
             };
         }
-        if (type == PhysicsConstraintType.LOCK) {
+        if (type == 5 /* PhysicsConstraintType.LOCK */) {
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.LINEAR_X, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.LINEAR_Y, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.LINEAR_Z, this._hknp.ConstraintAxisLimitMode.LOCKED);
@@ -1493,39 +1500,39 @@ export class HavokPlugin {
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.ANGULAR_Y, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.ANGULAR_Z, this._hknp.ConstraintAxisLimitMode.LOCKED);
         }
-        else if (type == PhysicsConstraintType.DISTANCE) {
+        else if (type == 2 /* PhysicsConstraintType.DISTANCE */) {
             const distance = options.maxDistance || 0;
             const dist3d = this._hknp.ConstraintAxis.LINEAR_DISTANCE;
             this._hknp.HP_Constraint_SetAxisMode(jointId, dist3d, this._hknp.ConstraintAxisLimitMode.LIMITED);
             this._hknp.HP_Constraint_SetAxisMinLimit(jointId, dist3d, distance);
             this._hknp.HP_Constraint_SetAxisMaxLimit(jointId, dist3d, distance);
         }
-        else if (type == PhysicsConstraintType.HINGE) {
+        else if (type == 3 /* PhysicsConstraintType.HINGE */) {
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.LINEAR_X, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.LINEAR_Y, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.LINEAR_Z, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.ANGULAR_Y, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.ANGULAR_Z, this._hknp.ConstraintAxisLimitMode.LOCKED);
         }
-        else if (type == PhysicsConstraintType.PRISMATIC) {
+        else if (type == 6 /* PhysicsConstraintType.PRISMATIC */) {
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.LINEAR_Y, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.LINEAR_Z, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.ANGULAR_X, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.ANGULAR_Y, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.ANGULAR_Z, this._hknp.ConstraintAxisLimitMode.LOCKED);
         }
-        else if (type == PhysicsConstraintType.SLIDER) {
+        else if (type == 4 /* PhysicsConstraintType.SLIDER */) {
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.LINEAR_Y, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.LINEAR_Z, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.ANGULAR_Y, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.ANGULAR_Z, this._hknp.ConstraintAxisLimitMode.LOCKED);
         }
-        else if (type == PhysicsConstraintType.BALL_AND_SOCKET) {
+        else if (type == 1 /* PhysicsConstraintType.BALL_AND_SOCKET */) {
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.LINEAR_X, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.LINEAR_Y, this._hknp.ConstraintAxisLimitMode.LOCKED);
             this._hknp.HP_Constraint_SetAxisMode(jointId, this._hknp.ConstraintAxis.LINEAR_Z, this._hknp.ConstraintAxisLimitMode.LOCKED);
         }
-        else if (type == PhysicsConstraintType.SIX_DOF) {
+        else if (type == 7 /* PhysicsConstraintType.SIX_DOF */) {
             const sixdofData = constraint;
             for (const l of sixdofData.limits) {
                 const axId = this._constraintAxisToNative(l.axis);
@@ -2046,7 +2053,7 @@ export class HavokPlugin {
                     collidedAgainstIndex: bodyInfoB.index,
                     type: this._nativeCollisionValueToCollisionType(event.type),
                 };
-                if (collisionInfo.type === PhysicsEventType.COLLISION_FINISHED) {
+                if (collisionInfo.type === "COLLISION_FINISHED" /* PhysicsEventType.COLLISION_FINISHED */) {
                     this.onCollisionEndedObservable.notifyObservers(collisionInfo);
                 }
                 else {
@@ -2058,9 +2065,11 @@ export class HavokPlugin {
                     collisionInfo.normal = event.contactOnA.normal;
                     this.onCollisionObservable.notifyObservers(collisionInfo);
                 }
-                if (this._bodyCollisionObservable.size && collisionInfo.type !== PhysicsEventType.COLLISION_FINISHED) {
+                if (this._bodyCollisionObservable.size && collisionInfo.type !== "COLLISION_FINISHED" /* PhysicsEventType.COLLISION_FINISHED */) {
                     const observableA = this._bodyCollisionObservable.get(event.contactOnA.bodyId);
                     const observableB = this._bodyCollisionObservable.get(event.contactOnB.bodyId);
+                    event.contactOnA.position.subtractToRef(event.contactOnB.position, this._tmpVec3[0]);
+                    const distance = Vector3.Dot(this._tmpVec3[0], event.contactOnB.normal);
                     if (observableA) {
                         observableA.notifyObservers(collisionInfo);
                     }
@@ -2070,6 +2079,9 @@ export class HavokPlugin {
                             colliderIndex: bodyInfoB.index,
                             collidedAgainst: bodyInfoA.body,
                             collidedAgainstIndex: bodyInfoA.index,
+                            point: event.contactOnB.position,
+                            distance: distance,
+                            impulse: event.impulseApplied,
                             normal: event.contactOnB.normal,
                             type: this._nativeCollisionValueToCollisionType(event.type),
                         };
@@ -2079,6 +2091,8 @@ export class HavokPlugin {
                 else if (this._bodyCollisionEndedObservable.size) {
                     const observableA = this._bodyCollisionEndedObservable.get(event.contactOnA.bodyId);
                     const observableB = this._bodyCollisionEndedObservable.get(event.contactOnB.bodyId);
+                    event.contactOnA.position.subtractToRef(event.contactOnB.position, this._tmpVec3[0]);
+                    const distance = Vector3.Dot(this._tmpVec3[0], event.contactOnB.normal);
                     if (observableA) {
                         observableA.notifyObservers(collisionInfo);
                     }
@@ -2088,6 +2102,9 @@ export class HavokPlugin {
                             colliderIndex: bodyInfoB.index,
                             collidedAgainst: bodyInfoA.body,
                             collidedAgainstIndex: bodyInfoA.index,
+                            point: event.contactOnB.position,
+                            distance: distance,
+                            impulse: event.impulseApplied,
                             normal: event.contactOnB.normal,
                             type: this._nativeCollisionValueToCollisionType(event.type),
                         };
@@ -2128,9 +2145,9 @@ export class HavokPlugin {
     }
     _constraintMotorTypeToNative(motorType) {
         switch (motorType) {
-            case PhysicsConstraintMotorType.POSITION:
+            case 2 /* PhysicsConstraintMotorType.POSITION */:
                 return this._hknp.ConstraintMotorType.POSITION;
-            case PhysicsConstraintMotorType.VELOCITY:
+            case 1 /* PhysicsConstraintMotorType.VELOCITY */:
                 return this._hknp.ConstraintMotorType.VELOCITY;
         }
         return this._hknp.ConstraintMotorType.NONE;
@@ -2138,100 +2155,100 @@ export class HavokPlugin {
     _nativeToMotorType(motorType) {
         switch (motorType) {
             case this._hknp.ConstraintMotorType.POSITION:
-                return PhysicsConstraintMotorType.POSITION;
+                return 2 /* PhysicsConstraintMotorType.POSITION */;
             case this._hknp.ConstraintMotorType.VELOCITY:
-                return PhysicsConstraintMotorType.VELOCITY;
+                return 1 /* PhysicsConstraintMotorType.VELOCITY */;
         }
-        return PhysicsConstraintMotorType.NONE;
+        return 0 /* PhysicsConstraintMotorType.NONE */;
     }
     _materialCombineToNative(mat) {
         switch (mat) {
-            case PhysicsMaterialCombineMode.GEOMETRIC_MEAN:
+            case 0 /* PhysicsMaterialCombineMode.GEOMETRIC_MEAN */:
                 return this._hknp.MaterialCombine.GEOMETRIC_MEAN;
-            case PhysicsMaterialCombineMode.MINIMUM:
+            case 1 /* PhysicsMaterialCombineMode.MINIMUM */:
                 return this._hknp.MaterialCombine.MINIMUM;
-            case PhysicsMaterialCombineMode.MAXIMUM:
+            case 2 /* PhysicsMaterialCombineMode.MAXIMUM */:
                 return this._hknp.MaterialCombine.MAXIMUM;
-            case PhysicsMaterialCombineMode.ARITHMETIC_MEAN:
+            case 3 /* PhysicsMaterialCombineMode.ARITHMETIC_MEAN */:
                 return this._hknp.MaterialCombine.ARITHMETIC_MEAN;
-            case PhysicsMaterialCombineMode.MULTIPLY:
+            case 4 /* PhysicsMaterialCombineMode.MULTIPLY */:
                 return this._hknp.MaterialCombine.MULTIPLY;
         }
     }
     _nativeToMaterialCombine(mat) {
         switch (mat) {
             case this._hknp.MaterialCombine.GEOMETRIC_MEAN:
-                return PhysicsMaterialCombineMode.GEOMETRIC_MEAN;
+                return 0 /* PhysicsMaterialCombineMode.GEOMETRIC_MEAN */;
             case this._hknp.MaterialCombine.MINIMUM:
-                return PhysicsMaterialCombineMode.MINIMUM;
+                return 1 /* PhysicsMaterialCombineMode.MINIMUM */;
             case this._hknp.MaterialCombine.MAXIMUM:
-                return PhysicsMaterialCombineMode.MAXIMUM;
+                return 2 /* PhysicsMaterialCombineMode.MAXIMUM */;
             case this._hknp.MaterialCombine.ARITHMETIC_MEAN:
-                return PhysicsMaterialCombineMode.ARITHMETIC_MEAN;
+                return 3 /* PhysicsMaterialCombineMode.ARITHMETIC_MEAN */;
             case this._hknp.MaterialCombine.MULTIPLY:
-                return PhysicsMaterialCombineMode.MULTIPLY;
+                return 4 /* PhysicsMaterialCombineMode.MULTIPLY */;
             default:
                 return undefined;
         }
     }
     _constraintAxisToNative(axId) {
         switch (axId) {
-            case PhysicsConstraintAxis.LINEAR_X:
+            case 0 /* PhysicsConstraintAxis.LINEAR_X */:
                 return this._hknp.ConstraintAxis.LINEAR_X;
-            case PhysicsConstraintAxis.LINEAR_Y:
+            case 1 /* PhysicsConstraintAxis.LINEAR_Y */:
                 return this._hknp.ConstraintAxis.LINEAR_Y;
-            case PhysicsConstraintAxis.LINEAR_Z:
+            case 2 /* PhysicsConstraintAxis.LINEAR_Z */:
                 return this._hknp.ConstraintAxis.LINEAR_Z;
-            case PhysicsConstraintAxis.ANGULAR_X:
+            case 3 /* PhysicsConstraintAxis.ANGULAR_X */:
                 return this._hknp.ConstraintAxis.ANGULAR_X;
-            case PhysicsConstraintAxis.ANGULAR_Y:
+            case 4 /* PhysicsConstraintAxis.ANGULAR_Y */:
                 return this._hknp.ConstraintAxis.ANGULAR_Y;
-            case PhysicsConstraintAxis.ANGULAR_Z:
+            case 5 /* PhysicsConstraintAxis.ANGULAR_Z */:
                 return this._hknp.ConstraintAxis.ANGULAR_Z;
-            case PhysicsConstraintAxis.LINEAR_DISTANCE:
+            case 6 /* PhysicsConstraintAxis.LINEAR_DISTANCE */:
                 return this._hknp.ConstraintAxis.LINEAR_DISTANCE;
         }
     }
     _nativeToLimitMode(mode) {
         switch (mode) {
             case this._hknp.ConstraintAxisLimitMode.FREE:
-                return PhysicsConstraintAxisLimitMode.FREE;
+                return 0 /* PhysicsConstraintAxisLimitMode.FREE */;
             case this._hknp.ConstraintAxisLimitMode.LIMITED:
-                return PhysicsConstraintAxisLimitMode.LIMITED;
+                return 1 /* PhysicsConstraintAxisLimitMode.LIMITED */;
             case this._hknp.ConstraintAxisLimitMode.LOCKED:
-                return PhysicsConstraintAxisLimitMode.LOCKED;
+                return 2 /* PhysicsConstraintAxisLimitMode.LOCKED */;
         }
-        return PhysicsConstraintAxisLimitMode.FREE;
+        return 0 /* PhysicsConstraintAxisLimitMode.FREE */;
     }
     _limitModeToNative(mode) {
         switch (mode) {
-            case PhysicsConstraintAxisLimitMode.FREE:
+            case 0 /* PhysicsConstraintAxisLimitMode.FREE */:
                 return this._hknp.ConstraintAxisLimitMode.FREE;
-            case PhysicsConstraintAxisLimitMode.LIMITED:
+            case 1 /* PhysicsConstraintAxisLimitMode.LIMITED */:
                 return this._hknp.ConstraintAxisLimitMode.LIMITED;
-            case PhysicsConstraintAxisLimitMode.LOCKED:
+            case 2 /* PhysicsConstraintAxisLimitMode.LOCKED */:
                 return this._hknp.ConstraintAxisLimitMode.LOCKED;
         }
     }
     _nativeCollisionValueToCollisionType(type) {
         switch (type) {
             case this._hknp.EventType.COLLISION_STARTED.value:
-                return PhysicsEventType.COLLISION_STARTED;
+                return "COLLISION_STARTED" /* PhysicsEventType.COLLISION_STARTED */;
             case this._hknp.EventType.COLLISION_FINISHED.value:
-                return PhysicsEventType.COLLISION_FINISHED;
+                return "COLLISION_FINISHED" /* PhysicsEventType.COLLISION_FINISHED */;
             case this._hknp.EventType.COLLISION_CONTINUED.value:
-                return PhysicsEventType.COLLISION_CONTINUED;
+                return "COLLISION_CONTINUED" /* PhysicsEventType.COLLISION_CONTINUED */;
         }
-        return PhysicsEventType.COLLISION_STARTED;
+        return "COLLISION_STARTED" /* PhysicsEventType.COLLISION_STARTED */;
     }
     _nativeTriggerCollisionValueToCollisionType(type) {
         switch (type) {
             case 8:
-                return PhysicsEventType.TRIGGER_ENTERED;
+                return "TRIGGER_ENTERED" /* PhysicsEventType.TRIGGER_ENTERED */;
             case 16:
-                return PhysicsEventType.TRIGGER_EXITED;
+                return "TRIGGER_EXITED" /* PhysicsEventType.TRIGGER_EXITED */;
         }
-        return PhysicsEventType.TRIGGER_ENTERED;
+        return "TRIGGER_ENTERED" /* PhysicsEventType.TRIGGER_ENTERED */;
     }
 }
 //# sourceMappingURL=havokPlugin.js.map