@gg-web-engine/ammo 0.0.57 → 0.0.59

package/dist/ammo.js/ammo-ambient.d.ts

@@ -730,9 +730,7 @@ declare module Ammo {
     get_primitive_triangle(prim_index: number, triangle: btPrimitiveTriangle): void;
   }
   type eGIMPACT_SHAPE_TYPE =
-    | 'CONST_GIMPACT_COMPOUND_SHAPE'
-    | 'CONST_GIMPACT_TRIMESH_SHAPE_PART'
-    | 'CONST_GIMPACT_TRIMESH_SHAPE';
+    'CONST_GIMPACT_COMPOUND_SHAPE' | 'CONST_GIMPACT_TRIMESH_SHAPE_PART' | 'CONST_GIMPACT_TRIMESH_SHAPE';
   class btTetrahedronShapeEx {
     constructor();
     setVertices(v0: btVector3, v1: btVector3, v2: btVector3, v3: btVector3): void;
@@ -1111,10 +1109,7 @@ declare module Ammo {
     | 'FIXED_CONSTRAINT_TYPE'
     | 'MAX_CONSTRAINT_TYPE';
   type btConstraintParams =
-    | 'BT_CONSTRAINT_ERP'
-    | 'BT_CONSTRAINT_STOP_ERP'
-    | 'BT_CONSTRAINT_CFM'
-    | 'BT_CONSTRAINT_STOP_CFM';
+    'BT_CONSTRAINT_ERP' | 'BT_CONSTRAINT_STOP_ERP' | 'BT_CONSTRAINT_CFM' | 'BT_CONSTRAINT_STOP_CFM';
   class btPoint2PointConstraint extends btTypedConstraint {
     constructor(rbA: btRigidBody, rbB: btRigidBody, pivotInA: btVector3, pivotInB: btVector3);
     constructor(rbA: btRigidBody, pivotInA: btVector3);

package/dist/ammo.js/ammo.d.ts

@@ -731,9 +731,7 @@ declare module Ammo {
     get_primitive_triangle(prim_index: number, triangle: btPrimitiveTriangle): void;
   }
   type eGIMPACT_SHAPE_TYPE =
-    | 'CONST_GIMPACT_COMPOUND_SHAPE'
-    | 'CONST_GIMPACT_TRIMESH_SHAPE_PART'
-    | 'CONST_GIMPACT_TRIMESH_SHAPE';
+    'CONST_GIMPACT_COMPOUND_SHAPE' | 'CONST_GIMPACT_TRIMESH_SHAPE_PART' | 'CONST_GIMPACT_TRIMESH_SHAPE';
   class btTetrahedronShapeEx {
     constructor();
     setVertices(v0: btVector3, v1: btVector3, v2: btVector3, v3: btVector3): void;
@@ -1112,10 +1110,7 @@ declare module Ammo {
     | 'FIXED_CONSTRAINT_TYPE'
     | 'MAX_CONSTRAINT_TYPE';
   type btConstraintParams =
-    | 'BT_CONSTRAINT_ERP'
-    | 'BT_CONSTRAINT_STOP_ERP'
-    | 'BT_CONSTRAINT_CFM'
-    | 'BT_CONSTRAINT_STOP_CFM';
+    'BT_CONSTRAINT_ERP' | 'BT_CONSTRAINT_STOP_ERP' | 'BT_CONSTRAINT_CFM' | 'BT_CONSTRAINT_STOP_CFM';
   class btPoint2PointConstraint extends btTypedConstraint {
     constructor(rbA: btRigidBody, rbB: btRigidBody, pivotInA: btVector3, pivotInB: btVector3);
     constructor(rbA: btRigidBody, pivotInA: btVector3);

package/dist/components/ammo-body.component.d.ts

@@ -1,12 +1,12 @@
-import { CollisionGroup, Gg3dWorld, IEntity, Point3, Point4, Shape3DDescriptor, VisualTypeDocRepo3D } from '@gg-web-engine/core';
+import { CollisionGroup, IEntity, Point3, Point4, Shape3DDescriptor } from '@gg-web-engine/core';
 import { AmmoWorldComponent } from './ammo-world.component';
 import Ammo from '../ammo.js/ammo';
-import { AmmoPhysicsTypeDocRepo } from '../types';
+import { AmmoGgWorld } from '../types';
 export declare abstract class AmmoBodyComponent<T extends Ammo.btCollisionObject> {
     protected readonly world: AmmoWorldComponent;
     protected _nativeBody: T;
     readonly shape: Shape3DDescriptor;
-    protected static nativeBodyReverseMap: Map<number, AmmoBodyComponent<any>>;
+    static nativeBodyReverseMap: Map<number, AmmoBodyComponent<any>>;
     get position(): Point3;
     set position(value: Point3);
     get rotation(): Point4;
@@ -25,7 +25,7 @@ export declare abstract class AmmoBodyComponent<T extends Ammo.btCollisionObject
     set ownCollisionGroups(value: ReadonlyArray<CollisionGroup> | 'all');
     protected constructor(world: AmmoWorldComponent, _nativeBody: T, shape: Shape3DDescriptor);
     abstract clone(): AmmoBodyComponent<T>;
-    addToWorld(world: Gg3dWorld<VisualTypeDocRepo3D, AmmoPhysicsTypeDocRepo>): void;
-    removeFromWorld(world: Gg3dWorld<VisualTypeDocRepo3D, AmmoPhysicsTypeDocRepo>): void;
+    addToWorld(world: AmmoGgWorld): void;
+    removeFromWorld(world: AmmoGgWorld): void;
     dispose(): void;
 }

package/dist/components/ammo-body.component.js

@@ -1,4 +1,4 @@
-import { BitMask, } from '@gg-web-engine/core';
+import { BitMask } from '@gg-web-engine/core';
 import Ammo from '../ammo.js/ammo';
 export class AmmoBodyComponent {
     get position() {

package/dist/components/ammo-raycast-vehicle.component.d.ts

@@ -1,8 +1,8 @@
-import { CollisionGroup, Gg3dWorld, IRaycastVehicleComponent, Point3, Point4, RaycastVehicle3dEntity, SuspensionOptions, VisualTypeDocRepo3D, WheelOptions } from '@gg-web-engine/core';
+import { CollisionGroup, IRaycastVehicleComponent, Point3, Point4, RaycastVehicle3dEntity, SuspensionOptions, WheelOptions } from '@gg-web-engine/core';
 import Ammo from '../ammo.js/ammo';
 import { AmmoRigidBodyComponent } from './ammo-rigid-body.component';
 import { AmmoWorldComponent } from './ammo-world.component';
-import { AmmoPhysicsTypeDocRepo } from '../types';
+import { AmmoGgWorld, AmmoPhysicsTypeDocRepo } from '../types';
 export declare class AmmoRaycastVehicleComponent extends AmmoRigidBodyComponent implements IRaycastVehicleComponent<AmmoPhysicsTypeDocRepo> {
     protected readonly world: AmmoWorldComponent;
     chassisBody: AmmoRigidBodyComponent;
@@ -19,8 +19,8 @@ export declare class AmmoRaycastVehicleComponent extends AmmoRigidBodyComponent
     refreshCG(): void;
     constructor(world: AmmoWorldComponent, chassisBody: AmmoRigidBodyComponent);
     get wheelSpeed(): number;
-    addToWorld(world: Gg3dWorld<VisualTypeDocRepo3D, AmmoPhysicsTypeDocRepo>): void;
-    removeFromWorld(world: Gg3dWorld<VisualTypeDocRepo3D, AmmoPhysicsTypeDocRepo>): void;
+    addToWorld(world: AmmoGgWorld): void;
+    removeFromWorld(world: AmmoGgWorld): void;
     addWheel(options: WheelOptions, suspensionOptions: SuspensionOptions): void;
     setSteering(wheelIndex: number, steering: number): void;
     applyEngineForce(wheelIndex: number, force: number): void;

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

@@ -1,8 +1,8 @@
 import { AmmoWorldComponent } from './ammo-world.component';
 import Ammo from '../ammo.js/ammo';
 import { AmmoBodyComponent } from './ammo-body.component';
-import { DebugBody3DSettings, Entity3d, Gg3dWorld, IRigidBody3dComponent, Point3, Shape3DDescriptor, VisualTypeDocRepo3D } from '@gg-web-engine/core';
-import { AmmoPhysicsTypeDocRepo } from '../types';
+import { DebugBody3DSettings, Entity3d, IRigidBody3dComponent, Point3, Shape3DDescriptor } from '@gg-web-engine/core';
+import { AmmoGgWorld, AmmoPhysicsTypeDocRepo } from '../types';
 export declare class AmmoRigidBodyComponent extends AmmoBodyComponent<Ammo.btRigidBody> implements IRigidBody3dComponent<AmmoPhysicsTypeDocRepo> {
     protected readonly world: AmmoWorldComponent;
     protected _nativeBody: Ammo.btRigidBody;
@@ -15,8 +15,8 @@ export declare class AmmoRigidBodyComponent extends AmmoBodyComponent<Ammo.btRig
     readonly debugBodySettings: DebugBody3DSettings;
     constructor(world: AmmoWorldComponent, _nativeBody: Ammo.btRigidBody, shape: Shape3DDescriptor);
     clone(): AmmoRigidBodyComponent;
-    addToWorld(world: Gg3dWorld<VisualTypeDocRepo3D, AmmoPhysicsTypeDocRepo>): void;
-    removeFromWorld(world: Gg3dWorld<VisualTypeDocRepo3D, AmmoPhysicsTypeDocRepo>): void;
+    addToWorld(world: AmmoGgWorld): void;
+    removeFromWorld(world: AmmoGgWorld): void;
     refreshCG(): void;
     resetMotion(): void;
 }

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

@@ -1,6 +1,6 @@
 import Ammo from '../ammo.js/ammo';
 import { AmmoBodyComponent } from './ammo-body.component';
-import { DebugBody3DSettings, } from '@gg-web-engine/core';
+import { DebugBody3DSettings } from '@gg-web-engine/core';
 import { first } from 'rxjs';
 export class AmmoRigidBodyComponent extends AmmoBodyComponent {
     get linearVelocity() {

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

@@ -1,10 +1,10 @@
-import { DebugBody3DSettings, Gg3dWorld, IEntity, ITrigger3dComponent, Shape3DDescriptor, VisualTypeDocRepo3D } from '@gg-web-engine/core';
+import { DebugBody3DSettings, IEntity, ITrigger3dComponent, Shape3DDescriptor } from '@gg-web-engine/core';
 import { AmmoWorldComponent } from './ammo-world.component';
 import { Observable, Subject } from 'rxjs';
 import Ammo from '../ammo.js/ammo';
 import { AmmoBodyComponent } from './ammo-body.component';
 import { AmmoRigidBodyComponent } from './ammo-rigid-body.component';
-import { AmmoPhysicsTypeDocRepo } from '../types';
+import { AmmoGgWorld, AmmoPhysicsTypeDocRepo } from '../types';
 export declare class AmmoTriggerComponent extends AmmoBodyComponent<Ammo.btPairCachingGhostObject> implements ITrigger3dComponent<AmmoPhysicsTypeDocRepo> {
     protected readonly world: AmmoWorldComponent;
     protected _nativeBody: Ammo.btPairCachingGhostObject;
@@ -14,13 +14,13 @@ export declare class AmmoTriggerComponent extends AmmoBodyComponent<Ammo.btPairC
     get onEntityEntered(): Observable<AmmoRigidBodyComponent>;
     get onEntityLeft(): Observable<AmmoRigidBodyComponent | null>;
     constructor(world: AmmoWorldComponent, _nativeBody: Ammo.btPairCachingGhostObject, shape: Shape3DDescriptor);
+    protected readonly overlaps: Set<Ammo.btCollisionObject>;
     protected readonly onEnter$: Subject<number>;
     protected readonly onLeft$: Subject<number>;
-    protected readonly overlaps: Set<Ammo.btCollisionObject>;
     checkOverlaps(): void;
     clone(): AmmoTriggerComponent;
-    addToWorld(world: Gg3dWorld<VisualTypeDocRepo3D, AmmoPhysicsTypeDocRepo>): void;
-    removeFromWorld(world: Gg3dWorld<VisualTypeDocRepo3D, AmmoPhysicsTypeDocRepo>): void;
+    addToWorld(world: AmmoGgWorld): void;
+    removeFromWorld(world: AmmoGgWorld): void;
     refreshCG(): void;
     dispose(): void;
 }

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

@@ -1,4 +1,4 @@
-import { DebugBody3DSettings, } from '@gg-web-engine/core';
+import { DebugBody3DSettings } from '@gg-web-engine/core';
 import { filter, map, Subject } from 'rxjs';
 import Ammo from '../ammo.js/ammo';
 import { AmmoBodyComponent } from './ammo-body.component';
@@ -16,9 +16,9 @@ export class AmmoTriggerComponent extends AmmoBodyComponent {
         this.shape = shape;
         this.entity = null;
         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.overlaps = new Set();
     }
     checkOverlaps() {
         const numOverlappingObjects = this.nativeBody.getNumOverlappingObjects();

package/dist/components/ammo-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 { Subject } from 'rxjs';
 import Ammo from '../ammo.js/ammo';
 import { AmmoFactory } from '../ammo-factory';
@@ -35,5 +35,6 @@ export declare class AmmoWorldComponent implements IPhysicsWorld3dComponent<Ammo
     protected lockedCollisionGroups: number[];
     registerCollisionGroup(): CollisionGroup;
     deregisterCollisionGroup(group: CollisionGroup): void;
+    raycast(options: RaycastOptions<Point3>): RaycastResult<Point3, AmmoRigidBodyComponent | AmmoTriggerComponent>;
     dispose(): void;
 }

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

@@ -7,10 +7,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { BitMask, } from '@gg-web-engine/core';
 import { Subject } from 'rxjs';
 import Ammo from '../ammo.js/ammo';
 import { AmmoFactory } from '../ammo-factory';
 import { AmmoLoader } from '../ammo-loader';
+import { AmmoBodyComponent } from './ammo-body.component';
 export class AmmoWorldComponent {
     get factory() {
         if (!this._factory) {
@@ -89,6 +91,46 @@ export class AmmoWorldComponent {
     deregisterCollisionGroup(group) {
         this.lockedCollisionGroups = this.lockedCollisionGroups.filter(x => x !== group);
     }
+    raycast(options) {
+        if (!this._dynamicAmmoWorld) {
+            return { hasHit: false };
+        }
+        const from = new Ammo.btVector3(options.from.x, options.from.y, options.from.z);
+        const to = new Ammo.btVector3(options.to.x, options.to.y, options.to.z);
+        const rayCallback = new Ammo.ClosestRayResultCallback(from, to);
+        if (options.collisionFilterGroups) {
+            rayCallback.set_m_collisionFilterGroup(BitMask.pack(options.collisionFilterGroups, 16));
+        }
+        if (options.collisionFilterMask !== undefined) {
+            rayCallback.set_m_collisionFilterMask(BitMask.pack(options.collisionFilterMask, 16));
+        }
+        this._dynamicAmmoWorld.rayTest(from, to, rayCallback);
+        const hasHit = rayCallback.hasHit();
+        const result = { hasHit };
+        if (hasHit) {
+            result.hitBody = AmmoBodyComponent.nativeBodyReverseMap.get(Ammo.getPointer(rayCallback.get_m_collisionObject()));
+            const hitPointAmmo = rayCallback.get_m_hitPointWorld();
+            result.hitPoint = {
+                x: hitPointAmmo.x(),
+                y: hitPointAmmo.y(),
+                z: hitPointAmmo.z(),
+            };
+            const hitNormalAmmo = rayCallback.get_m_hitNormalWorld();
+            result.hitNormal = {
+                x: hitNormalAmmo.x(),
+                y: hitNormalAmmo.y(),
+                z: hitNormalAmmo.z(),
+            };
+            const dx = result.hitPoint.x - options.from.x;
+            const dy = result.hitPoint.y - options.from.y;
+            const dz = result.hitPoint.z - options.from.z;
+            result.hitDistance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        }
+        Ammo.destroy(from);
+        Ammo.destroy(to);
+        Ammo.destroy(rayCallback);
+        return result;
+    }
     dispose() {
         this.afterTick$.complete();
         Ammo.destroy(this._dynamicAmmoWorld);

package/dist/types.d.ts

@@ -3,6 +3,8 @@ import { AmmoTriggerComponent } from './components/ammo-trigger.component';
 import { AmmoRaycastVehicleComponent } from './components/ammo-raycast-vehicle.component';
 import { AmmoFactory } from './ammo-factory';
 import { AmmoLoader } from './ammo-loader';
+import { Gg3dWorld, Gg3dWorldSceneTypeDocPPatch, Gg3dWorldTypeDocPPatch } from '@gg-web-engine/core';
+import { AmmoWorldComponent } from './components/ammo-world.component';
 export type AmmoPhysicsTypeDocRepo = {
     factory: AmmoFactory;
     loader: AmmoLoader;
@@ -10,3 +12,6 @@ export type AmmoPhysicsTypeDocRepo = {
     trigger: AmmoTriggerComponent;
     raycastVehicle: AmmoRaycastVehicleComponent;
 };
+export type AmmoTypeDoc = Gg3dWorldTypeDocPPatch<AmmoPhysicsTypeDocRepo>;
+export type AmmoSceneTypeDoc = Gg3dWorldSceneTypeDocPPatch<AmmoPhysicsTypeDocRepo, AmmoWorldComponent>;
+export type AmmoGgWorld = Gg3dWorld<AmmoTypeDoc, AmmoSceneTypeDoc>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gg-web-engine/ammo",
-  "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",
@@ -34,7 +34,7 @@
   "dependencies": {
   },
   "devDependencies": {
-    "@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",
@@ -45,7 +45,7 @@
     "typescript": "~5.5.4"
   },
   "peerDependencies": {
-    "@gg-web-engine/core": "0.0.57",
+    "@gg-web-engine/core": "0.0.59",
     "mini-signals": "2.0.0",
     "rxjs": "7.8.1"
   },

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

@@ -97,6 +97,7 @@ describe(`AmmoTriggerComponent`, () => {
     trigger.onEntityLeft.subscribe(((obj) => {
       exitRegistered = obj === ball;
     }));
+    world.simulate(1);
     trigger.checkOverlaps();
     trigger.removeFromWorld({ physicsWorld: world } as any);
     expect(exitRegistered).toBe(true);
@@ -114,8 +115,10 @@ describe(`AmmoTriggerComponent`, () => {
     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/ammo-world.component.spec.ts

@@ -0,0 +1,296 @@
+import { Point3, RaycastOptions } from '@gg-web-engine/core';
+import { AmmoWorldComponent } from '../../src';
+
+describe('AmmoWorldComponent', () => {
+  let world: AmmoWorldComponent;
+
+  beforeEach(async () => {
+    if (world) {
+      world.dispose();
+    }
+    world = new AmmoWorldComponent();
+    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

@@ -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" }]
 }