@gg-web-engine/ammo 0.0.56 → 0.0.58

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;
@@ -18,14 +18,14 @@ export declare abstract class AmmoBodyComponent<T extends Ammo.btCollisionObject
     protected addedToWorld: boolean;
     protected _interactWithCGsMask: number;
     protected _ownCGsMask: number;
-    get interactWithCollisionGroups(): CollisionGroup[];
+    get interactWithCollisionGroups(): ReadonlyArray<CollisionGroup>;
     abstract refreshCG(): void;
-    set interactWithCollisionGroups(value: CollisionGroup[] | 'all');
-    get ownCollisionGroups(): CollisionGroup[];
-    set ownCollisionGroups(value: CollisionGroup[] | 'all');
+    set interactWithCollisionGroups(value: ReadonlyArray<CollisionGroup> | 'all');
+    get ownCollisionGroups(): ReadonlyArray<CollisionGroup>;
+    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() {
@@ -75,6 +75,7 @@ export class AmmoBodyComponent {
         this._interactWithCGsMask = BitMask.full(16);
         this._ownCGsMask = BitMask.full(16);
         AmmoBodyComponent.nativeBodyReverseMap.set(Ammo.getPointer(this.nativeBody), this);
+        this.ownCollisionGroups = this.interactWithCollisionGroups = [world.mainCollisionGroup];
     }
     addToWorld(world) {
         if (world.physicsWorld != this.world) {

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;
@@ -12,15 +12,15 @@ export declare class AmmoRaycastVehicleComponent extends AmmoRigidBodyComponent
     protected readonly wheelAxleCS: Ammo.btVector3;
     entity: RaycastVehicle3dEntity | null;
     protected readonly raycaster: Ammo.btDefaultVehicleRaycaster;
-    get interactWithCollisionGroups(): CollisionGroup[];
-    set interactWithCollisionGroups(value: CollisionGroup[] | 'all');
-    get ownCollisionGroups(): CollisionGroup[];
-    set ownCollisionGroups(value: CollisionGroup[] | 'all');
+    get interactWithCollisionGroups(): ReadonlyArray<CollisionGroup>;
+    set interactWithCollisionGroups(value: ReadonlyArray<CollisionGroup> | 'all');
+    get ownCollisionGroups(): ReadonlyArray<CollisionGroup>;
+    set ownCollisionGroups(value: ReadonlyArray<CollisionGroup> | 'all');
     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-raycast-vehicle.component.js

@@ -6,15 +6,19 @@ export class AmmoRaycastVehicleComponent extends AmmoRigidBodyComponent {
         return this.chassisBody.interactWithCollisionGroups;
     }
     set interactWithCollisionGroups(value) {
-        this.chassisBody.interactWithCollisionGroups = value;
-        this.raycaster.set_m_collisionFilterMask(BitMask.pack(this.chassisBody.interactWithCollisionGroups, 16));
+        if (this.chassisBody) {
+            this.chassisBody.interactWithCollisionGroups = value;
+            this.raycaster.set_m_collisionFilterMask(BitMask.pack(this.chassisBody.interactWithCollisionGroups, 16));
+        }
     }
     get ownCollisionGroups() {
         return this.chassisBody.ownCollisionGroups;
     }
     set ownCollisionGroups(value) {
-        this.chassisBody.ownCollisionGroups = value;
-        this.raycaster.set_m_collisionFilterGroup(BitMask.pack(this.chassisBody.ownCollisionGroups, 16));
+        if (this.chassisBody) {
+            this.chassisBody.ownCollisionGroups = value;
+            this.raycaster.set_m_collisionFilterGroup(BitMask.pack(this.chassisBody.ownCollisionGroups, 16));
+        }
     }
     refreshCG() {
         this.chassisBody.refreshCG();

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;
@@ -12,11 +12,11 @@ export declare class AmmoRigidBodyComponent extends AmmoBodyComponent<Ammo.btRig
     set linearVelocity(value: Point3);
     get angularVelocity(): Point3;
     set angularVelocity(value: Point3);
-    get debugBodySettings(): DebugBody3DSettings;
+    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,5 +1,6 @@
 import Ammo from '../ammo.js/ammo';
 import { AmmoBodyComponent } from './ammo-body.component';
+import { DebugBody3DSettings } from '@gg-web-engine/core';
 import { first } from 'rxjs';
 export class AmmoRigidBodyComponent extends AmmoBodyComponent {
     get linearVelocity() {
@@ -16,20 +17,15 @@ export class AmmoRigidBodyComponent extends AmmoBodyComponent {
     set angularVelocity(value) {
         this.nativeBody.setAngularVelocity(new Ammo.btVector3(value.x, value.y, value.z));
     }
-    get debugBodySettings() {
-        if (this._nativeBody.isStaticOrKinematicObject()) {
-            return { shape: this.shape, type: 'RIGID_STATIC' };
-        }
-        else {
-            return { shape: this.shape, type: 'RIGID_DYNAMIC', sleeping: !this._nativeBody.isActive() };
-        }
-    }
     constructor(world, _nativeBody, shape) {
         super(world, _nativeBody, shape);
         this.world = world;
         this._nativeBody = _nativeBody;
         this.shape = shape;
         this.entity = null;
+        this.debugBodySettings = new DebugBody3DSettings(this._nativeBody.isStaticOrKinematicObject()
+            ? { type: 'RIGID_STATIC' }
+            : { type: 'RIGID_DYNAMIC', sleeping: () => !this._nativeBody.isActive() }, this.shape);
     }
     clone() {
         return this.world.factory.createRigidBodyFromShape(this._nativeBody.getCollisionShape(), this.shape, {

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

@@ -1,26 +1,26 @@
-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;
     readonly shape: Shape3DDescriptor;
     entity: IEntity | null;
-    get debugBodySettings(): DebugBody3DSettings;
+    readonly debugBodySettings: DebugBody3DSettings;
     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,10 +1,8 @@
+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';
 export class AmmoTriggerComponent extends AmmoBodyComponent {
-    get debugBodySettings() {
-        return { shape: this.shape, type: 'TRIGGER' };
-    }
     get onEntityEntered() {
         return this.onEnter$.pipe(map(b => AmmoBodyComponent.nativeBodyReverseMap.get(b)), filter(x => !!x));
     }
@@ -17,9 +15,10 @@ export class AmmoTriggerComponent extends AmmoBodyComponent {
         this._nativeBody = _nativeBody;
         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';
@@ -18,6 +18,7 @@ export declare class AmmoWorldComponent implements IPhysicsWorld3dComponent<Ammo
     private _gravity;
     get gravity(): Point3;
     set gravity(value: Point3);
+    readonly mainCollisionGroup: CollisionGroup;
     maxSubSteps?: number;
     fixedTimeStep?: number;
     get dynamicAmmoWorld(): Ammo.btDiscreteDynamicsWorld | undefined;
@@ -34,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) {
@@ -46,6 +48,7 @@ export class AmmoWorldComponent {
         this.children = [];
         this._loader = null;
         this._gravity = { x: 0, y: 0, z: -9.82 };
+        this.mainCollisionGroup = 0;
         this.maxSubSteps = 100;
         this.fixedTimeStep = 0.01;
         this.lockedCollisionGroups = [];
@@ -77,7 +80,7 @@ export class AmmoWorldComponent {
         this.afterTick$.next();
     }
     registerCollisionGroup() {
-        for (let i = 0; i < 16; i++) {
+        for (let i = 1; i < 16; i++) {
             if (!this.lockedCollisionGroups.includes(i)) {
                 this.lockedCollisionGroups.push(i);
                 return i;
@@ -88,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,4 @@ export type AmmoPhysicsTypeDocRepo = {
     trigger: AmmoTriggerComponent;
     raycastVehicle: AmmoRaycastVehicleComponent;
 };
+export type AmmoGgWorld = Gg3dWorld<Gg3dWorldTypeDocPPatch<AmmoPhysicsTypeDocRepo>, Gg3dWorldSceneTypeDocPPatch<AmmoPhysicsTypeDocRepo, AmmoWorldComponent>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gg-web-engine/ammo",
-  "version": "0.0.56",
+  "version": "0.0.58",
   "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.56",
+    "@gg-web-engine/core": "0.0.58",
     "@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.56",
+    "@gg-web-engine/core": "0.0.58",
     "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();
+    });
+  });
+});