@gg-web-engine/matter 0.0.57 → 0.0.59

package/dist/components/matter-rigid-body.component.d.ts

@@ -1,7 +1,6 @@
-import { CollisionGroup, DebugBody2DSettings, Entity2d, Gg2dWorld, IRigidBody2dComponent, IVisualScene2dComponent, Point2, Shape2DDescriptor, VisualTypeDocRepo2D } from '@gg-web-engine/core';
+import { CollisionGroup, DebugBody2DSettings, Entity2d, IRigidBody2dComponent, Point2, Shape2DDescriptor } from '@gg-web-engine/core';
 import { Body } from 'matter-js';
-import { MatterPhysicsTypeDocRepo } from '../types';
-import { MatterWorldComponent } from './matter-world.component';
+import { MatterGgWorld, MatterPhysicsTypeDocRepo } from '../types';
 export declare class MatterRigidBodyComponent implements IRigidBody2dComponent<MatterPhysicsTypeDocRepo> {
     nativeBody: Body;
     readonly shape: Shape2DDescriptor;
@@ -16,14 +15,17 @@ export declare class MatterRigidBodyComponent implements IRigidBody2dComponent<M
     name: string;
     entity: Entity2d | null;
     readonly debugBodySettings: DebugBody2DSettings;
+    protected _interactWithCGsMask: number;
+    protected _ownCGsMask: number;
     constructor(nativeBody: Body, shape: Shape2DDescriptor);
     get interactWithCollisionGroups(): ReadonlyArray<CollisionGroup>;
     set interactWithCollisionGroups(value: ReadonlyArray<CollisionGroup> | 'all');
     get ownCollisionGroups(): ReadonlyArray<CollisionGroup>;
     set ownCollisionGroups(value: ReadonlyArray<CollisionGroup> | 'all');
+    protected updateCollisionFilter(): void;
     clone(): MatterRigidBodyComponent;
-    addToWorld(world: Gg2dWorld<VisualTypeDocRepo2D, MatterPhysicsTypeDocRepo, IVisualScene2dComponent, MatterWorldComponent>): void;
-    removeFromWorld(world: Gg2dWorld<VisualTypeDocRepo2D, MatterPhysicsTypeDocRepo, IVisualScene2dComponent, MatterWorldComponent>): void;
+    addToWorld(world: MatterGgWorld): void;
+    removeFromWorld(world: MatterGgWorld): void;
     dispose(): void;
     resetMotion(): void;
 }

package/dist/components/matter-rigid-body.component.js

@@ -1,8 +1,10 @@
-import { DebugBody2DSettings, Pnt2, } from '@gg-web-engine/core';
+import { BitMask, DebugBody2DSettings, Pnt2, } from '@gg-web-engine/core';
 import { Body, Composite, Vector } from 'matter-js';
+// FIXME why this needs to be introduced? investigate units in matter.js
+const MATTER_VELOCITY_SCALE = 0.0166667;
 export class MatterRigidBodyComponent {
     get position() {
-        return this.nativeBody.position;
+        return Pnt2.clone(this.nativeBody.position);
     }
     set position(value) {
         Body.setPosition(this.nativeBody, Vector.create(value.x, value.y));
@@ -14,10 +16,10 @@ export class MatterRigidBodyComponent {
         this.nativeBody.angle = value;
     }
     get linearVelocity() {
-        return Pnt2.clone(this.nativeBody.velocity);
+        return Pnt2.scalarMult(this.nativeBody.velocity, 1 / MATTER_VELOCITY_SCALE);
     }
     set linearVelocity(value) {
-        Body.setVelocity(this.nativeBody, Vector.create(value.x, value.y));
+        Body.setVelocity(this.nativeBody, Vector.create(value.x * MATTER_VELOCITY_SCALE, value.y * MATTER_VELOCITY_SCALE));
     }
     get angularVelocity() {
         return this.nativeBody.angularVelocity;
@@ -33,22 +35,51 @@ export class MatterRigidBodyComponent {
         this.debugBodySettings = new DebugBody2DSettings(isFinite(this.nativeBody.mass)
             ? { type: 'RIGID_DYNAMIC', sleeping: () => this.nativeBody.isSleeping }
             : { type: 'RIGID_STATIC' }, this.shape);
+        this._interactWithCGsMask = BitMask.full(16);
+        this._ownCGsMask = BitMask.full(16);
+        this.updateCollisionFilter();
     }
     get interactWithCollisionGroups() {
-        throw new Error('Collision groups not implemented for Matter.js');
+        return BitMask.unpack(this._interactWithCGsMask, 16);
     }
     set interactWithCollisionGroups(value) {
-        throw new Error('Collision groups not implemented for Matter.js');
+        let mask;
+        if (value === 'all') {
+            mask = BitMask.full(16);
+        }
+        else {
+            mask = BitMask.pack(value, 16);
+        }
+        if (this._interactWithCGsMask !== mask) {
+            this._interactWithCGsMask = mask;
+            this.updateCollisionFilter();
+        }
     }
     get ownCollisionGroups() {
-        throw new Error('Collision groups not implemented for Matter.js');
+        return BitMask.unpack(this._ownCGsMask, 16);
     }
     set ownCollisionGroups(value) {
-        throw new Error('Collision groups not implemented for Matter.js');
+        let mask;
+        if (value === 'all') {
+            mask = BitMask.full(16);
+        }
+        else {
+            mask = BitMask.pack(value, 16);
+        }
+        if (this._ownCGsMask !== mask) {
+            this._ownCGsMask = mask;
+            this.updateCollisionFilter();
+        }
+    }
+    updateCollisionFilter() {
+        this.nativeBody.collisionFilter = Object.assign(Object.assign({}, this.nativeBody.collisionFilter), { category: this._ownCGsMask, mask: this._interactWithCGsMask });
     }
     clone() {
-        // TODO
-        throw new Error('Gg2dBody.clone() not implemented for Matter.js');
+        const clonedBody = Body.create(Object.assign(Object.assign({}, this.nativeBody), { collisionFilter: Object.assign({}, this.nativeBody.collisionFilter) }));
+        const component = new MatterRigidBodyComponent(clonedBody, this.shape);
+        component.ownCollisionGroups = this.ownCollisionGroups;
+        component.interactWithCollisionGroups = this.interactWithCollisionGroups;
+        return component;
     }
     addToWorld(world) {
         Composite.add(world.physicsWorld.matterWorld, this.nativeBody);

package/dist/components/matter-trigger.component.d.ts

@@ -0,0 +1,24 @@
+import { Observable, Subject } from 'rxjs';
+import { Body } from 'matter-js';
+import { MatterRigidBodyComponent } from './matter-rigid-body.component';
+import { DebugBody2DSettings, ITrigger2dComponent, Shape2DDescriptor } from '@gg-web-engine/core';
+import { MatterWorldComponent } from './matter-world.component';
+import { MatterGgWorld, MatterPhysicsTypeDocRepo } from '../types';
+export declare class MatterTriggerComponent extends MatterRigidBodyComponent implements ITrigger2dComponent<MatterPhysicsTypeDocRepo> {
+    readonly shape: Shape2DDescriptor;
+    protected readonly world: MatterWorldComponent;
+    get onEntityEntered(): Observable<MatterRigidBodyComponent>;
+    get onEntityLeft(): Observable<MatterRigidBodyComponent>;
+    protected readonly onEnter$: Subject<MatterRigidBodyComponent>;
+    protected readonly onLeft$: Subject<MatterRigidBodyComponent>;
+    readonly debugBodySettings: DebugBody2DSettings;
+    protected intersectionsAmount: number;
+    protected currentOverlaps: Set<MatterRigidBodyComponent>;
+    private onCollisionStart;
+    private onCollisionEnd;
+    constructor(nativeBody: Body, shape: Shape2DDescriptor, world: MatterWorldComponent);
+    addToWorld(world: MatterGgWorld): void;
+    removeFromWorld(world: MatterGgWorld): void;
+    checkOverlaps(): void;
+    clone(): MatterTriggerComponent;
+}

package/dist/components/matter-trigger.component.js

@@ -0,0 +1,96 @@
+import { map, merge, Subject } from 'rxjs';
+import { Body, Events } from 'matter-js';
+import { MatterRigidBodyComponent } from './matter-rigid-body.component';
+import { DebugBody2DSettings } from '@gg-web-engine/core';
+export class MatterTriggerComponent extends MatterRigidBodyComponent {
+    get onEntityEntered() {
+        return this.onEnter$.asObservable();
+    }
+    get onEntityLeft() {
+        return this.onLeft$.asObservable();
+    }
+    onCollisionStart(event) {
+        for (const pair of event.pairs) {
+            let body = null;
+            if (pair.bodyA === this.nativeBody) {
+                body = pair.bodyB;
+            }
+            else if (pair.bodyB === this.nativeBody) {
+                body = pair.bodyA;
+            }
+            if (body) {
+                let comp = this.world.children.find(c => c.nativeBody === body);
+                if (comp) {
+                    this.onEnter$.next(comp);
+                }
+            }
+        }
+    }
+    onCollisionEnd(event) {
+        for (const pair of event.pairs) {
+            let body = null;
+            if (pair.bodyA === this.nativeBody) {
+                body = pair.bodyB;
+            }
+            else if (pair.bodyB === this.nativeBody) {
+                body = pair.bodyA;
+            }
+            if (body) {
+                let comp = this.world.children.find(c => c.nativeBody === body);
+                if (comp) {
+                    this.onLeft$.next(comp);
+                }
+            }
+        }
+    }
+    constructor(nativeBody, shape, world) {
+        super(nativeBody, shape);
+        this.shape = shape;
+        this.world = world;
+        this.onEnter$ = new Subject();
+        this.onLeft$ = new Subject();
+        this.debugBodySettings = new DebugBody2DSettings({ type: 'TRIGGER', activated: () => this.intersectionsAmount > 0 }, this.shape);
+        this.intersectionsAmount = 0;
+        this.currentOverlaps = new Set();
+        this.nativeBody.isSensor = true;
+        merge(this.onEnter$.pipe(map(() => true)), this.onLeft$.pipe(map(() => false))).subscribe(enter => {
+            if (enter) {
+                this.intersectionsAmount++;
+            }
+            else {
+                this.intersectionsAmount--;
+            }
+        });
+        this.onCollisionStart = this.onCollisionStart.bind(this);
+        this.onCollisionEnd = this.onCollisionEnd.bind(this);
+    }
+    addToWorld(world) {
+        if (world.physicsWorld != this.world) {
+            throw new Error('Matter bodies cannot be shared between different worlds');
+        }
+        this.intersectionsAmount = 0;
+        this.currentOverlaps.clear();
+        super.addToWorld(world);
+        Events.on(world.physicsWorld.matterEngine, 'collisionStart', this.onCollisionStart);
+        Events.on(world.physicsWorld.matterEngine, 'collisionEnd', this.onCollisionEnd);
+    }
+    removeFromWorld(world) {
+        Events.off(world.physicsWorld.matterEngine, 'collisionStart', this.onCollisionStart);
+        Events.off(world.physicsWorld.matterEngine, 'collisionEnd', this.onCollisionEnd);
+        for (const body of this.currentOverlaps) {
+            this.onLeft$.next(body);
+        }
+        this.currentOverlaps.clear();
+        super.removeFromWorld(world);
+    }
+    checkOverlaps() {
+        // do nothing, for matter.js we handle this differently
+    }
+    clone() {
+        const clonedBody = Body.create(Object.assign(Object.assign({}, this.nativeBody), { isSensor: true, collisionFilter: Object.assign({}, this.nativeBody.collisionFilter) }));
+        const component = new MatterTriggerComponent(clonedBody, this.shape, this.world);
+        component.ownCollisionGroups = this.ownCollisionGroups;
+        component.interactWithCollisionGroups = this.interactWithCollisionGroups;
+        return component;
+    }
+}

package/dist/components/matter-world.component.d.ts

@@ -1,24 +1,29 @@
-import { CollisionGroup, IPhysicsWorld2dComponent, Point2 } from '@gg-web-engine/core';
+import { CollisionGroup, IPhysicsWorld2dComponent, Point2, RaycastOptions, RaycastResult } from '@gg-web-engine/core';
 import { Engine, World } from 'matter-js';
 import { MatterFactory } from '../matter-factory';
 import { MatterPhysicsTypeDocRepo } from '../types';
 import { Subject } from 'rxjs';
 import { MatterRigidBodyComponent } from './matter-rigid-body.component';
+import { MatterTriggerComponent } from './matter-trigger.component';
 export declare class MatterWorldComponent implements IPhysicsWorld2dComponent<MatterPhysicsTypeDocRepo> {
-    protected matterEngine: Engine | null;
+    protected matterEngine_: Engine | null;
+    get matterEngine(): Engine | null;
     get matterWorld(): World | null;
     readonly factory: MatterFactory;
-    readonly added$: Subject<MatterRigidBodyComponent>;
-    readonly removed$: Subject<MatterRigidBodyComponent>;
-    readonly children: MatterRigidBodyComponent[];
+    readonly added$: Subject<MatterRigidBodyComponent | MatterTriggerComponent>;
+    readonly removed$: Subject<MatterRigidBodyComponent | MatterTriggerComponent>;
+    readonly children: (MatterRigidBodyComponent | MatterTriggerComponent)[];
     private _gravity;
     get gravity(): Point2;
     set gravity(value: Point2);
     readonly mainCollisionGroup: CollisionGroup;
     constructor();
     init(): Promise<void>;
+    protected lockedCollisionGroups: number[];
     registerCollisionGroup(): CollisionGroup;
     deregisterCollisionGroup(group: CollisionGroup): void;
+    private lastDelta;
     simulate(delta: number): void;
+    raycast(options: RaycastOptions<Point2>): RaycastResult<Point2, MatterRigidBodyComponent>;
     dispose(): void;
 }

package/dist/components/matter-world.component.js

@@ -10,8 +10,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { Engine } from 'matter-js';
 import { MatterFactory } from '../matter-factory';
 import { Subject } from 'rxjs';
-// TODO implement bindings for collision groups. Matter.js has elegant solution for that, read body.collisionFilter
+// TODO probably should be configurable in world
+const MATTER_WORLD_SCALE = 0.0001;
 export class MatterWorldComponent {
+    get matterEngine() {
+        return this.matterEngine_;
+    }
     get matterWorld() {
         return this.matterEngine && this.matterEngine.world;
     }
@@ -26,29 +30,43 @@ export class MatterWorldComponent {
         }
     }
     constructor() {
-        this.matterEngine = null;
-        this.factory = new MatterFactory();
+        this.matterEngine_ = null;
         this.added$ = new Subject();
         this.removed$ = new Subject();
         this.children = [];
         this._gravity = { x: 0, y: 9.82 };
         this.mainCollisionGroup = 0;
+        this.lockedCollisionGroups = [];
+        this.lastDelta = 0;
         this.added$.subscribe(c => this.children.push(c));
         this.removed$.subscribe(c => this.children.splice(this.children.indexOf(c), 1));
+        this.factory = new MatterFactory(this);
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.matterEngine = Engine.create({ gravity: Object.assign(Object.assign({}, this._gravity), { scale: 0.0001 }) });
+            this.matterEngine_ = Engine.create({
+                gravity: Object.assign(Object.assign({}, this._gravity), { scale: MATTER_WORLD_SCALE }),
+            });
         });
     }
     registerCollisionGroup() {
-        throw new Error('Collision groups not implemented for Matter.js');
+        for (let i = 1; i < 16; i++) {
+            if (!this.lockedCollisionGroups.includes(i)) {
+                this.lockedCollisionGroups.push(i);
+                return i;
+            }
+        }
+        throw new Error('App tries to register 17th collision group, but Matter.js supports only 16');
     }
     deregisterCollisionGroup(group) {
-        throw new Error('Collision groups not implemented for Matter.js');
+        this.lockedCollisionGroups = this.lockedCollisionGroups.filter(x => x !== group);
     }
     simulate(delta) {
-        Engine.update(this.matterEngine, delta);
+        Engine.update(this.matterEngine, delta, this.lastDelta > 0 ? delta / this.lastDelta : 1);
+        this.lastDelta = delta;
+    }
+    raycast(options) {
+        throw new Error('Ray casting is not implemented for Matter.js');
     }
     dispose() {
         Engine.clear(this.matterEngine);

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './components/matter-rigid-body.component';
+export * from './components/matter-trigger.component';
 export * from './components/matter-world.component';
 export * from './matter-factory';
 export * from './types';

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from './components/matter-rigid-body.component';
+export * from './components/matter-trigger.component';
 export * from './components/matter-world.component';
 export * from './matter-factory';
 export * from './types';

package/dist/matter-factory.d.ts

@@ -1,7 +1,11 @@
 import { BodyShape2DDescriptor, IPhysicsBody2dComponentFactory, Point2, Shape2DDescriptor } from '@gg-web-engine/core';
 import { MatterRigidBodyComponent } from './components/matter-rigid-body.component';
+import { MatterTriggerComponent } from './components/matter-trigger.component';
+import { MatterWorldComponent } from './components/matter-world.component';
 import { MatterPhysicsTypeDocRepo } from './types';
 export declare class MatterFactory implements IPhysicsBody2dComponentFactory<MatterPhysicsTypeDocRepo> {
+    protected readonly world: MatterWorldComponent;
+    constructor(world: MatterWorldComponent);
     createRigidBody(descriptor: BodyShape2DDescriptor, transform?: {
         position?: Point2;
         rotation?: number;
@@ -9,6 +13,6 @@ export declare class MatterFactory implements IPhysicsBody2dComponentFactory<Mat
     createTrigger(descriptor: Shape2DDescriptor, transform?: {
         position?: Point2;
         rotation?: number;
-    }): never;
+    }): MatterTriggerComponent;
     private transformOptions;
 }

package/dist/matter-factory.js

@@ -1,6 +1,10 @@
 import { MatterRigidBodyComponent } from './components/matter-rigid-body.component';
+import { MatterTriggerComponent } from './components/matter-trigger.component';
 import { Bodies, Vector } from 'matter-js';
 export class MatterFactory {
+    constructor(world) {
+        this.world = world;
+    }
     createRigidBody(descriptor, transform) {
         var _a, _b;
         let nativeBody = null;
@@ -20,7 +24,26 @@ export class MatterFactory {
         return new MatterRigidBodyComponent(nativeBody, descriptor.shape);
     }
     createTrigger(descriptor, transform) {
-        throw new Error('Triggers not implemented for Matter.js');
+        var _a, _b;
+        let nativeBody = null;
+        switch (descriptor.shape) {
+            case 'SQUARE':
+                nativeBody = Bodies.rectangle(0, 0, descriptor.dimensions.x, descriptor.dimensions.y, { isSensor: true });
+                break;
+            case 'CIRCLE':
+                nativeBody = Bodies.circle(0, 0, descriptor.radius, { isSensor: true });
+                break;
+        }
+        if (!nativeBody) {
+            throw new Error(`Shape "${descriptor.shape}" not implemented for Matter.js`);
+        }
+        nativeBody.position.x = ((_a = transform === null || transform === void 0 ? void 0 : transform.position) === null || _a === void 0 ? void 0 : _a.x) || 0;
+        nativeBody.position.y = ((_b = transform === null || transform === void 0 ? void 0 : transform.position) === null || _b === void 0 ? void 0 : _b.y) || 0;
+        nativeBody.angle = (transform === null || transform === void 0 ? void 0 : transform.rotation) || 0;
+        if (!this.world) {
+            throw new Error('MatterFactory: World not set. Make sure the factory is created by MatterWorldComponent.');
+        }
+        return new MatterTriggerComponent(nativeBody, descriptor, this.world);
     }
     transformOptions(options) {
         const res = {

package/dist/types.d.ts

@@ -1,7 +1,13 @@
 import { MatterFactory } from './matter-factory';
 import { MatterRigidBodyComponent } from './components/matter-rigid-body.component';
+import { MatterTriggerComponent } from './components/matter-trigger.component';
+import { Gg2dWorld, Gg2dWorldSceneTypeDocPPatch, Gg2dWorldTypeDocPPatch } from '@gg-web-engine/core';
+import { MatterWorldComponent } from './components/matter-world.component';
 export type MatterPhysicsTypeDocRepo = {
     factory: MatterFactory;
     rigidBody: MatterRigidBodyComponent;
-    trigger: never;
+    trigger: MatterTriggerComponent;
 };
+export type MatterTypeDoc = Gg2dWorldTypeDocPPatch<MatterPhysicsTypeDocRepo>;
+export type MatterSceneTypeDoc = Gg2dWorldSceneTypeDocPPatch<MatterPhysicsTypeDocRepo, MatterWorldComponent>;
+export type MatterGgWorld = Gg2dWorld<MatterTypeDoc, MatterSceneTypeDoc>;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@gg-web-engine/matter",
-  "version": "0.0.57",
+  "version": "0.0.59",
   "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",
+    "test": "jest",
     "prettier-format": "prettier --config ../core/.prettierrc 'src/**/*.ts' --write",
     "prepublish": "rm -rf ./dist/ && tsc",
     "build": "tsc"
@@ -30,15 +30,41 @@
   },
   "devDependencies": {
     "@types/matter-js": "0.19.7",
-    "@gg-web-engine/core": "0.0.57",
+    "@gg-web-engine/core": "0.0.59",
+    "@types/jest": "^29.5.12",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
     "matter-js": "0.20.0",
     "prettier": "^3.3.3",
     "rxjs": "7.8.1",
+    "ts-jest": "^29.2.4",
     "typescript": "~5.5.4"
   },
   "peerDependencies": {
-    "@gg-web-engine/core": "0.0.57",
+    "@gg-web-engine/core": "0.0.59",
     "matter-js": "0.20.0",
     "rxjs": "7.8.1"
+  },
+  "jest": {
+    "rootDir": ".",
+    "testRegex": "\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "moduleNameMapper": {
+      "@gg-web-engine/core": "<rootDir>/../core/src/index.ts"
+    },
+    "preset": "ts-jest/presets/default",
+    "collectCoverageFrom": [
+      "**/*.ts",
+      "!**/*.module.ts"
+    ],
+    "coveragePathIgnorePatterns": [
+      "<rootDir>/node_modules/",
+      "<rootDir>/dist/",
+      "<rootDir>/test/"
+    ],
+    "coverageDirectory": "./coverage",
+    "testEnvironment": "jsdom"
   }
 }

package/test/components/matter-trigger.component.spec.ts

@@ -0,0 +1,131 @@
+import { Pnt2 } from '@gg-web-engine/core';
+import { MatterFactory, MatterWorldComponent } from '../../src';
+
+describe(`MatterTriggerComponent`, () => {
+
+  let world: MatterWorldComponent;
+  let factory: MatterFactory;
+  beforeEach(async () => {
+    if (world) {
+      world.dispose();
+    }
+    world = new MatterWorldComponent();
+    factory = new MatterFactory(world);
+    await world.init();
+    world.gravity = Pnt2.O;
+  });
+
+  afterAll(() => {
+    world.dispose();
+  });
+
+  // FIXME matter.js logic is kinda not intuitive. Spawning objects on some coordinates seems to cause collisions with
+  // all the objects that intersect the line between (0, 0) and desired position, sensors are flying away to the
+  // infinity just by setting it's position and other wonderful miracles. Investigate why these tests fail and try to fix.
+  // Note: this test is identical to rapier2d trigger test, and it is expected
+  it.skip(`should detect object intersection`, async () => {
+    const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
+    trigger.addToWorld({ physicsWorld: world } as any);
+    const circle = factory.createRigidBody({
+      shape: { shape: 'CIRCLE', radius: 1 },
+      body: { dynamic: true, mass: 1 },
+    }, { position: { x: 0, y: 12 } });
+    circle.addToWorld({ physicsWorld: world } as any);
+    circle.linearVelocity = { x: 0, y: -10 };
+    circle.nativeBody.frictionAir = 0;
+    let enterRegistered = false;
+    let exitRegistered = false;
+    trigger.onEntityEntered.subscribe(((obj) => {
+      enterRegistered = obj === circle;
+    }));
+    trigger.onEntityLeft.subscribe(((obj) => {
+      exitRegistered = obj === circle;
+    }));
+    world.simulate(500);
+    trigger.checkOverlaps(); // trigger entity performs that on tick
+    expect(enterRegistered).toBe(false);
+    expect(exitRegistered).toBe(false);
+
+    world.simulate(500);
+    trigger.checkOverlaps();
+    expect(enterRegistered).toBe(true);
+    expect(exitRegistered).toBe(false);
+  });
+
+  it.skip(`should detect end of object intersection`, async () => {
+    const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
+    trigger.addToWorld({ physicsWorld: world } as any);
+    const circle = factory.createRigidBody({
+      shape: { shape: 'CIRCLE', radius: 1 },
+      body: { dynamic: true, mass: 1 },
+    }, { position: { x: 0, y: 12 } });
+    circle.addToWorld({ physicsWorld: world } as any);
+    circle.linearVelocity = { x: 0, y: -10 };
+    circle.nativeBody.frictionAir = 0;
+    let exitRegistered = false;
+    trigger.onEntityLeft.subscribe(((obj) => {
+      exitRegistered = obj === circle;
+    }));
+    world.simulate(1000);
+    trigger.checkOverlaps();
+    expect(exitRegistered).toBe(false);
+    world.simulate(1000);
+    trigger.checkOverlaps();
+    expect(exitRegistered).toBe(true);
+  });
+
+  it.skip(`should fire object intersection if spawned inside`, async () => {
+    const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
+    trigger.addToWorld({ physicsWorld: world } as any);
+    const circle = factory.createRigidBody({
+      shape: { shape: 'CIRCLE', radius: 1 },
+      body: { dynamic: true, mass: 1 },
+    }, { position: Pnt2.O });
+    circle.addToWorld({ physicsWorld: world } as any);
+    let enterRegistered = false;
+    trigger.onEntityEntered.subscribe(((obj) => {
+      enterRegistered = obj === circle;
+    }));
+    world.simulate(1000);
+    trigger.checkOverlaps();
+    expect(enterRegistered).toBe(true);
+  });
+
+  it.skip(`should fire end of object intersection if trigger removed`, async () => {
+    const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
+    trigger.addToWorld({ physicsWorld: world } as any);
+    const circle = factory.createRigidBody({
+      shape: { shape: 'CIRCLE', radius: 1 },
+      body: { dynamic: true, mass: 1 },
+    }, { position: Pnt2.O });
+    circle.addToWorld({ physicsWorld: world } as any);
+    let exitRegistered = false;
+    trigger.onEntityLeft.subscribe(((obj) => {
+      exitRegistered = obj === circle;
+    }));
+    world.simulate(1);
+    trigger.checkOverlaps();
+    trigger.removeFromWorld({ physicsWorld: world } as any);
+    expect(exitRegistered).toBe(true);
+  });
+
+  it.skip(`should fire end of object intersection if object removed`, async () => {
+    const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
+    trigger.addToWorld({ physicsWorld: world } as any);
+    const circle = factory.createRigidBody({
+      shape: { shape: 'CIRCLE', radius: 1 },
+      body: { dynamic: true, mass: 1 },
+    }, { position: Pnt2.O });
+    circle.addToWorld({ physicsWorld: world } as any);
+    let exitRegistered = false;
+    trigger.onEntityLeft.subscribe(((obj) => {
+      exitRegistered = obj === circle;
+    }));
+    world.simulate(1);
+    trigger.checkOverlaps();
+    circle.removeFromWorld({ physicsWorld: world } as any);
+    world.simulate(1);
+    trigger.checkOverlaps();
+    expect(exitRegistered).toBe(true);
+  });
+});

package/test/components/matter-world.component.spec.ts

@@ -0,0 +1,301 @@
+import { Point2, RaycastOptions } from '@gg-web-engine/core';
+import { MatterWorldComponent } from '../../src';
+
+describe('MatterWorldComponent', () => {
+  let world: MatterWorldComponent;
+
+  beforeEach(async () => {
+    if (world) {
+      world.dispose();
+    }
+    world = new MatterWorldComponent();
+    await world.init();
+    world.gravity = { x: 0, y: 0 }; // Set gravity to zero for predictable physics
+  });
+
+  afterAll(() => {
+    world.dispose();
+  });
+
+  describe('Rigid bodies', () => {
+
+    it('should simulate inertial motion of rigid body', () => {
+
+      const circle = world.factory.createRigidBody({
+        shape: { shape: 'CIRCLE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: -5, y: 0 } });
+      circle.addToWorld({ physicsWorld: world } as any);
+      circle.linearVelocity = { x: 1, y: 0 };
+      circle.nativeBody.frictionAir = 0;
+
+      // simulate for 6 seconds
+      for (let i = 0; i < 100; i++) {
+        world.simulate(60);
+      }
+      expect(circle.position.x).toBeCloseTo(1);
+    });
+
+    it('should simulate collision of two rigid bodies', () => {
+
+      const circle0 = world.factory.createRigidBody({
+        shape: { shape: 'CIRCLE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: -5, y: 0 } });
+      circle0.addToWorld({ physicsWorld: world } as any);
+      circle0.linearVelocity = { x: 1, y: 0 };
+      circle0.nativeBody.frictionAir = 0;
+
+      const circle1 = world.factory.createRigidBody({
+        shape: { shape: 'CIRCLE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: 5, y: 0 } });
+      circle1.addToWorld({ physicsWorld: world } as any);
+      circle1.linearVelocity = { x: -1, y: 0 };
+      circle1.nativeBody.frictionAir = 0;
+
+      // simulate for 6 seconds
+      for (let i = 0; i < 100; i++) {
+        world.simulate(60);
+      }
+      expect(circle0.position.x).toBeLessThan(0);
+      expect(circle1.position.x).toBeGreaterThan(0);
+    });
+
+    it('should not simulate collision of two rigid bodies with different collision groups', () => {
+      const cg0 = world.registerCollisionGroup();
+      const circle0 = world.factory.createRigidBody({
+        shape: { shape: 'CIRCLE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: -5, y: 0 } });
+      circle0.addToWorld({ physicsWorld: world } as any);
+      circle0.linearVelocity = { x: 1, y: 0 };
+      circle0.nativeBody.frictionAir = 0;
+      circle0.ownCollisionGroups = circle0.interactWithCollisionGroups = [cg0];
+
+      const cg1 = world.registerCollisionGroup();
+      const circle1 = world.factory.createRigidBody({
+        shape: { shape: 'CIRCLE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: 5, y: 0 } });
+      circle1.addToWorld({ physicsWorld: world } as any);
+      circle1.linearVelocity = { x: -1, y: 0 };
+      circle1.nativeBody.frictionAir = 0;
+      circle1.ownCollisionGroups = circle1.interactWithCollisionGroups = [cg1];
+
+      // simulate for 6 seconds
+      for (let i = 0; i < 100; i++) {
+        world.simulate(60);
+      }
+      expect(circle0.position.x).toBeCloseTo(1);
+      expect(circle1.position.x).toBeCloseTo(-1);
+    });
+  });
+
+  describe.skip('Raycast', () => {
+
+    it('should return no hit when ray does not intersect any object', () => {
+      // Create a square far away from the ray
+      const square = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 1, y: 1 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 10, y: 10 } });
+      square.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray that doesn't hit anything
+      const raycastOptions: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+      };
+
+      const result = world.raycast(raycastOptions);
+      expect(result.hasHit).toBe(false);
+      expect(result.hitPoint).toBeUndefined();
+      expect(result.hitNormal).toBeUndefined();
+      expect(result.hitDistance).toBeUndefined();
+    });
+
+    it('should detect hit when ray intersects an object', () => {
+      // Create a square in the path of the ray
+      const square = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 2, y: 2 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: -5 } });
+      square.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray that hits the square
+      const raycastOptions: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+      };
+
+      const result = world.raycast(raycastOptions);
+      expect(result.hasHit).toBe(true);
+      expect(result.hitBody).toBe(square);
+      expect(result.hitPoint).toBeDefined();
+      expect(result.hitNormal).toBeDefined();
+      expect(result.hitDistance).toBeDefined();
+
+      // The hit should be at approximately y = -4 (box at y = -5 with size 2)
+      expect(result.hitPoint!.y).toBeCloseTo(-4, 0.1);
+
+      // The normal should point up (towards the ray origin)
+      expect(result.hitNormal!.y).toBeGreaterThan(0);
+    });
+
+    it('should respect collision filtering', () => {
+      // Register collision groups
+      const group1 = world.registerCollisionGroup();
+      const group2 = world.registerCollisionGroup();
+
+      // Create a square that only belongs to group1
+      const square1 = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 2, y: 2 } },
+        body: {
+          dynamic: false,
+          mass: 0,
+          ownCollisionGroups: [group1],
+          interactWithCollisionGroups: [group1, group2],
+        },
+      }, { position: { x: 0, y: -5 } });
+      square1.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Ray that only checks against group2 should not hit
+      const rayOptions1: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+        collisionFilterGroups: [group2],
+        collisionFilterMask: [group2],
+      };
+
+      const result1 = world.raycast(rayOptions1);
+      expect(result1.hasHit).toBe(false);
+
+      // Ray that checks against group1 should hit
+      const rayOptions2: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+        collisionFilterGroups: [group1],
+        collisionFilterMask: [group1],
+      };
+
+      const result2 = world.raycast(rayOptions2);
+      expect(result2.hasHit).toBe(true);
+      expect(result2.hitBody).toBe(square1);
+    });
+
+    it('should calculate hit distance correctly', () => {
+      // Create a square at a known distance
+      const square = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 2, y: 2 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: -5 } });
+      square.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray from origin to y = -10
+      const raycastOptions: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+      };
+
+      const result = world.raycast(raycastOptions);
+      expect(result.hasHit).toBe(true);
+
+      // The hit distance should be approximately 4 units
+      // (from origin to the edge of the square at y = -4)
+      expect(result.hitDistance).toBeCloseTo(4, 0.1);
+    });
+
+    it('should handle array of collision groups correctly', () => {
+      // Register collision groups
+      const group1 = world.registerCollisionGroup();
+      const group2 = world.registerCollisionGroup();
+
+      // Create a square that belongs to group1
+      const square = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 2, y: 2 } },
+        body: {
+          dynamic: false,
+          mass: 0,
+          ownCollisionGroups: [group1],
+          interactWithCollisionGroups: [group1, group2],
+        },
+      }, { position: { x: 0, y: -5 } });
+      square.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Ray that checks against both groups should hit
+      const rayOptions: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+        collisionFilterGroups: [group1, group2],
+        collisionFilterMask: [group1, group2],
+      };
+
+      const result = world.raycast(rayOptions);
+      expect(result.hasHit).toBe(true);
+    });
+
+    it('should return correct hit body', () => {
+      // Create two squares at different positions
+      const square1 = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 1, y: 1 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: -3 } });
+      square1.addToWorld({ physicsWorld: world } as any);
+
+      const square2 = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 1, y: 1 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: -7 } });
+      square2.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray that should hit square1 first
+      const raycastOptions: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+      };
+
+      const result = world.raycast(raycastOptions);
+      expect(result.hasHit).toBe(true);
+      expect(result.hitBody).toBe(square1);
+      expect(result.hitPoint!.y).toBeCloseTo(-2.5, 0.1); // square1 edge is at y = -2.5
+    });
+
+    it('should handle edge case with ray starting inside an object', () => {
+      // Create a square
+      const square = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 4, y: 4 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: 0 } });
+      square.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray from inside the square
+      const raycastOptions: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 }, // Center of the square
+        to: { x: 0, y: -10 },
+      };
+
+      const result = world.raycast(raycastOptions);
+
+      // Behavior may vary depending on physics engine implementation
+      // Some engines might not detect hits when starting inside an object
+      // Others might detect the exit point
+      // We just verify the method doesn't crash and returns a valid result
+      expect(result).toBeDefined();
+    });
+  });
+});

package/tsconfig.json

@@ -2,7 +2,10 @@
   "extends": "./../../tsconfig.base.json",
   "compilerOptions": {
     "baseUrl": "./src/",
-    "outDir": "./dist/"
+    "outDir": "./dist/",
+    "rootDir": "./src/",
+    "tsBuildInfoFile": "./dist/tsconfig.tsbuildinfo"
   },
   "include": ["src/*.ts", "src/**/*.ts"],
+  "references": [{ "path": "../core" }]
 }