@gg-web-engine/ammo 0.0.1

package/README.md

@@ -0,0 +1,16 @@
+<p align="center">
+  <img src="../../documentation/assets/logo.png" style="height: 400px; width:400px;" alt=''/>
+</p>
+
+## [Ammo.js](https://github.com/kripken/ammo.js) integration for [gg-web-engine](https://github.com/AndyGura/gg-web-engine), providing 3D phycics simulation
+
+### Installation:
+1) make sure **@gg-web-engine/core** installed
+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"]
+```

package/dist/ammo-debugger.d.ts

@@ -0,0 +1,38 @@
+import Ammo from 'ammojs-typed';
+import { GgDebugPhysicsDrawer, Point3, Point4 } from '@gg-web-engine/core';
+import { Gg3dPhysicsWorld } from './impl/gg-3d-physics-world';
+export declare const DebugBufferSize: number;
+export declare 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 = 2048,
+    DrawConstraintLimits = 4096,
+    FastWireframe = 8192,
+    DrawNormals = 16384,
+    MAX_DEBUG_DRAW_MODE = 4294967295
+}
+export declare class AmmoDebugger implements Ammo.btIDebugDraw {
+    private readonly world;
+    private readonly drawer;
+    private debugMode;
+    constructor(world: Gg3dPhysicsWorld, drawer: GgDebugPhysicsDrawer<Point3, Point4>);
+    readonly ammoInstance: Ammo.btIDebugDraw;
+    draw3dText(location: Ammo.btVector3, textString: string): void;
+    drawContactPoint(pointOnB: Ammo.btVector3, normalOnB: Ammo.btVector3, distance: number, lifeTime: number, color: Ammo.btVector3): void;
+    drawLine(from: Ammo.btVector3, to: Ammo.btVector3, color: Ammo.btVector3): void;
+    getDebugMode(): number;
+    update(): void;
+    setDebugFlags(flags: AmmoDebugMode[]): void;
+    setDebugMode(debugMode: number): void;
+    reportErrorWarning(warningString: string): void;
+}

package/dist/ammo-debugger.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmmoDebugger = exports.AmmoDebugMode = exports.DebugBufferSize = void 0;
+exports.DebugBufferSize = 3 * 1000000;
+var AmmoDebugMode;
+(function (AmmoDebugMode) {
+    AmmoDebugMode[AmmoDebugMode["NoDebug"] = 0] = "NoDebug";
+    AmmoDebugMode[AmmoDebugMode["DrawWireframe"] = 1] = "DrawWireframe";
+    AmmoDebugMode[AmmoDebugMode["DrawAabb"] = 2] = "DrawAabb";
+    AmmoDebugMode[AmmoDebugMode["DrawFeaturesText"] = 4] = "DrawFeaturesText";
+    AmmoDebugMode[AmmoDebugMode["DrawContactPoints"] = 8] = "DrawContactPoints";
+    AmmoDebugMode[AmmoDebugMode["NoDeactivation"] = 16] = "NoDeactivation";
+    AmmoDebugMode[AmmoDebugMode["NoHelpText"] = 32] = "NoHelpText";
+    AmmoDebugMode[AmmoDebugMode["DrawText"] = 64] = "DrawText";
+    AmmoDebugMode[AmmoDebugMode["ProfileTimings"] = 128] = "ProfileTimings";
+    AmmoDebugMode[AmmoDebugMode["EnableSatComparison"] = 256] = "EnableSatComparison";
+    AmmoDebugMode[AmmoDebugMode["DisableBulletLCP"] = 512] = "DisableBulletLCP";
+    AmmoDebugMode[AmmoDebugMode["EnableCCD"] = 1024] = "EnableCCD";
+    AmmoDebugMode[AmmoDebugMode["DrawConstraints"] = 2048] = "DrawConstraints";
+    AmmoDebugMode[AmmoDebugMode["DrawConstraintLimits"] = 4096] = "DrawConstraintLimits";
+    AmmoDebugMode[AmmoDebugMode["FastWireframe"] = 8192] = "FastWireframe";
+    AmmoDebugMode[AmmoDebugMode["DrawNormals"] = 16384] = "DrawNormals";
+    AmmoDebugMode[AmmoDebugMode["MAX_DEBUG_DRAW_MODE"] = 4294967295] = "MAX_DEBUG_DRAW_MODE";
+})(AmmoDebugMode = exports.AmmoDebugMode || (exports.AmmoDebugMode = {}));
+const deserializeVector = function (ammo, vec) {
+    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() };
+};
+class AmmoDebugger {
+    constructor(world, drawer) {
+        this.world = world;
+        this.drawer = drawer;
+        this.debugMode = AmmoDebugMode.DrawWireframe;
+        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);
+    }
+    draw3dText(location, textString) {
+        console.log('DRAWER DEBUG', 'draw3dtext');
+    }
+    drawContactPoint(pointOnB, normalOnB, distance, lifeTime, color) {
+        this.drawer.drawContactPoint(deserializeVector(this.world.ammo, pointOnB), deserializeVector(this.world.ammo, normalOnB), deserializeVector(this.world.ammo, color));
+    }
+    drawLine(from, to, color) {
+        this.drawer.drawLine(deserializeVector(this.world.ammo, from), deserializeVector(this.world.ammo, to), deserializeVector(this.world.ammo, color));
+    }
+    getDebugMode() {
+        return this.debugMode;
+    }
+    update() {
+        var _a;
+        (_a = this.world.dynamicAmmoWorld) === null || _a === void 0 ? void 0 : _a.debugDrawWorld();
+        this.drawer.update();
+    }
+    setDebugFlags(flags) {
+        let res = 0;
+        for (const flag of flags) {
+            res = res | flag;
+        }
+        this.setDebugMode(res);
+    }
+    setDebugMode(debugMode) {
+        this.debugMode = debugMode;
+    }
+    reportErrorWarning(warningString) {
+        console.log('DRAWER DEBUG', 'reportErrorWarning', warningString);
+    }
+}
+exports.AmmoDebugger = AmmoDebugger;

package/dist/ammo-utils.d.ts

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

package/dist/ammo-utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ammoId = void 0;
+const ammoId = body => body.a;
+exports.ammoId = ammoId;

package/dist/impl/bodies/base-ammo-gg-body.d.ts

@@ -0,0 +1,24 @@
+import { IGg3dBody, Point3, Point4, Gg3dEntity } from '@gg-web-engine/core';
+import { Gg3dPhysicsWorld } from '../gg-3d-physics-world';
+import Ammo from 'ammojs-typed';
+export declare abstract class BaseAmmoGGBody<T extends Ammo.btCollisionObject> implements IGg3dBody {
+    protected readonly world: Gg3dPhysicsWorld;
+    protected _nativeBody: T;
+    protected static nativeBodyReverseMap: Map<number, IGg3dBody>;
+    protected get ammo(): typeof Ammo;
+    get position(): Point3;
+    set position(value: Point3);
+    get rotation(): Point4;
+    set rotation(value: Point4);
+    get scale(): Point3;
+    get nativeBody(): T;
+    set nativeBody(value: T);
+    name: string;
+    abstract entity: Gg3dEntity | null;
+    protected constructor(world: Gg3dPhysicsWorld, _nativeBody: T);
+    abstract clone(): BaseAmmoGGBody<T>;
+    abstract addToWorld(world: Gg3dPhysicsWorld): void;
+    abstract removeFromWorld(world: Gg3dPhysicsWorld): void;
+    dispose(): void;
+    abstract resetMotion(): void;
+}

package/dist/impl/bodies/base-ammo-gg-body.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAmmoGGBody = void 0;
+const ammo_utils_1 = require("../../ammo-utils");
+class BaseAmmoGGBody {
+    constructor(world, _nativeBody) {
+        this.world = world;
+        this._nativeBody = _nativeBody;
+        this.name = '';
+        BaseAmmoGGBody.nativeBodyReverseMap.set((0, ammo_utils_1.ammoId)(this.nativeBody), this);
+    }
+    get ammo() {
+        return this.world.ammo;
+    }
+    get position() {
+        const origin = this.nativeBody.getWorldTransform().getOrigin();
+        return { x: origin.x(), y: origin.y(), z: origin.z() };
+    }
+    set position(value) {
+        const transform = this.nativeBody.getWorldTransform();
+        transform.setOrigin(new this.ammo.btVector3(value.x, value.y, value.z));
+        this.nativeBody.setWorldTransform(transform);
+    }
+    get rotation() {
+        const quaternion = this.nativeBody.getWorldTransform().getRotation();
+        return { x: quaternion.x(), y: quaternion.y(), z: quaternion.z(), w: quaternion.w() };
+    }
+    set rotation(value) {
+        const transform = this.nativeBody.getWorldTransform();
+        transform.setRotation(new this.ammo.btQuaternion(value.x, value.y, value.z, value.w));
+        this.nativeBody.setWorldTransform(transform);
+    }
+    get scale() {
+        // hmm, is it even possible to be different?
+        return { x: 1, y: 1, z: 1 };
+    }
+    get nativeBody() {
+        return this._nativeBody;
+    }
+    set nativeBody(value) {
+        if (value == this._nativeBody) {
+            return;
+        }
+        BaseAmmoGGBody.nativeBodyReverseMap.delete((0, ammo_utils_1.ammoId)(this._nativeBody));
+        this._nativeBody = value;
+        BaseAmmoGGBody.nativeBodyReverseMap.set((0, ammo_utils_1.ammoId)(value), this);
+    }
+    dispose() {
+        try {
+            this.ammo.destroy(this.nativeBody);
+        }
+        catch (_a) {
+            // pass
+        }
+        BaseAmmoGGBody.nativeBodyReverseMap.delete((0, ammo_utils_1.ammoId)(this.nativeBody));
+    }
+}
+exports.BaseAmmoGGBody = BaseAmmoGGBody;
+BaseAmmoGGBody.nativeBodyReverseMap = new Map();

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

@@ -0,0 +1,14 @@
+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 declare class Gg3dBody extends BaseAmmoGGBody<Ammo.btRigidBody> {
+    protected readonly world: Gg3dPhysicsWorld;
+    protected _nativeBody: Ammo.btRigidBody;
+    entity: Gg3dEntity | null;
+    constructor(world: Gg3dPhysicsWorld, _nativeBody: Ammo.btRigidBody);
+    clone(): Gg3dBody;
+    addToWorld(world: Gg3dPhysicsWorld): void;
+    removeFromWorld(world: Gg3dPhysicsWorld): void;
+    resetMotion(): void;
+}

package/dist/impl/bodies/gg-3d-body.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gg3dBody = void 0;
+const base_ammo_gg_body_1 = require("./base-ammo-gg-body");
+class Gg3dBody extends base_ammo_gg_body_1.BaseAmmoGGBody {
+    constructor(world, _nativeBody) {
+        super(world, _nativeBody);
+        this.world = world;
+        this._nativeBody = _nativeBody;
+        this.entity = null;
+    }
+    clone() {
+        return this.world.factory.createRigidBodyFromShape(this._nativeBody.getCollisionShape(), {
+            dynamic: !this._nativeBody.isStaticObject(),
+            mass: 5,
+            friction: this._nativeBody.getFriction(),
+            restitution: this._nativeBody.getRestitution(),
+        }, {
+            position: this.position,
+            rotation: this.rotation,
+        });
+    }
+    addToWorld(world) {
+        var _a;
+        if (world != this.world) {
+            throw new Error('Ammo bodies cannot be shared between different worlds');
+        }
+        (_a = world.dynamicAmmoWorld) === null || _a === void 0 ? void 0 : _a.addRigidBody(this.nativeBody);
+    }
+    removeFromWorld(world) {
+        var _a;
+        (_a = world.dynamicAmmoWorld) === null || _a === void 0 ? void 0 : _a.removeRigidBody(this.nativeBody);
+    }
+    resetMotion() {
+        const emptyVector = new this.ammo.btVector3();
+        this.nativeBody.setLinearVelocity(emptyVector);
+        this.nativeBody.setAngularVelocity(emptyVector);
+        this.nativeBody.clearForces();
+        this.nativeBody.updateInertiaTensor();
+        this.ammo.destroy(emptyVector);
+    }
+}
+exports.Gg3dBody = Gg3dBody;

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

@@ -0,0 +1,22 @@
+import { Gg3dTriggerEntity, GgPositionable3dEntity, IGg3dTrigger } from '@gg-web-engine/core';
+import { Gg3dPhysicsWorld } from '../gg-3d-physics-world';
+import { Observable } from 'rxjs';
+import Ammo from 'ammojs-typed';
+import { BaseAmmoGGBody } from './base-ammo-gg-body';
+export declare class Gg3dTrigger extends BaseAmmoGGBody<Ammo.btPairCachingGhostObject> implements IGg3dTrigger {
+    protected readonly world: Gg3dPhysicsWorld;
+    protected _nativeBody: Ammo.btPairCachingGhostObject;
+    entity: Gg3dTriggerEntity | null;
+    get onEntityEntered(): Observable<GgPositionable3dEntity>;
+    get onEntityLeft(): Observable<GgPositionable3dEntity | null>;
+    constructor(world: Gg3dPhysicsWorld, _nativeBody: Ammo.btPairCachingGhostObject);
+    private readonly onEnter$;
+    private readonly onLeft$;
+    private readonly overlaps;
+    checkOverlaps(): void;
+    clone(): Gg3dTrigger;
+    addToWorld(world: Gg3dPhysicsWorld): void;
+    removeFromWorld(world: Gg3dPhysicsWorld): void;
+    dispose(): void;
+    resetMotion(): void;
+}

package/dist/impl/bodies/gg-3d-trigger.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gg3dTrigger = void 0;
+const core_1 = require("@gg-web-engine/core");
+const rxjs_1 = require("rxjs");
+const base_ammo_gg_body_1 = require("./base-ammo-gg-body");
+const ammo_utils_1 = require("../../ammo-utils");
+class Gg3dTrigger extends base_ammo_gg_body_1.BaseAmmoGGBody {
+    constructor(world, _nativeBody) {
+        super(world, _nativeBody);
+        this.world = world;
+        this._nativeBody = _nativeBody;
+        this.entity = null;
+        this.onEnter$ = new rxjs_1.Subject();
+        this.onLeft$ = new rxjs_1.Subject();
+        this.overlaps = new Set();
+    }
+    get onEntityEntered() {
+        return this.onEnter$.pipe((0, rxjs_1.map)(b => { var _a; return (_a = base_ammo_gg_body_1.BaseAmmoGGBody.nativeBodyReverseMap.get(b)) === null || _a === void 0 ? void 0 : _a.entity; }), (0, rxjs_1.filter)(x => !!x && x instanceof core_1.GgPositionable3dEntity));
+    }
+    get onEntityLeft() {
+        return this.onLeft$.pipe((0, rxjs_1.map)(b => { var _a; return ((_a = base_ammo_gg_body_1.BaseAmmoGGBody.nativeBodyReverseMap.get(b)) === null || _a === void 0 ? void 0 : _a.entity) || null; }));
+    }
+    checkOverlaps() {
+        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((0, ammo_utils_1.ammoId)(overlap));
+            }
+            else {
+                newOverlaps.delete(overlap);
+            }
+        }
+        for (const newOverlap of newOverlaps) {
+            this.overlaps.add(newOverlap);
+            this.onEnter$.next((0, ammo_utils_1.ammoId)(newOverlap));
+        }
+    }
+    clone() {
+        return this.world.factory.createTriggerFromShape(this._nativeBody.getCollisionShape(), {
+            position: this.position,
+            rotation: this.rotation,
+        });
+    }
+    addToWorld(world) {
+        var _a;
+        if (world != this.world) {
+            throw new Error('Ammo triggers cannot be shared between different worlds');
+        }
+        (_a = world.dynamicAmmoWorld) === null || _a === void 0 ? void 0 : _a.addCollisionObject(this.nativeBody);
+        this.overlaps.clear();
+    }
+    removeFromWorld(world) {
+        var _a;
+        for (const body of this.overlaps) {
+            this.onLeft$.next((0, ammo_utils_1.ammoId)(body));
+        }
+        this.overlaps.clear();
+        (_a = world.dynamicAmmoWorld) === null || _a === void 0 ? void 0 : _a.removeCollisionObject(this.nativeBody);
+    }
+    dispose() {
+        super.dispose();
+        this.overlaps.clear();
+        this.onEnter$.complete();
+        this.onLeft$.complete();
+    }
+    resetMotion() { }
+}
+exports.Gg3dTrigger = Gg3dTrigger;

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

@@ -0,0 +1,26 @@
+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 declare class Gg3dBodyFactory implements IGg3dBodyFactory<Gg3dBody, Gg3dTrigger> {
+    private readonly world;
+    constructor(world: Gg3dPhysicsWorld);
+    createRigidBody(descriptor: BodyShape3DDescriptor, transform?: {
+        position?: Point3;
+        rotation?: Point4;
+    }): Gg3dBody;
+    createTrigger(descriptor: Shape3DDescriptor, transform?: {
+        position?: Point3;
+        rotation?: Point4;
+    }): Gg3dTrigger;
+    private createShape;
+    createRigidBodyFromShape(shape: Ammo.btCollisionShape, options: Partial<Body3DOptions>, transform?: {
+        position?: Point3;
+        rotation?: Point4;
+    }): Gg3dBody;
+    createTriggerFromShape(shape: Ammo.btCollisionShape, transform?: {
+        position?: Point3;
+        rotation?: Point4;
+    }): Gg3dTrigger;
+}

package/dist/impl/gg-3d-body-factory.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gg3dBodyFactory = void 0;
+const gg_3d_body_1 = require("./bodies/gg-3d-body");
+const gg_3d_trigger_1 = require("./bodies/gg-3d-trigger");
+class Gg3dBodyFactory {
+    constructor(world) {
+        this.world = world;
+    }
+    createRigidBody(descriptor, transform) {
+        return this.createRigidBodyFromShape(this.createShape(descriptor.shape), descriptor.body, transform);
+    }
+    createTrigger(descriptor, transform) {
+        return this.createTriggerFromShape(this.createShape(descriptor), transform);
+    }
+    createShape(descriptor) {
+        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 = 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.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 = [
+                    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.shape}" not implemented for Ammo.js`);
+    }
+    createRigidBodyFromShape(shape, options, transform) {
+        if (options.dynamic === false) {
+            options.mass = 0;
+        }
+        const pos = (transform === null || transform === void 0 ? void 0 : transform.position) || { x: 0, y: 0, z: 0 };
+        const rot = (transform === null || transform === void 0 ? void 0 : 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 gg_3d_body_1.Gg3dBody(this.world, body);
+    }
+    createTriggerFromShape(shape, transform) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        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(((_a = transform === null || transform === void 0 ? void 0 : transform.position) === null || _a === void 0 ? void 0 : _a.x) || 0, ((_b = transform === null || transform === void 0 ? void 0 : transform.position) === null || _b === void 0 ? void 0 : _b.y) || 0, ((_c = transform === null || transform === void 0 ? void 0 : transform.position) === null || _c === void 0 ? void 0 : _c.z) || 0));
+        ghostObject
+            .getWorldTransform()
+            .setRotation(new this.world.ammo.btQuaternion(((_d = transform === null || transform === void 0 ? void 0 : transform.rotation) === null || _d === void 0 ? void 0 : _d.x) || 0, ((_e = transform === null || transform === void 0 ? void 0 : transform.rotation) === null || _e === void 0 ? void 0 : _e.y) || 0, ((_f = transform === null || transform === void 0 ? void 0 : transform.rotation) === null || _f === void 0 ? void 0 : _f.z) || 0, ((_g = transform === null || transform === void 0 ? void 0 : transform.rotation) === null || _g === void 0 ? void 0 : _g.w) || 1));
+        return new gg_3d_trigger_1.Gg3dTrigger(this.world, ghostObject);
+    }
+}
+exports.Gg3dBodyFactory = Gg3dBodyFactory;

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

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

package/dist/impl/gg-3d-body-loader.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gg3dBodyLoader = void 0;
+const core_1 = require("@gg-web-engine/core");
+class Gg3dBodyLoader extends core_1.IGg3dBodyLoader {
+    constructor(world) {
+        super(world);
+        this.world = world;
+    }
+}
+exports.Gg3dBodyLoader = Gg3dBodyLoader;

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

@@ -0,0 +1,34 @@
+import { Gg3dWorld, GgDebugPhysicsDrawer, IGg3dPhysicsWorld, Point3, Point4 } from '@gg-web-engine/core';
+import Ammo from 'ammojs-typed';
+import { Gg3dBodyFactory } from './gg-3d-body-factory';
+import { Gg3dBodyLoader } from './gg-3d-body-loader';
+export declare class Gg3dPhysicsWorld implements IGg3dPhysicsWorld {
+    private _factory;
+    get factory(): Gg3dBodyFactory;
+    private _loader;
+    get loader(): Gg3dBodyLoader;
+    private _gravity;
+    get gravity(): Point3;
+    set gravity(value: Point3);
+    private _timeScale;
+    get timeScale(): number;
+    set timeScale(value: number);
+    private _debugger;
+    private _debugDrawer;
+    get physicsDebugViewActive(): boolean;
+    private ammoInstance;
+    get ammo(): typeof Ammo;
+    get dynamicAmmoWorld(): Ammo.btDiscreteDynamicsWorld | undefined;
+    private collisionConfiguration;
+    private dispatcher;
+    private ghostPairCallback;
+    private broadphase;
+    private solver;
+    private gravityVector;
+    private _dynamicAmmoWorld;
+    init(): Promise<void>;
+    simulate(delta: number): void;
+    startDebugger(world: Gg3dWorld, drawer: GgDebugPhysicsDrawer<Point3, Point4>): void;
+    stopDebugger(world: Gg3dWorld): void;
+    dispose(): void;
+}