angular-three-rapier 4.0.0-next.116 → 4.0.0-next.118

package/fesm2022/angular-three-rapier.mjs

@@ -47,7 +47,32 @@ function interactionGroups(memberships, filters) {
 function bitmask(groups) {
     return [groups].flat().reduce((acc, layer) => acc | (1 << layer), 0);
 }
+/**
+ * Injection token for handlers that set collision groups on colliders.
+ * Used internally by rigid bodies and attractors to apply interaction groups.
+ */
 const COLLISION_GROUPS_HANDLER = new InjectionToken('COLLISION_GROUPS_HANDLER');
+/**
+ * Directive for setting collision/solver groups on a rigid body or collider.
+ * This allows filtering which objects can collide with each other.
+ *
+ * @example
+ * ```html
+ * <!-- Object in group 0, collides with groups 0 and 1 -->
+ * <ngt-object3D rigidBody [interactionGroups]="[[0], [0, 1]]">
+ *   <ngt-mesh>
+ *     <ngt-box-geometry />
+ *   </ngt-mesh>
+ * </ngt-object3D>
+ *
+ * <!-- Object in groups 0 and 1, collides with everything -->
+ * <ngt-object3D rigidBody [interactionGroups]="[[0, 1]]">
+ *   <ngt-mesh>
+ *     <ngt-sphere-geometry />
+ *   </ngt-mesh>
+ * </ngt-object3D>
+ * ```
+ */
 class NgtrInteractionGroups {
     inputs = input.required({ ...(ngDevMode ? { debugName: "inputs" } : {}), alias: 'interactionGroups' });
     interactionGroups = computed(() => {
@@ -73,6 +98,22 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
             args: [{ selector: 'ngt-object3D[interactionGroups]' }]
         }], ctorParameters: () => [], propDecorators: { inputs: [{ type: i0.Input, args: [{ isSignal: true, alias: "interactionGroups", required: true }] }] } });
 
+/**
+ * Debug visualization component for the physics world.
+ * Renders wireframe outlines of all colliders in the physics simulation.
+ *
+ * This component is automatically rendered when the `debug` option is set to `true`
+ * on the `NgtrPhysics` component. It updates every frame to show current collider positions.
+ *
+ * @example
+ * ```html
+ * <ngtr-physics [options]="{ debug: true }">
+ *   <ng-template>
+ *     <!-- Your physics scene -->
+ *   </ng-template>
+ * </ngtr-physics>
+ * ```
+ */
 class NgtrDebug {
     physics = inject(NgtrPhysics);
     lineSegmentsRef = viewChild.required('lineSegments');
@@ -120,6 +161,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
                 }]
         }], ctorParameters: () => [], propDecorators: { lineSegmentsRef: [{ type: i0.ViewChild, args: ['lineSegments', { isSignal: true }] }] } });
 
+/**
+ * Internal directive that manages the physics simulation loop.
+ * Handles both "follow" mode (tied to render loop) and "independent" mode (separate loop).
+ *
+ * This directive is used internally by NgtrPhysics and should not be used directly.
+ */
 class NgtrFrameStepper {
     ready = input(false, ...(ngDevMode ? [{ debugName: "ready" }] : []));
     updatePriority = input(0, ...(ngDevMode ? [{ debugName: "updatePriority" }] : []));
@@ -161,20 +208,48 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
             args: [{ selector: 'ngtr-frame-stepper' }]
         }], ctorParameters: () => [], propDecorators: { ready: [{ type: i0.Input, args: [{ isSignal: true, alias: "ready", required: false }] }], updatePriority: [{ type: i0.Input, args: [{ isSignal: true, alias: "updatePriority", required: false }] }], stepFn: [{ type: i0.Input, args: [{ isSignal: true, alias: "stepFn", required: true }] }], type: [{ type: i0.Input, args: [{ isSignal: true, alias: "type", required: true }] }] } });
 
+/**
+ * Shared reusable Three.js objects for internal calculations.
+ * These are used to avoid creating new objects on every frame,
+ * which would cause garbage collection pressure.
+ *
+ * @internal
+ */
+/** Shared quaternion for internal calculations */
 const _quaternion = new THREE.Quaternion();
+/** Shared euler angles for internal calculations */
 const _euler = new THREE.Euler();
+/** Shared vector3 for internal calculations */
 const _vector3 = new THREE.Vector3();
+/** Shared Object3D for internal calculations */
 const _object3d = new THREE.Object3D();
+/** Shared matrix4 for internal calculations */
 const _matrix4 = new THREE.Matrix4();
+/** Shared position vector for internal calculations */
 const _position = new THREE.Vector3();
+/** Shared rotation quaternion for internal calculations */
 const _rotation = new THREE.Quaternion();
+/** Shared scale vector for internal calculations */
 const _scale = new THREE.Vector3();
 
 /**
  * Creates a proxy that will create a singleton instance of the given class
- * when a property is accessed, and not before.
+ * when a property is accessed, and not before. This is useful for lazy initialization
+ * of expensive objects like physics worlds.
+ *
+ * @template SingletonClass - The type of the singleton instance
+ * @template CreationFn - The type of the factory function
+ * @param createInstance - A function that returns a new instance of the class
+ * @returns An object containing the proxy, reset function, and set function
  *
- * @returns A proxy and a reset function, so that the instance can created again
+ * @example
+ * ```typescript
+ * const { proxy, reset } = createSingletonProxy(() => new World(gravity));
+ * // Access the world lazily
+ * proxy.step();
+ * // Reset when done
+ * reset();
+ * ```
  */
 const createSingletonProxy = (
 /**
@@ -208,9 +283,29 @@ createInstance) => {
      */
     return { proxy, reset, set };
 };
+/**
+ * Converts a Rapier quaternion to a Three.js quaternion.
+ *
+ * @param quaternion - The Rapier quaternion to convert
+ * @returns A Three.js Quaternion with the same values
+ */
 function rapierQuaternionToQuaternion({ x, y, z, w }) {
     return _quaternion.set(x, y, z, w);
 }
+/**
+ * Converts an Angular Three vector representation to a Rapier Vector3.
+ * Supports arrays, numbers (uniform scale), and objects with x, y, z properties.
+ *
+ * @param v - The vector to convert (can be [x, y, z], a number, or {x, y, z})
+ * @returns A Rapier Vector3 instance
+ *
+ * @example
+ * ```typescript
+ * vector3ToRapierVector([1, 2, 3]); // RapierVector3(1, 2, 3)
+ * vector3ToRapierVector(5); // RapierVector3(5, 5, 5)
+ * vector3ToRapierVector({ x: 1, y: 2, z: 3 }); // RapierVector3(1, 2, 3)
+ * ```
+ */
 function vector3ToRapierVector(v) {
     if (Array.isArray(v)) {
         return new Vector3(v[0], v[1], v[2]);
@@ -220,6 +315,19 @@ function vector3ToRapierVector(v) {
     }
     return new Vector3(v.x, v.y, v.z);
 }
+/**
+ * Converts an Angular Three quaternion representation to a Rapier Quaternion.
+ * Supports arrays and objects with x, y, z, w properties.
+ *
+ * @param v - The quaternion to convert (can be [x, y, z, w] or {x, y, z, w})
+ * @returns A Rapier Quaternion instance
+ *
+ * @example
+ * ```typescript
+ * quaternionToRapierQuaternion([0, 0, 0, 1]); // Identity quaternion
+ * quaternionToRapierQuaternion({ x: 0, y: 0, z: 0, w: 1 }); // Identity quaternion
+ * ```
+ */
 function quaternionToRapierQuaternion(v) {
     if (Array.isArray(v)) {
         return new Quaternion(v[0], v[1], v[2], v[3]);
@@ -280,6 +388,21 @@ function getColliderArgsFromGeometry(geometry, colliders) {
     }
     return { args: [], offset: new THREE.Vector3() };
 }
+/**
+ * Creates collider options by traversing child meshes of an object and generating
+ * appropriate collider configurations based on their geometries.
+ *
+ * @param object - The parent Object3D to traverse for meshes
+ * @param options - The rigid body options containing collider type and other settings
+ * @param ignoreMeshColliders - Whether to skip meshes that are children of mesh colliders
+ * @returns Array of collider configurations with shape, args, position, rotation, and scale
+ *
+ * @example
+ * ```typescript
+ * const colliderOptions = createColliderOptions(rigidBodyObject, { colliders: 'cuboid' });
+ * // Returns array of collider configs for each mesh child
+ * ```
+ */
 function createColliderOptions(object, options, ignoreMeshColliders = true) {
     const childColliderOptions = [];
     object.updateWorldMatrix(true, false);
@@ -338,7 +461,23 @@ const defaultOptions$1 = {
     timeStep: 1 / 60,
     debug: false,
 };
+/**
+ * Directive for providing a fallback template when Rapier fails to load.
+ *
+ * @example
+ * ```html
+ * <ngtr-physics>
+ *   <ng-template>
+ *     <!-- Physics scene content -->
+ *   </ng-template>
+ *   <ng-template rapierFallback let-error="error">
+ *     <p>Failed to load physics: {{ error }}</p>
+ *   </ng-template>
+ * </ngtr-physics>
+ * ```
+ */
 class NgtrPhysicsFallback {
+    /** Type guard for template context */
     static ngTemplateContextGuard(_, ctx) {
         return true;
     }
@@ -349,7 +488,29 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
             type: Directive,
             args: [{ selector: 'ng-template[rapierFallback]' }]
         }] });
+/**
+ * Main physics component that creates and manages a Rapier physics world.
+ * Wrap your 3D scene content in this component to enable physics simulation.
+ *
+ * The component lazily loads the Rapier WASM module and provides the physics
+ * context to all child components.
+ *
+ * @example
+ * ```html
+ * <ngtr-physics [options]="{ gravity: [0, -9.81, 0], debug: true }">
+ *   <ng-template>
+ *     <ngt-object3D rigidBody>
+ *       <ngt-mesh>
+ *         <ngt-box-geometry />
+ *         <ngt-mesh-standard-material />
+ *       </ngt-mesh>
+ *     </ngt-object3D>
+ *   </ng-template>
+ * </ngtr-physics>
+ * ```
+ */
 class NgtrPhysics {
+    /** Physics configuration options */
     options = input(defaultOptions$1, { ...(ngDevMode ? { debugName: "options" } : {}), transform: mergeInputs(defaultOptions$1) });
     content = contentChild.required(TemplateRef);
     fallbackContent = contentChild(NgtrPhysicsFallback, { ...(ngDevMode ? { debugName: "fallbackContent" } : {}), read: TemplateRef });
@@ -365,27 +526,59 @@ class NgtrPhysics {
     lengthUnit = pick(this.options, 'lengthUnit');
     timeStep = pick(this.options, 'timeStep');
     interpolate = pick(this.options, 'interpolate');
+    /** Whether the physics simulation is paused */
     paused = pick(this.options, 'paused');
     debug = pick(this.options, 'debug');
+    /** The default collider type for automatic collider generation */
     colliders = pick(this.options, 'colliders');
     vGravity = vector3(this.options, 'gravity');
     store = injectStore();
     rapierConstruct = signal(null, ...(ngDevMode ? [{ debugName: "rapierConstruct" }] : []));
     rapierError = signal(null, ...(ngDevMode ? [{ debugName: "rapierError" }] : []));
+    /** The loaded Rapier module, null if not yet loaded */
     rapier = this.rapierConstruct.asReadonly();
     ready = computed(() => !!this.rapier(), ...(ngDevMode ? [{ debugName: "ready" }] : []));
+    /** Singleton proxy to the Rapier physics world */
     worldSingleton = computed(() => {
         const rapier = this.rapier();
         if (!rapier)
             return null;
         return createSingletonProxy(() => new rapier.World(untracked(this.vGravity)));
     }, ...(ngDevMode ? [{ debugName: "worldSingleton" }] : []));
+    /** Map of rigid body states indexed by handle */
     rigidBodyStates = new Map();
+    /** Map of collider states indexed by handle */
     colliderStates = new Map();
+    /** Map of rigid body event handlers indexed by handle */
     rigidBodyEvents = new Map();
+    /** Map of collider event handlers indexed by handle */
     colliderEvents = new Map();
+    /** Callbacks to run before each physics step */
     beforeStepCallbacks = new Set();
+    /** Callbacks to run after each physics step */
     afterStepCallbacks = new Set();
+    /** Callbacks to filter contact pairs */
+    filterContactPairCallbacks = new Set();
+    /** Callbacks to filter intersection pairs */
+    filterIntersectionPairCallbacks = new Set();
+    hooks = {
+        filterContactPair: (...args) => {
+            for (const callback of this.filterContactPairCallbacks) {
+                const result = callback(...args);
+                if (result !== null)
+                    return result;
+            }
+            return null;
+        },
+        filterIntersectionPair: (...args) => {
+            for (const callback of this.filterIntersectionPairCallbacks) {
+                const result = callback(...args);
+                if (result === false)
+                    return false;
+            }
+            return true;
+        },
+    };
     eventQueue = computed(() => {
         const rapier = this.rapier();
         if (!rapier)
@@ -412,6 +605,13 @@ class NgtrPhysics {
             }
         });
     }
+    /**
+     * Steps the physics simulation forward by the given delta time.
+     * This is called automatically by the frame stepper, but can be called manually
+     * if you need custom control over the simulation timing.
+     *
+     * @param delta - Time in seconds since the last step
+     */
     step(delta) {
         if (!this.paused()) {
             this.internalStep(delta);
@@ -454,7 +654,8 @@ class NgtrPhysics {
                 callback(world);
             });
             world.timestep = innerDelta;
-            world.step(eventQueue);
+            const hasHooks = this.filterContactPairCallbacks.size > 0 || this.filterIntersectionPairCallbacks.size > 0;
+            world.step(eventQueue, hasHooks ? this.hooks : undefined);
             // Trigger afterStep callbacks
             this.afterStepCallbacks.forEach((callback) => {
                 callback(world);
@@ -699,6 +900,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
 const colliderDefaultOptions = {
     contactSkin: 0,
 };
+/**
+ * Base directive for creating colliders in the physics simulation.
+ * This directive can be used to create any type of collider by specifying the shape.
+ *
+ * For convenience, use the specific collider directives like `NgtrCuboidCollider`,
+ * `NgtrBallCollider`, etc., which provide type-safe arguments.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [collider]="'cuboid'" [args]="[1, 1, 1]" [position]="[0, 5, 0]" />
+ * ```
+ */
 class NgtrAnyCollider {
     position = input([0, 0, 0], ...(ngDevMode ? [{ debugName: "position" }] : []));
     rotation = input(...(ngDevMode ? [undefined, { debugName: "rotation" }] : []));
@@ -989,12 +1202,17 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
             type: Directive,
             args: [{ selector: 'ngt-object3D[collider]' }]
         }], ctorParameters: () => [], propDecorators: { position: [{ type: i0.Input, args: [{ isSignal: true, alias: "position", required: false }] }], rotation: [{ type: i0.Input, args: [{ isSignal: true, alias: "rotation", required: false }] }], scale: [{ type: i0.Input, args: [{ isSignal: true, alias: "scale", required: false }] }], quaternion: [{ type: i0.Input, args: [{ isSignal: true, alias: "quaternion", required: false }] }], userData: [{ type: i0.Input, args: [{ isSignal: true, alias: "userData", required: false }] }], name: [{ type: i0.Input, args: [{ isSignal: true, alias: "name", required: false }] }], options: [{ type: i0.Input, args: [{ isSignal: true, alias: "options", required: false }] }], shape: [{ type: i0.Input, args: [{ isSignal: true, alias: "collider", required: false }] }, { type: i0.Output, args: ["colliderChange"] }], args: [{ type: i0.Input, args: [{ isSignal: true, alias: "args", required: false }] }, { type: i0.Output, args: ["argsChange"] }], collisionEnter: [{ type: i0.Output, args: ["collisionEnter"] }], collisionExit: [{ type: i0.Output, args: ["collisionExit"] }], intersectionEnter: [{ type: i0.Output, args: ["intersectionEnter"] }], intersectionExit: [{ type: i0.Output, args: ["intersectionExit"] }], contactForce: [{ type: i0.Output, args: ["contactForce"] }] } });
+/** Maps rigid body type strings to Rapier body type enum values */
 const RIGID_BODY_TYPE_MAP = {
     fixed: 1,
     dynamic: 0,
     kinematicPosition: 2,
     kinematicVelocity: 3,
 };
+/**
+ * Default options for rigid bodies.
+ * These values are used when specific options are not provided.
+ */
 const rigidBodyDefaultOptions = {
     canSleep: true,
     linearVelocity: [0, 0, 0],
@@ -1005,6 +1223,38 @@ const rigidBodyDefaultOptions = {
     softCcdPrediction: 0,
     contactSkin: 0,
 };
+/**
+ * Component that creates a rigid body in the physics simulation.
+ * Rigid bodies can be dynamic (simulated), fixed (static), or kinematic (user-controlled).
+ *
+ * Child meshes automatically generate colliders based on their geometry.
+ * The collider type can be controlled via the `colliders` option.
+ *
+ * @example
+ * ```html
+ * <!-- Dynamic rigid body with automatic colliders -->
+ * <ngt-object3D rigidBody [position]="[0, 5, 0]">
+ *   <ngt-mesh>
+ *     <ngt-box-geometry />
+ *     <ngt-mesh-standard-material />
+ *   </ngt-mesh>
+ * </ngt-object3D>
+ *
+ * <!-- Fixed (static) rigid body -->
+ * <ngt-object3D rigidBody="fixed" [position]="[0, -1, 0]">
+ *   <ngt-mesh>
+ *     <ngt-plane-geometry [args]="[100, 100]" />
+ *   </ngt-mesh>
+ * </ngt-object3D>
+ *
+ * <!-- Kinematic rigid body -->
+ * <ngt-object3D rigidBody="kinematicPosition" #kinematicBody="rigidBody">
+ *   <ngt-mesh>
+ *     <ngt-sphere-geometry />
+ *   </ngt-mesh>
+ * </ngt-object3D>
+ * ```
+ */
 class NgtrRigidBody {
     type = input.required({ ...(ngDevMode ? { debugName: "type" } : {}), alias: 'rigidBody',
         transform: (value) => {
@@ -1333,248 +1583,470 @@ const ANY_COLLIDER_HOST_DIRECTIVE = {
     inputs: ['options', 'name', 'scale', 'position', 'quaternion', 'rotation', 'userData'],
     outputs: ['collisionEnter', 'collisionExit', 'intersectionEnter', 'intersectionExit', 'contactForce'],
 };
+/**
+ * Creates a cuboid (box) collider with specified half-extents.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [cuboidCollider]="[1, 0.5, 2]" [position]="[0, 0, 0]" />
+ * ```
+ */
 class NgtrCuboidCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'cuboidCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('cuboid');
+        this.anyCollider.setShape('cuboid');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrCuboidCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrCuboidCollider, isStandalone: true, selector: "ngt-object3D[cuboidCollider]", inputs: { args: { classPropertyName: "args", publicName: "cuboidCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrCuboidCollider, isStandalone: true, selector: "ngt-object3D[cuboidCollider]", inputs: { args: { classPropertyName: "args", publicName: "cuboidCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["cuboidCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrCuboidCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[cuboidCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[cuboidCollider]',
+                    exportAs: 'cuboidCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "cuboidCollider", required: true }] }] } });
+/**
+ * Creates a capsule collider with specified half-height and radius.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [capsuleCollider]="[0.5, 0.25]" [position]="[0, 1, 0]" />
+ * ```
+ */
 class NgtrCapsuleCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'capsuleCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('capsule');
+        this.anyCollider.setShape('capsule');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrCapsuleCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrCapsuleCollider, isStandalone: true, selector: "ngt-object3D[capsuleCollider]", inputs: { args: { classPropertyName: "args", publicName: "capsuleCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrCapsuleCollider, isStandalone: true, selector: "ngt-object3D[capsuleCollider]", inputs: { args: { classPropertyName: "args", publicName: "capsuleCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["capsuleCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrCapsuleCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[capsuleCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[capsuleCollider]',
+                    exportAs: 'capsuleCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "capsuleCollider", required: true }] }] } });
+/**
+ * Creates a spherical (ball) collider with specified radius.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [ballCollider]="[0.5]" [position]="[0, 2, 0]" />
+ * ```
+ */
 class NgtrBallCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'ballCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('ball');
+        this.anyCollider.setShape('ball');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrBallCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrBallCollider, isStandalone: true, selector: "ngt-object3D[ballCollider]", inputs: { args: { classPropertyName: "args", publicName: "ballCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrBallCollider, isStandalone: true, selector: "ngt-object3D[ballCollider]", inputs: { args: { classPropertyName: "args", publicName: "ballCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["ballCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrBallCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[ballCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[ballCollider]',
+                    exportAs: 'ballCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "ballCollider", required: true }] }] } });
+/**
+ * Creates a convex hull collider from an array of vertices.
+ * The convex hull is computed from the provided points.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [convexHullCollider]="[vertices]" />
+ * ```
+ */
 class NgtrConvexHullCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'convexHullCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('convexHull');
+        this.anyCollider.setShape('convexHull');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrConvexHullCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrConvexHullCollider, isStandalone: true, selector: "ngt-object3D[convexHullCollider]", inputs: { args: { classPropertyName: "args", publicName: "convexHullCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrConvexHullCollider, isStandalone: true, selector: "ngt-object3D[convexHullCollider]", inputs: { args: { classPropertyName: "args", publicName: "convexHullCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["convexHullCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrConvexHullCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[convexHullCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[convexHullCollider]',
+                    exportAs: 'convexHullCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "convexHullCollider", required: true }] }] } });
+/**
+ * Creates a heightfield collider for terrain-like surfaces.
+ * The heightfield is defined by a grid of height values.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [heightfieldCollider]="[width, height, heights, scale]" />
+ * ```
+ */
 class NgtrHeightfieldCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'heightfieldCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('heightfield');
+        this.anyCollider.setShape('heightfield');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrHeightfieldCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrHeightfieldCollider, isStandalone: true, selector: "ngt-object3D[heightfieldCollider]", inputs: { args: { classPropertyName: "args", publicName: "heightfieldCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrHeightfieldCollider, isStandalone: true, selector: "ngt-object3D[heightfieldCollider]", inputs: { args: { classPropertyName: "args", publicName: "heightfieldCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["heightfieldCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrHeightfieldCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[heightfieldCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[heightfieldCollider]',
+                    exportAs: 'heightfieldCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "heightfieldCollider", required: true }] }] } });
+/**
+ * Creates a triangle mesh collider for exact collision shapes.
+ * Note: Trimesh colliders are computationally expensive and should be used sparingly.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [trimeshCollider]="[vertices, indices]" />
+ * ```
+ */
 class NgtrTrimeshCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'trimeshCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('trimesh');
+        this.anyCollider.setShape('trimesh');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrTrimeshCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrTrimeshCollider, isStandalone: true, selector: "ngt-object3D[trimeshCollider]", inputs: { args: { classPropertyName: "args", publicName: "trimeshCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrTrimeshCollider, isStandalone: true, selector: "ngt-object3D[trimeshCollider]", inputs: { args: { classPropertyName: "args", publicName: "trimeshCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["trimeshCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrTrimeshCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[trimeshCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[trimeshCollider]',
+                    exportAs: 'trimeshCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "trimeshCollider", required: true }] }] } });
+/**
+ * Creates a polyline collider from connected line segments.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [polylineCollider]="[vertices, indices]" />
+ * ```
+ */
 class NgtrPolylineCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'polylineCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('polyline');
+        this.anyCollider.setShape('polyline');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrPolylineCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrPolylineCollider, isStandalone: true, selector: "ngt-object3D[polylineCollider]", inputs: { args: { classPropertyName: "args", publicName: "polylineCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrPolylineCollider, isStandalone: true, selector: "ngt-object3D[polylineCollider]", inputs: { args: { classPropertyName: "args", publicName: "polylineCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["polylineCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrPolylineCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[polylineCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[polylineCollider]',
+                    exportAs: 'polylineCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "polylineCollider", required: true }] }] } });
+/**
+ * Creates a cuboid collider with rounded corners.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [roundCuboidCollider]="[1, 0.5, 2, 0.1]" />
+ * ```
+ */
 class NgtrRoundCuboidCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'roundCuboidCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('roundCuboid');
+        this.anyCollider.setShape('roundCuboid');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrRoundCuboidCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrRoundCuboidCollider, isStandalone: true, selector: "ngt-object3D[roundCuboidCollider]", inputs: { args: { classPropertyName: "args", publicName: "roundCuboidCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrRoundCuboidCollider, isStandalone: true, selector: "ngt-object3D[roundCuboidCollider]", inputs: { args: { classPropertyName: "args", publicName: "roundCuboidCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["roundCuboidCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrRoundCuboidCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[roundCuboidCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[roundCuboidCollider]',
+                    exportAs: 'roundCuboidCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "roundCuboidCollider", required: true }] }] } });
+/**
+ * Creates a cylinder collider with specified half-height and radius.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [cylinderCollider]="[1, 0.5]" />
+ * ```
+ */
 class NgtrCylinderCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'cylinderCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('cylinder');
+        this.anyCollider.setShape('cylinder');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrCylinderCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrCylinderCollider, isStandalone: true, selector: "ngt-object3D[cylinderCollider]", inputs: { args: { classPropertyName: "args", publicName: "cylinderCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrCylinderCollider, isStandalone: true, selector: "ngt-object3D[cylinderCollider]", inputs: { args: { classPropertyName: "args", publicName: "cylinderCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["cylinderCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrCylinderCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[cylinderCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[cylinderCollider]',
+                    exportAs: 'cylinderCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "cylinderCollider", required: true }] }] } });
+/**
+ * Creates a cylinder collider with rounded edges.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [roundCylinderCollider]="[1, 0.5, 0.05]" />
+ * ```
+ */
 class NgtrRoundCylinderCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'roundCylinderCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('roundCylinder');
+        this.anyCollider.setShape('roundCylinder');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrRoundCylinderCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrRoundCylinderCollider, isStandalone: true, selector: "ngt-object3D[roundCylinderCollider]", inputs: { args: { classPropertyName: "args", publicName: "roundCylinderCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrRoundCylinderCollider, isStandalone: true, selector: "ngt-object3D[roundCylinderCollider]", inputs: { args: { classPropertyName: "args", publicName: "roundCylinderCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["roundCylinderCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrRoundCylinderCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[roundCylinderCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[roundCylinderCollider]',
+                    exportAs: 'roundCylinderCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "roundCylinderCollider", required: true }] }] } });
+/**
+ * Creates a cone collider with specified half-height and base radius.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [coneCollider]="[1, 0.5]" />
+ * ```
+ */
 class NgtrConeCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'coneCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('cone');
+        this.anyCollider.setShape('cone');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrConeCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrConeCollider, isStandalone: true, selector: "ngt-object3D[coneCollider]", inputs: { args: { classPropertyName: "args", publicName: "coneCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrConeCollider, isStandalone: true, selector: "ngt-object3D[coneCollider]", inputs: { args: { classPropertyName: "args", publicName: "coneCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["coneCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrConeCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[coneCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[coneCollider]',
+                    exportAs: 'coneCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "coneCollider", required: true }] }] } });
+/**
+ * Creates a cone collider with rounded edges.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [roundConeCollider]="[1, 0.5, 0.05]" />
+ * ```
+ */
 class NgtrRoundConeCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'roundConeCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('roundCone');
+        this.anyCollider.setShape('roundCone');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrRoundConeCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrRoundConeCollider, isStandalone: true, selector: "ngt-object3D[roundConeCollider]", inputs: { args: { classPropertyName: "args", publicName: "roundConeCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrRoundConeCollider, isStandalone: true, selector: "ngt-object3D[roundConeCollider]", inputs: { args: { classPropertyName: "args", publicName: "roundConeCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["roundConeCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrRoundConeCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[roundConeCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[roundConeCollider]',
+                    exportAs: 'roundConeCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "roundConeCollider", required: true }] }] } });
+/**
+ * Creates a convex mesh collider from vertices and indices.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [convexMeshCollider]="[vertices, indices]" />
+ * ```
+ */
 class NgtrConvexMeshCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'convexMeshCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('convexMesh');
+        this.anyCollider.setShape('convexMesh');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrConvexMeshCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrConvexMeshCollider, isStandalone: true, selector: "ngt-object3D[convexMeshCollider]", inputs: { args: { classPropertyName: "args", publicName: "convexMeshCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrConvexMeshCollider, isStandalone: true, selector: "ngt-object3D[convexMeshCollider]", inputs: { args: { classPropertyName: "args", publicName: "convexMeshCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["convexMeshCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrConvexMeshCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[convexMeshCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[convexMeshCollider]',
+                    exportAs: 'convexMeshCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "convexMeshCollider", required: true }] }] } });
+/**
+ * Creates a convex hull collider with rounded edges.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [roundConvexHullCollider]="[vertices, indices, 0.05]" />
+ * ```
+ */
 class NgtrRoundConvexHullCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'roundConvexHullCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('roundConvexHull');
+        this.anyCollider.setShape('roundConvexHull');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrRoundConvexHullCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrRoundConvexHullCollider, isStandalone: true, selector: "ngt-object3D[roundConvexHullCollider]", inputs: { args: { classPropertyName: "args", publicName: "roundConvexHullCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrRoundConvexHullCollider, isStandalone: true, selector: "ngt-object3D[roundConvexHullCollider]", inputs: { args: { classPropertyName: "args", publicName: "roundConvexHullCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["roundConvexHullCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrRoundConvexHullCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[roundConvexHullCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[roundConvexHullCollider]',
+                    exportAs: 'roundConvexHullCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "roundConvexHullCollider", required: true }] }] } });
+/**
+ * Creates a convex mesh collider with rounded edges.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [roundConvexMeshCollider]="[vertices, indices, 0.05]" />
+ * ```
+ */
 class NgtrRoundConvexMeshCollider {
     args = input.required({ ...(ngDevMode ? { debugName: "args" } : {}), alias: 'roundConvexMeshCollider' });
+    anyCollider = inject(NgtrAnyCollider, { host: true });
+    collider = this.anyCollider.collider;
     constructor() {
-        const anyCollider = inject(NgtrAnyCollider, { host: true });
-        anyCollider.setShape('roundConvexMesh');
+        this.anyCollider.setShape('roundConvexMesh');
         effect(() => {
-            anyCollider.setArgs(this.args());
+            this.anyCollider.setArgs(this.args());
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrRoundConvexMeshCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrRoundConvexMeshCollider, isStandalone: true, selector: "ngt-object3D[roundConvexMeshCollider]", inputs: { args: { classPropertyName: "args", publicName: "roundConvexMeshCollider", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.6", type: NgtrRoundConvexMeshCollider, isStandalone: true, selector: "ngt-object3D[roundConvexMeshCollider]", inputs: { args: { classPropertyName: "args", publicName: "roundConvexMeshCollider", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["roundConvexMeshCollider"], hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: NgtrRoundConvexMeshCollider, decorators: [{
             type: Directive,
-            args: [{ selector: 'ngt-object3D[roundConvexMeshCollider]', hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE] }]
+            args: [{
+                    selector: 'ngt-object3D[roundConvexMeshCollider]',
+                    exportAs: 'roundConvexMeshCollider',
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
         }], ctorParameters: () => [], propDecorators: { args: [{ type: i0.Input, args: [{ isSignal: true, alias: "roundConvexMeshCollider", required: true }] }] } });
 
 const defaultOptions = rigidBodyDefaultOptions;
+/**
+ * Component for creating multiple rigid bodies from a single InstancedMesh.
+ * This is highly efficient for scenes with many identical physics objects.
+ *
+ * Each instance gets its own rigid body but shares the same geometry for rendering.
+ * The component automatically syncs instance matrices with physics simulation.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D [instancedRigidBodies]="instances">
+ *   <ngt-instanced-mesh [count]="instances.length" castShadow receiveShadow>
+ *     <ngt-sphere-geometry [args]="[0.5]" />
+ *     <ngt-mesh-standard-material color="orange" />
+ *   </ngt-instanced-mesh>
+ * </ngt-object3D>
+ * ```
+ *
+ * ```typescript
+ * instances = Array.from({ length: 100 }, (_, i) => ({
+ *   key: i,
+ *   position: [Math.random() * 10, Math.random() * 10, 0] as [number, number, number],
+ * }));
+ * ```
+ */
 class NgtrInstancedRigidBodies {
     position = input([0, 0, 0], ...(ngDevMode ? [{ debugName: "position" }] : []));
     rotation = input(...(ngDevMode ? [undefined, { debugName: "rotation" }] : []));
@@ -1817,10 +2289,27 @@ function createJoint(jointDataFn) {
     };
 }
 /**
- * A fixed joint ensures that two rigid-bodies don't move relative to each other.
+ * Creates a fixed joint that prevents any relative movement between two rigid bodies.
  * Fixed joints are characterized by one local frame (represented by an isometry) on each rigid-body.
  * The fixed-joint makes these frames coincide in world-space.
  *
+ * @param bodyA - First rigid body (can be RigidBody, ElementRef, or getter function)
+ * @param bodyB - Second rigid body (can be RigidBody, ElementRef, or getter function)
+ * @param options - Joint configuration with data and optional injector
+ * @returns Signal containing the created joint or null
+ *
+ * @example
+ * ```typescript
+ * fixedJoint(bodyA, bodyB, {
+ *   data: {
+ *     body1Anchor: [0, 0, 0],
+ *     body1LocalFrame: [0, 0, 0, 1],
+ *     body2Anchor: [0, 0, 0],
+ *     body2LocalFrame: [0, 0, 0, 1]
+ *   }
+ * });
+ * ```
+ *
  * @category Hooks - Joints
  */
 const fixedJoint = createJoint((rapier, data) => rapier.JointData.fixed(vector3ToRapierVector(data.body1Anchor), quaternionToRapierQuaternion(data.body1LocalFrame), vector3ToRapierVector(data.body2Anchor), quaternionToRapierQuaternion(data.body2LocalFrame)));
@@ -1830,10 +2319,21 @@ const fixedJoint = createJoint((rapier, data) => rapier.JointData.fixed(vector3T
  */
 const injectFixedJoint = fixedJoint;
 /**
- * The spherical joint ensures that two points on the local-spaces of two rigid-bodies always coincide (it prevents any relative
- * translational motion at this points). This is typically used to simulate ragdolls arms, pendulums, etc.
- * They are characterized by one local anchor on each rigid-body. Each anchor represents the location of the
- * points that need to coincide on the local-space of each rigid-body.
+ * Creates a spherical (ball-and-socket) joint that ensures two anchor points always coincide.
+ * This prevents any relative translational motion at these points while allowing rotation.
+ * Typically used to simulate ragdoll arms, pendulums, etc.
+ *
+ * @param bodyA - First rigid body (can be RigidBody, ElementRef, or getter function)
+ * @param bodyB - Second rigid body (can be RigidBody, ElementRef, or getter function)
+ * @param options - Joint configuration with data and optional injector
+ * @returns Signal containing the created joint or null
+ *
+ * @example
+ * ```typescript
+ * sphericalJoint(bodyA, bodyB, {
+ *   data: { body1Anchor: [0, -0.5, 0], body2Anchor: [0, 0.5, 0] }
+ * });
+ * ```
  *
  * @category Hooks - Joints
  */
@@ -1844,9 +2344,26 @@ const sphericalJoint = createJoint((rapier, data) => rapier.JointData.spherical(
  */
 const injectSphericalJoint = sphericalJoint;
 /**
- * The revolute joint prevents any relative movement between two rigid-bodies, except for relative
- * rotations along one axis. This is typically used to simulate wheels, fans, etc.
- * They are characterized by one local anchor as well as one local axis on each rigid-body.
+ * Creates a revolute (hinge) joint that allows rotation only around one axis.
+ * Prevents any other relative movement between two rigid bodies.
+ * Typically used to simulate wheels, doors, fans, etc.
+ *
+ * @param bodyA - First rigid body (can be RigidBody, ElementRef, or getter function)
+ * @param bodyB - Second rigid body (can be RigidBody, ElementRef, or getter function)
+ * @param options - Joint configuration with data (including optional limits) and optional injector
+ * @returns Signal containing the created joint or null
+ *
+ * @example
+ * ```typescript
+ * revoluteJoint(bodyA, bodyB, {
+ *   data: {
+ *     body1Anchor: [0, 0, 0],
+ *     body2Anchor: [0, 1, 0],
+ *     axis: [0, 1, 0],
+ *     limits: [-Math.PI / 2, Math.PI / 2]
+ *   }
+ * });
+ * ```
  *
  * @category Hooks - Joints
  */
@@ -1864,9 +2381,26 @@ const revoluteJoint = createJoint((rapier, data) => {
  */
 const injectRevoluteJoint = revoluteJoint;
 /**
- * The prismatic joint prevents any relative movement between two rigid-bodies, except for relative translations along one axis.
- * It is characterized by one local anchor as well as one local axis on each rigid-body. In 3D, an optional
- * local tangent axis can be specified for each rigid-body.
+ * Creates a prismatic (slider) joint that allows translation only along one axis.
+ * Prevents any other relative movement between two rigid bodies.
+ * Typically used to simulate pistons, sliding doors, etc.
+ *
+ * @param bodyA - First rigid body (can be RigidBody, ElementRef, or getter function)
+ * @param bodyB - Second rigid body (can be RigidBody, ElementRef, or getter function)
+ * @param options - Joint configuration with data (including optional limits) and optional injector
+ * @returns Signal containing the created joint or null
+ *
+ * @example
+ * ```typescript
+ * prismaticJoint(bodyA, bodyB, {
+ *   data: {
+ *     body1Anchor: [0, 0, 0],
+ *     body2Anchor: [2, 0, 0],
+ *     axis: [1, 0, 0],
+ *     limits: [-1, 1]
+ *   }
+ * });
+ * ```
  *
  * @category Hooks - Joints
  */
@@ -1884,7 +2418,25 @@ const prismaticJoint = createJoint((rapier, data) => {
  */
 const injectPrismaticJoint = prismaticJoint;
 /**
- * The rope joint limits the max distance between two bodies.
+ * Creates a rope joint that limits the maximum distance between two anchor points.
+ * The bodies can move freely as long as the distance doesn't exceed the specified length.
+ *
+ * @param bodyA - First rigid body (can be RigidBody, ElementRef, or getter function)
+ * @param bodyB - Second rigid body (can be RigidBody, ElementRef, or getter function)
+ * @param options - Joint configuration with data and optional injector
+ * @returns Signal containing the created joint or null
+ *
+ * @example
+ * ```typescript
+ * ropeJoint(bodyA, bodyB, {
+ *   data: {
+ *     body1Anchor: [0, 0, 0],
+ *     body2Anchor: [0, 0, 0],
+ *     length: 5
+ *   }
+ * });
+ * ```
+ *
  * @category Hooks - Joints
  */
 const ropeJoint = createJoint((rapier, data) => rapier.JointData.rope(data.length, vector3ToRapierVector(data.body1Anchor), vector3ToRapierVector(data.body2Anchor)));
@@ -1894,7 +2446,27 @@ const ropeJoint = createJoint((rapier, data) => rapier.JointData.rope(data.lengt
  */
 const injectRopeJoint = ropeJoint;
 /**
- * The spring joint applies a force proportional to the distance between two objects.
+ * Creates a spring joint that applies a force proportional to the distance between two anchor points.
+ * The spring tries to maintain its rest length through spring forces.
+ *
+ * @param bodyA - First rigid body (can be RigidBody, ElementRef, or getter function)
+ * @param bodyB - Second rigid body (can be RigidBody, ElementRef, or getter function)
+ * @param options - Joint configuration with data and optional injector
+ * @returns Signal containing the created joint or null
+ *
+ * @example
+ * ```typescript
+ * springJoint(bodyA, bodyB, {
+ *   data: {
+ *     body1Anchor: [0, 0, 0],
+ *     body2Anchor: [0, 0, 0],
+ *     restLength: 2,
+ *     stiffness: 100,
+ *     damping: 10
+ *   }
+ * });
+ * ```
+ *
  * @category Hooks - Joints
  */
 const springJoint = createJoint((rapier, data) => {
@@ -1906,6 +2478,25 @@ const springJoint = createJoint((rapier, data) => {
  */
 const injectSpringJoint = springJoint;
 
+/**
+ * Component that generates colliders based on child mesh geometries.
+ * Use this when you want specific collider generation for a group of meshes
+ * within a rigid body.
+ *
+ * This is useful when you want different parts of a complex object to have
+ * different collider types than the parent rigid body's automatic colliders.
+ *
+ * @example
+ * ```html
+ * <ngt-object3D rigidBody [options]="{ colliders: false }">
+ *   <ngt-object3D [meshCollider]="'trimesh'">
+ *     <ngt-mesh>
+ *       <ngt-torus-geometry />
+ *     </ngt-mesh>
+ *   </ngt-object3D>
+ * </ngt-object3D>
+ * ```
+ */
 class NgtrMeshCollider {
     colliders = input.required({ ...(ngDevMode ? { debugName: "colliders" } : {}), alias: 'meshCollider' });
     objectRef = inject(ElementRef);
@@ -1966,6 +2557,24 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
                 }]
         }], ctorParameters: () => [], propDecorators: { colliders: [{ type: i0.Input, args: [{ isSignal: true, alias: "meshCollider", required: true }] }] } });
 
+/**
+ * Registers a callback to be executed before each physics world step.
+ * Useful for applying forces, updating kinematic bodies, or other pre-step logic.
+ *
+ * The callback is automatically unregistered when the component is destroyed.
+ *
+ * @param callback - Function to call before each physics step, receives the Rapier World
+ * @param injector - Optional injector for dependency injection context
+ *
+ * @example
+ * ```typescript
+ * beforePhysicsStep((world) => {
+ *   // Apply custom forces or update kinematic bodies
+ *   const body = world.getRigidBody(handle);
+ *   body?.applyImpulse({ x: 0, y: 10, z: 0 }, true);
+ * });
+ * ```
+ */
 function beforePhysicsStep(callback, injector) {
     return assertInjector(beforePhysicsStep, injector, () => {
         const physics = inject(NgtrPhysics);
@@ -1975,6 +2584,25 @@ function beforePhysicsStep(callback, injector) {
         });
     });
 }
+/**
+ * Registers a callback to be executed after each physics world step.
+ * Useful for reading physics state, updating visuals, or other post-step logic.
+ *
+ * The callback is automatically unregistered when the component is destroyed.
+ *
+ * @param callback - Function to call after each physics step, receives the Rapier World
+ * @param injector - Optional injector for dependency injection context
+ *
+ * @example
+ * ```typescript
+ * afterPhysicsStep((world) => {
+ *   // Read physics state after simulation
+ *   const body = world.getRigidBody(handle);
+ *   const position = body?.translation();
+ *   console.log('Body position:', position);
+ * });
+ * ```
+ */
 function afterPhysicsStep(callback, injector) {
     return assertInjector(afterPhysicsStep, injector, () => {
         const physics = inject(NgtrPhysics);
@@ -1984,10 +2612,59 @@ function afterPhysicsStep(callback, injector) {
         });
     });
 }
+/**
+ * Registers a callback to filter contact pairs.
+ *
+ * The callback determines if contact computation should happen between two colliders,
+ * and how the constraints solver should behave for these contacts.
+ *
+ * This will only be executed if at least one of the involved colliders contains the
+ * `ActiveHooks.FILTER_CONTACT_PAIRS` flag in its active hooks.
+ *
+ * @param callback - Function that returns:
+ *   - `SolverFlags.COMPUTE_IMPULSE` (1) - Process the collision normally
+ *   - `SolverFlags.EMPTY` (0) - Skip computing impulses (colliders pass through)
+ *   - `null` - Skip this hook; let the next registered hook decide
+ *
+ * When multiple hooks are registered, they are called in order until one returns a non-null value.
+ */
+function filterContactPair(callback, injector) {
+    return assertInjector(filterContactPair, injector, () => {
+        const physics = inject(NgtrPhysics);
+        physics.filterContactPairCallbacks.add(callback);
+        inject(DestroyRef).onDestroy(() => {
+            physics.filterContactPairCallbacks.delete(callback);
+        });
+    });
+}
+/**
+ * Registers a callback to filter intersection pairs.
+ *
+ * The callback determines if intersection computation should happen between two colliders
+ * (where at least one is a sensor).
+ *
+ * This will only be executed if at least one of the involved colliders contains the
+ * `ActiveHooks.FILTER_INTERSECTION_PAIR` flag in its active hooks.
+ *
+ * @param callback - Function that returns:
+ *   - `true` - Allow the intersection to be detected
+ *   - `false` - Block the intersection (no intersection events will fire)
+ *
+ * When multiple hooks are registered, the first hook that returns `false` blocks the intersection.
+ */
+function filterIntersectionPair(callback, injector) {
+    return assertInjector(filterIntersectionPair, injector, () => {
+        const physics = inject(NgtrPhysics);
+        physics.filterIntersectionPairCallbacks.add(callback);
+        inject(DestroyRef).onDestroy(() => {
+            physics.filterIntersectionPairCallbacks.delete(callback);
+        });
+    });
+}
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { COLLISION_GROUPS_HANDLER, NgtrAnyCollider, NgtrBallCollider, NgtrCapsuleCollider, NgtrConeCollider, NgtrConvexHullCollider, NgtrConvexMeshCollider, NgtrCuboidCollider, NgtrCylinderCollider, NgtrHeightfieldCollider, NgtrInstancedRigidBodies, NgtrInteractionGroups, NgtrMeshCollider, NgtrPhysics, NgtrPhysicsFallback, NgtrPolylineCollider, NgtrRigidBody, NgtrRoundConeCollider, NgtrRoundConvexHullCollider, NgtrRoundConvexMeshCollider, NgtrRoundCuboidCollider, NgtrRoundCylinderCollider, NgtrTrimeshCollider, afterPhysicsStep, beforePhysicsStep, fixedJoint, injectFixedJoint, injectPrismaticJoint, injectRevoluteJoint, injectRopeJoint, injectSphericalJoint, injectSpringJoint, interactionGroups, prismaticJoint, revoluteJoint, rigidBodyDefaultOptions, ropeJoint, sphericalJoint, springJoint };
+export { COLLISION_GROUPS_HANDLER, NgtrAnyCollider, NgtrBallCollider, NgtrCapsuleCollider, NgtrConeCollider, NgtrConvexHullCollider, NgtrConvexMeshCollider, NgtrCuboidCollider, NgtrCylinderCollider, NgtrHeightfieldCollider, NgtrInstancedRigidBodies, NgtrInteractionGroups, NgtrMeshCollider, NgtrPhysics, NgtrPhysicsFallback, NgtrPolylineCollider, NgtrRigidBody, NgtrRoundConeCollider, NgtrRoundConvexHullCollider, NgtrRoundConvexMeshCollider, NgtrRoundCuboidCollider, NgtrRoundCylinderCollider, NgtrTrimeshCollider, afterPhysicsStep, beforePhysicsStep, filterContactPair, filterIntersectionPair, fixedJoint, injectFixedJoint, injectPrismaticJoint, injectRevoluteJoint, injectRopeJoint, injectSphericalJoint, injectSpringJoint, interactionGroups, prismaticJoint, revoluteJoint, rigidBodyDefaultOptions, ropeJoint, sphericalJoint, springJoint };
 //# sourceMappingURL=angular-three-rapier.mjs.map