@gg-web-engine/ammo 0.0.1

package/dist/impl/gg-3d-physics-world.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gg3dPhysicsWorld = void 0;
+const AmmoModule = __importStar(require("ammojs-typed"));
+const gg_3d_body_factory_1 = require("./gg-3d-body-factory");
+const gg_3d_body_loader_1 = require("./gg-3d-body-loader");
+const ammo_debugger_1 = require("../ammo-debugger");
+class Gg3dPhysicsWorld {
+    constructor() {
+        this._factory = null;
+        this._loader = null;
+        this._gravity = { x: 0, y: 0, z: -9.82 };
+        this._timeScale = 1;
+        this._debugger = null;
+        this._debugDrawer = null;
+    }
+    get factory() {
+        if (!this._factory) {
+            throw new Error('Ammo world not initialized');
+        }
+        return this._factory;
+    }
+    get loader() {
+        if (!this._loader) {
+            throw new Error('Ammo world not initialized');
+        }
+        return this._loader;
+    }
+    get gravity() {
+        return this._gravity;
+    }
+    set gravity(value) {
+        var _a;
+        this._gravity = value;
+        if (this.gravityVector) {
+            this.gravityVector.setValue(value.x, value.y, value.z);
+            (_a = this._dynamicAmmoWorld) === null || _a === void 0 ? void 0 : _a.setGravity(this.gravityVector);
+        }
+    }
+    get timeScale() {
+        return this._timeScale;
+    }
+    set timeScale(value) {
+        this._timeScale = value;
+    }
+    get physicsDebugViewActive() {
+        return !!this._debugger;
+    }
+    get ammo() {
+        if (this.ammoInstance) {
+            return this.ammoInstance;
+        }
+        throw 'Physics world not initialized!';
+    }
+    get dynamicAmmoWorld() {
+        return this._dynamicAmmoWorld;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.ammoInstance = yield 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 gg_3d_body_factory_1.Gg3dBodyFactory(this);
+            this._loader = new gg_3d_body_loader_1.Gg3dBodyLoader(this);
+        });
+    }
+    simulate(delta) {
+        var _a;
+        (_a = this._dynamicAmmoWorld) === null || _a === void 0 ? void 0 : _a.stepSimulation((this._timeScale * delta) / 1000, 100, this._timeScale * 0.01);
+        if (this._debugger) {
+            this._debugger.update();
+        }
+    }
+    startDebugger(world, drawer) {
+        var _a;
+        if (!this._debugger) {
+            this._debugger = new ammo_debugger_1.AmmoDebugger(this, drawer);
+            (_a = this.dynamicAmmoWorld) === null || _a === void 0 ? void 0 : _a.setDebugDrawer(this._debugger.ammoInstance);
+        }
+        this._debugger.setDebugMode(ammo_debugger_1.AmmoDebugMode.DrawWireframe);
+        this._debugDrawer = drawer;
+        this._debugDrawer.addToWorld(world.visualScene);
+    }
+    stopDebugger(world) {
+        var _a;
+        if (this._debugger) {
+            (_a = this.dynamicAmmoWorld) === null || _a === void 0 ? void 0 : _a.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() {
+        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;
+    }
+}
+exports.Gg3dPhysicsWorld = Gg3dPhysicsWorld;

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

@@ -0,0 +1,26 @@
+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 declare class Gg3dRaycastVehicle extends Gg3dBody implements IGg3dRaycastVehicle {
+    protected readonly world: Gg3dPhysicsWorld;
+    chassisBody: Ammo.btRigidBody;
+    readonly nativeVehicle: Ammo.btRaycastVehicle;
+    readonly vehicleTuning: Ammo.btVehicleTuning;
+    protected readonly wheelDirectionCS0: Ammo.btVector3;
+    protected readonly wheelAxleCS: Ammo.btVector3;
+    entity: Gg3dRaycastVehicleEntity | null;
+    constructor(world: Gg3dPhysicsWorld, chassisBody: Ammo.btRigidBody);
+    get wheelSpeed(): number;
+    addToWorld(world: Gg3dPhysicsWorld): void;
+    addWheel(options: WheelOptions, suspensionOptions: SuspensionOptions): void;
+    setSteering(wheelIndex: number, steering: number): void;
+    applyEngineForce(wheelIndex: number, force: number): void;
+    applyBrake(wheelIndex: number, force: number): void;
+    isWheelTouchesGround(wheelIndex: number): boolean;
+    getWheelTransform(wheelIndex: number): {
+        position: Point3;
+        rotation: Point4;
+    };
+    resetSuspension(): void;
+}

package/dist/impl/gg-3d-raycast-vehicle.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gg3dRaycastVehicle = void 0;
+const gg_3d_body_1 = require("./bodies/gg-3d-body");
+class Gg3dRaycastVehicle extends gg_3d_body_1.Gg3dBody {
+    constructor(world, chassisBody) {
+        super(world, chassisBody);
+        this.world = world;
+        this.chassisBody = chassisBody;
+        this.vehicleTuning = new this.ammo.btVehicleTuning();
+        this.wheelDirectionCS0 = new this.ammo.btVector3(0, 0, -1);
+        this.wheelAxleCS = new this.ammo.btVector3(1, 0, 0);
+        this.entity = null;
+        this.nativeVehicle = new this.ammo.btRaycastVehicle(this.vehicleTuning, this.chassisBody, new this.ammo.btDefaultVehicleRaycaster(world.dynamicAmmoWorld));
+        this.nativeVehicle.setCoordinateSystem(0, 2, 1);
+    }
+    get wheelSpeed() {
+        // FIXME not correct (shows chassis speed in world)
+        return this.nativeVehicle.getCurrentSpeedKmHour() / 3.6;
+    }
+    addToWorld(world) {
+        var _a;
+        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
+        (_a = world.dynamicAmmoWorld) === null || _a === void 0 ? void 0 : _a.addRigidBody(this.chassisBody);
+        this.world.dynamicAmmoWorld.addAction(this.nativeVehicle);
+    }
+    addWheel(options, suspensionOptions) {
+        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, steering) {
+        this.nativeVehicle.setSteeringValue(steering, wheelIndex);
+    }
+    applyEngineForce(wheelIndex, force) {
+        this.nativeVehicle.applyEngineForce(force, wheelIndex);
+    }
+    applyBrake(wheelIndex, force) {
+        this.nativeVehicle.setBrake(force, wheelIndex);
+    }
+    isWheelTouchesGround(wheelIndex) {
+        return this.nativeVehicle.getWheelInfo(wheelIndex).get_m_raycastInfo().get_m_groundObject() > 0;
+    }
+    getWheelTransform(wheelIndex) {
+        // 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() {
+        this.nativeVehicle.resetSuspension();
+        for (let i = 0; i < this.nativeVehicle.getNumWheels(); i++) {
+            this.nativeVehicle.updateWheelTransform(i, true);
+        }
+    }
+}
+exports.Gg3dRaycastVehicle = Gg3dRaycastVehicle;

package/dist/index.d.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/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./impl/bodies/gg-3d-body"), exports);
+__exportStar(require("./impl/bodies/gg-3d-trigger"), exports);
+__exportStar(require("./impl/gg-3d-body-factory"), exports);
+__exportStar(require("./impl/gg-3d-body-loader"), exports);
+__exportStar(require("./impl/gg-3d-physics-world"), exports);
+__exportStar(require("./impl/gg-3d-raycast-vehicle"), exports);

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@gg-web-engine/ammo",
+  "version": "0.0.01",
+  "description": "An attempt to create open source game engine for browser",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prettier-format": "prettier --config ../core/.prettierrc 'src/**/*.ts' --write",
+    "prepublish": "tsc",
+    "build": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AndyGura/gg-web-engine.git"
+  },
+  "keywords": [
+    "game-development",
+    "game-engine",
+    "game-engine-framework",
+    "gamedev"
+  ],
+  "author": "AndyGura",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/AndyGura/gg-web-engine/issues"
+  },
+  "homepage": "https://github.com/AndyGura/gg-web-engine#readme",
+  "dependencies": {
+    "@gg-web-engine/core": "^0.0.1",
+    "ammojs-typed": "^1.0.6",
+    "fs-web": "^1.0.1",
+    "mini-signals": "^1.2.0",
+    "path-browserify": "^1.0.1",
+    "rxjs": "~7.5.0"
+  },
+  "devDependencies": {
+    "prettier": "^2.8.6",
+    "typescript": "~4.7.2"
+  }
+}

package/src/ammo-debugger.ts

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

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

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

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

@@ -0,0 +1,82 @@
+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 {}
+}