@gg-web-engine/rapier3d 0.0.57 → 0.0.59

package/dist/components/rapier-3d-raycast-vehicle.component.d.ts

@@ -1,8 +1,8 @@
-import { Gg3dWorld, IRaycastVehicleComponent, IVisualScene3dComponent, Point3, Point4, SuspensionOptions, VisualTypeDocRepo3D, WheelOptions } from '@gg-web-engine/core';
+import { IRaycastVehicleComponent, Point3, Point4, SuspensionOptions, WheelOptions } from '@gg-web-engine/core';
 import { DynamicRayCastVehicleController } from '@dimforge/rapier3d-compat';
 import { Rapier3dRigidBodyComponent } from './rapier-3d-rigid-body.component';
 import { Rapier3dWorldComponent } from './rapier-3d-world.component';
-import { Rapier3dPhysicsTypeDocRepo } from '../types';
+import { Rapier3dGgWorld, Rapier3dPhysicsTypeDocRepo } from '../types';
 export declare class Rapier3dRaycastVehicleComponent extends Rapier3dRigidBodyComponent implements IRaycastVehicleComponent<Rapier3dPhysicsTypeDocRepo> {
     protected readonly world: Rapier3dWorldComponent;
     private chassisBody;
@@ -11,8 +11,8 @@ export declare class Rapier3dRaycastVehicleComponent extends Rapier3dRigidBodyCo
     private wheelDescr;
     constructor(world: Rapier3dWorldComponent, chassisBody: Rapier3dRigidBodyComponent);
     get wheelSpeed(): number;
-    addToWorld(world: Gg3dWorld<VisualTypeDocRepo3D, Rapier3dPhysicsTypeDocRepo, IVisualScene3dComponent, Rapier3dWorldComponent>): void;
-    removeFromWorld(world: Gg3dWorld<VisualTypeDocRepo3D, Rapier3dPhysicsTypeDocRepo, IVisualScene3dComponent, Rapier3dWorldComponent>): void;
+    addToWorld(world: Rapier3dGgWorld): void;
+    removeFromWorld(world: Rapier3dGgWorld): void;
     addWheel(options: WheelOptions, suspensionOptions: SuspensionOptions): void;
     setSteering(wheelIndex: number, steering: number): void;
     applyEngineForce(wheelIndex: number, force: number): void;

package/dist/components/rapier-3d-rigid-body.component.d.ts

@@ -1,7 +1,7 @@
-import { Body3DOptions, CollisionGroup, DebugBody3DSettings, Entity3d, Gg3dWorld, IRigidBody3dComponent, Point3, Point4, Shape3DDescriptor, VisualTypeDocRepo3D } from '@gg-web-engine/core';
+import { Body3DOptions, CollisionGroup, DebugBody3DSettings, Entity3d, IRigidBody3dComponent, Point3, Point4, Shape3DDescriptor } from '@gg-web-engine/core';
 import { Collider, ColliderDesc, RigidBody, RigidBodyDesc } from '@dimforge/rapier3d-compat';
 import { Rapier3dWorldComponent } from './rapier-3d-world.component';
-import { Rapier3dPhysicsTypeDocRepo } from '../types';
+import { Rapier3dGgWorld, Rapier3dPhysicsTypeDocRepo } from '../types';
 import { InteractionGroups } from '@dimforge/rapier3d-compat/geometry/interaction_groups';
 export declare class Rapier3dRigidBodyComponent implements IRigidBody3dComponent<Rapier3dPhysicsTypeDocRepo> {
     protected readonly world: Rapier3dWorldComponent;
@@ -37,8 +37,8 @@ export declare class Rapier3dRigidBodyComponent implements IRigidBody3dComponent
     get ownCollisionGroups(): ReadonlyArray<CollisionGroup>;
     set ownCollisionGroups(value: ReadonlyArray<CollisionGroup> | 'all');
     clone(): Rapier3dRigidBodyComponent;
-    addToWorld(world: Gg3dWorld<VisualTypeDocRepo3D, Rapier3dPhysicsTypeDocRepo>): void;
-    removeFromWorld(world: Gg3dWorld<VisualTypeDocRepo3D, Rapier3dPhysicsTypeDocRepo>): void;
+    addToWorld(world: Rapier3dGgWorld): void;
+    removeFromWorld(world: Rapier3dGgWorld): void;
     resetMotion(): void;
     dispose(): void;
 }

package/dist/components/rapier-3d-trigger.component.d.ts

@@ -1,22 +1,24 @@
 import { Observable, Subject } from 'rxjs';
 import { ColliderDesc, RigidBodyDesc } from '@dimforge/rapier3d-compat';
 import { Rapier3dRigidBodyComponent } from './rapier-3d-rigid-body.component';
-import { DebugBody3DSettings, Gg3dWorld, ITrigger3dComponent, Shape3DDescriptor, VisualTypeDocRepo3D } from '@gg-web-engine/core';
+import { DebugBody3DSettings, ITrigger3dComponent, Shape3DDescriptor } from '@gg-web-engine/core';
 import { Rapier3dWorldComponent } from './rapier-3d-world.component';
-import { Rapier3dPhysicsTypeDocRepo } from '../types';
+import { Rapier3dGgWorld, Rapier3dPhysicsTypeDocRepo } from '../types';
 export declare class Rapier3dTriggerComponent extends Rapier3dRigidBodyComponent implements ITrigger3dComponent<Rapier3dPhysicsTypeDocRepo> {
     protected readonly world: Rapier3dWorldComponent;
     protected _colliderDescr: ColliderDesc[];
     readonly shape: Shape3DDescriptor;
     protected _bodyDescr: RigidBodyDesc;
+    readonly debugBodySettings: DebugBody3DSettings;
     get onEntityEntered(): Observable<Rapier3dRigidBodyComponent>;
     get onEntityLeft(): Observable<Rapier3dRigidBodyComponent>;
+    protected readonly overlaps: Set<Rapier3dRigidBodyComponent>;
     protected readonly onEnter$: Subject<Rapier3dRigidBodyComponent>;
     protected readonly onLeft$: Subject<Rapier3dRigidBodyComponent>;
-    readonly debugBodySettings: DebugBody3DSettings;
-    protected intersectionsAmount: number;
     constructor(world: Rapier3dWorldComponent, _colliderDescr: ColliderDesc[], shape: Shape3DDescriptor, _bodyDescr: RigidBodyDesc);
-    addToWorld(world: Gg3dWorld<VisualTypeDocRepo3D, Rapier3dPhysicsTypeDocRepo>): void;
+    addToWorld(world: Rapier3dGgWorld): void;
+    removeFromWorld(world: Rapier3dGgWorld): void;
     checkOverlaps(): void;
     clone(): Rapier3dTriggerComponent;
+    dispose(): void;
 }

package/dist/components/rapier-3d-trigger.component.js

@@ -1,6 +1,6 @@
-import { map, merge, Subject } from 'rxjs';
+import { Subject } from 'rxjs';
 import { Rapier3dRigidBodyComponent } from './rapier-3d-rigid-body.component';
-import { DebugBody3DSettings, } from '@gg-web-engine/core';
+import { DebugBody3DSettings } from '@gg-web-engine/core';
 export class Rapier3dTriggerComponent extends Rapier3dRigidBodyComponent {
     get onEntityEntered() {
         return this.onEnter$.asObservable();
@@ -14,29 +14,28 @@ export class Rapier3dTriggerComponent extends Rapier3dRigidBodyComponent {
         this._colliderDescr = _colliderDescr;
         this.shape = shape;
         this._bodyDescr = _bodyDescr;
+        this.debugBodySettings = new DebugBody3DSettings({ type: 'TRIGGER', activated: () => this.overlaps.size > 0 }, this.shape);
+        this.overlaps = new Set();
         this.onEnter$ = new Subject();
         this.onLeft$ = new Subject();
-        this.debugBodySettings = new DebugBody3DSettings({ type: 'TRIGGER', activated: () => this.intersectionsAmount > 0 }, this.shape);
-        this.intersectionsAmount = 0;
-        merge(this.onEnter$.pipe(map(() => true)), this.onLeft$.pipe(map(() => false))).subscribe(enter => {
-            if (enter) {
-                this.intersectionsAmount++;
-            }
-            else {
-                this.intersectionsAmount--;
-            }
-        });
     }
     addToWorld(world) {
         if (world.physicsWorld != this.world) {
             throw new Error('Rapier3D bodies cannot be shared between different worlds');
         }
-        this.intersectionsAmount = 0;
+        this.overlaps.clear();
         this._nativeBody = this.world.nativeWorld.createRigidBody(this._bodyDescr);
         this._nativeBodyColliders = this._colliderDescr.map(c => this.world.nativeWorld.createCollider(c, this._nativeBody));
         this.world.handleIdEntityMap.set(this._nativeBody.handle, this);
         this.world.added$.next(this);
     }
+    removeFromWorld(world) {
+        for (const body of this.overlaps) {
+            this.onLeft$.next(body);
+        }
+        this.overlaps.clear();
+        super.removeFromWorld(world);
+    }
     checkOverlaps() {
         this.world.eventQueue.drainCollisionEvents((h1, h2, started) => {
             var _a, _b;
@@ -49,8 +48,21 @@ export class Rapier3dTriggerComponent extends Rapier3dRigidBodyComponent {
             }
             if (!otherBody)
                 return;
-            (started ? this.onEnter$ : this.onLeft$).next(otherBody);
+            if (started) {
+                this.overlaps.add(otherBody);
+                this.onEnter$.next(otherBody);
+            }
+            else {
+                this.overlaps.delete(otherBody);
+                this.onLeft$.next(otherBody);
+            }
         });
+        for (const body of this.overlaps.keys()) {
+            if (!body.nativeBody) {
+                this.overlaps.delete(body);
+                this.onLeft$.next(body);
+            }
+        }
     }
     clone() {
         const [colliderDescr, sd, bd] = super.factoryProps;
@@ -59,4 +71,8 @@ export class Rapier3dTriggerComponent extends Rapier3dRigidBodyComponent {
         component.interactWithCollisionGroups = this.interactWithCollisionGroups;
         return component;
     }
+    dispose() {
+        this.overlaps.clear();
+        super.dispose();
+    }
 }

package/dist/components/rapier-3d-world.component.d.ts

@@ -1,4 +1,4 @@
-import { CollisionGroup, IPhysicsWorld3dComponent, Point3 } from '@gg-web-engine/core';
+import { CollisionGroup, IPhysicsWorld3dComponent, Point3, RaycastOptions, RaycastResult } from '@gg-web-engine/core';
 import { EventQueue, World } from '@dimforge/rapier3d-compat';
 import { Rapier3dRigidBodyComponent } from './rapier-3d-rigid-body.component';
 import { Rapier3dFactory } from '../rapier-3d-factory';
@@ -28,5 +28,6 @@ export declare class Rapier3dWorldComponent implements IPhysicsWorld3dComponent<
     protected lockedCollisionGroups: number[];
     registerCollisionGroup(): CollisionGroup;
     deregisterCollisionGroup(group: CollisionGroup): void;
+    raycast(options: RaycastOptions<Point3>): RaycastResult<Point3, Rapier3dRigidBodyComponent>;
     dispose(): void;
 }

package/dist/components/rapier-3d-world.component.js

@@ -7,6 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { BitMask, Pnt3, } from '@gg-web-engine/core';
 import { EventQueue, init, Vector3, World } from '@dimforge/rapier3d-compat';
 import { Rapier3dFactory } from '../rapier-3d-factory';
 import { Rapier3dLoader } from '../rapier-3d-loader';
@@ -88,6 +89,48 @@ export class Rapier3dWorldComponent {
     deregisterCollisionGroup(group) {
         this.lockedCollisionGroups = this.lockedCollisionGroups.filter(x => x !== group);
     }
+    raycast(options) {
+        if (!this._nativeWorld) {
+            return { hasHit: false };
+        }
+        const origin = options.from;
+        let direction = Pnt3.sub(options.to, options.from);
+        const rayLength = Pnt3.len(direction);
+        direction = Pnt3.norm(direction);
+        const ray = {
+            origin: new Vector3(...Pnt3.spr(origin)),
+            dir: new Vector3(...Pnt3.spr(direction)),
+            pointAt: (t) => {
+                return new Vector3(origin.x + direction.x * t, origin.y + direction.y * t, origin.z + direction.z * t);
+            },
+        };
+        const mask = (groups) => {
+            return groups ? BitMask.pack(groups, 16) : BitMask.full(16);
+        };
+        const hit = this._nativeWorld.castRay(ray, rayLength, true, undefined, (mask(options.collisionFilterGroups) << 16) | mask(options.collisionFilterMask));
+        if (!hit) {
+            return { hasHit: false };
+        }
+        const result = {
+            hasHit: true,
+        };
+        const collider = hit.collider;
+        if (collider) {
+            const rigidBody = collider.parent();
+            if (!rigidBody) {
+                return { hasHit: false };
+            }
+            result.hitBody = this.handleIdEntityMap.get(rigidBody.handle);
+            result.hitDistance = hit.timeOfImpact;
+            result.hitPoint = Pnt3.add(origin, Pnt3.scalarMult(direction, hit.timeOfImpact));
+            const rayIntersection = hit.collider.castRayAndGetNormal(ray, hit.timeOfImpact, true);
+            result.hitNormal = Pnt3.clone((rayIntersection === null || rayIntersection === void 0 ? void 0 : rayIntersection.normal) || Pnt3.O);
+        }
+        else {
+            result.hasHit = false;
+        }
+        return result;
+    }
     dispose() {
         var _a;
         (_a = this._nativeWorld) === null || _a === void 0 ? void 0 : _a.free();

package/dist/types.d.ts

@@ -2,6 +2,8 @@ import { Rapier3dFactory } from './rapier-3d-factory';
 import { Rapier3dLoader } from './rapier-3d-loader';
 import { Rapier3dRigidBodyComponent } from './components/rapier-3d-rigid-body.component';
 import { Rapier3dTriggerComponent } from './components/rapier-3d-trigger.component';
+import { Gg3dWorld, Gg3dWorldSceneTypeDocPPatch, Gg3dWorldTypeDocPPatch } from '@gg-web-engine/core';
+import { Rapier3dWorldComponent } from './components/rapier-3d-world.component';
 export type Rapier3dPhysicsTypeDocRepo = {
     factory: Rapier3dFactory;
     loader: Rapier3dLoader;
@@ -9,3 +11,6 @@ export type Rapier3dPhysicsTypeDocRepo = {
     trigger: Rapier3dTriggerComponent;
     raycastVehicle: never;
 };
+export type Rapier3dTypeDoc = Gg3dWorldTypeDocPPatch<Rapier3dPhysicsTypeDocRepo>;
+export type Rapier3dSceneTypeDoc = Gg3dWorldSceneTypeDocPPatch<Rapier3dPhysicsTypeDocRepo, Rapier3dWorldComponent>;
+export type Rapier3dGgWorld = Gg3dWorld<Rapier3dTypeDoc, Rapier3dSceneTypeDoc>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gg-web-engine/rapier3d",
-  "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",
@@ -28,7 +28,7 @@
   "homepage": "https://github.com/AndyGura/gg-web-engine#readme",
   "devDependencies": {
     "@dimforge/rapier3d-compat": "0.0.0-50223ff-20240729",
-    "@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",
@@ -39,7 +39,7 @@
   },
   "peerDependencies": {
     "@dimforge/rapier3d-compat": "0.0.0-50223ff-20240729",
-    "@gg-web-engine/core": "0.0.57",
+    "@gg-web-engine/core": "0.0.59",
     "rxjs": "7.8.1"
   },
   "jest": {

package/test/components/rapier-3d-trigger.component.spec.ts

@@ -1,5 +1,5 @@
-import { Rapier3dFactory, Rapier3dWorldComponent } from '../../src';
 import { Pnt3 } from '@gg-web-engine/core';
+import { Rapier3dFactory, Rapier3dWorldComponent } from '../../src';
 
 describe(`Rapier3dTriggerComponent`, () => {
 
@@ -85,40 +85,41 @@ describe(`Rapier3dTriggerComponent`, () => {
     expect(enterRegistered).toBe(true);
   });
 
-  // TODO implement functionality below
-  // it(`should fire end of object intersection if trigger removed`, async () => {
-  //   const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10, z: 10 } });
-  //   trigger.addToWorld({ physicsWorld: world } as any);
-  //   const ball = factory.createRigidBody({
-  //     shape: { shape: 'SPHERE', radius: 1 },
-  //     body: { dynamic: true, mass: 1 },
-  //   }, { position: { x: 0, y: 0, z: 0 } });
-  //   ball.addToWorld({ physicsWorld: world } as any);
-  //   let exitRegistered = false;
-  //   trigger.onEntityLeft.subscribe(((obj) => {
-  //     exitRegistered = obj === ball;
-  //   }));
-  //   world.simulate(1000);
-  //   trigger.checkOverlaps();
-  //   trigger.removeFromWorld({ physicsWorld: world } as any);
-  //   expect(exitRegistered).toBe(true);
-  // });
-  //
-  // it(`should fire end of object intersection if object removed`, async () => {
-  //   const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10, z: 10 } });
-  //   trigger.addToWorld({ physicsWorld: world } as any);
-  //   const ball = factory.createRigidBody({
-  //     shape: { shape: 'SPHERE', radius: 1 },
-  //     body: { dynamic: true, mass: 1 },
-  //   }, { position: { x: 0, y: 0, z: 0 } });
-  //   ball.addToWorld({ physicsWorld: world } as any);
-  //   let exitRegistered = false;
-  //   trigger.onEntityLeft.subscribe(((obj) => {
-  //     exitRegistered = obj === ball;
-  //   }));
-  //   world.simulate(1000);
-  //   trigger.checkOverlaps();
-  //   ball.removeFromWorld({ physicsWorld: world } as any);
-  //   expect(exitRegistered).toBe(true);
-  // });
+  it(`should fire end of object intersection if trigger removed`, async () => {
+    const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10, z: 10 } });
+    trigger.addToWorld({ physicsWorld: world } as any);
+    const ball = factory.createRigidBody({
+      shape: { shape: 'SPHERE', radius: 1 },
+      body: { dynamic: true, mass: 1 },
+    }, { position: { x: 0, y: 0, z: 0 } });
+    ball.addToWorld({ physicsWorld: world } as any);
+    let exitRegistered = false;
+    trigger.onEntityLeft.subscribe(((obj) => {
+      exitRegistered = obj === ball;
+    }));
+    world.simulate(1);
+    trigger.checkOverlaps();
+    trigger.removeFromWorld({ physicsWorld: world } as any);
+    expect(exitRegistered).toBe(true);
+  });
+
+  it(`should fire end of object intersection if object removed`, async () => {
+    const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10, z: 10 } });
+    trigger.addToWorld({ physicsWorld: world } as any);
+    const ball = factory.createRigidBody({
+      shape: { shape: 'SPHERE', radius: 1 },
+      body: { dynamic: true, mass: 1 },
+    }, { position: { x: 0, y: 0, z: 0 } });
+    ball.addToWorld({ physicsWorld: world } as any);
+    let exitRegistered = false;
+    trigger.onEntityLeft.subscribe(((obj) => {
+      exitRegistered = obj === ball;
+    }));
+    world.simulate(1);
+    trigger.checkOverlaps();
+    ball.removeFromWorld({ physicsWorld: world } as any);
+    world.simulate(1);
+    trigger.checkOverlaps();
+    expect(exitRegistered).toBe(true);
+  });
 });

package/test/components/rapier-3d-world.component.spec.ts

@@ -0,0 +1,296 @@
+import { Point3, RaycastOptions } from '@gg-web-engine/core';
+import { Rapier3dWorldComponent } from '../../src';
+
+describe('Rapier3dWorldComponent', () => {
+  let world: Rapier3dWorldComponent;
+
+  beforeEach(async () => {
+    if (world) {
+      world.dispose();
+    }
+    world = new Rapier3dWorldComponent();
+    await world.init();
+    world.gravity = { x: 0, y: 0, z: 0 }; // Set gravity to zero for predictable physics
+  });
+
+  afterAll(() => {
+    world.dispose();
+  });
+
+  describe('Rigid bodies', () => {
+
+    it('should simulate inertial motion of rigid body', () => {
+
+      const ball = world.factory.createRigidBody({
+        shape: { shape: 'SPHERE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: -5, y: 0, z: 0 } });
+      ball.addToWorld({ physicsWorld: world } as any);
+      ball.linearVelocity = { x: 1, y: 0, z: 0 };
+
+      // simulate for 6 seconds
+      for (let i = 0; i < 100; i++) {
+        world.simulate(60);
+      }
+      expect(ball.position.x).toBeCloseTo(1);
+    });
+
+    it('should simulate collision of two rigid bodies', () => {
+
+      const ball0 = world.factory.createRigidBody({
+        shape: { shape: 'SPHERE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: -5, y: 0, z: 0 } });
+      ball0.addToWorld({ physicsWorld: world } as any);
+      ball0.linearVelocity = { x: 1, y: 0, z: 0 };
+
+      const ball1 = world.factory.createRigidBody({
+        shape: { shape: 'SPHERE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: 5, y: 0, z: 0 } });
+      ball1.addToWorld({ physicsWorld: world } as any);
+      ball1.linearVelocity = { x: -1, y: 0, z: 0 };
+
+      // simulate for 6 seconds
+      for (let i = 0; i < 100; i++) {
+        world.simulate(60);
+      }
+      expect(ball0.position.x).toBeLessThan(0);
+      expect(ball1.position.x).toBeGreaterThan(0);
+    });
+
+    it('should not simulate collision of two rigid bodies with different collision groups', () => {
+      const cg0 = world.registerCollisionGroup();
+      const ball0 = world.factory.createRigidBody({
+        shape: { shape: 'SPHERE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: -5, y: 0, z: 0 } });
+      ball0.addToWorld({ physicsWorld: world } as any);
+      ball0.linearVelocity = { x: 1, y: 0, z: 0 };
+      ball0.ownCollisionGroups = ball0.interactWithCollisionGroups = [cg0];
+
+      const cg1 = world.registerCollisionGroup();
+      const ball1 = world.factory.createRigidBody({
+        shape: { shape: 'SPHERE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: 5, y: 0, z: 0 } });
+      ball1.addToWorld({ physicsWorld: world } as any);
+      ball1.linearVelocity = { x: -1, y: 0, z: 0 };
+      ball1.ownCollisionGroups = ball1.interactWithCollisionGroups = [cg1];
+
+      // simulate for 6 seconds
+      for (let i = 0; i < 100; i++) {
+        world.simulate(60);
+      }
+      expect(ball0.position.x).toBeCloseTo(1);
+      expect(ball1.position.x).toBeCloseTo(-1);
+    });
+  });
+
+  describe('Raycast', () => {
+
+    it('should return no hit when ray does not intersect any object', () => {
+      // Create a box far away from the ray
+      const box = world.factory.createRigidBody({
+        shape: { shape: 'BOX', dimensions: { x: 1, y: 1, z: 1 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 10, y: 10, z: 10 } });
+      box.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray that doesn't hit anything
+      const raycastOptions: RaycastOptions<Point3> = {
+        from: { x: 0, y: 0, z: 0 },
+        to: { x: 0, y: 0, z: -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 box in the path of the ray
+      const box = world.factory.createRigidBody({
+        shape: { shape: 'BOX', dimensions: { x: 2, y: 2, z: 2 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: 0, z: -5 } });
+      box.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray that hits the box
+      const raycastOptions: RaycastOptions<Point3> = {
+        from: { x: 0, y: 0, z: 0 },
+        to: { x: 0, y: 0, z: -10 },
+      };
+
+      const result = world.raycast(raycastOptions);
+      expect(result.hasHit).toBe(true);
+      expect(result.hitBody).toBe(box);
+      expect(result.hitPoint).toBeDefined();
+      expect(result.hitNormal).toBeDefined();
+      expect(result.hitDistance).toBeDefined();
+
+      // The hit should be at approximately z = -4 (box at z = -5 with size 2)
+      expect(result.hitPoint!.z).toBeCloseTo(-4, 0.1);
+
+      // The normal should point up (towards the ray origin)
+      expect(result.hitNormal!.z).toBeGreaterThan(0);
+    });
+
+    it('should respect collision filtering', () => {
+      // Register collision groups
+      const group1 = world.registerCollisionGroup();
+      const group2 = world.registerCollisionGroup();
+
+      // Create a box that only belongs to group1
+      const box1 = world.factory.createRigidBody({
+        shape: { shape: 'BOX', dimensions: { x: 2, y: 2, z: 2 } },
+        body: {
+          dynamic: false,
+          mass: 0,
+          ownCollisionGroups: [group1],
+          interactWithCollisionGroups: [group1, group2],
+        },
+      }, { position: { x: 0, y: 0, z: -5 } });
+      box1.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Ray that only checks against group2 should not hit
+      const rayOptions1: RaycastOptions<Point3> = {
+        from: { x: 0, y: 0, z: 0 },
+        to: { x: 0, y: 0, z: -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<Point3> = {
+        from: { x: 0, y: 0, z: 0 },
+        to: { x: 0, y: 0, z: -10 },
+        collisionFilterGroups: [group1],
+        collisionFilterMask: [group1],
+      };
+
+      const result2 = world.raycast(rayOptions2);
+      expect(result2.hasHit).toBe(true);
+      expect(result2.hitBody).toBe(box1);
+    });
+
+    it('should calculate hit distance correctly', () => {
+      // Create a box at a known distance
+      const box = world.factory.createRigidBody({
+        shape: { shape: 'BOX', dimensions: { x: 2, y: 2, z: 2 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: 0, z: -5 } });
+      box.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray from origin to z = -10
+      const raycastOptions: RaycastOptions<Point3> = {
+        from: { x: 0, y: 0, z: 0 },
+        to: { x: 0, y: 0, z: -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 box at z = -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 box that belongs to group1
+      const box = world.factory.createRigidBody({
+        shape: { shape: 'BOX', dimensions: { x: 2, y: 2, z: 2 } },
+        body: {
+          dynamic: false,
+          mass: 0,
+          ownCollisionGroups: [group1],
+          interactWithCollisionGroups: [group1, group2],
+        },
+      }, { position: { x: 0, y: 0, z: -5 } });
+      box.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Ray that checks against both groups should hit
+      const rayOptions: RaycastOptions<Point3> = {
+        from: { x: 0, y: 0, z: 0 },
+        to: { x: 0, y: 0, z: -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 boxes at different positions
+      const box1 = world.factory.createRigidBody({
+        shape: { shape: 'BOX', dimensions: { x: 1, y: 1, z: 1 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: 0, z: -3 } });
+      box1.addToWorld({ physicsWorld: world } as any);
+
+      const box2 = world.factory.createRigidBody({
+        shape: { shape: 'BOX', dimensions: { x: 1, y: 1, z: 1 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: 0, z: -7 } });
+      box2.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray that should hit box1 first
+      const raycastOptions: RaycastOptions<Point3> = {
+        from: { x: 0, y: 0, z: 0 },
+        to: { x: 0, y: 0, z: -10 },
+      };
+
+      const result = world.raycast(raycastOptions);
+      expect(result.hasHit).toBe(true);
+      expect(result.hitBody).toBe(box1);
+      expect(result.hitPoint!.z).toBeCloseTo(-2.5, 0.1); // box1 edge is at z = -2.5
+    });
+
+    it('should handle edge case with ray starting inside an object', () => {
+      // Create a box
+      const box = world.factory.createRigidBody({
+        shape: { shape: 'BOX', dimensions: { x: 4, y: 4, z: 4 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: 0, z: 0 } });
+      box.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray from inside the box
+      const raycastOptions: RaycastOptions<Point3> = {
+        from: { x: 0, y: 0, z: 0 }, // Center of the box
+        to: { x: 0, y: 0, z: -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

@@ -3,6 +3,9 @@
   "compilerOptions": {
     "baseUrl": "./src/",
     "outDir": "./dist/",
+    "rootDir": "./src/",
+    "tsBuildInfoFile": "./dist/tsconfig.tsbuildinfo",
   },
   "include": ["src/*.ts", "src/**/*.ts"],
+  "references": [{ "path": "../core" }]
 }