@gg-web-engine/ammo 0.0.1

package/src/impl/gg-3d-body-factory.ts

@@ -0,0 +1,164 @@
+import {
+  Body3DOptions,
+  BodyShape3DDescriptor,
+  IGg3dBodyFactory,
+  Point3,
+  Point4,
+  Shape3DDescriptor,
+} from '@gg-web-engine/core';
+import { Gg3dBody } from './bodies/gg-3d-body';
+import { Gg3dPhysicsWorld } from './gg-3d-physics-world';
+import Ammo from 'ammojs-typed';
+import { Gg3dTrigger } from './bodies/gg-3d-trigger';
+
+export class Gg3dBodyFactory implements IGg3dBodyFactory<Gg3dBody, Gg3dTrigger> {
+  constructor(private readonly world: Gg3dPhysicsWorld) {}
+
+  createRigidBody(
+    descriptor: BodyShape3DDescriptor,
+    transform?: {
+      position?: Point3;
+      rotation?: Point4;
+    },
+  ): Gg3dBody {
+    return this.createRigidBodyFromShape(this.createShape(descriptor.shape), descriptor.body, transform);
+  }
+
+  createTrigger(
+    descriptor: Shape3DDescriptor,
+    transform?: {
+      position?: Point3;
+      rotation?: Point4;
+    },
+  ): Gg3dTrigger {
+    return this.createTriggerFromShape(this.createShape(descriptor), transform);
+  }
+
+  private createShape(descriptor: Shape3DDescriptor): Ammo.btCollisionShape {
+    switch (descriptor.shape) {
+      case 'BOX':
+        return new this.world.ammo.btBoxShape(
+          new this.world.ammo.btVector3(
+            descriptor.dimensions.x / 2,
+            descriptor.dimensions.y / 2,
+            descriptor.dimensions.z / 2,
+          ),
+        );
+      case 'CAPSULE':
+        return new this.world.ammo.btCapsuleShapeZ(descriptor.radius, descriptor.centersDistance);
+      case 'CYLINDER':
+        return new this.world.ammo.btCylinderShapeZ(
+          new this.world.ammo.btVector3(descriptor.radius, descriptor.radius, descriptor.height / 2),
+        );
+      case 'CONE':
+        return new this.world.ammo.btConeShapeZ(descriptor.radius, descriptor.height);
+      case 'SPHERE':
+        return new this.world.ammo.btSphereShape(descriptor.radius);
+      case 'COMPOUND':
+        const compoundShape: Ammo.btCollisionShape = new this.world.ammo.btCompoundShape();
+        for (const item of descriptor.children) {
+          const subShape = this.createShape(item.shape);
+          if (!subShape) {
+            continue;
+          }
+          const subShapeTransform = new this.world.ammo.btTransform();
+          const pos = item.position || { x: 0, y: 0, z: 0 };
+          const rot = item.rotation || { x: 0, y: 0, z: 0, w: 1 };
+          subShapeTransform.setOrigin(new this.world.ammo.btVector3(pos.x, pos.y, pos.z));
+          subShapeTransform.setRotation(new this.world.ammo.btQuaternion(rot.x, rot.y, rot.z, rot.w));
+          (compoundShape as Ammo.btCompoundShape).addChildShape(subShapeTransform, subShape);
+        }
+        return compoundShape;
+      case 'CONVEX_HULL':
+        const shape = new this.world.ammo.btConvexHullShape();
+        const tmpVector = new this.world.ammo.btVector3();
+        for (const v of descriptor.vertices) {
+          tmpVector.setValue(v.x, v.y, v.z);
+          shape.addPoint(tmpVector);
+        }
+        this.world.ammo.destroy(tmpVector);
+        shape.recalcLocalAabb();
+        return shape;
+      case 'MESH':
+        const mesh = new this.world.ammo.btTriangleMesh(true, true);
+        const tmpVectors: [Ammo.btVector3, Ammo.btVector3, Ammo.btVector3] = [
+          new this.world.ammo.btVector3(),
+          new this.world.ammo.btVector3(),
+          new this.world.ammo.btVector3(),
+        ];
+        for (const f of descriptor.faces) {
+          for (let j = 0; j < 3; j++) {
+            tmpVectors[j].setValue(
+              descriptor.vertices[f[0]].x,
+              descriptor.vertices[f[1]].y,
+              descriptor.vertices[f[2]].z,
+            );
+          }
+          mesh.addTriangle(...tmpVectors, true);
+        }
+        tmpVectors.forEach(v => {
+          this.world.ammo.destroy(v);
+        });
+        return new this.world.ammo.btBvhTriangleMeshShape(mesh, false, true);
+    }
+    throw new Error(`Shape "${(descriptor as any).shape}" not implemented for Ammo.js`);
+  }
+
+  public createRigidBodyFromShape(
+    shape: Ammo.btCollisionShape,
+    options: Partial<Body3DOptions>,
+    transform?: { position?: Point3; rotation?: Point4 },
+  ): Gg3dBody {
+    if (options.dynamic === false) {
+      options.mass = 0;
+    }
+    const pos = transform?.position || { x: 0, y: 0, z: 0 };
+    const rot = transform?.rotation || { x: 0, y: 0, z: 0, w: 1 };
+    const ammo = this.world.ammo;
+    const ammoTransform = new ammo.btTransform();
+    ammoTransform.setOrigin(new ammo.btVector3(pos.x, pos.y, pos.z));
+    ammoTransform.setRotation(new ammo.btQuaternion(rot.x, rot.y, rot.z, rot.w));
+    const motionState = new ammo.btDefaultMotionState(ammoTransform);
+    const localInertia = new ammo.btVector3(0, 0, 0);
+    shape.calculateLocalInertia(options.mass || 0, localInertia);
+    const environmentBodyCI = new ammo.btRigidBodyConstructionInfo(options.mass || 0, motionState, shape, localInertia);
+    if (options.friction) {
+      environmentBodyCI.set_m_friction(options.friction);
+      environmentBodyCI.set_m_rollingFriction(options.friction);
+    }
+    if (options.restitution) {
+      environmentBodyCI.set_m_restitution(options.restitution);
+    }
+    const body = new this.world.ammo.btRigidBody(environmentBodyCI);
+    return new Gg3dBody(this.world, body);
+  }
+
+  public createTriggerFromShape(
+    shape: Ammo.btCollisionShape,
+    transform?: { position?: Point3; rotation?: Point4 },
+  ): Gg3dTrigger {
+    const ghostObject = new this.world.ammo.btPairCachingGhostObject();
+    ghostObject.setCollisionShape(shape);
+    ghostObject.setCollisionFlags(ghostObject.getCollisionFlags() | 4); // 4 is a CF_NO_CONTACT_RESPONSE collision flag
+    ghostObject
+      .getWorldTransform()
+      .setOrigin(
+        new this.world.ammo.btVector3(
+          transform?.position?.x || 0,
+          transform?.position?.y || 0,
+          transform?.position?.z || 0,
+        ),
+      );
+    ghostObject
+      .getWorldTransform()
+      .setRotation(
+        new this.world.ammo.btQuaternion(
+          transform?.rotation?.x || 0,
+          transform?.rotation?.y || 0,
+          transform?.rotation?.z || 0,
+          transform?.rotation?.w || 1,
+        ),
+      );
+    return new Gg3dTrigger(this.world, ghostObject);
+  }
+}

package/src/impl/gg-3d-body-loader.ts

@@ -0,0 +1,8 @@
+import { IGg3dBodyLoader } from '@gg-web-engine/core';
+import { Gg3dPhysicsWorld } from './gg-3d-physics-world';
+
+export class Gg3dBodyLoader extends IGg3dBodyLoader {
+  constructor(protected readonly world: Gg3dPhysicsWorld) {
+    super(world);
+  }
+}

package/src/impl/gg-3d-physics-world.ts

@@ -0,0 +1,141 @@
+import { Gg3dWorld, GgDebugPhysicsDrawer, IGg3dPhysicsWorld, Point3, Point4 } from '@gg-web-engine/core';
+import Ammo, * as AmmoModule from 'ammojs-typed';
+import { Gg3dBodyFactory } from './gg-3d-body-factory';
+import { Gg3dBodyLoader } from './gg-3d-body-loader';
+import { AmmoDebugger, AmmoDebugMode } from '../ammo-debugger';
+
+export class Gg3dPhysicsWorld implements IGg3dPhysicsWorld {
+  private _factory: Gg3dBodyFactory | null = null;
+  public get factory(): Gg3dBodyFactory {
+    if (!this._factory) {
+      throw new Error('Ammo world not initialized');
+    }
+    return this._factory;
+  }
+
+  private _loader: Gg3dBodyLoader | null = null;
+  public get loader(): Gg3dBodyLoader {
+    if (!this._loader) {
+      throw new Error('Ammo world not initialized');
+    }
+    return this._loader;
+  }
+
+  private _gravity: Point3 = { x: 0, y: 0, z: -9.82 };
+  public get gravity(): Point3 {
+    return this._gravity;
+  }
+
+  public set gravity(value: Point3) {
+    this._gravity = value;
+    if (this.gravityVector) {
+      this.gravityVector.setValue(value.x, value.y, value.z);
+      this._dynamicAmmoWorld?.setGravity(this.gravityVector);
+    }
+  }
+
+  private _timeScale: number = 1;
+  public get timeScale(): number {
+    return this._timeScale;
+  }
+
+  public set timeScale(value: number) {
+    this._timeScale = value;
+  }
+  private _debugger: AmmoDebugger | null = null;
+  private _debugDrawer: GgDebugPhysicsDrawer<Point3, Point4> | null = null;
+
+  get physicsDebugViewActive(): boolean {
+    return !!this._debugger;
+  }
+
+  private ammoInstance: typeof Ammo | undefined;
+
+  public get ammo(): typeof Ammo {
+    if (this.ammoInstance) {
+      return this.ammoInstance;
+    }
+    throw 'Physics world not initialized!';
+  }
+
+  public get dynamicAmmoWorld(): Ammo.btDiscreteDynamicsWorld | undefined {
+    return this._dynamicAmmoWorld;
+  }
+
+  private collisionConfiguration: Ammo.btDefaultCollisionConfiguration | undefined;
+  private dispatcher: Ammo.btCollisionDispatcher | undefined;
+  private ghostPairCallback: Ammo.btGhostPairCallback | undefined;
+  private broadphase: Ammo.btBroadphaseInterface | undefined;
+  private solver: Ammo.btSequentialImpulseConstraintSolver | undefined;
+  private gravityVector: Ammo.btVector3 | undefined;
+  private _dynamicAmmoWorld: Ammo.btDiscreteDynamicsWorld | undefined;
+
+  async init(): Promise<void> {
+    this.ammoInstance = await AmmoModule.default.bind(AmmoModule)();
+    this.collisionConfiguration = new this.ammo.btDefaultCollisionConfiguration();
+    this.dispatcher = new this.ammo.btCollisionDispatcher(this.collisionConfiguration);
+    this.broadphase = new this.ammo.btDbvtBroadphase();
+    this.ghostPairCallback = new this.ammo.btGhostPairCallback();
+    this.solver = new this.ammo.btSequentialImpulseConstraintSolver();
+    this.gravityVector = new this.ammo.btVector3(this._gravity.x, this._gravity.y, this._gravity.z);
+
+    this._dynamicAmmoWorld = new this.ammo.btDiscreteDynamicsWorld(
+      this.dispatcher,
+      this.broadphase,
+      this.solver,
+      this.collisionConfiguration,
+    );
+    this._dynamicAmmoWorld.getPairCache().setInternalGhostPairCallback(this.ghostPairCallback);
+    this._dynamicAmmoWorld.setGravity(this.gravityVector);
+    this._factory = new Gg3dBodyFactory(this);
+    this._loader = new Gg3dBodyLoader(this);
+  }
+
+  simulate(delta: number): void {
+    this._dynamicAmmoWorld?.stepSimulation((this._timeScale * delta) / 1000, 100, this._timeScale * 0.01);
+    if (this._debugger) {
+      this._debugger.update();
+    }
+  }
+
+  startDebugger(world: Gg3dWorld, drawer: GgDebugPhysicsDrawer<Point3, Point4>): void {
+    if (!this._debugger) {
+      this._debugger = new AmmoDebugger(this, drawer);
+      this.dynamicAmmoWorld?.setDebugDrawer(this._debugger.ammoInstance);
+    }
+    this._debugger!.setDebugMode(AmmoDebugMode.DrawWireframe);
+    this._debugDrawer = drawer;
+    this._debugDrawer.addToWorld(world.visualScene);
+  }
+
+  stopDebugger(world: Gg3dWorld): void {
+    if (this._debugger) {
+      this.dynamicAmmoWorld?.setDebugDrawer(null!);
+      this.ammo.destroy(this._debugger.ammoInstance);
+      this._debugger = null;
+    }
+    if (this._debugDrawer) {
+      this._debugDrawer!.removeFromWorld(world.visualScene);
+      this._debugDrawer!.dispose();
+      this._debugDrawer = null;
+    }
+  }
+
+  dispose(): void {
+    this.ammo.destroy(this._dynamicAmmoWorld);
+    this.ammo.destroy(this.solver);
+    this.ammo.destroy(this.broadphase);
+    this.ammo.destroy(this.dispatcher);
+    this.ammo.destroy(this.collisionConfiguration);
+    if (this._debugger) {
+      this.ammo.destroy(this._debugger.ammoInstance);
+    }
+    this._dynamicAmmoWorld =
+      this.solver =
+      this.broadphase =
+      this.dispatcher =
+      this.collisionConfiguration =
+      this.ammoInstance =
+        undefined;
+  }
+}

package/src/impl/gg-3d-raycast-vehicle.ts

@@ -0,0 +1,97 @@
+import {
+  IGg3dRaycastVehicle,
+  WheelOptions,
+  SuspensionOptions,
+  Point3,
+  Point4,
+  Gg3dRaycastVehicleEntity,
+} from '@gg-web-engine/core';
+import Ammo from 'ammojs-typed';
+import { Gg3dBody } from './bodies/gg-3d-body';
+import { Gg3dPhysicsWorld } from './gg-3d-physics-world';
+export class Gg3dRaycastVehicle extends Gg3dBody implements IGg3dRaycastVehicle {
+  public readonly nativeVehicle: Ammo.btRaycastVehicle;
+  public readonly vehicleTuning: Ammo.btVehicleTuning = new this.ammo.btVehicleTuning();
+  protected readonly wheelDirectionCS0: Ammo.btVector3 = new this.ammo.btVector3(0, 0, -1);
+  protected readonly wheelAxleCS: Ammo.btVector3 = new this.ammo.btVector3(1, 0, 0);
+
+  public entity: Gg3dRaycastVehicleEntity | null = null;
+
+  constructor(protected readonly world: Gg3dPhysicsWorld, public chassisBody: Ammo.btRigidBody) {
+    super(world, chassisBody);
+    this.nativeVehicle = new this.ammo.btRaycastVehicle(
+      this.vehicleTuning,
+      this.chassisBody,
+      new this.ammo.btDefaultVehicleRaycaster(world.dynamicAmmoWorld!),
+    );
+    this.nativeVehicle.setCoordinateSystem(0, 2, 1);
+  }
+
+  get wheelSpeed(): number {
+    // FIXME not correct (shows chassis speed in world)
+    return this.nativeVehicle.getCurrentSpeedKmHour() / 3.6;
+  }
+
+  addToWorld(world: Gg3dPhysicsWorld) {
+    if (world != this.world) {
+      throw new Error('Ammo raycast vehicle cannot be shared between different worlds');
+    }
+    // TODO parked cars can be deactivated until we start handling them. Needs explicit activation call
+    this.chassisBody.setActivationState(4); // btCollisionObject::DISABLE_DEACTIVATION
+    world.dynamicAmmoWorld?.addRigidBody(this.chassisBody);
+    this.world.dynamicAmmoWorld!.addAction(this.nativeVehicle);
+  }
+
+  addWheel(options: WheelOptions, suspensionOptions: SuspensionOptions): void {
+    const wheelInfo = this.nativeVehicle.addWheel(
+      new this.ammo.btVector3(options.position.x, options.position.y, options.position.z * 2),
+      this.wheelDirectionCS0,
+      this.wheelAxleCS,
+      suspensionOptions.restLength,
+      options.tyre_radius,
+      this.vehicleTuning,
+      options.isFront,
+    );
+    wheelInfo.set_m_suspensionStiffness(suspensionOptions.stiffness);
+    wheelInfo.set_m_wheelsDampingRelaxation(suspensionOptions.damping);
+    wheelInfo.set_m_wheelsDampingCompression(suspensionOptions.compression);
+    wheelInfo.set_m_frictionSlip(options.frictionSlip);
+    wheelInfo.set_m_rollInfluence(options.rollInfluence);
+    wheelInfo.set_m_maxSuspensionTravelCm(options.maxTravel * 100);
+  }
+
+  setSteering(wheelIndex: number, steering: number): void {
+    this.nativeVehicle.setSteeringValue(steering, wheelIndex);
+  }
+
+  applyEngineForce(wheelIndex: number, force: number): void {
+    this.nativeVehicle.applyEngineForce(force, wheelIndex);
+  }
+
+  applyBrake(wheelIndex: number, force: number): void {
+    this.nativeVehicle.setBrake(force, wheelIndex);
+  }
+
+  isWheelTouchesGround(wheelIndex: number): boolean {
+    return this.nativeVehicle.getWheelInfo(wheelIndex).get_m_raycastInfo().get_m_groundObject() > 0;
+  }
+
+  getWheelTransform(wheelIndex: number): { position: Point3; rotation: Point4 } {
+    // FIXME when set to `true`, wheels are jittering, but it was not the case in old sandbox app. Check why
+    this.nativeVehicle.updateWheelTransform(wheelIndex, false);
+    const transform = this.nativeVehicle.getWheelTransformWS(wheelIndex);
+    const origin = transform.getOrigin();
+    const quaternion = transform.getRotation();
+    return {
+      position: { x: origin.x(), y: origin.y(), z: origin.z() },
+      rotation: { x: quaternion.x(), y: quaternion.y(), z: quaternion.z(), w: quaternion.w() },
+    };
+  }
+
+  resetSuspension(): void {
+    this.nativeVehicle.resetSuspension();
+    for (let i = 0; i < this.nativeVehicle.getNumWheels(); i++) {
+      this.nativeVehicle.updateWheelTransform(i, true);
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './impl/bodies/gg-3d-body';
+export * from './impl/bodies/gg-3d-trigger';
+export * from './impl/gg-3d-body-factory';
+export * from './impl/gg-3d-body-loader';
+export * from './impl/gg-3d-physics-world';
+export * from './impl/gg-3d-raycast-vehicle';

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "./src/",
+    "outDir": "./dist/",
+  },
+  "include": ["*.ts", "**/*.ts"],
+}