@zephyr3d/scene 0.9.4 → 0.9.6

package/dist/animation/joint_dynamics/controller.js

@@ -1,7 +1,7 @@
 import { EPSILON } from './types.js';
 import { buildConstraints, buildSurfaceFaces } from './constraints.js';
 import { simulate, applyAngleLimits, applyResult } from './solver.js';
-import { Vector3, Quaternion, Matrix4x4, clamp01 } from '@zephyr3d/base';
+import { Vector3, Quaternion, Matrix4x4, clamp01, InterpolatorScalar } from '@zephyr3d/base';
 
 // High-level orchestrator - SPCRJointDynamicsController API
 /**
@@ -33,6 +33,10 @@ import { Vector3, Quaternion, Matrix4x4, clamp01 } from '@zephyr3d/base';
     _previousRootPosition = Vector3.zero();
     _previousRootRotation = Quaternion.identity();
     _rootTransform = null;
+    _rootPoints = [];
+    _allPoints = [];
+    _parentMap = new Map();
+    _maxPointDepth = 0;
     _pointTransforms = [];
     _colliderTransforms = [];
     _grabberTransforms = [];
@@ -42,6 +46,10 @@ import { Vector3, Quaternion, Matrix4x4, clamp01 } from '@zephyr3d/base';
     _colliderHandleToIndex = new Map();
     _flatPlaneHandleToIndex = new Map();
     _grabberHandleToIndex = new Map();
+    _baseSystemScale = 1;
+    _currentSystemScale = 1;
+    _basePointParentLengths = [];
+    _baseConstraintLengths = [];
     _nextColliderHandleId = 1;
     _nextFlatPlaneHandleId = 1;
     _nextGrabberHandleId = 1;
@@ -51,7 +59,7 @@ import { Vector3, Quaternion, Matrix4x4, clamp01 } from '@zephyr3d/base';
     _fadeTimer = 0;
     _fadeDuration = 0;
     constructor(config){
-        this._config = config;
+        this._config = this._sanitizeControllerConfig(this._cloneControllerConfig(config));
     }
     /**
    * Initializes the physics system.
@@ -63,32 +71,34 @@ import { Vector3, Quaternion, Matrix4x4, clamp01 } from '@zephyr3d/base';
    * @param flatPlanes - Plane limiters such as the floor to prevent penetration.
    */ initialize(rootTransform, rootPoints, pointTransforms, colliders, grabbers, flatPlanes) {
         this._rootTransform = rootTransform;
+        this._baseSystemScale = this._getSystemUniformScale();
+        this._currentSystemScale = this._baseSystemScale;
+        this._rootPoints = [
+            ...rootPoints
+        ];
         this._pointTransforms = pointTransforms;
         this._colliderTransforms = colliders.map((c)=>c.transform);
         this._grabberTransforms = grabbers.map((g)=>g.transform);
         // Build constraints
-        this._constraints = buildConstraints(rootPoints, this._config.constraintOptions);
-        this._surfaceConstraints = buildSurfaceFaces(rootPoints, this._config.constraintOptions.isLoop);
+        this._rebuildConstraints();
+        this._baseConstraintLengths = this._constraints.map((constraint)=>constraint.length);
         // Flatten bone hierarchy to point list, build parent map
         const allPoints = [];
-        const parentMap = new Map(); // child index -> parent index
-        function walk(node) {
+        this._parentMap = new Map(); // child index -> parent index
+        const walk = (node)=>{
             allPoints.push(node);
             for (const c of node.children){
-                parentMap.set(c.index, node.index);
+                this._parentMap.set(c.index, node.index);
                 walk(c);
             }
-        }
+        };
         for (const r of rootPoints){
             walk(r);
         }
-        const maxDepth = Math.max(...allPoints.map((p)=>p.depth));
+        this._allPoints = allPoints;
+        this._maxPointDepth = allPoints.length > 0 ? Math.max(...allPoints.map((p)=>p.depth)) : 0;
         // Compute boneAxis from transforms: local-space direction to first child
         // This is critical for correct bone rotation in skinned meshes
-        const indexToNode = new Map();
-        for (const p of allPoints){
-            indexToNode.set(p.index, p);
-        }
         for (const p of allPoints){
             if (!p.boneAxis && p.children.length > 0) {
                 const childPos = pointTransforms[p.children[0].index].getWorldPosition();
@@ -105,7 +115,8 @@ import { Vector3, Quaternion, Matrix4x4, clamp01 } from '@zephyr3d/base';
             }
         }
         // Build PointR/RW arrays
-        this._pointsR = allPoints.map((p)=>this._createPointR(p, maxDepth, parentMap, pointTransforms));
+        this._pointsR = allPoints.map((p)=>this._createPointR(p));
+        this._basePointParentLengths = this._pointsR.map((point)=>point.parentLength);
         this._pointsRW = allPoints.map(()=>this._createPointRW());
         this._positionsToTransform = new Array(allPoints.length).fill(Vector3.zero());
         // Initialize colliders
@@ -168,6 +179,7 @@ import { Vector3, Quaternion, Matrix4x4, clamp01 } from '@zephyr3d/base';
             }
         }
         const blendRatio = this._computeBlendRatio();
+        this._updateScaleDependentParameters();
         // Capture current transforms
         const rootPos = this._rootTransform.getWorldPosition();
         const rootRot = this._rootTransform.getWorldRotation();
@@ -243,6 +255,189 @@ import { Vector3, Quaternion, Matrix4x4, clamp01 } from '@zephyr3d/base';
             }));
     }
     /**
+   * Returns a detached snapshot of the current runtime configuration.
+   */ getConfig() {
+        return this._cloneControllerConfig(this._config);
+    }
+    /**
+   * Returns detached collider snapshots for persistence.
+   */ getColliderSnapshots() {
+        return this._collidersR.map((r, index)=>({
+                r: {
+                    ...r
+                },
+                transform: this._colliderTransforms[index]?.node ?? null,
+                enabled: this._collidersRW[index]?.enabled !== 0
+            }));
+    }
+    /**
+   * Returns detached flat-plane snapshots for persistence.
+   */ getFlatPlaneSnapshots() {
+        return this._flatPlaneAll.map((plane, index)=>({
+                up: plane.normal.clone(),
+                position: Vector3.scale(plane.normal, -plane.distance),
+                enabled: this._flatPlaneEnabled[index] ?? true
+            }));
+    }
+    /**
+   * Returns detached grabber snapshots for persistence.
+   */ getGrabberSnapshots() {
+        return this._grabbersR.map((r, index)=>({
+                r: {
+                    ...r
+                },
+                transform: this._grabberTransforms[index]?.node ?? null,
+                enabled: this._grabbersRW[index]?.enabled !== 0
+            }));
+    }
+    /**
+   * Replaces the runtime configuration.
+   *
+   * If the controller is already initialized, cached per-point parameters and generated
+   * constraints are refreshed immediately so editor-driven changes take effect in the next step.
+   *
+   * @param config - Complete controller configuration to apply.
+   */ setConfig(config) {
+        this._config = this._sanitizeControllerConfig(this._cloneControllerConfig(config));
+        this._refreshCachedSimulationConfig();
+    }
+    /**
+   * Applies a partial runtime configuration update.
+   *
+   * This is intended for editor workflows that tweak one or more simulation parameters live.
+   * The controller updates only the affected caches: global step parameters are applied directly,
+   * per-point curve/gravity changes rebuild cached point coefficients, and constraint option
+   * changes rebuild the generated constraints.
+   *
+   * @param config - Partial configuration update.
+   */ updateConfig(config) {
+        let refreshPoints = false;
+        let refreshConstraints = false;
+        if (config.gravity) {
+            this._config.gravity = config.gravity.clone();
+            refreshPoints = true;
+        }
+        if (config.windForce) {
+            this._config.windForce = config.windForce.clone();
+        }
+        if (typeof config.relaxation === 'number') {
+            this._config.relaxation = Math.max(0, Math.trunc(config.relaxation));
+        }
+        if (typeof config.subSteps === 'number') {
+            this._config.subSteps = Math.max(1, Math.trunc(config.subSteps));
+        }
+        if (typeof config.rootSlideLimit === 'number') {
+            this._config.rootSlideLimit = config.rootSlideLimit;
+        }
+        if (typeof config.rootRotateLimit === 'number') {
+            this._config.rootRotateLimit = config.rootRotateLimit;
+        }
+        if (typeof config.constraintShrinkLimit === 'number') {
+            this._config.constraintShrinkLimit = Math.max(0, config.constraintShrinkLimit);
+        }
+        if (typeof config.blendRatio === 'number') {
+            this._config.blendRatio = clamp01(config.blendRatio);
+        }
+        if (typeof config.stabilizationFrameRate === 'number') {
+            this._config.stabilizationFrameRate = config.stabilizationFrameRate;
+        }
+        if (typeof config.isFakeWave === 'boolean') {
+            this._config.isFakeWave = config.isFakeWave;
+        }
+        if (typeof config.fakeWaveSpeed === 'number') {
+            this._config.fakeWaveSpeed = config.fakeWaveSpeed;
+        }
+        if (typeof config.fakeWavePower === 'number') {
+            this._config.fakeWavePower = config.fakeWavePower;
+        }
+        if (typeof config.enableSurfaceCollision === 'boolean') {
+            this._config.enableSurfaceCollision = config.enableSurfaceCollision;
+            if (!config.constraintOptions || config.constraintOptions.enableSurfaceCollision === undefined) {
+                this._config.constraintOptions.enableSurfaceCollision = config.enableSurfaceCollision;
+                refreshConstraints = true;
+            }
+        }
+        if (typeof config.enableBroadPhase === 'boolean') {
+            this._config.enableBroadPhase = config.enableBroadPhase;
+        }
+        if (typeof config.preserveTwist === 'boolean') {
+            this._config.preserveTwist = config.preserveTwist;
+        }
+        if (config.angleLimitConfig) {
+            if (typeof config.angleLimitConfig.angleLimit === 'number') {
+                this._config.angleLimitConfig.angleLimit = config.angleLimitConfig.angleLimit;
+            }
+            if (typeof config.angleLimitConfig.limitFromRoot === 'boolean') {
+                this._config.angleLimitConfig.limitFromRoot = config.angleLimitConfig.limitFromRoot;
+            }
+        }
+        if (config.curves) {
+            const curveKeys = [
+                'massScale',
+                'gravityScale',
+                'windForceScale',
+                'resistance',
+                'hardness',
+                'friction',
+                'pointRadius',
+                'sliderJointLength',
+                'allShrinkScale',
+                'allStretchScale',
+                'structuralShrinkVertical',
+                'structuralStretchVertical',
+                'structuralShrinkHorizontal',
+                'structuralStretchHorizontal',
+                'shearShrink',
+                'shearStretch',
+                'bendingShrinkVertical',
+                'bendingStretchVertical',
+                'bendingShrinkHorizontal',
+                'bendingStretchHorizontal',
+                'fakeWavePower',
+                'fakeWaveFreq'
+            ];
+            for (const key of curveKeys){
+                const curve = config.curves[key];
+                if (curve !== undefined) {
+                    this._config.curves[key] = this._cloneInterpolatorScalar(curve);
+                    refreshPoints = true;
+                }
+            }
+        }
+        if (config.constraintOptions) {
+            const optionKeys = [
+                'structuralVertical',
+                'structuralHorizontal',
+                'shear',
+                'bendingVertical',
+                'bendingHorizontal',
+                'isLoop',
+                'collideStructuralVertical',
+                'collideStructuralHorizontal',
+                'collideShear',
+                'enableSurfaceCollision'
+            ];
+            for (const key of optionKeys){
+                const value = config.constraintOptions[key];
+                if (value !== undefined) {
+                    this._config.constraintOptions[key] = value;
+                    if (key === 'enableSurfaceCollision' && config.enableSurfaceCollision === undefined) {
+                        this._config.enableSurfaceCollision = value;
+                    }
+                    refreshConstraints = true;
+                }
+            }
+        }
+        if (refreshConstraints) {
+            this._rebuildConstraints();
+            this._baseConstraintLengths = this._constraints.map((constraint)=>constraint.length);
+            this._updateScaleDependentParameters(true);
+        }
+        if (refreshPoints) {
+            this._refreshPointParameters();
+        }
+    }
+    /**
    * Compensates for teleportation by resetting the previous root transform to the current one.
    * Call this after a character warp or teleport to avoid a large root-motion impulse on the
    * next simulation step.
@@ -326,7 +521,7 @@ import { Vector3, Quaternion, Matrix4x4, clamp01 } from '@zephyr3d/base';
    * The final wind contribution is still scaled per point by `windForceScale` and mass.
    * @param wind - Wind vector in world space.
    */ setWindForce(wind) {
-        this._config.windForce = wind;
+        this._config.windForce = wind.clone();
     }
     /**
    * Enable/disable broad-phase pruning for runtime performance comparison
@@ -595,6 +790,10 @@ import { Vector3, Quaternion, Matrix4x4, clamp01 } from '@zephyr3d/base';
         }
         return this._config.blendRatio;
     }
+    _refreshCachedSimulationConfig() {
+        this._rebuildConstraints();
+        this._refreshPointParameters();
+    }
     _getColliderIndex(handle) {
         if (handle.type !== 'collider') {
             return -1;
@@ -647,13 +846,61 @@ import { Vector3, Quaternion, Matrix4x4, clamp01 } from '@zephyr3d/base';
             this._grabberHandleToIndex.set(this._grabberHandleIds[i], i);
         }
     }
-    _createPointR(node, maxDepth, parentMap, transforms) {
-        const rate = maxDepth > 0 ? node.depth / maxDepth : 0;
-        const c = this._config.curves;
-        const parentIdx = parentMap.get(node.index) ?? -1;
+    _rebuildConstraints() {
+        if (this._rootPoints.length === 0) {
+            this._constraints = [];
+            this._surfaceConstraints = [];
+            return;
+        }
+        this._constraints = buildConstraints(this._rootPoints, this._config.constraintOptions);
+        this._surfaceConstraints = buildSurfaceFaces(this._rootPoints, this._config.constraintOptions.isLoop);
+    }
+    _getSystemUniformScale() {
+        if (!this._rootTransform) {
+            return 1;
+        }
+        const scale = this._rootTransform.getWorldScale();
+        return Math.max((Math.abs(scale.x) + Math.abs(scale.y) + Math.abs(scale.z)) / 3, EPSILON);
+    }
+    _updateScaleDependentParameters(force = false) {
+        const systemScale = this._getSystemUniformScale();
+        const scaleChanged = Math.abs(systemScale - this._currentSystemScale) > EPSILON;
+        if (!force && !scaleChanged) {
+            return;
+        }
+        this._currentSystemScale = systemScale;
+        const ratio = this._baseSystemScale > EPSILON ? systemScale / this._baseSystemScale : 1;
+        for(let i = 0; i < this._pointsR.length; i++){
+            this._pointsR[i].parentLength = (this._basePointParentLengths[i] ?? this._pointsR[i].parentLength) * ratio;
+        }
+        for(let i = 0; i < this._constraints.length; i++){
+            this._constraints[i].length = (this._baseConstraintLengths[i] ?? this._constraints[i].length) * ratio;
+        }
+        this._refreshPointParameters();
+        if (scaleChanged) {
+            for(let i = 0; i < this._pointsRW.length; i++){
+                const pos = this._pointTransforms[i].getWorldPosition();
+                this._pointsRW[i].positionCurrent = pos.clone();
+                this._pointsRW[i].positionPrevious = pos.clone();
+                this._pointsRW[i].positionCurrentTransform = pos.clone();
+                this._pointsRW[i].positionPreviousTransform = pos.clone();
+            }
+            this.warp();
+        }
+    }
+    _refreshPointParameters() {
+        if (!this._initialized) {
+            return;
+        }
+        for(let i = 0; i < this._allPoints.length; i++){
+            this._applyConfigToPoint(this._pointsR[i], this._allPoints[i]);
+        }
+    }
+    _createPointR(node) {
+        const parentIdx = this._parentMap.get(node.index) ?? -1;
         const childIdx = node.children.length > 0 ? node.children[0].index : -1;
         // Capture initial local transform for rotation blending
-        const t = transforms[node.index];
+        const t = this._pointTransforms[node.index];
         const initLocalPos = t.getLocalPosition();
         const initLocalRot = t.getLocalRotation();
         const initLocalScale = t.getLocalScale();
@@ -662,39 +909,39 @@ import { Vector3, Quaternion, Matrix4x4, clamp01 } from '@zephyr3d/base';
         // ParentLength: distance to parent
         let parentLength = 0;
         if (parentIdx !== -1) {
-            const pPos = transforms[parentIdx].getWorldPosition();
-            const cPos = transforms[node.index].getWorldPosition();
+            const pPos = this._pointTransforms[parentIdx].getWorldPosition();
+            const cPos = this._pointTransforms[node.index].getWorldPosition();
             parentLength = Vector3.distance(pPos, cPos);
         }
-        return {
+        const point = {
             parent: parentIdx,
             child: childIdx,
             applyInvertCollision: 0,
             movableLimitIndex: -1,
             movableLimitRadius: 0,
             weight: node.isFixed ? 0 : 1,
-            mass: c.massScale.evaluate(rate),
-            resistance: clamp01(c.resistance.evaluate(rate)),
-            hardness: clamp01(c.hardness.evaluate(rate)),
-            frictionScale: c.friction.evaluate(rate),
-            sliderJointLength: c.sliderJointLength.evaluate(rate),
+            mass: 0,
+            resistance: 0,
+            hardness: 0,
+            frictionScale: 0,
+            sliderJointLength: 0,
             parentLength,
-            structuralShrinkVertical: c.structuralShrinkVertical.evaluate(rate) * 0.5,
-            structuralStretchVertical: c.structuralStretchVertical.evaluate(rate) * 0.5,
-            structuralShrinkHorizontal: c.structuralShrinkHorizontal.evaluate(rate) * 0.5,
-            structuralStretchHorizontal: c.structuralStretchHorizontal.evaluate(rate) * 0.5,
-            shearShrink: c.shearShrink.evaluate(rate) * 0.5,
-            shearStretch: c.shearStretch.evaluate(rate) * 0.5,
-            bendingShrinkVertical: c.bendingShrinkVertical.evaluate(rate) * 0.5,
-            bendingStretchVertical: c.bendingStretchVertical.evaluate(rate) * 0.5,
-            bendingShrinkHorizontal: c.bendingShrinkHorizontal.evaluate(rate) * 0.5,
-            bendingStretchHorizontal: c.bendingStretchHorizontal.evaluate(rate) * 0.5,
-            windForceScale: c.windForceScale.evaluate(rate) * rate,
-            fakeWavePower: c.fakeWavePower.evaluate(rate),
-            fakeWaveFreq: c.fakeWaveFreq.evaluate(rate),
+            structuralShrinkVertical: 0,
+            structuralStretchVertical: 0,
+            structuralShrinkHorizontal: 0,
+            structuralStretchHorizontal: 0,
+            shearShrink: 0,
+            shearStretch: 0,
+            bendingShrinkVertical: 0,
+            bendingStretchVertical: 0,
+            bendingShrinkHorizontal: 0,
+            bendingStretchHorizontal: 0,
+            windForceScale: 0,
+            fakeWavePower: 0,
+            fakeWaveFreq: 0,
             forceFadeRatio: 0,
-            pointRadius: Math.max(0, c.pointRadius.evaluate(rate)),
-            gravity: Vector3.scale(this._config.gravity, c.gravityScale.evaluate(rate)),
+            pointRadius: 0,
+            gravity: Vector3.zero(),
             boneAxis,
             initialLocalScale: initLocalScale,
             initialLocalRotation: initLocalRot,
@@ -705,6 +952,35 @@ import { Vector3, Quaternion, Matrix4x4, clamp01 } from '@zephyr3d/base';
             })(),
             initialLocalPosition: initLocalPos
         };
+        this._applyConfigToPoint(point, node);
+        return point;
+    }
+    _applyConfigToPoint(point, node) {
+        const rate = this._maxPointDepth > 0 ? node.depth / this._maxPointDepth : 0;
+        const c = this._config.curves;
+        const allShrinkScale = c.allShrinkScale.evaluate(rate);
+        const allStretchScale = c.allStretchScale.evaluate(rate);
+        point.mass = c.massScale.evaluate(rate);
+        point.resistance = clamp01(c.resistance.evaluate(rate));
+        point.hardness = clamp01(c.hardness.evaluate(rate));
+        point.frictionScale = c.friction.evaluate(rate);
+        point.sliderJointLength = c.sliderJointLength.evaluate(rate);
+        point.structuralShrinkVertical = c.structuralShrinkVertical.evaluate(rate) * allShrinkScale * 0.5;
+        point.structuralStretchVertical = c.structuralStretchVertical.evaluate(rate) * allStretchScale * 0.5;
+        point.structuralShrinkHorizontal = c.structuralShrinkHorizontal.evaluate(rate) * allShrinkScale * 0.5;
+        point.structuralStretchHorizontal = c.structuralStretchHorizontal.evaluate(rate) * allStretchScale * 0.5;
+        point.shearShrink = c.shearShrink.evaluate(rate) * allShrinkScale * 0.5;
+        point.shearStretch = c.shearStretch.evaluate(rate) * allStretchScale * 0.5;
+        point.bendingShrinkVertical = c.bendingShrinkVertical.evaluate(rate) * allShrinkScale * 0.5;
+        point.bendingStretchVertical = c.bendingStretchVertical.evaluate(rate) * allStretchScale * 0.5;
+        point.bendingShrinkHorizontal = c.bendingShrinkHorizontal.evaluate(rate) * allShrinkScale * 0.5;
+        point.bendingStretchHorizontal = c.bendingStretchHorizontal.evaluate(rate) * allStretchScale * 0.5;
+        point.windForceScale = c.windForceScale.evaluate(rate) * rate;
+        point.fakeWavePower = c.fakeWavePower.evaluate(rate);
+        point.fakeWaveFreq = c.fakeWaveFreq.evaluate(rate);
+        const systemScale = this._currentSystemScale;
+        point.pointRadius = Math.max(0, c.pointRadius.evaluate(rate) * systemScale);
+        point.gravity = Vector3.scale(this._config.gravity, c.gravityScale.evaluate(rate) * systemScale);
     }
     _createPointRW() {
         return {
@@ -738,9 +1014,80 @@ import { Vector3, Quaternion, Matrix4x4, clamp01 } from '@zephyr3d/base';
             localBoundsMin: Vector3.zero(),
             localBoundsMax: Vector3.zero(),
             radius: 0,
+            height: 0,
             enabled: 1
         };
     }
+    _cloneControllerConfig(config) {
+        const curves = {
+            massScale: this._cloneInterpolatorScalar(config.curves.massScale),
+            gravityScale: this._cloneInterpolatorScalar(config.curves.gravityScale),
+            windForceScale: this._cloneInterpolatorScalar(config.curves.windForceScale),
+            resistance: this._cloneInterpolatorScalar(config.curves.resistance),
+            hardness: this._cloneInterpolatorScalar(config.curves.hardness),
+            friction: this._cloneInterpolatorScalar(config.curves.friction),
+            pointRadius: this._cloneInterpolatorScalar(config.curves.pointRadius),
+            sliderJointLength: this._cloneInterpolatorScalar(config.curves.sliderJointLength),
+            allShrinkScale: this._cloneInterpolatorScalar(config.curves.allShrinkScale),
+            allStretchScale: this._cloneInterpolatorScalar(config.curves.allStretchScale),
+            structuralShrinkVertical: this._cloneInterpolatorScalar(config.curves.structuralShrinkVertical),
+            structuralStretchVertical: this._cloneInterpolatorScalar(config.curves.structuralStretchVertical),
+            structuralShrinkHorizontal: this._cloneInterpolatorScalar(config.curves.structuralShrinkHorizontal),
+            structuralStretchHorizontal: this._cloneInterpolatorScalar(config.curves.structuralStretchHorizontal),
+            shearShrink: this._cloneInterpolatorScalar(config.curves.shearShrink),
+            shearStretch: this._cloneInterpolatorScalar(config.curves.shearStretch),
+            bendingShrinkVertical: this._cloneInterpolatorScalar(config.curves.bendingShrinkVertical),
+            bendingStretchVertical: this._cloneInterpolatorScalar(config.curves.bendingStretchVertical),
+            bendingShrinkHorizontal: this._cloneInterpolatorScalar(config.curves.bendingShrinkHorizontal),
+            bendingStretchHorizontal: this._cloneInterpolatorScalar(config.curves.bendingStretchHorizontal),
+            fakeWavePower: this._cloneInterpolatorScalar(config.curves.fakeWavePower),
+            fakeWaveFreq: this._cloneInterpolatorScalar(config.curves.fakeWaveFreq)
+        };
+        return {
+            gravity: config.gravity.clone(),
+            windForce: config.windForce.clone(),
+            relaxation: config.relaxation,
+            subSteps: config.subSteps,
+            rootSlideLimit: config.rootSlideLimit,
+            rootRotateLimit: config.rootRotateLimit,
+            constraintShrinkLimit: config.constraintShrinkLimit,
+            blendRatio: config.blendRatio,
+            stabilizationFrameRate: config.stabilizationFrameRate,
+            isFakeWave: config.isFakeWave,
+            fakeWaveSpeed: config.fakeWaveSpeed,
+            fakeWavePower: config.fakeWavePower,
+            enableSurfaceCollision: config.enableSurfaceCollision,
+            enableBroadPhase: config.enableBroadPhase,
+            preserveTwist: config.preserveTwist,
+            angleLimitConfig: {
+                angleLimit: config.angleLimitConfig.angleLimit,
+                limitFromRoot: config.angleLimitConfig.limitFromRoot
+            },
+            curves,
+            constraintOptions: {
+                structuralVertical: config.constraintOptions.structuralVertical,
+                structuralHorizontal: config.constraintOptions.structuralHorizontal,
+                shear: config.constraintOptions.shear,
+                bendingVertical: config.constraintOptions.bendingVertical,
+                bendingHorizontal: config.constraintOptions.bendingHorizontal,
+                isLoop: config.constraintOptions.isLoop,
+                collideStructuralVertical: config.constraintOptions.collideStructuralVertical,
+                collideStructuralHorizontal: config.constraintOptions.collideStructuralHorizontal,
+                collideShear: config.constraintOptions.collideShear,
+                enableSurfaceCollision: config.constraintOptions.enableSurfaceCollision
+            }
+        };
+    }
+    _cloneInterpolatorScalar(curve) {
+        return new InterpolatorScalar(curve.mode, new Float32Array(curve.inputs), new Float32Array(curve.outputs));
+    }
+    _sanitizeControllerConfig(config) {
+        config.relaxation = Math.max(0, Math.trunc(config.relaxation));
+        config.subSteps = Math.max(1, Math.trunc(config.subSteps));
+        config.constraintShrinkLimit = Math.max(0, config.constraintShrinkLimit);
+        config.blendRatio = clamp01(config.blendRatio);
+        return config;
+    }
 }
 
 export { JointDynamicsSystemController };