@needle-tools/engine 4.3.0-alpha → 4.3.0-alpha.1

package/dist/needle-engine.light.d.ts

@@ -1,15 +1,6 @@
 export { }
 
 
-declare global {
-    interface NavigatorUAData {
-        platform: string;
-    }
-    interface Navigator {
-        userAgentData?: NavigatorUAData;
-    }
-}
-
 declare module 'three' {
     interface SkinnedMesh {
         staticGenerator?: StaticGeometryGenerator;
@@ -25,6 +16,15 @@ declare module 'three' {
     }
 }
 
+declare global {
+    interface NavigatorUAData {
+        platform: string;
+    }
+    interface Navigator {
+        userAgentData?: NavigatorUAData;
+    }
+}
+
 declare module 'three' {
     interface Object3D {
         get guid(): string | undefined;

package/lib/engine/engine_types.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="webxr" />
-import type { QueryFilterFlags } from "@dimforge/rapier3d-compat";
+import type { QueryFilterFlags, World } from "@dimforge/rapier3d-compat";
 import { AnimationClip, Color, Material, Mesh, Object3D, Quaternion } from "three";
 import { Vector3 } from "three";
 import { type GLTF as THREE_GLTF } from "three/examples/jsm/loaders/GLTFLoader.js";
@@ -335,69 +335,214 @@ export declare class SphereOverlapResult {
     constructor(object: Object3D, collider: ICollider);
 }
 export interface IPhysicsEngine {
+    /** Initializes the physics engine */
     initialize(): Promise<boolean>;
+    /** Indicates whether the physics engine has been initialized */
     get isInitialized(): boolean;
+    /** Advances physics simulation by the given time step */
     step(dt: number): void;
     postStep(): any;
+    /** Indicates whether the physics engine is currently updating */
     get isUpdating(): boolean;
-    /** clear all possibly cached data (e.g. mesh data when creating scaled mesh colliders) */
+    /** Clears all cached data (e.g., mesh data when creating scaled mesh colliders) */
     clearCaches(): any;
+    /** Enables or disables the physics engine */
     enabled: boolean;
-    get world(): any;
+    /** Returns the underlying physics world object */
+    get world(): World | undefined;
+    /** Sets the gravity vector for the physics simulation */
     set gravity(vec3: Vec3);
+    /** Gets the current gravity vector */
     get gravity(): Vec3;
-    /** Get the rapier body for a Needle component */
+    /**
+     * Gets the rapier physics body for a Needle component
+     * @param obj The collider or rigidbody component
+     * @returns The underlying physics body or null if not found
+     */
     getBody(obj: ICollider | IRigidbody): null | any;
-    /** Get the Needle Engine component for a rapier object */
+    /**
+     * Gets the Needle Engine component for a rapier physics object
+     * @param rapierObject The rapier physics object
+     * @returns The associated component or null if not found
+     */
     getComponent(rapierObject: object): IComponent | null;
-    /** Fast raycast against physics colliders
-     * @param origin ray origin in screen or worldspace
-     * @param direction ray direction in worldspace
-     * @param options additional options
+    /**
+     * Performs a fast raycast against physics colliders
+     * @param origin Ray origin in screen or worldspace
+     * @param direction Ray direction in worldspace
+     * @param options Additional raycast configuration options
+     * @returns Raycast result containing hit point and collider, or null if no hit
      */
     raycast(origin?: Vec2 | Vec3, direction?: Vec3, options?: {
         maxDistance?: number;
         /** True if you want to also hit objects when the raycast starts from inside a collider */
         solid?: boolean;
         queryFilterFlags?: QueryFilterFlags;
-        /** Raycast filter groups.  Groups are used to apply the collision group rules for the scene query. The scene query will only consider hits with colliders with collision groups compatible with this collision group (using the bitwise test described in the collision groups section). See https://rapier.rs/docs/user_guides/javascript/colliders#collision-groups-and-solver-groups
-         * For example membership 0x0001 and filter 0x0002 should be 0x00010002 */
+        /**
+         * Raycast filter groups. Groups are used to apply the collision group rules for the scene query.
+         * The scene query will only consider hits with colliders with collision groups compatible with
+         * this collision group (using the bitwise test described in the collision groups section).
+         * For example membership 0x0001 and filter 0x0002 should be 0x00010002
+         * @see https://rapier.rs/docs/user_guides/javascript/colliders#collision-groups-and-solver-groups
+         */
         filterGroups?: number;
-        /** Return false to ignore this collider */
+        /**
+         * Predicate to filter colliders in raycast results
+         * @param collider The collider being tested
+         * @returns False to ignore this collider, true to include it
+         */
         filterPredicate?: (collider: ICollider) => boolean;
     }): RaycastResult;
-    /** raycast that also gets the normal vector. If you don't need it use raycast() */
+    /**
+     * Performs a raycast that also returns the normal vector at the hit point
+     * @param origin Ray origin in screen or worldspace
+     * @param direction Ray direction in worldspace
+     * @param options Additional raycast configuration options
+     * @returns Raycast result containing hit point, normal, and collider, or null if no hit
+     */
     raycastAndGetNormal(origin?: Vec2 | Vec3, direction?: Vec3, options?: {
         maxDistance?: number;
         /** True if you want to also hit objects when the raycast starts from inside a collider */
         solid?: boolean;
         queryFilterFlags?: QueryFilterFlags;
-        /** Raycast filter groups.  Groups are used to apply the collision group rules for the scene query. The scene query will only consider hits with colliders with collision groups compatible with this collision group (using the bitwise test described in the collision groups section). See https://rapier.rs/docs/user_guides/javascript/colliders#collision-groups-and-solver-groups
-         * For example membership 0x0001 and filter 0x0002 should be 0x00010002 */
+        /**
+         * Raycast filter groups. Groups are used to apply the collision group rules for the scene query.
+         * The scene query will only consider hits with colliders with collision groups compatible with
+         * this collision group (using the bitwise test described in the collision groups section).
+         * For example membership 0x0001 and filter 0x0002 should be 0x00010002
+         * @see https://rapier.rs/docs/user_guides/javascript/colliders#collision-groups-and-solver-groups
+         */
         filterGroups?: number;
-        /** Return false to ignore this collider */
+        /**
+         * Predicate to filter colliders in raycast results
+         * @param collider The collider being tested
+         * @returns False to ignore this collider, true to include it
+         */
         filterPredicate?: (collider: ICollider) => boolean;
     }): RaycastResult;
+    /**
+     * Finds all colliders within a sphere
+     * @param point The center point of the sphere
+     * @param radius The radius of the sphere
+     * @returns Array of objects that overlap with the sphere
+     */
     sphereOverlap(point: Vector3, radius: number): Array<SphereOverlapResult>;
+    /**
+     * Adds a sphere collider to the physics world
+     * @param collider The collider component to add
+     */
     addSphereCollider(collider: ICollider): any;
+    /**
+     * Adds a box collider to the physics world
+     * @param collider The collider component to add
+     * @param size The size of the box
+     */
     addBoxCollider(collider: ICollider, size: Vector3): any;
+    /**
+     * Adds a capsule collider to the physics world
+     * @param collider The collider component to add
+     * @param radius The radius of the capsule
+     * @param height The height of the capsule
+     */
     addCapsuleCollider(collider: ICollider, radius: number, height: number): any;
+    /**
+     * Adds a mesh collider to the physics world
+     * @param collider The collider component to add
+     * @param mesh The mesh to use for collision
+     * @param convex Whether the collision mesh should be treated as convex
+     * @param scale Optional scale to apply to the mesh
+     */
     addMeshCollider(collider: ICollider, mesh: Mesh, convex: boolean, scale?: Vector3 | undefined): any;
+    /**
+     * Updates the physics material properties of a collider
+     * @param collider The collider to update
+     */
     updatePhysicsMaterial(collider: ICollider): any;
+    /**
+     * Wakes up a sleeping rigidbody
+     * @param rb The rigidbody to wake up
+     */
     wakeup(rb: IRigidbody): any;
+    /**
+     * Checks if a rigidbody is currently sleeping
+     * @param rb The rigidbody to check
+     * @returns Whether the rigidbody is sleeping or undefined if cannot be determined
+     */
     isSleeping(rb: IRigidbody): boolean | undefined;
+    /**
+     * Updates the physical properties of a rigidbody or collider
+     * @param rb The rigidbody or collider to update
+     */
     updateProperties(rb: IRigidbody | ICollider): any;
+    /**
+     * Resets all forces acting on a rigidbody
+     * @param rb The rigidbody to reset forces on
+     * @param wakeup Whether to wake up the rigidbody
+     */
     resetForces(rb: IRigidbody, wakeup: boolean): any;
+    /**
+     * Resets all torques acting on a rigidbody
+     * @param rb The rigidbody to reset torques on
+     * @param wakeup Whether to wake up the rigidbody
+     */
     resetTorques(rb: IRigidbody, wakeup: boolean): any;
+    /**
+     * Adds a continuous force to a rigidbody
+     * @param rb The rigidbody to add force to
+     * @param vec The force vector to add
+     * @param wakeup Whether to wake up the rigidbody
+     */
     addForce(rb: IRigidbody, vec: Vec3, wakeup: boolean): any;
+    /**
+     * Applies an instantaneous impulse to a rigidbody
+     * @param rb The rigidbody to apply impulse to
+     * @param vec The impulse vector to apply
+     * @param wakeup Whether to wake up the rigidbody
+     */
     applyImpulse(rb: IRigidbody, vec: Vec3, wakeup: boolean): any;
-    /** Returns the linear velocity of a rigidbody or the rigidbody of a collider */
+    /**
+     * Gets the linear velocity of a rigidbody or the rigidbody attached to a collider
+     * @param rb The rigidbody or collider to get velocity from
+     * @returns The linear velocity vector or null if not available
+     */
     getLinearVelocity(rb: IRigidbody | ICollider): Vec3 | null;
+    /**
+     * Gets the angular velocity of a rigidbody
+     * @param rb The rigidbody to get angular velocity from
+     * @returns The angular velocity vector or null if not available
+     */
     getAngularVelocity(rb: IRigidbody): Vec3 | null;
+    /**
+     * Sets the angular velocity of a rigidbody
+     * @param rb The rigidbody to set angular velocity for
+     * @param vec The angular velocity vector to set
+     * @param wakeup Whether to wake up the rigidbody
+     */
     setAngularVelocity(rb: IRigidbody, vec: Vec3, wakeup: boolean): any;
+    /**
+     * Sets the linear velocity of a rigidbody
+     * @param rb The rigidbody to set linear velocity for
+     * @param vec The linear velocity vector to set
+     * @param wakeup Whether to wake up the rigidbody
+     */
     setLinearVelocity(rb: IRigidbody, vec: Vec3, wakeup: boolean): any;
+    /**
+     * Updates the position and/or rotation of a physics body
+     * @param comp The collider or rigidbody component to update
+     * @param translation Whether to update the position
+     * @param rotation Whether to update the rotation
+     */
     updateBody(comp: ICollider | IRigidbody, translation: boolean, rotation: boolean): any;
+    /**
+     * Removes a physics body from the simulation
+     * @param body The component whose physics body should be removed
+     */
     removeBody(body: IComponent): any;
+    /**
+     * Gets the physics body for a component
+     * @param obj The collider or rigidbody component
+     * @returns The underlying physics body or null if not found
+     */
     getBody(obj: ICollider | IRigidbody): null | any;
     addFixedJoint(body1: IRigidbody, body2: IRigidbody): any;
     addHingeJoint(body1: IRigidbody, body2: IRigidbody, anchor: Vec3, axis: Vec3): any;

package/lib/engine-components/Animator.d.ts

@@ -3,97 +3,205 @@ import { IAnimationComponent } from "../engine/engine_types.js";
 import type { AnimatorControllerModel } from "../engine/extensions/NEEDLE_animator_controller_model.js";
 import { AnimatorController } from "./AnimatorController.js";
 import { Behaviour } from "./Component.js";
+/**
+ * Represents an event emitted by an animation mixer
+ * @category Animation and Sequencing
+ */
 export declare class MixerEvent {
+    /** The type of event that occurred */
     type: string;
+    /** The animation action that triggered this event */
     action: AnimationAction;
+    /** Number of loops completed in this cycle */
     loopDelta: number;
+    /** The animation mixer that emitted this event */
     target: AnimationMixer;
 }
+/**
+ * Configuration options for playing animations
+ * @category Animation and Sequencing
+ */
 export declare class PlayOptions {
+    /** Whether the animation should loop, and if so, which loop style to use */
     loop?: boolean | AnimationActionLoopStyles;
+    /** Whether the final animation state should be maintained after playback completes */
     clampWhenFinished?: boolean;
 }
-/** The Animator component is used to play animations on a GameObject. It is used in combination with an AnimatorController (which is a state machine for animations)
- * A new AnimatorController can be created from code via `AnimatorController.createFromClips`
+/**
+ * The Animator component plays and manages animations on a GameObject.
+ * It works with an AnimatorController to handle state transitions and animation blending.
+ * A new AnimatorController can be created from code via `AnimatorController.createFromClips`.
  * @category Animation and Sequencing
  * @group Components
 */
 export declare class Animator extends Behaviour implements IAnimationComponent {
+    /**
+     * Identifies this component as an animation component in the engine
+     */
     get isAnimationComponent(): boolean;
+    /**
+     * When enabled, animation will affect the root transform position and rotation
+     */
     applyRootMotion: boolean;
+    /**
+     * Indicates whether this animator contains root motion data
+     */
     hasRootMotion: boolean;
+    /**
+     * When enabled, the animator will maintain its state when the component is disabled
+     */
     keepAnimatorControllerStateOnDisable: boolean;
+    /**
+     * Sets or replaces the animator controller for this component.
+     * Handles binding the controller to this animator instance and ensures
+     * proper initialization when the controller changes.
+     * @param val The animator controller model or instance to use
+     */
     set runtimeAnimatorController(val: AnimatorControllerModel | AnimatorController | undefined | null);
+    /**
+     * Gets the current animator controller instance
+     * @returns The current animator controller or null if none is assigned
+     */
     get runtimeAnimatorController(): AnimatorController | undefined | null;
-    /** The current state info of the animator.
-     * If you just want to access the currently playing animation action you can use currentAction
-     * @returns {AnimatorStateInfo} The current state info of the animator or null if no state is playing
-    */
+    /**
+     * Retrieves information about the current animation state
+     * @returns The current state information, or undefined if no state is playing
+     */
     getCurrentStateInfo(): import("../engine/extensions/NEEDLE_animator_controller_model.js").AnimatorStateInfo | null | undefined;
-    /** The current action playing. It can be used to modify the action
-     * @returns {AnimationAction | null} The current action playing or null if no state is playing
-    */
+    /**
+     * The currently playing animation action that can be used to modify animation properties
+     * @returns The current animation action, or null if no animation is playing
+     */
     get currentAction(): AnimationAction | null;
-    /** @returns {boolean} True if parameters have been changed */
+    /**
+     * Indicates whether animation parameters have been modified since the last update
+     * @returns True if parameters have been changed
+     */
     get parametersAreDirty(): boolean;
     private _parametersAreDirty;
-    /** @returns {boolean} True if the animator has been changed */
+    /**
+     * Indicates whether the animator state has changed since the last update
+     * @returns True if the animator has been changed
+     */
     get isDirty(): boolean;
     private _isDirty;
     /**@deprecated use play() */
     Play(name: string | number, layer?: number, normalizedTime?: number, transitionDurationInSec?: number): void;
-    /** Plays an animation on the animator
-     * @param {string | number} name The name of the animation to play. Can also be the hash of the animation
-     * @param {number} layer The layer to play the animation on. Default is -1
-     * @param {number} normalizedTime The normalized time to start the animation at. Default is Number.NEGATIVE_INFINITY
-     * @param {number} transitionDurationInSec The duration of the transition to the new animation. Default is 0
-     * @returns {void}
-     * */
+    /**
+     * Plays an animation on the animator
+     * @param name The name or hash of the animation to play
+     * @param layer The layer to play the animation on (-1 for default layer)
+     * @param normalizedTime The time position to start playing (0-1 range, NEGATIVE_INFINITY for current position)
+     * @param transitionDurationInSec The duration of the blend transition in seconds
+     */
     play(name: string | number, layer?: number, normalizedTime?: number, transitionDurationInSec?: number): void;
     /**@deprecated use reset */
     Reset(): void;
-    /** Resets the animatorcontroller */
+    /**
+     * Resets the animator controller to its initial state
+     */
     reset(): void;
     /**@deprecated use setBool */
     SetBool(name: string | number, val: boolean): void;
+    /**
+     * Sets a boolean parameter in the animator
+     * @param name The name or hash of the parameter
+     * @param value The boolean value to set
+     */
     setBool(name: string | number, value: boolean): void;
     /**@deprecated use getBool */
     GetBool(name: string | number): boolean;
+    /**
+     * Gets a boolean parameter from the animator
+     * @param name The name or hash of the parameter
+     * @returns The value of the boolean parameter, or false if not found
+     */
     getBool(name: string | number): boolean;
+    /**
+     * Toggles a boolean parameter between true and false
+     * @param name The name or hash of the parameter
+     */
     toggleBool(name: string | number): void;
     /**@deprecated use setFloat */
     SetFloat(name: string | number, val: number): void;
+    /**
+     * Sets a float parameter in the animator
+     * @param name The name or hash of the parameter
+     * @param val The float value to set
+     */
     setFloat(name: string | number, val: number): void;
     /**@deprecated use getFloat */
     GetFloat(name: string | number): number;
+    /**
+     * Gets a float parameter from the animator
+     * @param name The name or hash of the parameter
+     * @returns The value of the float parameter, or -1 if not found
+     */
     getFloat(name: string | number): number;
     /**@deprecated use setInteger */
     SetInteger(name: string | number, val: number): void;
+    /**
+     * Sets an integer parameter in the animator
+     * @param name The name or hash of the parameter
+     * @param val The integer value to set
+     */
     setInteger(name: string | number, val: number): void;
     /**@deprecated use getInteger */
     GetInteger(name: string | number): number;
+    /**
+     * Gets an integer parameter from the animator
+     * @param name The name or hash of the parameter
+     * @returns The value of the integer parameter, or -1 if not found
+     */
     getInteger(name: string | number): number;
     /**@deprecated use setTrigger */
     SetTrigger(name: string | number): void;
+    /**
+     * Activates a trigger parameter in the animator
+     * @param name The name or hash of the trigger parameter
+     */
     setTrigger(name: string | number): void;
     /**@deprecated use resetTrigger */
     ResetTrigger(name: string | number): void;
+    /**
+     * Resets a trigger parameter in the animator
+     * @param name The name or hash of the trigger parameter
+     */
     resetTrigger(name: string | number): void;
     /**@deprecated use getTrigger */
     GetTrigger(name: string | number): void;
+    /**
+     * Gets the state of a trigger parameter from the animator
+     * @param name The name or hash of the trigger parameter
+     * @returns The state of the trigger parameter
+     */
     getTrigger(name: string | number): boolean | undefined;
     /**@deprecated use isInTransition */
     IsInTransition(): boolean;
-    /** @returns `true` if the animator is currently in a transition */
+    /**
+     * Checks if the animator is currently in a transition between states
+     * @returns True if the animator is currently blending between animations
+     */
     isInTransition(): boolean;
     /**@deprecated use setSpeed */
     SetSpeed(speed: number): void;
+    /**
+     * Sets the playback speed of the animator
+     * @param speed The new playback speed multiplier
+     */
     setSpeed(speed: number): void;
-    /** Will generate a random speed between the min and max values and set it to the animatorcontroller */
+    /**
+     * Sets a random playback speed between the min and max values
+     * @param minMax Object with x (minimum) and y (maximum) speed values
+     */
     set minMaxSpeed(minMax: {
         x: number;
         y: number;
     });
+    /**
+     * Sets a random normalized time offset for animations between min (x) and max (y) values
+     * @param minMax Object with x (min) and y (max) values for the offset range
+     */
     set minMaxOffsetNormalized(minMax: {
         x: number;
         y: number;