@zephyr3d/scene 0.7.1 → 0.8.0

package/dist/index.d.ts

@@ -2229,6 +2229,9 @@ declare class LambertMaterial extends LambertMaterial_base implements Clonable<L
  */
 type IMixinBlinnPhong = {
     shininess: number;
+    scatterWrap: number;
+    scatterWidth: number;
+    scatterColor: Vector4;
     blinnPhongLight(scope: PBInsideFunctionScope, worldPos: PBShaderExp, normal: PBShaderExp, viewVec: PBShaderExp, albedo: PBShaderExp, outRoughness?: PBShaderExp): PBShaderExp;
 } & IMixinLight;
 /**
@@ -4919,7 +4922,11 @@ declare class AssetSkeleton extends NamedObject {
     /** Inverse of the binding matrices of the joints */
     inverseBindMatrices: Matrix4x4[];
     /** Binding pose matrices of the joints */
-    bindPoseMatrices: Matrix4x4[];
+    bindPose: {
+        position: Vector3;
+        rotation: Quaternion;
+        scale: Vector3;
+    }[];
     /**
      * Creates an instance of AssetSkeleton
      * @param name - Name of the skeleton
@@ -12092,6 +12099,55 @@ declare class Scene extends Scene_base implements IRenderable {
     protected onDispose(): void;
 }
 
+/**
+ * Abstract base class for skeleton post-processors.
+ *
+ * Post-processors are applied after the base animation/bind pose layer,
+ * allowing procedural modifications like IK, spring physics, or manual overrides.
+ *
+ * @public
+ */
+declare abstract class SkeletonModifier {
+    /** Blend weight for this processor [0-1] */
+    protected _weight: number;
+    /** Whether this processor is enabled */
+    protected _enabled: boolean;
+    constructor(weight?: number);
+    /**
+     * Get the blend weight [0-1]
+     */
+    get weight(): number;
+    /**
+     * Set the blend weight [0-1]
+     */
+    set weight(value: number);
+    /**
+     * Get whether this processor is enabled
+     */
+    get enabled(): boolean;
+    /**
+     * Set whether this processor is enabled
+     */
+    set enabled(value: boolean);
+    /**
+     * Apply post-processing to skeleton joints.
+     *
+     * This method is called after the base animation/bind pose has been applied.
+     * Implementations should modify joint transforms and blend with the current state
+     * using the processor's weight.
+     *
+     * @param skeleton - The skeleton to process
+     * @param deltaTime - Time elapsed since last frame (in seconds)
+     */
+    abstract apply(skeleton: Skeleton, deltaTime: number): void;
+    /**
+     * Reset the processor to its initial state.
+     *
+     * Called when the skeleton or animation state changes significantly.
+     */
+    abstract reset(): void;
+}
+
 /**
  * Skinned bounding box information for a submesh.
  *
@@ -12149,9 +12205,9 @@ declare class Skeleton extends Disposable {
      * @param inverseBindMatrices - Inverse bind matrices for each joint.
      * @param bindPoseMatrices - Bind pose matrices for each joint (model-space).
      */
-    constructor(joints: SceneNode[], inverseBindMatrices: Matrix4x4[], bindPoseMatrices: Matrix4x4[], jointTransforms?: {
-        scale: Vector3;
+    constructor(joints: SceneNode[], inverseBindMatrices: Matrix4x4[], bindPose: {
         rotation: Quaternion;
+        scale: Vector3;
         position: Vector3;
     }[]);
     set playing(b: boolean);
@@ -12162,6 +12218,24 @@ declare class Skeleton extends Disposable {
      * Each matrix is stored in 4 texels (one row per texel, RGBA = 4 floats).
      */
     get jointTexture(): Texture2D<unknown>;
+    /**
+     * Get joint index by joint node
+     * @param joint - joint node
+     * @returns The index of the joint
+     */
+    getJointIndex(joint: SceneNode): number;
+    /**
+     * Get joint index by joint name
+     * @param jointName - joint name
+     * @returns The index of the joint
+     */
+    getJointIndexByName(jointName: string): number;
+    /**
+     * Get all modifiers attached to this skeleton.
+     *
+     * @public
+     */
+    get modifiers(): SkeletonModifier[];
     /**
      * Dispose GPU resources and references held by the skeleton.
      *
@@ -12875,6 +12949,1313 @@ declare class MorphTargetTrack extends AnimationTrack<MorphState> {
     reset(node: SceneNode): void;
 }
 
+/**
+ * Represents a joint in an IK chain.
+ *
+ * @public
+ */
+interface IKJoint {
+    /** The scene node associated with this joint */
+    node: SceneNode;
+    /** Current position in world space (updated during solving) */
+    position: Vector3;
+    /** Original position before solving (for reference) */
+    originalPosition: Vector3;
+    /** Current rotation in world space */
+    rotation: Quaternion;
+    /** Original rotation before solving (for reference) */
+    originalRotation: Quaternion;
+    /** Length of the bone from this joint to the next (0 for end effector) */
+    boneLength: number;
+    /** Previous IK world rotation (for twist continuity across frames) */
+    previousIKRotation?: Quaternion;
+    /** Previous twist angle in radians (for twist smoothing) */
+    previousTwist?: number;
+}
+
+/**
+ * Base class for IK constraints.
+ *
+ * Constraints are applied after each FABRIK iteration to enforce
+ * joint limitations (angle limits, pole vectors, etc.).
+ *
+ * @public
+ */
+declare abstract class IKConstraint {
+    /** The joint index this constraint applies to */
+    protected _jointIndex: number;
+    /**
+     * Create an IK constraint.
+     *
+     * @param jointIndex - Index of the joint in the chain (0 = root)
+     */
+    constructor(jointIndex: number);
+    /**
+     * Get the joint index this constraint applies to.
+     */
+    get jointIndex(): number;
+    /**
+     * Apply the constraint to the joint chain.
+     *
+     * This method modifies joint positions to satisfy the constraint.
+     *
+     * @param joints - Array of all joints in the chain
+     */
+    abstract apply(joints: IKJoint[]): void;
+}
+/**
+ * Twist constraint configuration for a joint.
+ *
+ * @public
+ */
+interface TwistConstraint {
+    /** Minimum twist angle in radians */
+    minTwist: number;
+    /** Maximum twist angle in radians */
+    maxTwist: number;
+    /** Smoothing factor [0-1], 0 = no smoothing, 1 = full smoothing */
+    smoothFactor: number;
+}
+
+/**
+ * Represents a chain of joints for IK solving.
+ *
+ * @public
+ */
+declare class IKChain {
+    /** Array of joints in the chain (root to end effector) */
+    private _joints;
+    /** Total length of the chain */
+    private _totalLength;
+    /** Constraints applied to joints */
+    private _constraints;
+    /**
+     * Create an IK chain from an array of scene nodes.
+     *
+     * @param nodes - Array of scene nodes from root to end effector
+     */
+    constructor(nodes: SceneNode[]);
+    /**
+     * Create an IK chain by traversing from a start node to an end node.
+     *
+     * @remarks
+     * This method walks up the parent chain from the end node until it
+     * reaches the start node, building the joint chain in the process.
+     *
+     * @param startNode - The root joint of the chain
+     * @param endNode - The end effector joint
+     * @returns The created IK chain
+     */
+    static fromNodeHierarchy(startNode: SceneNode, endNode: SceneNode): IKChain;
+    /**
+     * Get all joints in the chain.
+     */
+    get joints(): IKJoint[];
+    /**
+     * Get the root joint (first joint in the chain).
+     */
+    get root(): IKJoint;
+    /**
+     * Get the end effector (last joint in the chain).
+     */
+    get endEffector(): IKJoint;
+    /**
+     * Get the total length of the chain.
+     */
+    get totalLength(): number;
+    /**
+     * Get the number of joints in the chain.
+     */
+    get length(): number;
+    /**
+     * Update joint positions from their scene nodes.
+     */
+    updateFromNodes(): void;
+    /**
+     * Store current positions as original positions.
+     */
+    storeOriginalPositions(): void;
+    /**
+     * Restore joints to their original positions.
+     */
+    restoreOriginalPositions(): void;
+    /**
+     * Add a constraint to a specific joint.
+     *
+     * @param constraint - The constraint to add
+     */
+    addConstraint(constraint: IKConstraint): void;
+    /**
+     * Remove a constraint from the chain.
+     *
+     * @param constraint - The constraint to remove
+     * @returns True if the constraint was found and removed
+     */
+    removeConstraint(constraint: IKConstraint): boolean;
+    /**
+     * Clear all constraints from the chain.
+     */
+    clearConstraints(): void;
+    /**
+     * Get all constraints in the chain.
+     */
+    get constraints(): readonly IKConstraint[];
+    /**
+     * Apply all constraints to the joint chain.
+     */
+    applyConstraints(): void;
+}
+
+/**
+ * Base class for IK solvers.
+ *
+ * @public
+ */
+declare abstract class IKSolver {
+    /** The IK chain to solve */
+    protected _chain: IKChain;
+    /** Maximum number of iterations */
+    protected _maxIterations: number;
+    /** Convergence tolerance (distance threshold) */
+    protected _tolerance: number;
+    /**
+     * Create an IK solver.
+     *
+     * @param chain - The IK chain to solve
+     * @param maxIterations - Maximum number of iterations (default: 10)
+     * @param tolerance - Convergence tolerance in world units (default: 0.001)
+     */
+    constructor(chain: IKChain, maxIterations?: number, tolerance?: number);
+    /**
+     * Get the IK chain.
+     */
+    get chain(): IKChain;
+    /**
+     * Set maximum number of iterations.
+     */
+    setMaxIterations(value: number): void;
+    /**
+     * Get maximum number of iterations.
+     */
+    getMaxIterations(): number;
+    /**
+     * Set convergence tolerance.
+     */
+    setTolerance(value: number): void;
+    /**
+     * Get convergence tolerance.
+     */
+    getTolerance(): number;
+    /**
+     * Solve the IK chain to reach the target position.
+     *
+     * @param target - Target position for the end effector
+     * @returns True if converged, false otherwise
+     */
+    abstract solve(target: Vector3): boolean;
+    /**
+     * Apply the solved positions to the scene nodes as rotations.
+     *
+     * @param weight - Blend weight (0 = original, 1 = full IK)
+     */
+    abstract applyToNodes(weight?: number): void;
+}
+
+/**
+ * Skeleton modifier for IK solvers.
+ *
+ * Integrates IK solving into the skeleton post-processing pipeline.
+ * The IK solver is executed each frame and results are blended with the base animation.
+ *
+ * @public
+ */
+declare class IKModifier<Solver extends IKSolver = IKSolver> extends SkeletonModifier {
+    private _solver;
+    private _target;
+    /**
+     * Create an IK post-processor.
+     *
+     * @param solver - The IK solver to integrate
+     * @param target - Target position for the end effector
+     * @param weight - Blend weight [0-1] (default: 1.0)
+     */
+    constructor(solver: Solver, target: Vector3, weight?: number);
+    /**
+     * Get the IK solver.
+     */
+    get solver(): Solver;
+    /**
+     * Get the current target position.
+     */
+    get target(): Vector3;
+    /**
+     * Set the target position for the end effector.
+     *
+     * @param target - New target position (will be cloned)
+     */
+    setTarget(target: Vector3): void;
+    /**
+     * Apply IK solving to skeleton joints.
+     */
+    apply(_skeleton: Skeleton, _deltaTime: number): void;
+    /**
+     * Reset the IK solver to initial state.
+     */
+    reset(): void;
+}
+
+/**
+ * Represents a particle in the spring system
+ *
+ * @public
+ */
+interface SpringParticle {
+    /** Current position in world space */
+    position: Vector3;
+    /** Previous position for Verlet integration */
+    prevPosition: Vector3;
+    /** Original position for reset */
+    originalPosition: Vector3;
+    /** Original world rotation (for calculating rotation delta) */
+    originalRotation: Quaternion | null;
+    /** Mass of the particle (affects inertia) */
+    mass: number;
+    /** Damping coefficient [0-1] (0 = no damping, 1 = full damping) */
+    damping: number;
+    /** Whether this particle is fixed (anchor point) */
+    fixed: boolean;
+    /** Associated scene node (optional) */
+    node: Nullable<SceneNode>;
+    /** Previous frame position (used to calculate velocity for inertial forces) */
+    lastFramePosition: Vector3;
+    /** Position history for rotation center estimation (for fixed particles) */
+    positionHistory?: Vector3[];
+}
+/**
+ * Creates a new spring particle
+ *
+ * @public
+ */
+declare function createSpringParticle(position: Vector3, options?: {
+    mass?: number;
+    damping?: number;
+    fixed?: boolean;
+    node?: SceneNode;
+    originalRotation?: Quaternion;
+}): SpringParticle;
+
+/**
+ * Represents a spring constraint between two particles
+ *
+ * @public
+ */
+interface SpringConstraint {
+    /** Index of the first particle */
+    particleA: number;
+    /** Index of the second particle */
+    particleB: number;
+    /** Rest length of the spring */
+    restLength: number;
+    /** Stiffness coefficient [0-1] used by Verlet solver (0 = no constraint, 1 = rigid) */
+    stiffness: number;
+    /**
+     * XPBD compliance (inverse stiffness) in m/N.
+     * 0 = perfectly rigid, larger values = softer spring.
+     * Typical ranges: 0 (rigid) ~ 1e-7 (very stiff) ~ 1e-3 (soft cloth) ~ 1e-1 (rubber band).
+     * Only used when solver is 'xpbd'.
+     */
+    compliance: number;
+    /**
+     * XPBD Lagrange multiplier accumulator, reset to 0 at the start of each time step.
+     * Managed internally by the solver — do not set manually.
+     */
+    lambda: number;
+}
+/**
+ * Creates a new spring constraint
+ *
+ * @public
+ */
+declare function createSpringConstraint(particleA: number, particleB: number, restLength: number, stiffness?: number, compliance?: number): SpringConstraint;
+
+/**
+ * Manages a chain of spring particles and constraints
+ *
+ * @public
+ */
+declare class SpringChain {
+    /** Array of particles in the chain */
+    particles: SpringParticle[];
+    /** Array of constraints between particles */
+    constraints: SpringConstraint[];
+    constructor();
+    /**
+     * Creates a spring chain from a bone hierarchy
+     * @param startNode - Root node of the bone chain
+     * @param endNode - End node of the bone chain (optional, if null uses all descendants)
+     * @param options - Additional options
+     * @returns A new SpringChain instance
+     */
+    static fromBoneChain(startNode: SceneNode, endNode?: SceneNode | null, options?: {
+        mass?: number;
+        damping?: number;
+        stiffness?: number;
+    }): SpringChain;
+    /**
+     * Adds a particle to the chain
+     * @param particle - The particle to add
+     * @returns The index of the added particle
+     */
+    addParticle(particle: SpringParticle): number;
+    /**
+     * Adds a constraint to the chain
+     * @param constraint - The constraint to add
+     */
+    addConstraint(constraint: SpringConstraint): void;
+    /**
+     * Adds cross constraints between particles for cloth-like behavior
+     * @param stiffness - Stiffness of the cross constraints
+     * @param skipDistance - Distance between particles to connect (default: 2)
+     */
+    addCrossConstraints(stiffness?: number, skipDistance?: number): void;
+    /**
+     * Resets all particles to their original positions
+     */
+    reset(): void;
+}
+
+/**
+ * Base interface for spring collision shapes
+ *
+ * @public
+ */
+interface SpringCollider {
+    /** Type of collider */
+    type: 'sphere' | 'capsule' | 'plane';
+    /** Associated scene node (optional, for dynamic colliders) */
+    node?: Nullable<SceneNode>;
+    /** Whether this collider is enabled */
+    enabled: boolean;
+}
+/**
+ * Sphere collider for spring collision detection
+ *
+ * @public
+ */
+interface SphereCollider extends SpringCollider {
+    type: 'sphere';
+    /** Center position in world space */
+    center: Vector3;
+    /** Radius of the sphere */
+    radius: number;
+    /** Local offset from node (if node is set) */
+    localOffset?: Vector3;
+}
+/**
+ * Capsule collider for spring collision detection
+ *
+ * @public
+ */
+interface CapsuleCollider extends SpringCollider {
+    type: 'capsule';
+    /** Start point of the capsule axis in world space */
+    start: Vector3;
+    /** End point of the capsule axis in world space */
+    end: Vector3;
+    /** Radius of the capsule */
+    radius: number;
+    /** Local start offset from node (if node is set) */
+    localStartOffset?: Vector3;
+    /** Local end offset from node (if node is set) */
+    localEndOffset?: Vector3;
+}
+/**
+ * Plane collider for spring collision detection
+ *
+ * @public
+ */
+interface PlaneCollider extends SpringCollider {
+    type: 'plane';
+    /** Point on the plane in world space */
+    point: Vector3;
+    /** Normal vector of the plane (should be normalized) */
+    normal: Vector3;
+    /** Local point offset from node (if node is set) */
+    localPointOffset?: Vector3;
+    /** Local normal direction (if node is set) */
+    localNormal?: Vector3;
+}
+/**
+ * Creates a sphere collider
+ * @param centerOrOffset - Center position in world space, or local offset if node is provided
+ * @param radius - Radius of the sphere
+ * @param node - Optional scene node to attach to (if provided, centerOrOffset is treated as local offset)
+ *
+ * @public
+ */
+declare function createSphereCollider(centerOrOffset: Vector3, radius: number, node?: SceneNode): SphereCollider;
+/**
+ * Creates a capsule collider
+ * @param startOrOffset - Start point in world space, or local offset if node is provided
+ * @param endOrOffset - End point in world space, or local offset if node is provided
+ * @param radius - Radius of the capsule
+ * @param node - Optional scene node to attach to (if provided, offsets are treated as local)
+ *
+ * @public
+ */
+declare function createCapsuleCollider(startOrOffset: Vector3, endOrOffset: Vector3, radius: number, node?: SceneNode): CapsuleCollider;
+/**
+ * Creates a plane collider
+ * @param pointOrOffset - Point on plane in world space, or local offset if node is provided
+ * @param normal - Normal vector (will be normalized)
+ * @param node - Optional scene node to attach to (if provided, pointOrOffset is treated as local offset)
+ *
+ * @public
+ */
+declare function createPlaneCollider(pointOrOffset: Vector3, normal: Vector3, node?: SceneNode): PlaneCollider;
+/**
+ * Resolves collision between a particle and a sphere collider
+ * @returns true if collision occurred
+ *
+ * @public
+ */
+declare function resolveSphereCollision(particlePos: Vector3, collider: SphereCollider): boolean;
+/**
+ * Resolves collision between a particle and a capsule collider
+ * @returns true if collision occurred
+ *
+ * @public
+ */
+declare function resolveCapsuleCollision(particlePos: Vector3, collider: CapsuleCollider): boolean;
+/**
+ * Resolves collision between a particle and a plane collider
+ * @returns true if collision occurred
+ *
+ * @public
+ */
+declare function resolvePlaneCollision(particlePos: Vector3, collider: PlaneCollider): boolean;
+/**
+ * Updates collider position from its associated node
+ *
+ * @public
+ */
+declare function updateColliderFromNode(collider: SpringCollider): void;
+
+/**
+ * Options for creating a SpringSystem
+ *
+ * @public
+ */
+interface SpringSystemOptions {
+    /** Number of constraint solver iterations (default: 5) */
+    iterations?: number;
+    /** Gravity force vector (default: (0, -9.8, 0)) */
+    gravity?: Vector3;
+    /** Wind force vector (default: (0, 0, 0)) */
+    wind?: Vector3;
+    /** Enable inertial forces (centrifugal/Coriolis) when root rotates (default: true) */
+    enableInertialForces?: boolean;
+    /** Centrifugal force multiplier (default: 1.0) */
+    centrifugalScale?: number;
+    /** Coriolis force multiplier (default: 1.0) */
+    coriolisScale?: number;
+    /**
+     * Constraint solver type (default: 'verlet').
+     * - 'verlet': Classic Verlet integration with iterative position correction.
+     *   stiffness [0-1] controls correction strength per iteration.
+     * - 'xpbd': Extended Position-Based Dynamics (Müller et al. 2020).
+     *   Uses compliance (inverse stiffness in m/N) for physically correct,
+     *   iteration-count-independent constraint solving.
+     */
+    solver?: 'verlet' | 'xpbd';
+}
+/**
+ * Physics engine for spring-based particle simulation
+ * Uses Verlet integration and iterative constraint solving
+ *
+ * @public
+ */
+declare class SpringSystem {
+    private _chain;
+    private _iterations;
+    private _gravity;
+    private _wind;
+    private _enableInertialForces;
+    private _centrifugalScale;
+    private _coriolisScale;
+    private _colliders;
+    private _solver;
+    constructor(chain: SpringChain, options?: SpringSystemOptions);
+    /**
+     * Updates the physics simulation
+     * @param deltaTime - Time step in seconds
+     */
+    update(deltaTime: number): void;
+    /**
+     * Updates fixed particles to match their scene node positions
+     */
+    private updateFixedParticles;
+    /**
+     * Calculates global rotation parameters from fixed particle movements
+     * Uses position history to estimate rotation center
+     */
+    private calculateGlobalRotation;
+    /**
+     * Estimates rotation center from a single particle's position history
+     * Uses circular motion fitting
+     */
+    private estimateRotationCenterFromHistory;
+    /**
+     * Calculates the center of a circle passing through 3 points
+     * Uses perpendicular bisector method
+     */
+    private calculateCircleCenter;
+    /**
+     * Calculates inertial acceleration for a particle in a rotating reference frame
+     */
+    private calculateInertialAcceleration;
+    /**
+     * Solves a single spring constraint using XPBD (Extended Position-Based Dynamics).
+     *
+     * Reference: Müller et al., "Detailed Rigid Body Simulation with Extended Position Based Dynamics", 2020.
+     *
+     * The XPBD correction for a distance constraint C(x) = |x_b - x_a| - L is:
+     *   α̃ = compliance / dt²          (scaled compliance)
+     *   Δλ = (-C - α̃·λ) / (w_a + w_b + α̃)
+     *   λ  += Δλ
+     *   Δx_a = -w_a · Δλ · n̂
+     *   Δx_b = +w_b · Δλ · n̂
+     * where w = 1/mass (0 for fixed particles), n̂ = unit vector from a to b.
+     */
+    private solveConstraintXPBD;
+    /**
+     * Solves a single spring constraint (Verlet / PBD)
+     */
+    private solveConstraint;
+    /**
+     * Solves collisions for all particles
+     */
+    private solveCollisions;
+    /**
+     * Applies simulation results to scene nodes
+     * @param weight - Blend weight [0-1] (default: 1.0)
+     */
+    applyToNodes(weight?: number): void;
+    /**
+     * Resets the simulation to initial state
+     */
+    reset(): void;
+    /**
+     * Gets the spring chain
+     */
+    get chain(): SpringChain;
+    /**
+     * Gets the current gravity
+     */
+    get gravity(): Vector3;
+    set gravity(gravity: Vector3);
+    /**
+     * Gets the current wind
+     */
+    get wind(): Vector3;
+    set wind(wind: Vector3);
+    /**
+     * Gets the number of iterations
+     */
+    get iterations(): number;
+    set iterations(count: number);
+    /**
+     * Gets whether inertial forces are enabled
+     */
+    get enableInertialForces(): boolean;
+    set enableInertialForces(enabled: boolean);
+    /**
+     * Gets the centrifugal force scale
+     */
+    get centrifugalScale(): number;
+    set centrifugalScale(scale: number);
+    /**
+     * Gets the Coriolis force scale
+     */
+    get coriolisScale(): number;
+    /**
+     * Sets the Coriolis force scale
+     */
+    set coriolisScale(scale: number);
+    /**
+     * Gets the constraint solver type
+     */
+    get solver(): 'verlet' | 'xpbd';
+    /**
+     * Sets the constraint solver type.
+     * Switching to 'xpbd' resets all Lagrange multipliers.
+     */
+    set solver(type: 'verlet' | 'xpbd');
+    /**
+     * Adds a collider to the system
+     */
+    addCollider(collider: SpringCollider): void;
+    /**
+     * Removes a collider from the system
+     */
+    removeCollider(collider: SpringCollider): boolean;
+    /**
+     * Clears all colliders
+     */
+    clearColliders(): void;
+    /**
+     * Gets all colliders
+     */
+    get colliders(): SpringCollider[];
+}
+
+/**
+ * Post-processor wrapper for spring physics systems.
+ *
+ * Integrates spring-based physics simulation into the skeleton post-processing pipeline.
+ * The spring system is updated each frame and results are blended with the base animation.
+ *
+ * @public
+ */
+declare class SpringModifier extends SkeletonModifier {
+    private _springSystem;
+    /**
+     * Create a spring post-processor.
+     *
+     * @param springSystem - The spring system to integrate
+     * @param weight - Blend weight [0-1] (default: 1.0)
+     */
+    constructor(springSystem: SpringSystem, weight?: number);
+    /**
+     * Get the spring system.
+     */
+    get springSystem(): SpringSystem;
+    /**
+     * Apply spring physics to skeleton joints.
+     */
+    apply(_skeleton: Skeleton, deltaTime: number): void;
+    /**
+     * Reset the spring system to initial state.
+     */
+    reset(): void;
+}
+
+/**
+ * FABRIK (Forward And Backward Reaching Inverse Kinematics) solver.
+ *
+ * @remarks
+ * FABRIK is an iterative IK algorithm that alternates between:
+ * 1. Forward pass: Move from end effector to root, pulling joints toward target
+ * 2. Backward pass: Move from root to end effector, restoring root position
+ *
+ * Supports multiple pole vectors to control the bending direction of different joints.
+ *
+ * @public
+ */
+declare class FABRIKSolver extends IKSolver {
+    /** Map of joint index to pole vector configuration */
+    private _poleVectors;
+    /** Twist constraints for each joint (indexed by joint index) */
+    private _twistConstraints;
+    /**
+     * Create a FABRIK solver.
+     *
+     * @param chain - The IK chain to solve
+     * @param maxIterations - Maximum number of iterations (default: 15)
+     * @param tolerance - Convergence tolerance in world units (default: 0.001)
+     */
+    constructor(chain: IKChain, maxIterations?: number, tolerance?: number);
+    /**
+     * Set twist constraint for a specific joint.
+     *
+     * @param jointIndex - Index of the joint
+     * @param minTwist - Minimum twist angle in radians
+     * @param maxTwist - Maximum twist angle in radians
+     * @param smoothFactor - Smoothing factor [0-1] (default: 0.3)
+     */
+    setTwistConstraint(jointIndex: number, minTwist: number, maxTwist: number, smoothFactor?: number): void;
+    /**
+     * Get twist constraint for a specific joint.
+     *
+     * @param jointIndex - Index of the joint
+     * @returns Twist constraint or undefined if not set
+     */
+    getTwistConstraint(jointIndex: number): TwistConstraint | undefined;
+    /**
+     * Remove twist constraint for a specific joint.
+     *
+     * @param jointIndex - Index of the joint
+     * @returns True if a constraint was removed
+     */
+    removeTwistConstraint(jointIndex: number): boolean;
+    /**
+     * Clear all twist constraints.
+     */
+    clearTwistConstraints(): void;
+    /**
+     * Set pole vector for a specific joint.
+     *
+     * @param jointIndex - Index of the joint to apply pole vector to
+     * @param poleVector - Pole vector position in world space
+     * @param weight - Weight of the pole vector constraint (0-1, default: 1)
+     */
+    setPoleVector(jointIndex: number, poleVector: Vector3, weight?: number): void;
+    /**
+     * Remove pole vector for a specific joint.
+     *
+     * @param jointIndex - Index of the joint to remove pole vector from
+     * @returns True if a pole vector was removed, false if none existed
+     */
+    removePoleVector(jointIndex: number): boolean;
+    /**
+     * Clear all pole vectors.
+     */
+    clearPoleVectors(): void;
+    /**
+     * Get pole vector configuration for a specific joint.
+     *
+     * @param jointIndex - Index of the joint
+     * @returns Pole vector configuration or undefined if not set
+     */
+    getPoleVector(jointIndex: number): {
+        position: Vector3;
+        weight: number;
+    } | undefined;
+    /**
+     * Check if a joint has a pole vector.
+     *
+     * @param jointIndex - Index of the joint
+     * @returns True if the joint has a pole vector
+     */
+    hasPoleVector(jointIndex: number): boolean;
+    /**
+     * Solve the IK chain to reach the target position using FABRIK algorithm.
+     *
+     * @param target - Target position for the end effector
+     * @returns True if converged within tolerance, false otherwise
+     */
+    solve(target: Vector3): boolean;
+    /**
+     * Apply the solved joint positions to scene nodes as rotations.
+     *
+     * @param weight - Blend weight (0 = original, 1 = full IK, default: 1)
+     */
+    applyToNodes(weight?: number): void;
+    /**
+     * Forward pass: move from end effector toward root.
+     * Each joint is pulled toward its child, maintaining bone length.
+     * Constraints are applied immediately after each joint adjustment.
+     *
+     * @param target - Target position for end effector
+     */
+    private _forwardPass;
+    /**
+     * Backward pass: move from root toward end effector.
+     * Each joint is pulled toward its parent, maintaining bone length.
+     * Constraints are applied immediately after each joint adjustment.
+     *
+     * @param rootPos - Original root position to restore
+     */
+    private _backwardPass;
+    /**
+     * Apply constraints for a specific joint.
+     * This is called during the FABRIK passes to integrate constraints into the algorithm.
+     *
+     * @param jointIndex - Index of the joint to apply constraints to
+     */
+    private _applyConstraintsForJoint;
+    /**
+     * Apply pole vector twist to a specific joint.
+     *
+     * @remarks
+     * This method adjusts the joint position to align with the pole vector.
+     * It uses the same algorithm as IKPoleVectorConstraint but is integrated
+     * into the solver for better performance and control.
+     *
+     * @param jointIndex - Index of the pole joint
+     * @param poleVector - Pole vector position in world space
+     * @param weight - Weight of the pole vector constraint (0-1)
+     */
+    private _applyPoleVectorTwist;
+    /**
+     * Stretch the chain toward an unreachable target.
+     * All joints are aligned in a straight line toward the target.
+     *
+     * @param target - Unreachable target position
+     */
+    private _stretchToward;
+}
+
+/**
+ * Two Bone IK solver for chains with exactly 3 joints (2 bones).
+ *
+ * @remarks
+ * This solver uses an analytical solution specifically optimized for
+ * two-bone chains like arms (shoulder-elbow-wrist) or legs (hip-knee-ankle).
+ * It's faster and more stable than iterative methods like FABRIK for this case.
+ *
+ * The solver supports an optional pole vector to control the bending direction
+ * of the middle joint (elbow/knee).
+ *
+ * @public
+ */
+declare class TwoBoneIKSolver extends IKSolver {
+    /** Optional pole vector position in world space */
+    private _poleVector;
+    /** Weight of the pole vector constraint (0-1) */
+    private _poleWeight;
+    /** Twist constraints for each joint (indexed by joint index) */
+    private _twistConstraints;
+    /**
+     * Create a Two Bone IK solver.
+     *
+     * @param chain - The IK chain to solve (must have exactly 3 joints)
+     * @param poleVector - Optional pole vector position in world space
+     * @param poleWeight - Weight of the pole vector constraint (0-1, default: 1)
+     */
+    constructor(chain: IKChain, poleVector?: Vector3 | null, poleWeight?: number);
+    /**
+     * Set twist constraint for a specific joint.
+     *
+     * @param jointIndex - Index of the joint (0 = root, 1 = middle)
+     * @param minTwist - Minimum twist angle in radians
+     * @param maxTwist - Maximum twist angle in radians
+     * @param smoothFactor - Smoothing factor [0-1] (default: 0.3)
+     */
+    setTwistConstraint(jointIndex: number, minTwist: number, maxTwist: number, smoothFactor?: number): void;
+    /**
+     * Get twist constraint for a specific joint.
+     *
+     * @param jointIndex - Index of the joint
+     * @returns Twist constraint or undefined if not set
+     */
+    getTwistConstraint(jointIndex: number): TwistConstraint | undefined;
+    /**
+     * Remove twist constraint for a specific joint.
+     *
+     * @param jointIndex - Index of the joint
+     * @returns True if a constraint was removed
+     */
+    removeTwistConstraint(jointIndex: number): boolean;
+    /**
+     * Clear all twist constraints.
+     */
+    clearTwistConstraints(): void;
+    /**
+     * Get the pole vector position.
+     */
+    get poleVector(): Vector3 | null;
+    /**
+     * Set the pole vector position.
+     */
+    set poleVector(value: Vector3 | null);
+    /**
+     * Get the pole vector weight.
+     */
+    get poleWeight(): number;
+    /**
+     * Set the pole vector weight (0-1).
+     */
+    set poleWeight(value: number);
+    /**
+     * Solve the IK chain to reach the target position using Two Bone IK algorithm.
+     *
+     * @param target - Target position for the end effector
+     * @returns True if the target is reachable, false if stretched to maximum
+     */
+    solve(target: Vector3): boolean;
+    /**
+     * Apply all constraints to the joint chain.
+     * After applying constraints, we need to restore bone lengths.
+     */
+    private _applyConstraints;
+    /**
+     * Restore bone lengths after constraints have been applied.
+     * This ensures that the chain maintains correct bone lengths.
+     */
+    private _restoreBoneLengths;
+    /**
+     * Apply the solved joint positions to scene nodes as rotations.
+     *
+     * @param weight - Blend weight (0 = original, 1 = full IK, default: 1)
+     */
+    applyToNodes(weight?: number): void;
+    /**
+     * Get a default bend normal when no pole vector is specified.
+     * This tries to find a reasonable perpendicular direction.
+     *
+     * @param rootToTarget - Direction from root to target
+     * @returns A normalized perpendicular vector
+     */
+    private _getDefaultBendNormal;
+}
+
+/**
+ * CCD (Cyclic Coordinate Descent) IK solver.
+ *
+ * @remarks
+ * CCD is an iterative IK algorithm that works by:
+ * 1. Starting from the joint closest to the end effector
+ * 2. Rotating each joint to point the end effector toward the target
+ * 3. Moving backward through the chain to the root
+ * 4. Repeating until convergence or max iterations
+ *
+ * CCD is generally faster than FABRIK and works well for chains of any length.
+ * It's particularly good for tentacles, tails, and other flexible chains.
+ *
+ * Supports multiple pole vectors to control the bending direction of different joints.
+ *
+ * @public
+ */
+declare class CCDSolver extends IKSolver {
+    /** Map of joint index to pole vector configuration */
+    private _poleVectors;
+    /** Twist constraints for each joint (indexed by joint index) */
+    private _twistConstraints;
+    /**
+     * Create a CCD solver.
+     *
+     * @param chain - The IK chain to solve
+     * @param maxIterations - Maximum number of iterations (default: 10)
+     * @param tolerance - Convergence tolerance in world units (default: 0.001)
+     */
+    constructor(chain: IKChain, maxIterations?: number, tolerance?: number);
+    /**
+     * Set twist constraint for a specific joint.
+     *
+     * @param jointIndex - Index of the joint
+     * @param minTwist - Minimum twist angle in radians
+     * @param maxTwist - Maximum twist angle in radians
+     * @param smoothFactor - Smoothing factor [0-1] (default: 0.3)
+     */
+    setTwistConstraint(jointIndex: number, minTwist: number, maxTwist: number, smoothFactor?: number): void;
+    /**
+     * Get twist constraint for a specific joint.
+     *
+     * @param jointIndex - Index of the joint
+     * @returns Twist constraint or undefined if not set
+     */
+    getTwistConstraint(jointIndex: number): TwistConstraint | undefined;
+    /**
+     * Remove twist constraint for a specific joint.
+     *
+     * @param jointIndex - Index of the joint
+     * @returns True if a constraint was removed
+     */
+    removeTwistConstraint(jointIndex: number): boolean;
+    /**
+     * Clear all twist constraints.
+     */
+    clearTwistConstraints(): void;
+    /**
+     * Set pole vector for a specific joint.
+     *
+     * @param jointIndex - Index of the joint to apply pole vector to
+     * @param poleVector - Pole vector position in world space
+     * @param weight - Weight of the pole vector constraint (0-1, default: 1)
+     */
+    setPoleVector(jointIndex: number, poleVector: Vector3, weight?: number): void;
+    /**
+     * Remove pole vector for a specific joint.
+     *
+     * @param jointIndex - Index of the joint to remove pole vector from
+     * @returns True if a pole vector was removed, false if none existed
+     */
+    removePoleVector(jointIndex: number): boolean;
+    /**
+     * Clear all pole vectors.
+     */
+    clearPoleVectors(): void;
+    /**
+     * Get pole vector configuration for a specific joint.
+     *
+     * @param jointIndex - Index of the joint
+     * @returns Pole vector configuration or undefined if not set
+     */
+    getPoleVector(jointIndex: number): {
+        position: Vector3;
+        weight: number;
+    } | undefined;
+    /**
+     * Check if a joint has a pole vector.
+     *
+     * @param jointIndex - Index of the joint
+     * @returns True if the joint has a pole vector
+     */
+    hasPoleVector(jointIndex: number): boolean;
+    /**
+     * Solve the IK chain to reach the target position using CCD algorithm.
+     *
+     * @param target - Target position for the end effector
+     * @returns True if converged within tolerance, false otherwise
+     */
+    solve(target: Vector3): boolean;
+    /**
+     * Rotate all joints from the given index to the end effector around a pivot point.
+     *
+     * @param startIndex - Index of the joint to start rotating from
+     * @param rotation - Rotation to apply
+     * @param pivot - Pivot point for rotation (position of the joint being adjusted)
+     */
+    private _rotateJointsFromIndex;
+    /**
+     * Apply all pole vector constraints.
+     *
+     * @remarks
+     * This method applies all configured pole vectors to their respective joints.
+     * Pole vectors are applied in reverse order (from end to root) to minimize
+     * interference between multiple pole vectors. This ensures that pole vectors
+     * closer to the end effector are not affected by pole vectors closer to the root.
+     */
+    private _applyAllPoleVectors;
+    /**
+     * Apply pole vector twist to a specific joint.
+     *
+     * @remarks
+     * This method is called after the base CCD rotation has been applied.
+     * It adds an additional twist rotation around the joint-to-end axis
+     * to make the next joint (child) bend toward the pole vector.
+     *
+     * @param jointIndex - Index of the pole joint
+     * @param poleVector - Pole vector position in world space
+     * @param weight - Weight of the pole vector constraint (0-1)
+     */
+    private _applyPoleVectorTwist;
+    /**
+     * Apply constraints for a specific joint.
+     *
+     * @param jointIndex - Index of the joint to apply constraints to
+     */
+    private _applyConstraintsForJoint;
+    /**
+     * Apply the solved joint positions to scene nodes as rotations.
+     *
+     * @param weight - Blend weight (0 = original, 1 = full IK, default: 1)
+     */
+    applyToNodes(weight?: number): void;
+}
+
+/**
+ * Angle constraint for IK joints.
+ *
+ * Limits the angle between the bone from parent to this joint
+ * and the bone from this joint to child.
+ *
+ * @remarks
+ * This is useful for joints like elbows and knees that have
+ * limited range of motion.
+ *
+ * @public
+ */
+declare class IKAngleConstraint extends IKConstraint {
+    /** Minimum angle in degrees */
+    private _minAngle;
+    /** Maximum angle in degrees */
+    private _maxAngle;
+    /**
+     * Create an angle constraint.
+     *
+     * @param jointIndex - Index of the joint in the chain
+     * @param minAngle - Minimum angle in degrees (0 = straight)
+     * @param maxAngle - Maximum angle in degrees (180 = fully bent)
+     */
+    constructor(jointIndex: number, minAngle: number, maxAngle: number);
+    /**
+     * Get the minimum angle in degrees.
+     */
+    get minAngle(): number;
+    /**
+     * Set the minimum angle in degrees.
+     */
+    set minAngle(value: number);
+    /**
+     * Get the maximum angle in degrees.
+     */
+    get maxAngle(): number;
+    /**
+     * Set the maximum angle in degrees.
+     */
+    set maxAngle(value: number);
+    /**
+     * Apply the angle constraint to limit joint bending.
+     */
+    apply(joints: IKJoint[]): void;
+    /**
+     * Apply constraint to end effector joint.
+     */
+    private _applyEndEffectorConstraint;
+    /**
+     * Apply constraint to regular joint.
+     */
+    private _applyRegularConstraint;
+    /**
+     * Adjust joint angle by rotating the outgoing bone.
+     */
+    private _adjustJointAngle;
+}
+
+/**
+ * Constraint between particles in different chains
+ *
+ * @public
+ */
+interface InterChainConstraint {
+    /** Index of the first chain */
+    chainAIndex: number;
+    /** Index of the second chain */
+    chainBIndex: number;
+    /** Index of particle in chain A */
+    particleAIndex: number;
+    /** Index of particle in chain B */
+    particleBIndex: number;
+    /** Desired distance between particles */
+    restLength: number;
+    /** Constraint strength [0-1], used by Verlet solver */
+    stiffness: number;
+    /**
+     * XPBD compliance (inverse stiffness) in m/N.
+     * Only used when solver is 'xpbd'.
+     */
+    compliance: number;
+    /** XPBD Lagrange multiplier accumulator, reset each time step. */
+    lambda: number;
+}
+/**
+ * Options for creating a MultiChainSpringSystem
+ *
+ * @public
+ */
+interface MultiChainSpringSystemOptions {
+    /** Number of constraint solver iterations (default: 5) */
+    iterations?: number;
+    /** Gravity force vector (default: (0, -9.8, 0)) */
+    gravity?: Vector3;
+    /** Wind force vector (default: (0, 0, 0)) */
+    wind?: Vector3;
+    /** Enable inertial forces (centrifugal/Coriolis) when root rotates (default: true) */
+    enableInertialForces?: boolean;
+    /** Centrifugal force multiplier (default: 1.0) */
+    centrifugalScale?: number;
+    /** Coriolis force multiplier (default: 1.0) */
+    coriolisScale?: number;
+    /**
+     * Constraint solver type (default: 'verlet').
+     * - 'verlet': stiffness [0-1] controls per-iteration correction strength.
+     * - 'xpbd': compliance (m/N) gives physically correct, iteration-independent results.
+     */
+    solver?: 'verlet' | 'xpbd';
+}
+/**
+ * Physics engine for multiple spring chains with inter-chain constraints
+ * Suitable for cloth, skirts, capes, and other multi-chain simulations
+ *
+ * @public
+ */
+declare class MultiChainSpringSystem {
+    private _chains;
+    private _interChainConstraints;
+    private _iterations;
+    private _gravity;
+    private _wind;
+    private _enableInertialForces;
+    private _centrifugalScale;
+    private _coriolisScale;
+    private _solver;
+    constructor(options?: MultiChainSpringSystemOptions);
+    /**
+     * Adds a spring chain to the system
+     * @param chain - The chain to add
+     * @returns The index of the added chain
+     */
+    addChain(chain: SpringChain): number;
+    /**
+     * Adds an inter-chain constraint
+     * @param constraint - The constraint to add
+     */
+    addInterChainConstraint(constraint: InterChainConstraint): void;
+    /**
+     * Creates radial constraints between adjacent chains
+     * Useful for skirts, capes, and other radial multi-chain structures
+     * @param options - Configuration options
+     */
+    createRadialConstraints(options: {
+        /** Constraint stiffness [0-1], used by Verlet solver */
+        stiffness: number;
+        /** Maximum distance to create constraints (particles further apart are not connected) */
+        maxDistance: number;
+        /** Skip first N rows of particles (e.g., anchor points at waist) */
+        skipRows?: number;
+        /** Connect to next N chains (default: 1, only adjacent chains) */
+        connectDistance?: number;
+        /** XPBD compliance in m/N (default: 0 = rigid). Only used when solver is 'xpbd'. */
+        compliance?: number;
+    }): void;
+    /**
+     * Updates the physics simulation for all chains
+     * @param deltaTime - Time step in seconds
+     */
+    update(deltaTime: number): void;
+    private updateFixedParticles;
+    private calculateGlobalRotation;
+    private estimateRotationCenterFromHistory;
+    private calculateCircleCenter;
+    private calculateInertialAcceleration;
+    private solveConstraint;
+    private solveInterChainConstraint;
+    private solveConstraintXPBD;
+    private solveInterChainConstraintXPBD;
+    /**
+     * Applies simulation results to scene nodes
+     * @param weight - Blend weight [0-1] (default: 1.0)
+     */
+    applyToNodes(weight?: number): void;
+    private applyChainToNodes;
+    /**
+     * Resets the simulation to initial state
+     */
+    reset(): void;
+    /**
+     * Gets the spring chains
+     */
+    get chains(): SpringChain[];
+    /**
+     * Gets the inter-chain constraints
+     */
+    get interChainConstraints(): InterChainConstraint[];
+    /**
+     * Gets the current gravity
+     */
+    get gravity(): Vector3;
+    set gravity(gravity: Vector3);
+    /**
+     * Gets the current wind
+     */
+    get wind(): Vector3;
+    set wind(wind: Vector3);
+    /**
+     * Gets the number of iterations
+     */
+    get iterations(): number;
+    set iterations(count: number);
+    /**
+     * Gets whether inertial forces are enabled
+     */
+    get enableInertialForces(): boolean;
+    set enableInertialForces(enabled: boolean);
+    /**
+     * Gets the centrifugal force scale
+     */
+    get centrifugalScale(): number;
+    set centrifugalScale(scale: number);
+    /**
+     * Gets the Coriolis force scale
+     */
+    get coriolisScale(): number;
+    set coriolisScale(scale: number);
+    get solver(): 'verlet' | 'xpbd';
+    set solver(type: 'verlet' | 'xpbd');
+}
+
 /**
  * Manages serialization and deserialization of engine objects to/from JSON,
  * including asset resolution via a virtual file system (VFS) and asset manager.
@@ -18961,4 +20342,4 @@ declare const ATMOSPHERIC_FOG_BIT: number;
  */
 declare const HEIGHT_FOG_BIT: number;
 
-export { AABBTree, ABufferOIT, ATMOSPHERIC_FOG_BIT, AbsNode, AbstractPostEffect, AllConditionNode, AnimationClip, AnimationSet, AnimationTrack, AnyConditionNode, type AppCreationOptions, type AppOptions, Application, ArcCosNode, ArcSinNode, ArcTan2Node, ArcTanNode, ArccosineHNode, ArcsineHNode, ArctangentHNode, type AssetAnimationData, type AssetAnimationTrack, AssetHierarchyNode, AssetManager, type AssetMaterial, type AssetMaterialClearcoat, type AssetMaterialCommon, type AssetMaterialIridescence, type AssetMaterialSheen, type AssetMaterialTransmission, type AssetMeshData, type AssetPBRMaterialCommon, type AssetPBRMaterialMR, type AssetPBRMaterialSG, type AssetRotationTrack, type AssetScaleTrack, AssetScene, type AssetSkeletalAnimationTrack, AssetSkeleton, type AssetSubMeshData, type AssetTranslationTrack, type AssetUnlitMaterial, BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, BaseCameraController, BaseGraphNode, BaseLight, BaseSprite, BaseTextureNode, type BatchDrawable, BatchGroup, BillboardMatrixNode, type BlendMode, BlinnMaterial, type BlitType, Blitter, Bloom, type BluePrintEditorState, type BluePrintUniformTexture, type BluePrintUniformValue, type BlueprintDAG, BoundingBox, type BoundingVolume, type BoxCreationOptions, BoxFilterBlitter, BoxFrameShape, BoxShape, type CachedBindGroup, Camera, type CameraHistoryData, CameraNearFarNode, CameraPositionNode, CeilNode, ClampNode, ClipmapTerrain, ClipmapTerrainMaterial, CompAddNode, CompComparisonNode, CompDivNode, CompMulNode, CompSubNode, type ComparisonMode, Compositor, type CompositorContext, ConstantBVec2Node, ConstantBVec3Node, ConstantBVec4Node, ConstantBooleanNode, ConstantScalarNode, ConstantTexture2DArrayNode, ConstantTexture2DNode, ConstantTextureCubeNode, ConstantVec2Node, ConstantVec3Node, ConstantVec4Node, CopyBlitter, CosHNode, CosNode, CrossProductNode, CubemapSHProjector, CullVisitor, type CylinderCreationOptions, CylinderShape, DDXNode, DDYNode, Degrees2RadiansNode, DepthPass, DirectionalLight, DistanceNode, DotProductNode, DracoMeshDecoder, type DrawContext, type Drawable, type DrawableInstanceInfo, type EditorMode, ElapsedTimeNode, type EmitterBehavior, type EmitterShape, Engine, EnvConstantAmbient, EnvHemisphericAmbient, type EnvLightType, EnvLightWrapper, EnvShIBL, Environment, EnvironmentLighting, EqualNode, Exp2Node, ExpNode, type ExtractMixinReturnType, type ExtractMixinType, FBMWaveGenerator, FFTWaveGenerator, FPSCameraController, type FPSCameraControllerOptions, FWidthNode, FXAA, FaceForwardNode, FloorNode, FmaNode, type FogType, FractNode, FunctionCallNode, FunctionInputNode, FunctionOutputNode, GaussianBlurBlitter, GenericMathNode, GerstnerWaveGenerator, GraphNode, type GraphNodeInput, type GraphNodeOutput, type GraphStructure, type GrassInstanceInfo, GrassLayer, GrassMaterial, GrassRenderer, Grayscale, HEIGHT_FOG_BIT, Hash1Node, Hash2Node, Hash3Node, type Host, type IAttachedScript, type IBaseEvent, type IControllerKeyboardEvent, type IControllerKeydownEvent, type IControllerKeypressEvent, type IControllerKeyupEvent, type IControllerMouseEvent, type IControllerPointerCancelEvent, type IControllerPointerDownEvent, type IControllerPointerMoveEvent, type IControllerPointerUpEvent, type IControllerWheelEvent, type IGraphNode, type IMixinAlbedoColor, type IMixinBlinnPhong, type IMixinFoliage, type IMixinLambert, type IMixinLight, type IMixinPBRBluePrint, type IMixinPBRCommon, type IMixinPBRMetallicRoughness, type IMixinPBRSpecularGlossiness, type IMixinVertexColor, type IModKey, type IRUniformTexture, type IRUniformValue, type IRenderHook, type IRenderable, type InputEventHandler, InputManager, InstanceBindGroupAllocator, type InstanceData, type InstanceUniformType, InvProjMatrixNode, InvSqrtNode, InvViewProjMatrixNode, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT, LambertMaterial, LengthNode, Log2Node, type LogMode, LogNode, LogicallyAndNode, LogicallyOrNode, MAX_CLUSTERED_LIGHTS, MAX_GERSTNER_WAVE_COUNT, MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MAX_TERRAIN_MIPMAP_LEVELS, MORPH_ATTRIBUTE_VECTOR_COUNT, MORPH_TARGET_COLOR, MORPH_TARGET_NORMAL, MORPH_TARGET_POSITION, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_WEIGHTS_VECTOR_COUNT, MakeVectorNode, Material, MaterialBlueprintIR, type MaterialBlueprintIRBehaviors, type MaterialTextureInfo, MaterialVaryingFlags, MaxNode, Mesh, MeshMaterial, type Metadata, MinNode, MixNode, ModNode, type ModelFetchOptions, type ModelInfo, type MorphData, type MorphInfo, type MorphState, MorphTargetTrack, NamedObject, type NodeConnection, NodeEulerRotationTrack, type NodeIterateFunc, NodeRotationTrack, NodeScaleTrack, NodeTranslationTrack, NormalizeNode, NotEqualNode, type OIT, Octree, OctreeNode, OctreeNodeChunk, OctreePlacement, OrbitCameraController, type OrbitCameraControllerOptions, OrthoCamera, PBRBlockNode, PBRBluePrintMaterial, PBRMetallicRoughnessMaterial, PBRSpecularGlossinessMaterial, ParticleMaterial, ParticleSystem, PerlinNoise2DNode, PerspectiveCamera, type PickResult, type PickTarget, type PlaneCreationOptions, PlaneShape, type PlayAnimationOptions, PointLight, type PointTransform, PostEffectLayer, PowNode, Primitive, ProjectionMatrixNode, type PropEdit, type PropertyAccessor, type PropertyAccessorOptions, type PropertyToType, PropertyTrack, type PropertyType, type PropertyValue, PunctualLight, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_SHADOWMAP, Radians2DegreesNode, ReflectNode, RefractNode, RenderContext, type RenderItemList, type RenderItemListBundle, type RenderItemListInfo, RenderPass, RenderQueue, type RenderQueueItem, type RenderQueueRef, RenderTarget, type ResolutionTransform, ResolveVertexNormalNode, ResolveVertexPositionNode, ResolveVertexTangentNode, ResourceManager, RuntimeScript, SAO, type SamplerType, SaturateNode, Scene, SceneNode, type SceneNodeVisible, ScreenAdapter, type ScreenConfig, ScreenRenderTarget, type ScreenScaleMode, ScriptRegistry, ScriptingSystem, type ScriptingSystemOptions, SelectionNode, type SerializableClass, ShaderHelper, ShadowMapPass, ShadowMapper, type ShadowMode, Shape, type ShapeCreationOptions, type ShapeOptionType, type ShapeType, SharedModel, SignNode, SimplexNoise2DNode, SinHNode, SinNode, Skeleton, type SkinnedBoundingBox, SkyEnvTextureNode, SkyRenderer, type SkyType, SmoothStepNode, type SphereCreationOptions, SphereShape, SpotLight, Sprite, SpriteBlockNode, SpriteBlueprintMaterial, SpriteMaterial, SqrtNode, StandardSpriteMaterial, StepNode, type StopAnimationOptions, SwizzleNode, TanHNode, TanNode, type TerrainDebugMode, type TetrahedronCreationOptions, TetrahedronFrameShape, TetrahedronShape, type TextureFetchOptions, type TextureMixinInstanceTypes, type TextureMixinTypes, type TextureProp, type TexturePropUniforms, TextureSampleGrad, TextureSampleNode, type ToMixedTextureType, Tonemap, type TorusCreationOptions, TorusShape, TransformNode, UnlitMaterial, VertexBinormalNode, VertexBlockNode, VertexColorNode, VertexNormalNode, VertexPositionNode, VertexTangentNode, VertexUVNode, ViewMatrixNode, ViewProjMatrixNode, type Visitor, Water, type WaveGenerator, WeightedBlendedOIT, applyMaterialMixins, decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, defineProps, encode2HalfToRGBA, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, fetchSampler, gammaToLinear, getApp, getDevice, getEngine, getInput, gradient, hash11, hash12, hash13, hash21, hash22, hash23, hash31, hash32, hash33, interleavedGradientNoise, linearToGamma, mixinAlbedoColor, mixinBlinnPhong, mixinFoliage, mixinLambert, mixinLight, mixinPBRBluePrint, mixinPBRCommon, mixinPBRMetallicRoughness, mixinPBRSpecularGlossness, mixinTextureProps, mixinVertexColor, noise3D, panoramaToCubemap, perlinNoise2D, perlinNoise3D, prefilterCubemap, smoothNoise3D, temporalResolve, tryGetApp, valueNoise, whiteNoise, worleyFBM, worleyNoise };
+export { AABBTree, ABufferOIT, ATMOSPHERIC_FOG_BIT, AbsNode, AbstractPostEffect, AllConditionNode, AnimationClip, AnimationSet, AnimationTrack, AnyConditionNode, type AppCreationOptions, type AppOptions, Application, ArcCosNode, ArcSinNode, ArcTan2Node, ArcTanNode, ArccosineHNode, ArcsineHNode, ArctangentHNode, type AssetAnimationData, type AssetAnimationTrack, AssetHierarchyNode, AssetManager, type AssetMaterial, type AssetMaterialClearcoat, type AssetMaterialCommon, type AssetMaterialIridescence, type AssetMaterialSheen, type AssetMaterialTransmission, type AssetMeshData, type AssetPBRMaterialCommon, type AssetPBRMaterialMR, type AssetPBRMaterialSG, type AssetRotationTrack, type AssetScaleTrack, AssetScene, type AssetSkeletalAnimationTrack, AssetSkeleton, type AssetSubMeshData, type AssetTranslationTrack, type AssetUnlitMaterial, BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, BaseCameraController, BaseGraphNode, BaseLight, BaseSprite, BaseTextureNode, type BatchDrawable, BatchGroup, BillboardMatrixNode, type BlendMode, BlinnMaterial, type BlitType, Blitter, Bloom, type BluePrintEditorState, type BluePrintUniformTexture, type BluePrintUniformValue, type BlueprintDAG, BoundingBox, type BoundingVolume, type BoxCreationOptions, BoxFilterBlitter, BoxFrameShape, BoxShape, CCDSolver, type CachedBindGroup, Camera, type CameraHistoryData, CameraNearFarNode, CameraPositionNode, type CapsuleCollider, CeilNode, ClampNode, ClipmapTerrain, ClipmapTerrainMaterial, CompAddNode, CompComparisonNode, CompDivNode, CompMulNode, CompSubNode, type ComparisonMode, Compositor, type CompositorContext, ConstantBVec2Node, ConstantBVec3Node, ConstantBVec4Node, ConstantBooleanNode, ConstantScalarNode, ConstantTexture2DArrayNode, ConstantTexture2DNode, ConstantTextureCubeNode, ConstantVec2Node, ConstantVec3Node, ConstantVec4Node, CopyBlitter, CosHNode, CosNode, CrossProductNode, CubemapSHProjector, CullVisitor, type CylinderCreationOptions, CylinderShape, DDXNode, DDYNode, Degrees2RadiansNode, DepthPass, DirectionalLight, DistanceNode, DotProductNode, DracoMeshDecoder, type DrawContext, type Drawable, type DrawableInstanceInfo, type EditorMode, ElapsedTimeNode, type EmitterBehavior, type EmitterShape, Engine, EnvConstantAmbient, EnvHemisphericAmbient, type EnvLightType, EnvLightWrapper, EnvShIBL, Environment, EnvironmentLighting, EqualNode, Exp2Node, ExpNode, type ExtractMixinReturnType, type ExtractMixinType, FABRIKSolver, FBMWaveGenerator, FFTWaveGenerator, FPSCameraController, type FPSCameraControllerOptions, FWidthNode, FXAA, FaceForwardNode, FloorNode, FmaNode, type FogType, FractNode, FunctionCallNode, FunctionInputNode, FunctionOutputNode, GaussianBlurBlitter, GenericMathNode, GerstnerWaveGenerator, GraphNode, type GraphNodeInput, type GraphNodeOutput, type GraphStructure, type GrassInstanceInfo, GrassLayer, GrassMaterial, GrassRenderer, Grayscale, HEIGHT_FOG_BIT, Hash1Node, Hash2Node, Hash3Node, type Host, type IAttachedScript, type IBaseEvent, type IControllerKeyboardEvent, type IControllerKeydownEvent, type IControllerKeypressEvent, type IControllerKeyupEvent, type IControllerMouseEvent, type IControllerPointerCancelEvent, type IControllerPointerDownEvent, type IControllerPointerMoveEvent, type IControllerPointerUpEvent, type IControllerWheelEvent, type IGraphNode, IKAngleConstraint, IKChain, IKConstraint, type IKJoint, IKModifier, IKSolver, type IMixinAlbedoColor, type IMixinBlinnPhong, type IMixinFoliage, type IMixinLambert, type IMixinLight, type IMixinPBRBluePrint, type IMixinPBRCommon, type IMixinPBRMetallicRoughness, type IMixinPBRSpecularGlossiness, type IMixinVertexColor, type IModKey, type IRUniformTexture, type IRUniformValue, type IRenderHook, type IRenderable, type InputEventHandler, InputManager, InstanceBindGroupAllocator, type InstanceData, type InstanceUniformType, type InterChainConstraint, InvProjMatrixNode, InvSqrtNode, InvViewProjMatrixNode, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT, LambertMaterial, LengthNode, Log2Node, type LogMode, LogNode, LogicallyAndNode, LogicallyOrNode, MAX_CLUSTERED_LIGHTS, MAX_GERSTNER_WAVE_COUNT, MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MAX_TERRAIN_MIPMAP_LEVELS, MORPH_ATTRIBUTE_VECTOR_COUNT, MORPH_TARGET_COLOR, MORPH_TARGET_NORMAL, MORPH_TARGET_POSITION, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_WEIGHTS_VECTOR_COUNT, MakeVectorNode, Material, MaterialBlueprintIR, type MaterialBlueprintIRBehaviors, type MaterialTextureInfo, MaterialVaryingFlags, MaxNode, Mesh, MeshMaterial, type Metadata, MinNode, MixNode, ModNode, type ModelFetchOptions, type ModelInfo, type MorphData, type MorphInfo, type MorphState, MorphTargetTrack, MultiChainSpringSystem, type MultiChainSpringSystemOptions, NamedObject, type NodeConnection, NodeEulerRotationTrack, type NodeIterateFunc, NodeRotationTrack, NodeScaleTrack, NodeTranslationTrack, NormalizeNode, NotEqualNode, type OIT, Octree, OctreeNode, OctreeNodeChunk, OctreePlacement, OrbitCameraController, type OrbitCameraControllerOptions, OrthoCamera, PBRBlockNode, PBRBluePrintMaterial, PBRMetallicRoughnessMaterial, PBRSpecularGlossinessMaterial, ParticleMaterial, ParticleSystem, PerlinNoise2DNode, PerspectiveCamera, type PickResult, type PickTarget, type PlaneCollider, type PlaneCreationOptions, PlaneShape, type PlayAnimationOptions, PointLight, type PointTransform, PostEffectLayer, PowNode, Primitive, ProjectionMatrixNode, type PropEdit, type PropertyAccessor, type PropertyAccessorOptions, type PropertyToType, PropertyTrack, type PropertyType, type PropertyValue, PunctualLight, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_SHADOWMAP, Radians2DegreesNode, ReflectNode, RefractNode, RenderContext, type RenderItemList, type RenderItemListBundle, type RenderItemListInfo, RenderPass, RenderQueue, type RenderQueueItem, type RenderQueueRef, RenderTarget, type ResolutionTransform, ResolveVertexNormalNode, ResolveVertexPositionNode, ResolveVertexTangentNode, ResourceManager, RuntimeScript, SAO, type SamplerType, SaturateNode, Scene, SceneNode, type SceneNodeVisible, ScreenAdapter, type ScreenConfig, ScreenRenderTarget, type ScreenScaleMode, ScriptRegistry, ScriptingSystem, type ScriptingSystemOptions, SelectionNode, type SerializableClass, ShaderHelper, ShadowMapPass, ShadowMapper, type ShadowMode, Shape, type ShapeCreationOptions, type ShapeOptionType, type ShapeType, SharedModel, SignNode, SimplexNoise2DNode, SinHNode, SinNode, Skeleton, SkeletonModifier, type SkinnedBoundingBox, SkyEnvTextureNode, SkyRenderer, type SkyType, SmoothStepNode, type SphereCollider, type SphereCreationOptions, SphereShape, SpotLight, SpringChain, type SpringCollider, type SpringConstraint, SpringModifier, type SpringParticle, SpringSystem, type SpringSystemOptions, Sprite, SpriteBlockNode, SpriteBlueprintMaterial, SpriteMaterial, SqrtNode, StandardSpriteMaterial, StepNode, type StopAnimationOptions, SwizzleNode, TanHNode, TanNode, type TerrainDebugMode, type TetrahedronCreationOptions, TetrahedronFrameShape, TetrahedronShape, type TextureFetchOptions, type TextureMixinInstanceTypes, type TextureMixinTypes, type TextureProp, type TexturePropUniforms, TextureSampleGrad, TextureSampleNode, type ToMixedTextureType, Tonemap, type TorusCreationOptions, TorusShape, TransformNode, type TwistConstraint, TwoBoneIKSolver, UnlitMaterial, VertexBinormalNode, VertexBlockNode, VertexColorNode, VertexNormalNode, VertexPositionNode, VertexTangentNode, VertexUVNode, ViewMatrixNode, ViewProjMatrixNode, type Visitor, Water, type WaveGenerator, WeightedBlendedOIT, applyMaterialMixins, createCapsuleCollider, createPlaneCollider, createSphereCollider, createSpringConstraint, createSpringParticle, decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, defineProps, encode2HalfToRGBA, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, fetchSampler, gammaToLinear, getApp, getDevice, getEngine, getInput, gradient, hash11, hash12, hash13, hash21, hash22, hash23, hash31, hash32, hash33, interleavedGradientNoise, linearToGamma, mixinAlbedoColor, mixinBlinnPhong, mixinFoliage, mixinLambert, mixinLight, mixinPBRBluePrint, mixinPBRCommon, mixinPBRMetallicRoughness, mixinPBRSpecularGlossness, mixinTextureProps, mixinVertexColor, noise3D, panoramaToCubemap, perlinNoise2D, perlinNoise3D, prefilterCubemap, resolveCapsuleCollision, resolvePlaneCollision, resolveSphereCollision, smoothNoise3D, temporalResolve, tryGetApp, updateColliderFromNode, valueNoise, whiteNoise, worleyFBM, worleyNoise };