@gg-web-engine/ammo 0.0.1 → 0.0.2

package/README.md

@@ -9,8 +9,7 @@
 1) `npm install --save @gg-web-engine/ammo`
 1) Add to your `tsconfig.json` in the record `compilerOptions.paths`:
 ```json lines
-"mini-signals": ["./node_modules/@gg-web-engine/ammo/node_modules/mini-signals/index.js"],
-"path": ["./node_modules/@gg-web-engine/ammo/node_modules/path-browserify"],
-"fs": ["./node_modules/@gg-web-engine/ammo/node_modules/fs-web"],
-"ammojs-typed": ["./node_modules/@gg-web-engine/ammo/node_modules/ammojs-typed"]
+"mini-signals": ["./node_modules/mini-signals/index.js"],
+"path": ["./node_modules/path-browserify"],
+"fs": ["./node_modules/fs-web"],
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gg-web-engine/ammo",
-  "version": "0.0.01",
+  "version": "0.0.02",
   "description": "An attempt to create open source game engine for browser",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/AndyGura/gg-web-engine#readme",
   "dependencies": {
-    "@gg-web-engine/core": "^0.0.1",
+    "@gg-web-engine/core": "^0.0.2",
     "ammojs-typed": "^1.0.6",
     "fs-web": "^1.0.1",
     "mini-signals": "^1.2.0",

package/src/ammo-debugger.ts

@@ -1,104 +0,0 @@
-import Ammo from 'ammojs-typed';
-import { GgDebugPhysicsDrawer, Point3, Point4 } from '@gg-web-engine/core';
-import { Gg3dPhysicsWorld } from './impl/gg-3d-physics-world';
-
-export const DebugBufferSize = 3 * 1000000;
-
-export enum AmmoDebugMode {
-  NoDebug = 0,
-  DrawWireframe = 1,
-  DrawAabb = 2,
-  DrawFeaturesText = 4,
-  DrawContactPoints = 8,
-  NoDeactivation = 16,
-  NoHelpText = 32,
-  DrawText = 64,
-  ProfileTimings = 128,
-  EnableSatComparison = 256,
-  DisableBulletLCP = 512,
-  EnableCCD = 1024,
-  DrawConstraints = 1 << 11, //2048
-  DrawConstraintLimits = 1 << 12, //4096
-  FastWireframe = 1 << 13, //8192
-  DrawNormals = 1 << 14, //16384
-  MAX_DEBUG_DRAW_MODE = 0xffffffff,
-}
-
-const deserializeVector = function (ammo: typeof Ammo, vec: Ammo.btVector3): Point3 {
-  if (!isNaN(+vec)) {
-    const heap = ammo.HEAPF32;
-    return {
-      x: heap[+vec / 4],
-      y: heap[(+vec + 4) / 4],
-      z: heap[(+vec + 8) / 4],
-    };
-  }
-  return { x: vec.x(), y: vec.y(), z: vec.z() };
-};
-
-export class AmmoDebugger implements Ammo.btIDebugDraw {
-  private debugMode: AmmoDebugMode = AmmoDebugMode.DrawWireframe;
-
-  constructor(private readonly world: Gg3dPhysicsWorld, private readonly drawer: GgDebugPhysicsDrawer<Point3, Point4>) {
-    this.ammoInstance = new this.world.ammo.DebugDrawer();
-    this.ammoInstance.drawLine = this.drawLine.bind(this);
-    this.ammoInstance.drawContactPoint = this.drawContactPoint.bind(this);
-    this.ammoInstance.reportErrorWarning = this.reportErrorWarning.bind(this);
-    this.ammoInstance.draw3dText = this.draw3dText.bind(this);
-    this.ammoInstance.setDebugMode = this.setDebugMode.bind(this);
-    this.ammoInstance.getDebugMode = this.getDebugMode.bind(this);
-  }
-
-  public readonly ammoInstance: Ammo.btIDebugDraw;
-
-  draw3dText(location: Ammo.btVector3, textString: string): void {
-    console.log('DRAWER DEBUG', 'draw3dtext');
-  }
-
-  drawContactPoint(
-    pointOnB: Ammo.btVector3,
-    normalOnB: Ammo.btVector3,
-    distance: number,
-    lifeTime: number,
-    color: Ammo.btVector3,
-  ): void {
-    this.drawer.drawContactPoint(
-      deserializeVector(this.world.ammo, pointOnB),
-      deserializeVector(this.world.ammo, normalOnB),
-      deserializeVector(this.world.ammo, color),
-    );
-  }
-
-  drawLine(from: Ammo.btVector3, to: Ammo.btVector3, color: Ammo.btVector3): void {
-    this.drawer.drawLine(
-      deserializeVector(this.world.ammo, from),
-      deserializeVector(this.world.ammo, to),
-      deserializeVector(this.world.ammo, color),
-    );
-  }
-
-  getDebugMode(): number {
-    return this.debugMode;
-  }
-
-  update(): void {
-    this.world.dynamicAmmoWorld?.debugDrawWorld();
-    this.drawer.update();
-  }
-
-  setDebugFlags(flags: AmmoDebugMode[]): void {
-    let res = 0;
-    for (const flag of flags) {
-      res = res | flag;
-    }
-    this.setDebugMode(res);
-  }
-
-  setDebugMode(debugMode: number): void {
-    this.debugMode = debugMode;
-  }
-
-  reportErrorWarning(warningString: string): void {
-    console.log('DRAWER DEBUG', 'reportErrorWarning', warningString);
-  }
-}

package/src/ammo-utils.ts

@@ -1,3 +0,0 @@
-import Ammo from 'ammojs-typed';
-
-export const ammoId: (body: Ammo.btCollisionObject) => number = body => (body as any).a;

package/src/impl/bodies/base-ammo-gg-body.ts

@@ -1,76 +0,0 @@
-import { IGg3dBody, Point3, Point4, Gg3dEntity } from '@gg-web-engine/core';
-import { Gg3dPhysicsWorld } from '../gg-3d-physics-world';
-import Ammo from 'ammojs-typed';
-import { ammoId } from '../../ammo-utils';
-
-export abstract class BaseAmmoGGBody<T extends Ammo.btCollisionObject> implements IGg3dBody {
-  protected static nativeBodyReverseMap: Map<number, IGg3dBody> = new Map<number, IGg3dBody>();
-
-  protected get ammo(): typeof Ammo {
-    return this.world.ammo;
-  }
-
-  public get position(): Point3 {
-    const origin = this.nativeBody.getWorldTransform().getOrigin();
-    return { x: origin.x(), y: origin.y(), z: origin.z() };
-  }
-
-  public set position(value: Point3) {
-    const transform = this.nativeBody.getWorldTransform();
-    transform.setOrigin(new this.ammo.btVector3(value.x, value.y, value.z));
-    this.nativeBody.setWorldTransform(transform);
-  }
-
-  public get rotation(): Point4 {
-    const quaternion = this.nativeBody.getWorldTransform().getRotation();
-    return { x: quaternion.x(), y: quaternion.y(), z: quaternion.z(), w: quaternion.w() };
-  }
-
-  public set rotation(value: Point4) {
-    const transform = this.nativeBody.getWorldTransform();
-    transform.setRotation(new this.ammo.btQuaternion(value.x, value.y, value.z, value.w));
-    this.nativeBody.setWorldTransform(transform);
-  }
-
-  public get scale(): Point3 {
-    // hmm, is it even possible to be different?
-    return { x: 1, y: 1, z: 1 };
-  }
-  get nativeBody(): T {
-    return this._nativeBody;
-  }
-
-  set nativeBody(value: T) {
-    if (value == this._nativeBody) {
-      return;
-    }
-    BaseAmmoGGBody.nativeBodyReverseMap.delete(ammoId(this._nativeBody));
-    this._nativeBody = value;
-    BaseAmmoGGBody.nativeBodyReverseMap.set(ammoId(value), this);
-  }
-
-  public name: string = '';
-
-  abstract entity: Gg3dEntity | null;
-
-  protected constructor(protected readonly world: Gg3dPhysicsWorld, protected _nativeBody: T) {
-    BaseAmmoGGBody.nativeBodyReverseMap.set(ammoId(this.nativeBody), this);
-  }
-
-  abstract clone(): BaseAmmoGGBody<T>;
-
-  abstract addToWorld(world: Gg3dPhysicsWorld): void;
-
-  abstract removeFromWorld(world: Gg3dPhysicsWorld): void;
-
-  dispose(): void {
-    try {
-      this.ammo.destroy(this.nativeBody);
-    } catch {
-      // pass
-    }
-    BaseAmmoGGBody.nativeBodyReverseMap.delete(ammoId(this.nativeBody));
-  }
-
-  abstract resetMotion(): void;
-}

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

@@ -1,48 +0,0 @@
-import { Gg3dPhysicsWorld } from '../gg-3d-physics-world';
-import Ammo from 'ammojs-typed';
-import { BaseAmmoGGBody } from './base-ammo-gg-body';
-import { Gg3dEntity } from '@gg-web-engine/core';
-
-export class Gg3dBody extends BaseAmmoGGBody<Ammo.btRigidBody> {
-  public entity: Gg3dEntity | null = null;
-
-  constructor(protected readonly world: Gg3dPhysicsWorld, protected _nativeBody: Ammo.btRigidBody) {
-    super(world, _nativeBody);
-  }
-
-  clone(): Gg3dBody {
-    return this.world.factory.createRigidBodyFromShape(
-      this._nativeBody.getCollisionShape(),
-      {
-        dynamic: !this._nativeBody.isStaticObject(),
-        mass: 5, // FIXME how to get mass??
-        friction: this._nativeBody.getFriction(),
-        restitution: this._nativeBody.getRestitution(),
-      },
-      {
-        position: this.position,
-        rotation: this.rotation,
-      },
-    );
-  }
-
-  addToWorld(world: Gg3dPhysicsWorld): void {
-    if (world != this.world) {
-      throw new Error('Ammo bodies cannot be shared between different worlds');
-    }
-    world.dynamicAmmoWorld?.addRigidBody(this.nativeBody);
-  }
-
-  removeFromWorld(world: Gg3dPhysicsWorld): void {
-    world.dynamicAmmoWorld?.removeRigidBody(this.nativeBody);
-  }
-
-  resetMotion(): void {
-    const emptyVector = new this.ammo.btVector3();
-    this.nativeBody.setLinearVelocity(emptyVector);
-    this.nativeBody.setAngularVelocity(emptyVector);
-    this.nativeBody.clearForces();
-    this.nativeBody.updateInertiaTensor();
-    this.ammo.destroy(emptyVector);
-  }
-}

package/src/impl/bodies/gg-3d-trigger.ts

@@ -1,82 +0,0 @@
-import { Gg3dTriggerEntity, GgPositionable3dEntity, IGg3dTrigger } from '@gg-web-engine/core';
-import { Gg3dPhysicsWorld } from '../gg-3d-physics-world';
-import { filter, map, Observable, Subject } from 'rxjs';
-import Ammo from 'ammojs-typed';
-import { BaseAmmoGGBody } from './base-ammo-gg-body';
-import { ammoId } from '../../ammo-utils';
-
-export class Gg3dTrigger extends BaseAmmoGGBody<Ammo.btPairCachingGhostObject> implements IGg3dTrigger {
-  public entity: Gg3dTriggerEntity | null = null;
-
-  get onEntityEntered(): Observable<GgPositionable3dEntity> {
-    return this.onEnter$.pipe(
-      map(b => BaseAmmoGGBody.nativeBodyReverseMap.get(b)?.entity),
-      filter(x => !!x && x instanceof GgPositionable3dEntity),
-    ) as Observable<GgPositionable3dEntity>;
-  }
-
-  get onEntityLeft(): Observable<GgPositionable3dEntity | null> {
-    return this.onLeft$.pipe(
-      map(b => BaseAmmoGGBody.nativeBodyReverseMap.get(b)?.entity || null),
-    ) as Observable<GgPositionable3dEntity | null>;
-  }
-
-  constructor(protected readonly world: Gg3dPhysicsWorld, protected _nativeBody: Ammo.btPairCachingGhostObject) {
-    super(world, _nativeBody);
-  }
-
-  private readonly onEnter$: Subject<number> = new Subject<number>();
-  private readonly onLeft$: Subject<number> = new Subject<number>();
-  private readonly overlaps: Set<Ammo.btCollisionObject> = new Set<Ammo.btCollisionObject>();
-
-  checkOverlaps(): void {
-    const numOverlappingObjects = this.nativeBody.getNumOverlappingObjects();
-    const newOverlaps = new Set(
-      new Array(numOverlappingObjects).fill(null).map((_, i) => this.nativeBody.getOverlappingObject(i)),
-    );
-    for (const overlap of this.overlaps.keys()) {
-      if (!newOverlaps.has(overlap)) {
-        this.overlaps.delete(overlap);
-        this.onLeft$.next(ammoId(overlap));
-      } else {
-        newOverlaps.delete(overlap);
-      }
-    }
-    for (const newOverlap of newOverlaps) {
-      this.overlaps.add(newOverlap);
-      this.onEnter$.next(ammoId(newOverlap));
-    }
-  }
-
-  clone(): Gg3dTrigger {
-    return this.world.factory.createTriggerFromShape(this._nativeBody.getCollisionShape(), {
-      position: this.position,
-      rotation: this.rotation,
-    });
-  }
-
-  addToWorld(world: Gg3dPhysicsWorld) {
-    if (world != this.world) {
-      throw new Error('Ammo triggers cannot be shared between different worlds');
-    }
-    world.dynamicAmmoWorld?.addCollisionObject(this.nativeBody);
-    this.overlaps.clear();
-  }
-
-  removeFromWorld(world: Gg3dPhysicsWorld): void {
-    for (const body of this.overlaps) {
-      this.onLeft$.next(ammoId(body));
-    }
-    this.overlaps.clear();
-    world.dynamicAmmoWorld?.removeCollisionObject(this.nativeBody);
-  }
-
-  dispose(): void {
-    super.dispose();
-    this.overlaps.clear();
-    this.onEnter$.complete();
-    this.onLeft$.complete();
-  }
-
-  resetMotion(): void {}
-}

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

@@ -1,164 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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';