3D physics vehicle

Extensions/Physics3DBehavior/Physics3DRuntimeBehavior.ts

@@ -283,11 +283,11 @@ namespace gdjs {
   gdjs.registerRuntimeSceneUnloadedCallback(function (runtimeScene) {
     const physics3DSharedData = runtimeScene.physics3DSharedData;
     if (physics3DSharedData) {
-      Jolt.destroy(physics3DSharedData.jolt);
       Jolt.destroy(physics3DSharedData.contactListener);
       Jolt.destroy(physics3DSharedData._tempVec3);
       Jolt.destroy(physics3DSharedData._tempRVec3);
       Jolt.destroy(physics3DSharedData._tempQuat);
+      Jolt.destroy(physics3DSharedData.jolt);
       runtimeScene.physics3DSharedData = null;
     }
   });
@@ -302,18 +302,25 @@ namespace gdjs {
     fixedRotation: boolean;
     private shape: string;
     private shapeOrientation: string;
-    private shapeDimensionA: any;
-    private shapeDimensionB: any;
-    private shapeDimensionC: any;
+    private shapeDimensionA: float;
+    private shapeDimensionB: float;
+    private shapeDimensionC: float;
+    private shapeOffsetX: float;
+    private shapeOffsetY: float;
+    shapeOffsetZ: float;
+    private massCenterOffsetX: float;
+    private massCenterOffsetY: float;
+    private massCenterOffsetZ: float;
     private density: float;
+    massOverride: float;
     friction: float;
     restitution: float;
     linearDamping: float;
     angularDamping: float;
     gravityScale: float;
     private layers: integer;
     private masks: integer;
-    private shapeScale: number = 1;
+    shapeScale: number = 1;
 
     /**
      * Array containing the beginning of contacts reported by onContactBegin. Each contact
@@ -348,7 +355,10 @@ namespace gdjs {
     /**
      * When set to `true` the shape will be recreated before the next physics step.
      */
-    private _needToRecreateShape: boolean = false;
+    _needToRecreateShape: boolean = false;
+
+    _shapeHalfWidth: float = 0;
+    _shapeHalfHeight: float = 0;
     /**
      * Used by {@link gdjs.PhysicsCharacter3DRuntimeBehavior} to convert coordinates.
      */
@@ -391,7 +401,14 @@ namespace gdjs {
       this.shapeDimensionA = behaviorData.shapeDimensionA;
       this.shapeDimensionB = behaviorData.shapeDimensionB;
       this.shapeDimensionC = behaviorData.shapeDimensionC;
+      this.shapeOffsetX = behaviorData.shapeOffsetX || 0;
+      this.shapeOffsetY = behaviorData.shapeOffsetY || 0;
+      this.shapeOffsetZ = behaviorData.shapeOffsetZ || 0;
+      this.massCenterOffsetX = behaviorData.massCenterOffsetX || 0;
+      this.massCenterOffsetY = behaviorData.massCenterOffsetY || 0;
+      this.massCenterOffsetZ = behaviorData.massCenterOffsetZ || 0;
       this.density = behaviorData.density;
+      this.massOverride = behaviorData.massOverride;
       this.friction = behaviorData.friction;
       this.restitution = behaviorData.restitution;
       this.linearDamping = Math.max(0, behaviorData.linearDamping);
@@ -424,7 +441,7 @@ namespace gdjs {
       return tempQuat;
     }
 
-    updateFromBehaviorData(oldBehaviorData, newBehaviorData): boolean {
+    override updateFromBehaviorData(oldBehaviorData, newBehaviorData): boolean {
       if (oldBehaviorData.bullet !== newBehaviorData.bullet) {
         this.setBullet(newBehaviorData.bullet);
       }
@@ -477,7 +494,7 @@ namespace gdjs {
       return true;
     }
 
-    getNetworkSyncData(): Physics3DNetworkSyncData {
+    override getNetworkSyncData(): Physics3DNetworkSyncData {
       let bodyProps;
       if (this._body) {
         const position = this._body.GetPosition();
@@ -528,7 +545,9 @@ namespace gdjs {
       };
     }
 
-    updateFromNetworkSyncData(networkSyncData: Physics3DNetworkSyncData) {
+    override updateFromNetworkSyncData(
+      networkSyncData: Physics3DNetworkSyncData
+    ) {
       super.updateFromNetworkSyncData(networkSyncData);
 
       const behaviorSpecificProps = networkSyncData.props;
@@ -608,15 +627,15 @@ namespace gdjs {
       }
     }
 
-    onDeActivate() {
+    override onDeActivate() {
       this._sharedData.removeFromBehaviorsList(this);
       this.bodyUpdater.destroyBody();
       this._contactsEndedThisFrame.length = 0;
       this._contactsStartedThisFrame.length = 0;
       this._currentContacts.length = 0;
     }
 
-    onActivate() {
+    override onActivate() {
       this._sharedData.addToBehaviorsList(this);
 
       this._contactsEndedThisFrame.length = 0;
@@ -625,12 +644,45 @@ namespace gdjs {
       this.updateBodyFromObject();
     }
 
-    onDestroy() {
+    override onDestroy() {
       this._destroyedDuringFrameLogic = true;
       this.onDeActivate();
     }
 
     createShape(): Jolt.Shape {
+      if (
+        this.massCenterOffsetX === 0 &&
+        this.massCenterOffsetY === 0 &&
+        this.massCenterOffsetZ === 0
+      ) {
+        return this.createShapeWithoutMassCenterOffset();
+      }
+      const rotatedShapeSettings =
+        this._createShapeSettingsWithoutMassCenterOffset();
+      const shapeScale = this.shapeScale * this._sharedData.worldInvScale;
+      const offsetCenterShapeSettings =
+        new Jolt.OffsetCenterOfMassShapeSettings(
+          this.getVec3(
+            this.massCenterOffsetX * shapeScale,
+            this.massCenterOffsetY * shapeScale,
+            this.massCenterOffsetZ * shapeScale
+          ),
+          rotatedShapeSettings
+        );
+      const shape = offsetCenterShapeSettings.Create().Get();
+      Jolt.destroy(offsetCenterShapeSettings);
+      return shape;
+    }
+
+    createShapeWithoutMassCenterOffset(): Jolt.Shape {
+      const rotatedShapeSettings =
+        this._createShapeSettingsWithoutMassCenterOffset();
+      const shape = rotatedShapeSettings.Create().Get();
+      Jolt.destroy(rotatedShapeSettings);
+      return shape;
+    }
+
+    private _createShapeSettingsWithoutMassCenterOffset(): Jolt.RotatedTranslatedShapeSettings {
       let width = this.owner3D.getWidth() * this._sharedData.worldInvScale;
       let height = this.owner3D.getHeight() * this._sharedData.worldInvScale;
       let depth = this.owner3D.getDepth() * this._sharedData.worldInvScale;
@@ -676,6 +728,8 @@ namespace gdjs {
           convexRadius
         );
         quat = this.getQuat(0, 0, 0, 1);
+        this._shapeHalfWidth = boxWidth / 2;
+        this._shapeHalfHeight = boxHeight / 2;
         this._shapeHalfDepth = boxDepth / 2;
       } else if (this.shape === 'Capsule') {
         const radius =
@@ -691,8 +745,12 @@ namespace gdjs {
           radius
         );
         quat = this._getShapeOrientationQuat();
+        this._shapeHalfWidth =
+          this.shapeOrientation === 'X' ? capsuleDepth / 2 : radius;
+        this._shapeHalfHeight =
+          this.shapeOrientation === 'Y' ? capsuleDepth / 2 : radius;
         this._shapeHalfDepth =
-          this.shapeOrientation !== 'Z' ? radius : capsuleDepth / 2;
+          this.shapeOrientation === 'Z' ? capsuleDepth / 2 : radius;
       } else if (this.shape === 'Cylinder') {
         const radius =
           shapeDimensionA > 0
@@ -713,8 +771,12 @@ namespace gdjs {
           convexRadius
         );
         quat = this._getShapeOrientationQuat();
+        this._shapeHalfWidth =
+          this.shapeOrientation === 'X' ? cylinderDepth / 2 : radius;
+        this._shapeHalfHeight =
+          this.shapeOrientation === 'Y' ? cylinderDepth / 2 : radius;
         this._shapeHalfDepth =
-          this.shapeOrientation !== 'Z' ? radius : cylinderDepth / 2;
+          this.shapeOrientation === 'Z' ? cylinderDepth / 2 : radius;
       } else {
         // Create a 'Sphere' by default.
         const radius =
@@ -725,19 +787,20 @@ namespace gdjs {
               : onePixel;
         shapeSettings = new Jolt.SphereShapeSettings(radius);
         quat = this.getQuat(0, 0, 0, 1);
+        this._shapeHalfWidth = radius;
+        this._shapeHalfHeight = radius;
         this._shapeHalfDepth = radius;
       }
       shapeSettings.mDensity = this.density;
-      const rotatedShape = new Jolt.RotatedTranslatedShapeSettings(
-        this.getVec3(0, 0, 0),
+      return new Jolt.RotatedTranslatedShapeSettings(
+        this.getVec3(
+          this.shapeOffsetX * shapeScale,
+          this.shapeOffsetY * shapeScale,
+          this.shapeOffsetZ * shapeScale
+        ),
         quat,
         shapeSettings
-      )
-        .Create()
-        .Get();
-
-      Jolt.destroy(shapeSettings);
-      return rotatedShape;
+      );
     }
 
     private _getShapeOrientationQuat(): Jolt.Quat {
@@ -822,7 +885,7 @@ namespace gdjs {
         : this.masks;
     }
 
-    doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) {
+    override doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) {
       // Step the world if not done this frame yet.
       // Don't step at the first frame to allow events to handle overlapping objects.
       if (
@@ -836,7 +899,9 @@ namespace gdjs {
       }
     }
 
-    doStepPostEvents(instanceContainer: gdjs.RuntimeInstanceContainer) {
+    override doStepPostEvents(
+      instanceContainer: gdjs.RuntimeInstanceContainer
+    ) {
       // Reset world step to update next frame
       this._sharedData.stepped = false;
     }
@@ -1100,6 +1165,18 @@ namespace gdjs {
       this._needToRecreateShape = true;
     }
 
+    getMassOverride(): float {
+      return this.massOverride;
+    }
+
+    setMassOverride(mass: float): void {
+      if (this.massOverride === mass) {
+        return;
+      }
+      this.massOverride = mass;
+      this._needToRecreateBody = true;
+    }
+
     getFriction(): float {
       return this.friction;
     }
@@ -1765,7 +1842,9 @@ namespace gdjs {
       destroyBody(): void;
     }
 
-    export class DefaultBodyUpdater {
+    export class DefaultBodyUpdater
+      implements gdjs.Physics3DRuntimeBehavior.BodyUpdater
+    {
       behavior: gdjs.Physics3DRuntimeBehavior;
 
       constructor(behavior: gdjs.Physics3DRuntimeBehavior) {
@@ -1801,6 +1880,12 @@ namespace gdjs {
         bodyCreationSettings.mLinearDamping = behavior.linearDamping;
         bodyCreationSettings.mAngularDamping = behavior.angularDamping;
         bodyCreationSettings.mGravityFactor = behavior.gravityScale;
+        if (behavior.massOverride > 0) {
+          bodyCreationSettings.mOverrideMassProperties =
+            Jolt.EOverrideMassProperties_CalculateInertia;
+          bodyCreationSettings.mMassPropertiesOverride.mMass =
+            behavior.massOverride;
+        }
 
         const bodyInterface = _sharedData.bodyInterface;
         const body = bodyInterface.CreateBody(bodyCreationSettings);