@directivegames/genesys.js 3.1.24

package/dist/src/physics/implementations/RapierPhysics.js

@@ -0,0 +1,1191 @@
+/**
+ * RapierPhysicsEngine powers Genesys physics using the Rapier library.
+ *
+ * This implementation extends `BasePhysicsEngine` and converts scene components
+ * into Rapier rigid bodies and colliders. A single `Rapier.World` instance is
+ * maintained along with an event queue to capture collision events which are
+ * then mapped back to components. The engine supports mesh-based colliders,
+ * terrain height fields and character controllers, and it can optionally draw
+ * debug lines using `RapierDebugRenderer`.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Instantiate via `createPhysicsEngine` with `PhysicsEngine.Rapier`.
+ * - Call `addComponent` only after a component's mesh or collision shape is
+ *   initialized so colliders are created correctly.
+ * - Enable the debug renderer during development with
+ *   `setDebugRendererEnabled(true)` to visualize physics bodies.
+ * - Prefer simplified or convex meshes when possible to keep performance high.
+ */
+import * as RAPIER from '@dimforge/rapier3d-compat';
+import * as THREE from 'three';
+import { CollisionMeshType, PhysicsMotionType } from '../../physics/PhysicsTypes.js';
+import { CollisionConfig, getCollisionChannelBit, resolveChannelName } from '../../systems/collision/CollisionConfig.js';
+import { CollisionMode, CollisionResponse, DefaultCollisionProfile } from '../../systems/collision/CollisionTypes.js';
+import { ensure } from '../../utils/Utils.js';
+import { BasePhysicsEngine } from '../BasePhysicsEngine.js';
+import { JointType } from '../BasePhysicsEngine.js';
+import { PhysicsScalarParam, PhysicsVectorParam } from '../PhysicsEngine.js';
+import { CollisionEventType } from '../PhysicsEngine.js';
+import { RapierDebugRenderer } from './RapierDebugRender.js';
+import { RapierVehicle } from './RapierVehicle.js';
+export class RapierPhysicsEngine extends BasePhysicsEngine {
+    constructor(gameWorld) {
+        super(gameWorld);
+        Object.defineProperty(this, "pendingCollisions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "world", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "eventQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Map from collider to component for fast lookup during collision processing
+        Object.defineProperty(this, "colliderToComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        // Set of ignored collider pairs (stored as "handle1,handle2" strings)
+        Object.defineProperty(this, "ignoredColliderPairs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        // Debug renderer
+        Object.defineProperty(this, "debugRenderer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Vehicle controllers
+        Object.defineProperty(this, "vehicles", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        // cache for collider desc without scale, mapping from a list of meshes and the collision mesh type
+        Object.defineProperty(this, "cachedColliderDescTemplates", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "cachedCharacterControllerCollisions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    async doCreate(options) {
+        await RAPIER.init();
+        this.world = new RAPIER.World(this.makeVector(options.gravity.toArray()));
+        this.eventQueue = new RAPIER.EventQueue(true);
+        // Initialize debug renderer if we have a scene to render to
+        if (this.gameWorld && this.gameWorld.scene) {
+            this.debugRenderer = new RapierDebugRenderer(this.gameWorld.scene, this.world);
+            this.debugRenderer.enabled = options.debugVisualization ?? false;
+        }
+        return true;
+    }
+    doDestroy() {
+        this.cachedCharacterControllerCollisions.clear();
+        this.pendingCollisions = [];
+        const world = this.world;
+        // Clean up vehicles
+        this.vehicles.forEach((vehicle, _) => {
+            vehicle.destroy();
+        });
+        this.vehicles.clear();
+        // Remove all physics bodies and colliders first
+        this.bodies.forEach((records, _) => {
+            records.forEach(([body, collider]) => {
+                world.removeRigidBody(body);
+                world.removeCollider(collider, false);
+            });
+        });
+        this.bodies.clear();
+        // Clean up character controllers
+        this.characterControllers.forEach((controller, _) => {
+            world.removeCharacterController(controller);
+        });
+        this.characterControllers.clear();
+        // Clean up joints
+        this.joints.forEach((joint, _) => {
+            world.removeImpulseJoint(joint, true);
+        });
+        this.joints.clear();
+        // Free the WASM world object
+        world.free();
+        this.world = null;
+        if (this.eventQueue) {
+            this.eventQueue.free();
+            this.eventQueue = null;
+        }
+        // Clean up debug renderer
+        if (this.debugRenderer) {
+            this.debugRenderer.dispose();
+            this.debugRenderer = null;
+        }
+        this.colliderToComponent.clear();
+        this.ignoredColliderPairs.clear();
+        return true;
+    }
+    doTick(deltaTime) {
+        this.world.step(this.eventQueue);
+        for (const vehicle of this.vehicles.values()) {
+            vehicle.tick(deltaTime);
+        }
+        // Process collision events from Rapier
+        this.eventQueue.drainCollisionEvents((handle1, handle2, started) => {
+            this.handleRapierCollision(handle1, handle2, started);
+        });
+        const objectPosition = new THREE.Vector3();
+        const objectQuat = new THREE.Quaternion();
+        // Update all object positions based on physics
+        this.bodies.forEach((records, object) => {
+            records.forEach(([body, _]) => {
+                const motionType = object.getMotionType();
+                if (motionType === PhysicsMotionType.Static) {
+                    // static objects cannot be moved by the physics engine
+                    // so there's no need to sync its transform back to the scene component
+                    return;
+                }
+                const position = body.translation();
+                const rotation = body.rotation();
+                objectPosition.x = position.x;
+                objectPosition.y = position.y;
+                objectPosition.z = position.z;
+                objectQuat.x = rotation.x;
+                objectQuat.y = rotation.y;
+                objectQuat.z = rotation.z;
+                objectQuat.w = rotation.w;
+                object.syncFromPhysics(objectPosition, objectQuat);
+            });
+        });
+        // Update debug renderer if available
+        if (this.debugRenderer) {
+            this.debugRenderer.update();
+        }
+    }
+    handleRapierCollision(handle1, handle2, started) {
+        // Check if this collision pair should be ignored
+        const pairKey1 = `${handle1},${handle2}`;
+        const pairKey2 = `${handle2},${handle1}`;
+        if (this.ignoredColliderPairs.has(pairKey1) || this.ignoredColliderPairs.has(pairKey2)) {
+            return; // Ignore this collision
+        }
+        const collider1 = this.world.getCollider(handle1);
+        const collider2 = this.world.getCollider(handle2);
+        if (!collider1 || !collider2)
+            return;
+        const componentA = this.colliderToComponent.get(handle1);
+        const componentB = this.colliderToComponent.get(handle2);
+        if (!componentA || !componentB)
+            return;
+        const contact = collider1.contactCollider(collider2, 0.1);
+        let contactPointA = null;
+        let contactNormalA = null;
+        let contactPointB = null;
+        let contactNormalB = null;
+        if (contact) {
+            contactPointA = new THREE.Vector3(contact.point1.x, contact.point1.y, contact.point1.z);
+            contactNormalA = new THREE.Vector3(contact.normal1.x, contact.normal1.y, contact.normal1.z);
+            contactPointB = new THREE.Vector3(contact.point2.x, contact.point2.y, contact.point2.z);
+            contactNormalB = new THREE.Vector3(contact.normal2.x, contact.normal2.y, contact.normal2.z);
+        }
+        // Calculate relative velocity at the contact point
+        const bodyA = collider1.parent();
+        const bodyB = collider2.parent();
+        let relativeVelocity = null;
+        if (bodyA && bodyB) {
+            const velA = bodyA.linvel();
+            const velB = bodyB.linvel();
+            // Calculate squared length manually
+            const dx = velB.x - velA.x;
+            const dy = velB.y - velA.y;
+            const dz = velB.z - velA.z;
+            relativeVelocity = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        }
+        // Create collision info
+        const collision = {
+            componentA,
+            componentB,
+            pointA: contactPointA,
+            normalA: contactNormalA,
+            pointB: contactPointB,
+            normalB: contactNormalB,
+            relativeVelocity,
+            isTriggerEvent: collider1.isSensor() || collider2.isSensor(),
+            eventType: started ? CollisionEventType.Started : CollisionEventType.Ended,
+        };
+        this.pendingCollisions.push(collision);
+    }
+    doCreateBoxBody(desc) {
+        const colliderDesc = RAPIER.ColliderDesc.cuboid(desc.size.x / 2, desc.size.y / 2, desc.size.z / 2);
+        const record = this.createBody(colliderDesc, desc);
+        return record;
+    }
+    populateVerticesAndIndices(meshes, populateIndices = true) {
+        let totalVertexCount = 0;
+        let totalIndexCount = 0;
+        const validMeshes = [];
+        for (const mesh of meshes) {
+            const geometry = mesh.geometry;
+            if (!geometry.isBufferGeometry) {
+                console.error('Geometry is not a BufferGeometry');
+                continue;
+            }
+            const positionAttribute = geometry.getAttribute('position');
+            if (!positionAttribute) {
+                console.error('Geometry has no position attribute');
+                continue;
+            }
+            totalVertexCount += positionAttribute.count;
+            const indexAttribute = geometry.getIndex();
+            if (indexAttribute) {
+                totalIndexCount += indexAttribute.count;
+            }
+            validMeshes.push(mesh);
+        }
+        const vertices = new Float32Array(totalVertexCount * 3);
+        const indices = new Uint32Array(populateIndices ? totalIndexCount : 0);
+        let vertexOffset = 0;
+        let indexOffset = 0;
+        for (const mesh of validMeshes) {
+            const geometry = mesh.geometry;
+            if (indices !== null) {
+                const indexAttribute = geometry.getIndex();
+                if (indexAttribute) {
+                    for (let i = 0; i < indexAttribute.count; i++) {
+                        indices[indexOffset + i] = indexAttribute.getX(i) + vertexOffset;
+                    }
+                    indexOffset += indexAttribute.count;
+                }
+            }
+            const matrix = mesh.matrixWorld;
+            const positionAttribute = geometry.getAttribute('position');
+            for (let i = 0; i < positionAttribute.count; i++) {
+                // Must apply the mesh's matrix as there can be a transform from the mesh inside gltf
+                const vertex = new THREE.Vector3(positionAttribute.getX(i), positionAttribute.getY(i), positionAttribute.getZ(i));
+                vertex.applyMatrix4(matrix);
+                vertices[(vertexOffset + i) * 3] = vertex.x;
+                vertices[(vertexOffset + i) * 3 + 1] = vertex.y;
+                vertices[(vertexOffset + i) * 3 + 2] = vertex.z;
+            }
+            vertexOffset += positionAttribute.count;
+        }
+        return { vertices, indices };
+    }
+    calcBoundingPrimitive(meshes, calcBoundingFunc, getBoundingFunc, primitiveType) {
+        const combined = new primitiveType();
+        for (const mesh of meshes) {
+            const geometry = mesh.geometry;
+            {
+                const bounding = getBoundingFunc(geometry);
+                if (!bounding) {
+                    calcBoundingFunc(geometry);
+                }
+            }
+            const bounding = getBoundingFunc(geometry).clone();
+            // The bounding (box/sphere/etc...) is calculated from the geometry with no transforms
+            // its parent node in glb can carry extra transforms, so we need to take that into account
+            bounding.applyMatrix4(mesh.matrixWorld);
+            combined.union(bounding);
+        }
+        return combined;
+    }
+    makeMeshColliderDescTemplate(meshes, collisionMeshType = CollisionMeshType.ConvexHull) {
+        if (!meshes || meshes.length === 0) {
+            console.error('No meshes provided to create mesh body');
+            return null;
+        }
+        const cacheKey = meshes.map(m => m.id).sort().join(',') + '|' + collisionMeshType;
+        if (this.cachedColliderDescTemplates.has(cacheKey)) {
+            return this.cachedColliderDescTemplates.get(cacheKey);
+        }
+        let colliderDesc = null;
+        // Use the combined data for collider creation
+        try {
+            // Determine which type of collider to create based on collisionMeshType
+            switch (collisionMeshType) {
+                case CollisionMeshType.Trimesh:
+                    {
+                        const { vertices, indices } = this.populateVerticesAndIndices(meshes, true);
+                        console.log('Create Trimesh collider with', vertices.length, 'vertices', indices.length, 'indices');
+                        colliderDesc = RAPIER.ColliderDesc.trimesh(vertices, indices);
+                        break;
+                    }
+                case CollisionMeshType.ConvexHull:
+                    {
+                        const { vertices } = this.populateVerticesAndIndices(meshes, false);
+                        console.log('Create ConvexHull collider with', vertices.length, 'vertices');
+                        colliderDesc = RAPIER.ColliderDesc.convexHull(vertices);
+                        break;
+                    }
+                case CollisionMeshType.BoundingBox:
+                    {
+                        const boundingBox = this.calcBoundingPrimitive(meshes, (geometry) => geometry.computeBoundingBox(), (geometry) => geometry.boundingBox, THREE.Box3);
+                        const halfExtents = new THREE.Vector3();
+                        boundingBox.getSize(halfExtents);
+                        halfExtents.multiplyScalar(0.5);
+                        // Create box collider using the combined bounding box dimensions
+                        console.log('Created box collider with half dimensions', halfExtents.x, halfExtents.y, halfExtents.z, 'from', meshes.length, 'meshes');
+                        colliderDesc = RAPIER.ColliderDesc.cuboid(halfExtents.x, halfExtents.y, halfExtents.z);
+                        const offset = boundingBox.getCenter(new THREE.Vector3());
+                        colliderDesc.setTranslation(offset.x, offset.y, offset.z);
+                        break;
+                    }
+                case CollisionMeshType.BoundingSphere:
+                    {
+                        const combinedBoundingSphere = this.calcBoundingPrimitive(meshes, (geometry) => geometry.computeBoundingSphere(), (geometry) => geometry.boundingSphere, THREE.Sphere);
+                        const radius = combinedBoundingSphere.radius;
+                        console.log('Created sphere collider with radius', radius, 'from', meshes.length, 'meshes');
+                        colliderDesc = RAPIER.ColliderDesc.ball(radius);
+                        const offset = combinedBoundingSphere.center;
+                        colliderDesc.setTranslation(offset.x, offset.y, offset.z);
+                        break;
+                    }
+                case CollisionMeshType.Voxels:
+                    {
+                        // until we support generating voxels from meshes, we expect the user to provide voxel coords and process that in doCreateVoxelBody
+                        console.error('Voxel type collision mesh should be handled by doCreateVoxelBody');
+                        break;
+                    }
+                default:
+                    console.error('Invalid collision mesh type:', collisionMeshType);
+                    break;
+            }
+        }
+        catch (error) {
+            console.error('Error creating mesh collider:', error);
+        }
+        this.cachedColliderDescTemplates.set(cacheKey, colliderDesc);
+        return colliderDesc;
+    }
+    scaleMeshColliderDesc(colliderDesc, scale) {
+        // don't bother for (1, 1, 1) scale
+        if (scale.x === 1 && scale.y === 1 && scale.z === 1)
+            return colliderDesc;
+        if (!colliderDesc)
+            return null;
+        switch (colliderDesc.shape.type) {
+            case RAPIER.ShapeType.Cuboid: {
+                const halfExtents = colliderDesc.shape.halfExtents;
+                const scaledDesc = RAPIER.ColliderDesc.cuboid(halfExtents.x * scale.x, halfExtents.y * scale.y, halfExtents.z * scale.z);
+                const translation = colliderDesc.translation;
+                scaledDesc.setTranslation(translation.x * scale.x, translation.y * scale.y, translation.z * scale.z);
+                return scaledDesc;
+            }
+            case RAPIER.ShapeType.Ball: {
+                const radius = colliderDesc.shape.radius;
+                const scaledDesc = RAPIER.ColliderDesc.ball(radius * Math.max(scale.x, scale.y, scale.z));
+                const translation = colliderDesc.translation;
+                scaledDesc.setTranslation(translation.x * scale.x, translation.y * scale.y, translation.z * scale.z);
+                return scaledDesc;
+            }
+            case RAPIER.ShapeType.TriMesh: {
+                const vertices = colliderDesc.shape.vertices.map((v, i) => v * (i % 3 === 0 ? scale.x : (i % 3 === 1 ? scale.y : scale.z)));
+                const indices = colliderDesc.shape.indices;
+                return RAPIER.ColliderDesc.trimesh(vertices, indices);
+            }
+            case RAPIER.ShapeType.ConvexPolyhedron: {
+                const vertices = colliderDesc.shape.vertices.map((v, i) => v * (i % 3 === 0 ? scale.x : (i % 3 === 1 ? scale.y : scale.z)));
+                return RAPIER.ColliderDesc.convexHull(vertices);
+            }
+        }
+        console.error(`Unknown collision type: ${colliderDesc.shape.type}`);
+        return colliderDesc;
+    }
+    /**
+     * Creates a mesh-based collider using either trimesh, convexMesh, or convexHull
+     * based on the mesh geometry and collisionMeshType option
+     */
+    doCreateMeshBody(desc, worldScale) {
+        const colliderDesc = this.scaleMeshColliderDesc(this.makeMeshColliderDescTemplate(desc.meshes, desc.options.collisionMeshType), worldScale);
+        if (!colliderDesc) {
+            return null;
+        }
+        return this.createBody(colliderDesc, desc);
+    }
+    doCreateMeshBodiesWithTransformOverrides(desc, transforms) {
+        const templateColliderDesc = this.makeMeshColliderDescTemplate(desc.meshes, desc.options.collisionMeshType);
+        if (!templateColliderDesc) {
+            return [];
+        }
+        const baseDesc = {
+            motionType: desc.motionType,
+            options: desc.options,
+            worldPos: desc.worldPos,
+            worldQuat: desc.worldQuat,
+            mass: desc.mass,
+        };
+        const cachedColliderDesc = {};
+        const records = [];
+        for (const transform of transforms) {
+            const scale = transform.scale ?? new THREE.Vector3(1, 1, 1);
+            const scaleKey = String(scale.toArray());
+            cachedColliderDesc[scaleKey] ??= this.scaleMeshColliderDesc(templateColliderDesc, scale);
+            const colliderDesc = cachedColliderDesc[scaleKey];
+            if (colliderDesc) {
+                // overwrite the position and rotation
+                baseDesc.worldPos = transform.position ?? new THREE.Vector3(0, 0, 0);
+                baseDesc.worldQuat = transform.rotation ?? new THREE.Quaternion(0, 0, 0, 1);
+                const record = this.createBody(colliderDesc, baseDesc);
+                if (record) {
+                    records.push(record);
+                }
+            }
+        }
+        return records;
+    }
+    doCreateVoxelBody(desc) {
+        const voxelSize = desc.voxelSize;
+        const voxels = desc.voxels;
+        const colliderDesc = RAPIER.ColliderDesc.voxels(voxels, new RAPIER.Vector3(voxelSize.x, voxelSize.y, voxelSize.z));
+        const offset = desc.offset;
+        if (offset) {
+            colliderDesc.setTranslation(offset.x, offset.y, offset.z);
+        }
+        return this.createBody(colliderDesc, desc);
+    }
+    doCreateSphereBody(desc) {
+        const colliderDesc = RAPIER.ColliderDesc.ball(desc.radius);
+        return this.createBody(colliderDesc, desc);
+    }
+    doCreateCylinderBody(desc) {
+        const colliderDesc = RAPIER.ColliderDesc.cylinder(desc.height / 2, desc.radius);
+        return this.createBody(colliderDesc, desc);
+    }
+    doCreateConeBody(desc) {
+        const colliderDesc = RAPIER.ColliderDesc.cone(desc.height / 2, desc.radius);
+        return this.createBody(colliderDesc, desc);
+    }
+    doCreateCapsuleBody(desc) {
+        const colliderDesc = RAPIER.ColliderDesc.capsule(desc.height / 2, desc.radius);
+        return this.createBody(colliderDesc, desc);
+    }
+    doCreateHeightFieldBody(desc) {
+        // Transform heightmap data to match RAPIER's format
+        const transformedHeightMap = new Float32Array(desc.heights.length);
+        for (var z = 0; z < desc.depthPixels; z++) {
+            for (var x = 0; x < desc.widthPixels; x++) {
+                const readIndex = z * desc.widthPixels + x;
+                const writeIndex = x * desc.depthPixels + z;
+                transformedHeightMap[writeIndex] = desc.heights[readIndex];
+            }
+        }
+        const terrainScale = this.makeVector([
+            desc.width,
+            1,
+            desc.depth
+        ]);
+        const colliderDesc = RAPIER.ColliderDesc.heightfield(desc.widthPixels - 1, desc.depthPixels - 1, transformedHeightMap, terrainScale);
+        return this.createBody(colliderDesc, desc);
+    }
+    doRemoveComponent(record) {
+        const world = this.world;
+        const collider = record[1];
+        this.colliderToComponent.delete(collider.handle);
+        world.removeRigidBody(record[0]);
+        world.removeCollider(collider, false);
+        return true;
+    }
+    doUpdateTransform(component, record) {
+        const body = record[0];
+        const motionType = record[2];
+        const worldPosition = new THREE.Vector3();
+        const worldQuat = new THREE.Quaternion();
+        component.getWorldPosition(worldPosition);
+        component.getWorldQuaternion(worldQuat);
+        const flags = component.getPhysicsTransformUpdateFlags();
+        const newRotation = this.makeRotation(worldQuat.toArray());
+        const newPosition = this.makeVector(worldPosition.toArray());
+        switch (motionType) {
+            case PhysicsMotionType.Static:
+                if (flags.sendPosition) {
+                    body.setTranslation(newPosition, true);
+                }
+                if (flags.sendRotation) {
+                    body.setRotation(newRotation, true);
+                }
+                break;
+            case PhysicsMotionType.Dynamic:
+                if (flags.sendPosition) {
+                    body.setTranslation(newPosition, true);
+                }
+                if (flags.sendRotation) {
+                    body.setRotation(newRotation, true);
+                }
+                break;
+            case PhysicsMotionType.KinematicPositionBased:
+                if (flags.sendPosition) {
+                    body.setNextKinematicTranslation(newPosition);
+                }
+                if (flags.sendRotation) {
+                    body.setNextKinematicRotation(newRotation);
+                }
+                break;
+            case PhysicsMotionType.KinematicVelocityBased:
+                const userData = (body.userData ?? {});
+                const linearVelocity = userData[PhysicsVectorParam.LinearVelocity];
+                const angularVelocity = userData[PhysicsVectorParam.AngularVelocity];
+                if (flags.sendPosition && !linearVelocity) {
+                    const currentPosition = body.translation();
+                    const timestep = this.world.timestep;
+                    const velocity = {
+                        x: (newPosition.x - currentPosition.x) / timestep,
+                        y: (newPosition.y - currentPosition.y) / timestep,
+                        z: (newPosition.z - currentPosition.z) / timestep,
+                    };
+                    body.setLinvel(velocity, true);
+                }
+                if (flags.sendRotation && !angularVelocity) {
+                    const currentRotation = body.rotation();
+                    const timestep = this.world.timestep;
+                    // Calculate quaternion difference: q_diff = newRotation * currentRotation^-1
+                    const qx = newRotation.w * currentRotation.x - newRotation.x * currentRotation.w - newRotation.y * currentRotation.z + newRotation.z * currentRotation.y;
+                    const qy = newRotation.w * currentRotation.y + newRotation.x * currentRotation.z - newRotation.y * currentRotation.w - newRotation.z * currentRotation.x;
+                    const qz = newRotation.w * currentRotation.z - newRotation.x * currentRotation.y + newRotation.y * currentRotation.x - newRotation.z * currentRotation.w;
+                    const qw = newRotation.w * currentRotation.w + newRotation.x * currentRotation.x + newRotation.y * currentRotation.y + newRotation.z * currentRotation.z;
+                    // Convert quaternion to axis-angle, then to angular velocity
+                    const sinHalfAngle = Math.sqrt(qx * qx + qy * qy + qz * qz);
+                    const angle = 2 * Math.atan2(sinHalfAngle, qw);
+                    const scale = sinHalfAngle > 1e-6 ? angle / sinHalfAngle / timestep : 2 / timestep;
+                    const velocity = {
+                        x: qx * scale,
+                        y: qy * scale,
+                        z: qz * scale,
+                    };
+                    body.setAngvel(velocity, true);
+                }
+                break;
+        }
+    }
+    doGetScalarParam(record, param) {
+        const body = record[0];
+        switch (param) {
+            case PhysicsScalarParam.LinearDamping:
+                return body.linearDamping();
+            case PhysicsScalarParam.AngularDamping:
+                return body.angularDamping();
+            case PhysicsScalarParam.GravityScale:
+                return body.gravityScale();
+            default:
+                ensure(false);
+        }
+        return null;
+    }
+    doSetScalarParam(records, param, value) {
+        const doTask = (record) => {
+            const body = record[0];
+            switch (param) {
+                case PhysicsScalarParam.LinearDamping:
+                    body.setLinearDamping(value);
+                    return true;
+                case PhysicsScalarParam.AngularDamping:
+                    body.setAngularDamping(value);
+                    return true;
+                case PhysicsScalarParam.GravityScale:
+                    body.setGravityScale(value, true);
+                    return true;
+                default:
+                    ensure(false);
+            }
+            return false;
+        };
+        let result = true;
+        for (const record of records) {
+            result &&= doTask(record);
+        }
+        return result;
+    }
+    doGetVectorParam(record, param) {
+        const body = record[0];
+        let ret = null;
+        switch (param) {
+            case PhysicsVectorParam.LinearVelocity:
+                ret = body.linvel();
+                break;
+            case PhysicsVectorParam.AngularVelocity:
+                ret = body.angvel();
+                break;
+            default:
+                ensure(false);
+        }
+        return ret ? [ret.x, ret.y, ret.z] : null;
+    }
+    doSetVectorParam(record, param, value) {
+        const body = record[0];
+        body.userData ??= {};
+        body.userData[param] = value;
+        switch (param) {
+            case PhysicsVectorParam.LinearVelocity:
+                body.setLinvel(this.makeVector(value), true);
+                return true;
+            case PhysicsVectorParam.AngularVelocity:
+                body.setAngvel(this.makeVector(value), true);
+                return true;
+            default:
+                ensure(false);
+        }
+        return false;
+    }
+    doClearVectorParam(record, param) {
+        const body = record[0];
+        body.userData ??= {};
+        body.userData[param] = undefined;
+        return true;
+    }
+    doCreateCharacterController(options) {
+        const world = this.world;
+        const controller = world.createCharacterController(options.offset);
+        controller.setUp({ x: 0.0, y: 1.0, z: 0.0 });
+        if (options.applyImpulsesToDynamicBodies !== undefined) {
+            controller.setApplyImpulsesToDynamicBodies(options.applyImpulsesToDynamicBodies);
+        }
+        if (options.characterMass !== undefined) {
+            controller.setCharacterMass(options.characterMass);
+        }
+        if (options.slideEnabled !== undefined) {
+            controller.setSlideEnabled(options.slideEnabled);
+        }
+        if (options.maxSlopeClimbAngle !== undefined) {
+            controller.setMaxSlopeClimbAngle(options.maxSlopeClimbAngle);
+        }
+        if (options.minSlopeSlideAngle !== undefined) {
+            controller.setMinSlopeSlideAngle(options.minSlopeSlideAngle);
+        }
+        if (options.snapToGroundDistance !== undefined) {
+            controller.enableSnapToGround(options.snapToGroundDistance);
+        }
+        if (options.autoStepConfig !== undefined) {
+            controller.enableAutostep(options.autoStepConfig.maxHeight, options.autoStepConfig.minWidth, options.autoStepConfig.includeDynamicBodies);
+        }
+        return controller;
+    }
+    doRemoveCharacterController(record) {
+        const world = this.world;
+        world.removeCharacterController(record);
+        return true;
+    }
+    doComputeCharacterMovement(record, recordToMove, movement, ignoreCollision) {
+        // See https://rapier.rs/docs/user_guides/javascript/character_controller
+        const controller = record;
+        const body = recordToMove[0];
+        const collider = recordToMove[1];
+        const motionType = recordToMove[2];
+        controller.computeColliderMovement(collider, this.makeVector(movement), RAPIER.QueryFilterFlags.EXCLUDE_SENSORS, collider.collisionGroups(), ignoreCollision ? (collider) => { return false; } : undefined);
+        const actualMovement = controller.computedMovement();
+        const bodyPosition = body.translation();
+        bodyPosition.x += actualMovement.x;
+        bodyPosition.y += actualMovement.y;
+        bodyPosition.z += actualMovement.z;
+        switch (motionType) {
+            case PhysicsMotionType.Dynamic:
+                body.setTranslation(bodyPosition, true);
+                break;
+            case PhysicsMotionType.KinematicPositionBased:
+                body.setNextKinematicTranslation(bodyPosition);
+                break;
+            case PhysicsMotionType.KinematicVelocityBased:
+                const timestep = this.world.timestep;
+                const velocity = { x: actualMovement.x / timestep, y: actualMovement.y / timestep, z: actualMovement.z / timestep };
+                body.setLinvel(velocity, true);
+                break;
+        }
+        // Get grounded state from controller
+        let isGrounded = controller.computedGrounded();
+        // Workaround for voxel colliders: if controller says not grounded but we had downward movement
+        // and the actual movement was much less than requested (indicating collision), consider grounded
+        if (!isGrounded && movement[1] < 0) {
+            // We intended to move down, check if we were blocked
+            const intendedVertical = movement[1];
+            const actualVertical = actualMovement.y;
+            // If actual movement is significantly less than intended (more than 90% blocked), we hit ground
+            if (Math.abs(actualVertical) < Math.abs(intendedVertical) * 0.1) {
+                isGrounded = true;
+            }
+        }
+        const handleA = collider.handle;
+        const numCollisions = controller.numComputedCollisions();
+        const previousCollidedHandles = this.cachedCharacterControllerCollisions.get(handleA) ?? [];
+        const newCollidedHandles = [];
+        for (let index = 0; index < numCollisions; index++) {
+            const collision = controller.computedCollision(index);
+            if (collision && collision.collider) {
+                const handleB = collision.collider.handle;
+                newCollidedHandles.push(handleB);
+                if (!previousCollidedHandles.includes(handleB)) {
+                    this.handleRapierCollision(handleA, handleB, true);
+                }
+            }
+        }
+        for (const handleB of previousCollidedHandles) {
+            if (!newCollidedHandles.includes(handleB)) {
+                this.handleRapierCollision(handleA, handleB, false);
+            }
+        }
+        this.cachedCharacterControllerCollisions.set(handleA, newCollidedHandles);
+        return { isGrounded };
+    }
+    getComponentState(component) {
+        const records = this.bodies.get(component);
+        if (!records || records.length === 0) {
+            return null;
+        }
+        const record = records[0];
+        return {
+            isTrigger: record[1].isSensor(),
+            motionType: record[2],
+        };
+    }
+    //====================================================================================================
+    getCollisionEvents() {
+        return this.pendingCollisions;
+    }
+    clearCollisionEvents() {
+        this.pendingCollisions = [];
+    }
+    /**
+     * Toggles the physics debug renderer visibility
+     * @param enabled Whether the debug renderer should be visible
+     * @returns Whether the debug renderer is now enabled
+     */
+    setDebugRendererEnabled(enabled) {
+        if (this.debugRenderer) {
+            this.debugRenderer.enabled = enabled;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Checks if the physics debug renderer is enabled
+     * @returns Whether the debug renderer is currently enabled, or false if not available
+     */
+    isDebugRendererEnabled() {
+        return this.debugRenderer?.enabled ?? false;
+    }
+    createBody(colliderDesc, desc) {
+        const world = this.world;
+        const collisionProfileName = desc.options.collisionProfile ?? DefaultCollisionProfile.Default;
+        const collisionConfig = CollisionConfig.getInstance();
+        const collisionProfile = collisionConfig.profiles.find(p => p.name === collisionProfileName);
+        const isSensor = collisionProfile?.mode === CollisionMode.QueryOnly;
+        // FIXME: Find out what of this should be configured based on the profile instead
+        const rigidBodyDesc = this.createRigidBodyDesc(desc.motionType);
+        rigidBodyDesc.mass = desc.mass;
+        rigidBodyDesc.setCcdEnabled(!!desc.options.enableCCD);
+        const generateCollisionEvents = !!desc.options.generateCollisionEvents || isSensor;
+        colliderDesc.setActiveEvents(generateCollisionEvents ? RAPIER.ActiveEvents.COLLISION_EVENTS : RAPIER.ActiveEvents.NONE);
+        if (generateCollisionEvents) {
+            colliderDesc.setActiveCollisionTypes(RAPIER.ActiveCollisionTypes.ALL);
+        }
+        const createCollider = (pos, rot) => {
+            const rigidBody = world.createRigidBody(rigidBodyDesc);
+            rigidBody.setTranslation(this.makeVector(pos.toArray()), true);
+            rigidBody.setRotation(this.makeRotation(rot.toArray()), true);
+            const collider = world.createCollider(colliderDesc, rigidBody);
+            collider.setSensor(isSensor);
+            rigidBody.setGravityScale(desc.options.gravityScale ?? 1, true);
+            if (collisionProfile) {
+                collider.setCollisionGroups(this.getCollisionGroups(collisionProfile));
+            }
+            return { rigidBody, collider };
+        };
+        const { rigidBody, collider } = createCollider(desc.worldPos, desc.worldQuat);
+        return [rigidBody, collider, desc.motionType];
+    }
+    getCollisionGroups(collisionProfile) {
+        // top 16 bits indicate what channel this object occupies, for now that's always a single channel
+        // bottom 16 bits indicate what channels it can interact with
+        let groups = getCollisionChannelBit(collisionProfile.objectChannel) << 16;
+        collisionProfile.responses.forEach(r => {
+            // need to set the collision group even for overlapping interaction, otherwise collision event will NOT be generated
+            if (r.response !== CollisionResponse.Ignore) {
+                const channelEnum = typeof r.channel === 'string' ? resolveChannelName(r.channel) : r.channel;
+                if (channelEnum !== undefined) {
+                    groups |= getCollisionChannelBit(channelEnum);
+                }
+            }
+        });
+        return groups;
+    }
+    createRigidBodyDesc(motionType) {
+        switch (motionType) {
+            case PhysicsMotionType.Static:
+                return RAPIER.RigidBodyDesc.fixed();
+            case PhysicsMotionType.KinematicVelocityBased:
+                return RAPIER.RigidBodyDesc.kinematicVelocityBased();
+            case PhysicsMotionType.KinematicPositionBased:
+                return RAPIER.RigidBodyDesc.kinematicPositionBased();
+            case PhysicsMotionType.Dynamic:
+                return RAPIER.RigidBodyDesc.dynamic();
+        }
+    }
+    makeVector(v) {
+        return {
+            x: v[0],
+            y: v[1],
+            z: v[2],
+        };
+    }
+    makeRotation(r) {
+        return {
+            x: r[0],
+            y: r[1],
+            z: r[2],
+            w: r[3],
+        };
+    }
+    // Override addComponent to handle collider mapping
+    addComponent(component) {
+        const motionType = super.addComponent(component);
+        const records = this.bodies.get(component);
+        if (records) {
+            records.forEach((record) => {
+                const collider = record[1];
+                this.colliderToComponent.set(collider.handle, component);
+            });
+        }
+        return motionType;
+    }
+    doSetComponentCollisionIgnore(recordA, recordB, ignore) {
+        const colliderA = recordA[1];
+        const colliderB = recordB[1];
+        const pairKey = `${colliderA.handle},${colliderB.handle}`;
+        if (ignore) {
+            this.ignoredColliderPairs.add(pairKey);
+        }
+        else {
+            this.ignoredColliderPairs.delete(pairKey);
+        }
+        return true;
+    }
+    doCreateJoint(desc, recordA, recordB) {
+        const world = this.world;
+        const bodyA = recordA[0];
+        const bodyB = recordB[0];
+        try {
+            let jointData;
+            switch (desc.type) {
+                case JointType.Spherical:
+                    jointData = RAPIER.JointData.spherical({ x: desc.anchorA.x, y: desc.anchorA.y, z: desc.anchorA.z }, { x: desc.anchorB.x, y: desc.anchorB.y, z: desc.anchorB.z });
+                    break;
+                case JointType.Fixed:
+                    jointData = RAPIER.JointData.fixed({ x: desc.anchorA.x, y: desc.anchorA.y, z: desc.anchorA.z }, { x: 0, y: 0, z: 0, w: 1 }, // Identity quaternion for now
+                    { x: desc.anchorB.x, y: desc.anchorB.y, z: desc.anchorB.z }, { x: 0, y: 0, z: 0, w: 1 } // Identity quaternion for now
+                    );
+                    break;
+                case JointType.Revolute:
+                    if (!desc.axis) {
+                        console.error('Revolute joint requires an axis');
+                        return null;
+                    }
+                    jointData = RAPIER.JointData.revolute({ x: desc.anchorA.x, y: desc.anchorA.y, z: desc.anchorA.z }, { x: desc.anchorB.x, y: desc.anchorB.y, z: desc.anchorB.z }, { x: desc.axis.x, y: desc.axis.y, z: desc.axis.z });
+                    break;
+                case JointType.Prismatic:
+                    if (!desc.axis) {
+                        console.error('Prismatic joint requires an axis');
+                        return null;
+                    }
+                    jointData = RAPIER.JointData.prismatic({ x: desc.anchorA.x, y: desc.anchorA.y, z: desc.anchorA.z }, { x: desc.anchorB.x, y: desc.anchorB.y, z: desc.anchorB.z }, { x: desc.axis.x, y: desc.axis.y, z: desc.axis.z });
+                    break;
+                default:
+                    console.error('Unsupported joint type:', desc.type);
+                    return null;
+            }
+            const joint = world.createImpulseJoint(jointData, bodyA, bodyB, true);
+            return joint;
+        }
+        catch (error) {
+            console.error('Failed to create joint:', error);
+            return null;
+        }
+    }
+    doRemoveJoint(jointRecord) {
+        const world = this.world;
+        try {
+            world.removeImpulseJoint(jointRecord, true);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to remove joint:', error);
+            return false;
+        }
+    }
+    doCreateJointFromRecords(type, recordA, recordB, anchorA, anchorB, axis) {
+        const world = this.world;
+        const bodyA = recordA[0];
+        const bodyB = recordB[0];
+        try {
+            let jointData;
+            switch (type) {
+                case JointType.Spherical:
+                    jointData = RAPIER.JointData.spherical({ x: anchorA.x, y: anchorA.y, z: anchorA.z }, { x: anchorB.x, y: anchorB.y, z: anchorB.z });
+                    break;
+                case JointType.Fixed:
+                    jointData = RAPIER.JointData.fixed({ x: anchorA.x, y: anchorA.y, z: anchorA.z }, { x: 0, y: 0, z: 0, w: 1 }, // Identity quaternion for now
+                    { x: anchorB.x, y: anchorB.y, z: anchorB.z }, { x: 0, y: 0, z: 0, w: 1 } // Identity quaternion for now
+                    );
+                    break;
+                case JointType.Revolute:
+                    if (!axis) {
+                        console.error('Revolute joint requires an axis');
+                        return null;
+                    }
+                    jointData = RAPIER.JointData.revolute({ x: anchorA.x, y: anchorA.y, z: anchorA.z }, { x: anchorB.x, y: anchorB.y, z: anchorB.z }, { x: axis.x, y: axis.y, z: axis.z });
+                    break;
+                case JointType.Prismatic:
+                    if (!axis) {
+                        console.error('Prismatic joint requires an axis');
+                        return null;
+                    }
+                    jointData = RAPIER.JointData.prismatic({ x: anchorA.x, y: anchorA.y, z: anchorA.z }, { x: anchorB.x, y: anchorB.y, z: anchorB.z }, { x: axis.x, y: axis.y, z: axis.z });
+                    break;
+                default:
+                    console.error('Unsupported joint type:', type);
+                    return null;
+            }
+            const joint = world.createImpulseJoint(jointData, bodyA, bodyB, true);
+            return joint;
+        }
+        catch (error) {
+            console.error('Failed to create joint from records:', error);
+            return null;
+        }
+    }
+    // Direct physics body management implementations
+    doCreateDirectBody(desc) {
+        const world = this.world;
+        try {
+            // Create collider based on shape type
+            let colliderDesc;
+            switch (desc.shape.type) {
+                case 'box':
+                    const size = desc.shape.size;
+                    colliderDesc = RAPIER.ColliderDesc.cuboid(size.x / 2, size.y / 2, size.z / 2);
+                    break;
+                case 'sphere':
+                    colliderDesc = RAPIER.ColliderDesc.ball(desc.shape.radius);
+                    break;
+                case 'cylinder':
+                    colliderDesc = RAPIER.ColliderDesc.cylinder(desc.shape.height / 2, desc.shape.radius);
+                    break;
+                case 'capsule':
+                    colliderDesc = RAPIER.ColliderDesc.capsule(desc.shape.height / 2, desc.shape.radius);
+                    break;
+                default:
+                    console.error(`Unsupported shape type: ${desc.shape.type}`);
+                    return null;
+            }
+            // Create rigid body
+            let rigidBodyDesc;
+            switch (desc.motionType) {
+                case PhysicsMotionType.Static:
+                    rigidBodyDesc = RAPIER.RigidBodyDesc.fixed();
+                    break;
+                case PhysicsMotionType.KinematicPositionBased:
+                    rigidBodyDesc = RAPIER.RigidBodyDesc.kinematicPositionBased();
+                    break;
+                case PhysicsMotionType.KinematicVelocityBased:
+                    rigidBodyDesc = RAPIER.RigidBodyDesc.kinematicVelocityBased();
+                    break;
+                case PhysicsMotionType.Dynamic:
+                default:
+                    rigidBodyDesc = RAPIER.RigidBodyDesc.dynamic();
+                    break;
+            }
+            rigidBodyDesc
+                .setTranslation(desc.position.x, desc.position.y, desc.position.z)
+                .setRotation({ x: desc.rotation.x, y: desc.rotation.y, z: desc.rotation.z, w: desc.rotation.w });
+            const rigidBody = world.createRigidBody(rigidBodyDesc);
+            const collider = world.createCollider(colliderDesc, rigidBody);
+            // Set mass for dynamic bodies
+            if (desc.motionType === PhysicsMotionType.Dynamic && desc.mass > 0) {
+                collider.setMass(desc.mass);
+            }
+            // Set enabled state
+            if (desc.enabled !== undefined) {
+                rigidBody.setEnabled(desc.enabled);
+            }
+            return [rigidBody, collider, desc.motionType];
+        }
+        catch (error) {
+            console.error('Failed to create direct physics body:', error);
+            return null;
+        }
+    }
+    doRemoveDirectBody(record) {
+        const world = this.world;
+        const [rigidBody, collider] = record;
+        try {
+            world.removeRigidBody(rigidBody);
+            world.removeCollider(collider, false);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to remove direct physics body:', error);
+            return false;
+        }
+    }
+    doGetBodyPosition(record) {
+        const [rigidBody] = record;
+        try {
+            const translation = rigidBody.translation();
+            return new THREE.Vector3(translation.x, translation.y, translation.z);
+        }
+        catch (error) {
+            console.error('Failed to get body position:', error);
+            return null;
+        }
+    }
+    doGetBodyRotation(record) {
+        const [rigidBody] = record;
+        try {
+            const rotation = rigidBody.rotation();
+            return new THREE.Quaternion(rotation.x, rotation.y, rotation.z, rotation.w);
+        }
+        catch (error) {
+            console.error('Failed to get body rotation:', error);
+            return null;
+        }
+    }
+    doSetBodyPosition(record, position) {
+        const [rigidBody] = record;
+        try {
+            rigidBody.setTranslation({ x: position.x, y: position.y, z: position.z }, true);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to set body position:', error);
+            return false;
+        }
+    }
+    doSetBodyRotation(record, rotation) {
+        const [rigidBody] = record;
+        try {
+            rigidBody.setRotation({ x: rotation.x, y: rotation.y, z: rotation.z, w: rotation.w }, true);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to set body rotation:', error);
+            return false;
+        }
+    }
+    doApplyBodyImpulse(record, impulse, worldSpace) {
+        const [rigidBody] = record;
+        try {
+            rigidBody.applyImpulse({ x: impulse.x, y: impulse.y, z: impulse.z }, worldSpace);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to apply body impulse:', error);
+            return false;
+        }
+    }
+    doSetBodyEnabled(record, enabled) {
+        const [rigidBody] = record;
+        try {
+            rigidBody.setEnabled(enabled);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to set body enabled state:', error);
+            return false;
+        }
+    }
+    buildHitTestResult(origin, direction, intersection) {
+        const hitComponent = this.colliderToComponent.get(intersection.collider.handle) ?? null;
+        return {
+            origin: origin,
+            direction: direction,
+            hitLocation: origin.clone().add(direction.clone().multiplyScalar(intersection.timeOfImpact)),
+            hitNormal: new THREE.Vector3(intersection.normal.x, intersection.normal.y, intersection.normal.z),
+            hitComponent: hitComponent,
+            hitActor: hitComponent?.getActor() ?? null,
+        };
+    }
+    performHitTest(options) {
+        const world = this.world;
+        const ray = new RAPIER.Ray({ x: options.origin.x, y: options.origin.y, z: options.origin.z }, { x: options.direction.x, y: options.direction.y, z: options.direction.z });
+        const groups = options.collisionProfile ? this.getCollisionGroups(options.collisionProfile) : undefined;
+        const filterPredicate = (collider) => {
+            if (options.ignoredActors || options.ignoredComponents) {
+                const component = this.colliderToComponent.get(collider.handle);
+                if (!component) {
+                    return false;
+                }
+                if (options.ignoredActors && options.ignoredActors.includes(component.getActor())) {
+                    return false;
+                }
+                if (options.ignoredComponents && options.ignoredComponents.includes(component)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        const results = [];
+        if (options.stopOnFirstHit) {
+            const intersection = world.castRayAndGetNormal(ray, options.maxDistance, true, RAPIER.QueryFilterFlags.EXCLUDE_SENSORS, groups, undefined, undefined, filterPredicate);
+            if (intersection) {
+                results.push(this.buildHitTestResult(options.origin, options.direction, intersection));
+            }
+        }
+        else {
+            world.intersectionsWithRay(ray, options.maxDistance, true, (intersect) => {
+                results.push(this.buildHitTestResult(options.origin, options.direction, intersect));
+                return true;
+            }, RAPIER.QueryFilterFlags.EXCLUDE_SENSORS, groups, undefined, undefined, filterPredicate);
+        }
+        return results;
+    }
+    // Vehicle controller implementation
+    createVehicle(movementComponent, chassisComponent) {
+        if (!this.world)
+            return null;
+        // Get the chassis physics record
+        const chassisRecords = this.bodies.get(chassisComponent);
+        if (!chassisRecords || chassisRecords.length !== 1) {
+            console.error('VehicleController: Chassis component not found in physics simulation');
+            return null;
+        }
+        if (this.vehicles.has(movementComponent)) {
+            console.error('VehicleController: Vehicle controller already exists for component:', movementComponent.getPathName());
+            return null;
+        }
+        try {
+            // Create the vehicle controller using Rapier's DynamicRayCastVehicleController
+            const chassisRecord = chassisRecords[0];
+            const chassisBody = chassisRecord[0];
+            // Create and return the physics vehicle interface
+            const vehicle = new RapierVehicle({
+                world: this.world,
+                chassis: chassisBody,
+            });
+            // Store the record for cleanup purposes
+            this.vehicles.set(movementComponent, vehicle);
+            console.log('VehicleController: Created vehicle controller for component:', movementComponent.getPathName());
+            return vehicle;
+        }
+        catch (error) {
+            console.error('VehicleController: Failed to create vehicle controller:', error);
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RapierPhysics.js","sourceRoot":"","sources":["../../../../src/physics/implementations/RapierPhysics.ts"],"names":[],"mappings":"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"}