@babylonjs/loaders 9.26.0 → 9.26.2

package/FBX/fbxConstraintBehavior.js

@@ -0,0 +1,532 @@
+import { Matrix, Quaternion, Vector3 } from "@babylonjs/core/Maths/math.vector.pure.js";
+import { eulerToMatrixXYZ } from "./interpreter/transform.js";
+const DEG2RAD = Math.PI / 180;
+/** Scratch objects shared by every solve; the solver runs on one thread, one constraint at a time. */
+const Scratch = {
+    invRoot: new Matrix(),
+    parent: new Matrix(),
+    invParent: new Matrix(),
+    world: new Matrix(),
+    local: new Matrix(),
+    mA: new Matrix(),
+    mB: new Matrix(),
+    mC: new Matrix(),
+    mD: new Matrix(),
+    position: new Vector3(),
+    scale: new Vector3(),
+    translation: new Vector3(),
+    decomposedScale: new Vector3(),
+    localValue: new Vector3(),
+    up: new Vector3(),
+    forward: new Vector3(),
+    origin: new Vector3(),
+    axisA: new Vector3(),
+    axisB: new Vector3(),
+    axisC: new Vector3(),
+    eulerA: new Vector3(),
+    eulerB: new Vector3(),
+    rotation: new Quaternion(),
+    decomposedRotation: new Quaternion(),
+    result: new Quaternion(),
+};
+const Solvers = new WeakMap();
+/**
+ * Solves every FBX constraint of a scene once per frame, in dependency order, from the scene's animation phase
+ * observers (`beginFrame` before animations, `solve` after them). Created on demand by the first
+ * `FBXConstraintBehavior` attached in the scene and removed with the last one.
+ */
+export class FBXConstraintSolver {
+    constructor(scene) {
+        this._behaviors = [];
+        this._ordered = [];
+        this._cyclic = [];
+        this._dirty = false;
+        this._beforeAnimations = null;
+        this._afterAnimations = null;
+        this._scene = scene;
+    }
+    /**
+     * Solver of a scene, if any constraint behavior is attached in it.
+     * @param scene - Scene to look up
+     * @returns The solver, or undefined
+     */
+    static Get(scene) {
+        return Solvers.get(scene);
+    }
+    /**
+     * Solver of a scene, created when missing.
+     * @param scene - Scene to look up
+     * @returns The solver
+     */
+    static GetOrCreate(scene) {
+        let solver = Solvers.get(scene);
+        if (!solver) {
+            solver = new FBXConstraintSolver(scene);
+            Solvers.set(scene, solver);
+        }
+        return solver;
+    }
+    /** Registered behaviors in solve order (a target's constraint before the constraints that read it). */
+    get constraints() {
+        this._ensureOrder();
+        return this._ordered;
+    }
+    /**
+     * Behaviors that take part in a dependency cycle (A targets B while B targets A). They are solved after all
+     * acyclic constraints, in registration order, so each sees the other's result from the previous solve.
+     */
+    get cyclicConstraints() {
+        this._ensureOrder();
+        return this._cyclic;
+    }
+    /**
+     * Adds a behavior to the solve set.
+     * @param behavior - Behavior to add
+     */
+    register(behavior) {
+        if (this._behaviors.indexOf(behavior) >= 0) {
+            return;
+        }
+        this._behaviors.push(behavior);
+        this._dirty = true;
+        if (!this._beforeAnimations) {
+            this._beforeAnimations = this._scene.onBeforeAnimationsObservable.add(() => this.beginFrame());
+            this._afterAnimations = this._scene.onAfterAnimationsObservable.add(() => this.solve());
+        }
+    }
+    /**
+     * Removes a behavior from the solve set; the solver disposes itself with the last one.
+     * @param behavior - Behavior to remove
+     */
+    unregister(behavior) {
+        const index = this._behaviors.indexOf(behavior);
+        if (index < 0) {
+            return;
+        }
+        this._behaviors.splice(index, 1);
+        this._dirty = true;
+        if (this._behaviors.length === 0) {
+            this._scene.onBeforeAnimationsObservable.remove(this._beforeAnimations);
+            this._scene.onAfterAnimationsObservable.remove(this._afterAnimations);
+            this._beforeAnimations = null;
+            this._afterAnimations = null;
+            Solvers.delete(this._scene);
+        }
+    }
+    /** Marks the solve order stale, e.g. after re-parenting a constrained node. */
+    invalidateOrder() {
+        this._dirty = true;
+    }
+    /**
+     * Start of a frame, before animations run: every constrained node gets its unconstrained transform back, so
+     * that animation either overwrites it or leaves it untouched.
+     */
+    beginFrame() {
+        for (const behavior of this._behaviors) {
+            behavior.restoreBase();
+        }
+    }
+    /**
+     * End of the animation phase: takes every constrained node's current transform as its unconstrained value,
+     * then solves every registered constraint once, in dependency order.
+     */
+    solve() {
+        this._ensureOrder();
+        for (const behavior of this._behaviors) {
+            behavior.captureBase();
+        }
+        for (const behavior of this._ordered) {
+            behavior.evaluate();
+        }
+    }
+    _ensureOrder() {
+        if (!this._dirty) {
+            return;
+        }
+        this._dirty = false;
+        const behaviors = this._behaviors;
+        const count = behaviors.length;
+        // dependencies[i] lists the behaviors that must be solved before behaviors[i]
+        const dependencies = behaviors.map(() => []);
+        for (let i = 0; i < count; i++) {
+            const reads = behaviors[i].dependencyNodes();
+            for (let j = 0; j < count; j++) {
+                if (i === j) {
+                    continue;
+                }
+                const driven = behaviors[j].attachedNode;
+                if (driven && reads.some((node) => FBXConstraintSolver._IsAncestorOrSelf(driven, node))) {
+                    dependencies[i].push(j);
+                }
+            }
+        }
+        // Kahn's algorithm; whatever is left when no free behavior remains sits on a cycle.
+        const remaining = dependencies.map((deps) => deps.length);
+        const done = behaviors.map(() => false);
+        const ordered = [];
+        let progressed = true;
+        while (progressed) {
+            progressed = false;
+            for (let i = 0; i < count; i++) {
+                if (done[i] || remaining[i] > 0) {
+                    continue;
+                }
+                done[i] = true;
+                ordered.push(behaviors[i]);
+                progressed = true;
+                for (let k = 0; k < count; k++) {
+                    if (!done[k] && dependencies[k].indexOf(i) >= 0) {
+                        remaining[k]--;
+                    }
+                }
+            }
+        }
+        const cyclic = [];
+        for (let i = 0; i < count; i++) {
+            if (!done[i]) {
+                cyclic.push(behaviors[i]);
+                ordered.push(behaviors[i]);
+            }
+        }
+        this._ordered = ordered;
+        this._cyclic = cyclic;
+    }
+    static _IsAncestorOrSelf(ancestor, node) {
+        let current = node;
+        while (current) {
+            if (current === ancestor) {
+                return true;
+            }
+            current = current.parent;
+        }
+        return false;
+    }
+}
+/** Babylon behavior evaluating an FBX aim, parent, position, rotation or scale constraint. */
+export class FBXConstraintBehavior {
+    /**
+     * Creates the behavior.
+     * @param constraint - Constraint data extracted from the file
+     * @param _options - Resolved targets and scene information
+     */
+    constructor(
+    /** Constraint data extracted from the file */
+    constraint, _options) {
+        this.constraint = constraint;
+        this._options = _options;
+        /** Node the behavior is attached to */
+        this.attachedNode = null;
+        /** Set to false to pause the constraint without detaching it */
+        this.enabled = true;
+        /** Unconstrained transform of the current frame (what animation produced), blended towards the constraint's result. */
+        this._base = { position: new Vector3(), rotation: new Quaternion(), scaling: new Vector3() };
+        this._hasBase = false;
+        this.name = `fbxConstraint:${constraint.name}`;
+        this._offsetTranslation = new Vector3(constraint.offsetTranslation[0], constraint.offsetTranslation[1], constraint.offsetTranslation[2]);
+        this._offsetRotation = eulerToMatrixXYZ(constraint.offsetRotation[0] * DEG2RAD, constraint.offsetRotation[1] * DEG2RAD, constraint.offsetRotation[2] * DEG2RAD);
+        this._offsetScale = new Vector3(constraint.offsetScale[0], constraint.offsetScale[1], constraint.offsetScale[2]);
+        const localBasis = new Matrix();
+        this._localBasisTransposed = FBXConstraintBehavior._OrthonormalBasisToRef(new Vector3(constraint.aimVector[0], constraint.aimVector[1], constraint.aimVector[2]), new Vector3(constraint.upVector[0], constraint.upVector[1], constraint.upVector[2]), localBasis)
+            ? localBasis.transpose()
+            : null;
+    }
+    /** Nothing to initialize */
+    init() { }
+    /**
+     * Registers the behavior with the scene's solver, takes the node's current transform as the unconstrained
+     * value and solves the constraint once.
+     * @param target - Node to constrain
+     */
+    attach(target) {
+        this.attachedNode = target;
+        FBXConstraintSolver.GetOrCreate(target.getScene()).register(this);
+        this.captureBase();
+        this.evaluate();
+    }
+    /** Unregisters the behavior; the node keeps its last solved transform. */
+    detach() {
+        if (this.attachedNode) {
+            FBXConstraintSolver.Get(this.attachedNode.getScene())?.unregister(this);
+        }
+        this.attachedNode = null;
+        this._hasBase = false;
+    }
+    /**
+     * Takes the node's current transform as the unconstrained value the next solve blends from. The solver calls
+     * this after the scene's animations ran; call it yourself after writing a transform by hand.
+     */
+    captureBase() {
+        const node = this.attachedNode;
+        if (!node) {
+            return;
+        }
+        if (!node.rotationQuaternion) {
+            node.rotationQuaternion = Quaternion.FromEulerVector(node.rotation);
+        }
+        this._base.position.copyFrom(node.position);
+        this._base.rotation.copyFrom(node.rotationQuaternion);
+        this._base.scaling.copyFrom(node.scaling);
+        this._hasBase = true;
+    }
+    /**
+     * Writes the unconstrained transform back to the node. The solver calls this before the scene's animations
+     * run, so a node nothing animates keeps its unconstrained value between frames instead of the solved one.
+     */
+    restoreBase() {
+        const node = this.attachedNode;
+        if (!node || !this._hasBase) {
+            return;
+        }
+        node.position.copyFrom(this._base.position);
+        node.rotationQuaternion.copyFrom(this._base.rotation);
+        node.scaling.copyFrom(this._base.scaling);
+    }
+    /**
+     * Nodes whose world transform the solve reads: the targets, the up node and the constrained node's parent.
+     * @returns The nodes, used by the solver to order constraints
+     */
+    dependencyNodes() {
+        const nodes = this._options.targets.map((t) => t.node);
+        nodes.push(this._options.upNode);
+        nodes.push(this.attachedNode ? this.attachedNode.parent : null);
+        return nodes;
+    }
+    /**
+     * Solves the constraint from the captured unconstrained transform and writes the node's local transform.
+     * Blends are relative to the value captured by `captureBase`, not to whatever the node holds now.
+     */
+    evaluate() {
+        const node = this.attachedNode;
+        const c = this.constraint;
+        if (!node || !this.enabled || !c.active || c.weight <= 0 || this._options.targets.length === 0) {
+            return;
+        }
+        if (!this._hasBase) {
+            this.captureBase();
+        }
+        this._options.root.computeWorldMatrix(true).invertToRef(Scratch.invRoot);
+        const parent = node.parent;
+        if (parent && typeof parent.computeWorldMatrix === "function") {
+            this._fbxWorld(parent, Scratch.parent);
+        }
+        else {
+            Matrix.IdentityToRef(Scratch.parent);
+        }
+        Scratch.parent.invertToRef(Scratch.invParent);
+        switch (c.type) {
+            case "position":
+                this._solvePosition(node);
+                break;
+            case "rotation":
+                this._solveRotation(node);
+                break;
+            case "scale":
+                this._solveScale(node);
+                break;
+            case "parent":
+                this._solveParent(node);
+                break;
+            case "aim":
+                this._solveAim(node);
+                break;
+            default:
+                break;
+        }
+    }
+    /**
+     * World matrix of a node relative to the asset root (FBX space).
+     * @param node - node to evaluate
+     * @param out - matrix receiving the result
+     * @returns `out`
+     */
+    _fbxWorld(node, out) {
+        node.computeWorldMatrix(true).multiplyToRef(Scratch.invRoot, out);
+        return out;
+    }
+    /**
+     * Weighted blend of the targets' world transforms (relative to the root).
+     * @param position - Receives the blended translation
+     * @param rotation - Receives the blended rotation
+     * @param scale - Receives the blended scale
+     * @returns The total target weight, 0 when no target contributes
+     */
+    _blendTargets(position, rotation, scale) {
+        position.set(0, 0, 0);
+        scale.set(0, 0, 0);
+        rotation.set(0, 0, 0, 1);
+        let total = 0;
+        for (const target of this._options.targets) {
+            if (target.weight <= 0) {
+                continue;
+            }
+            target.offset.multiplyToRef(this._fbxWorld(target.node, Scratch.world), Scratch.local);
+            Scratch.local.decompose(Scratch.decomposedScale, Scratch.decomposedRotation, Scratch.translation);
+            const next = total + target.weight;
+            position.addInPlace(Scratch.translation.scaleInPlace(target.weight));
+            scale.addInPlace(Scratch.decomposedScale.scaleInPlace(target.weight));
+            if (total === 0) {
+                rotation.copyFrom(Scratch.decomposedRotation);
+            }
+            else {
+                Quaternion.SlerpToRef(rotation, Scratch.decomposedRotation, target.weight / next, rotation);
+            }
+            total = next;
+        }
+        if (total > 0) {
+            position.scaleInPlace(1 / total);
+            scale.scaleInPlace(1 / total);
+        }
+        return total;
+    }
+    _applyWeighted(base, desired, mask, out) {
+        const w = this.constraint.weight;
+        out.set(mask[0] ? base.x + (desired.x - base.x) * w : base.x, mask[1] ? base.y + (desired.y - base.y) * w : base.y, mask[2] ? base.z + (desired.z - base.z) * w : base.z);
+    }
+    _applyRotation(node, desiredLocal, mask) {
+        const base = this._base.rotation;
+        const result = Scratch.result;
+        result.copyFrom(desiredLocal);
+        if (!(mask[0] && mask[1] && mask[2])) {
+            base.toEulerAnglesToRef(Scratch.eulerA);
+            desiredLocal.toEulerAnglesToRef(Scratch.eulerB);
+            Quaternion.FromEulerAnglesToRef(mask[0] ? Scratch.eulerB.x : Scratch.eulerA.x, mask[1] ? Scratch.eulerB.y : Scratch.eulerA.y, mask[2] ? Scratch.eulerB.z : Scratch.eulerA.z, result);
+        }
+        if (this.constraint.weight < 1) {
+            Quaternion.SlerpToRef(base, result, this.constraint.weight, result);
+        }
+        node.rotationQuaternion.copyFrom(result);
+    }
+    _writePosition(node, desiredLocal) {
+        this._applyWeighted(this._base.position, desiredLocal, this.constraint.affectTranslation, node.position);
+    }
+    _writeScaling(node, desiredLocal) {
+        this._applyWeighted(this._base.scaling, desiredLocal, this.constraint.affectScale, node.scaling);
+    }
+    _solvePosition(node) {
+        if (this._blendTargets(Scratch.position, Scratch.rotation, Scratch.scale) === 0) {
+            return;
+        }
+        Vector3.TransformCoordinatesToRef(Scratch.position, Scratch.invParent, Scratch.localValue);
+        Scratch.localValue.addInPlace(this._offsetTranslation);
+        this._writePosition(node, Scratch.localValue);
+    }
+    _solveRotation(node) {
+        if (this._blendTargets(Scratch.position, Scratch.rotation, Scratch.scale) === 0) {
+            return;
+        }
+        Matrix.FromQuaternionToRef(Scratch.rotation, Scratch.mA);
+        this._offsetRotation.multiplyToRef(Scratch.mA, Scratch.mB);
+        Scratch.mB.multiplyToRef(Scratch.invParent, Scratch.mC);
+        Scratch.mC.decompose(Scratch.decomposedScale, Scratch.decomposedRotation, Scratch.translation);
+        this._applyRotation(node, Scratch.decomposedRotation, this.constraint.affectRotation);
+    }
+    _solveScale(node) {
+        if (this._blendTargets(Scratch.position, Scratch.rotation, Scratch.scale) === 0) {
+            return;
+        }
+        Scratch.parent.decompose(Scratch.decomposedScale, Scratch.decomposedRotation, Scratch.translation);
+        const parentScale = Scratch.decomposedScale;
+        const scale = Scratch.scale;
+        Scratch.localValue.set((parentScale.x !== 0 ? scale.x / parentScale.x : scale.x) * this._offsetScale.x, (parentScale.y !== 0 ? scale.y / parentScale.y : scale.y) * this._offsetScale.y, (parentScale.z !== 0 ? scale.z / parentScale.z : scale.z) * this._offsetScale.z);
+        this._writeScaling(node, Scratch.localValue);
+    }
+    _solveParent(node) {
+        if (this._blendTargets(Scratch.position, Scratch.rotation, Scratch.scale) === 0) {
+            return;
+        }
+        Matrix.ComposeToRef(Scratch.scale, Scratch.rotation, Scratch.position, Scratch.mA);
+        Scratch.mA.multiplyToRef(Scratch.invParent, Scratch.mB);
+        Scratch.mB.decompose(Scratch.decomposedScale, Scratch.decomposedRotation, Scratch.translation);
+        this._writePosition(node, Scratch.translation);
+        this._applyRotation(node, Scratch.decomposedRotation, this.constraint.affectRotation);
+        this._writeScaling(node, Scratch.decomposedScale);
+    }
+    _solveAim(node) {
+        const c = this.constraint;
+        if (!this._localBasisTransposed || this._blendTargets(Scratch.position, Scratch.rotation, Scratch.scale) === 0) {
+            return;
+        }
+        // The node's own world position (after animation) is the origin of the aim.
+        const nodeWorld = this._fbxWorld(node, Scratch.world);
+        nodeWorld.getTranslationToRef(Scratch.origin);
+        Scratch.position.subtractToRef(Scratch.origin, Scratch.forward);
+        if (Scratch.forward.lengthSquared() < 1e-20) {
+            return;
+        }
+        Scratch.forward.normalize();
+        // Up direction in world space
+        const up = Scratch.up;
+        switch (c.worldUpType) {
+            case 1: // aim the up vector at the up node
+                if (this._options.upNode) {
+                    this._fbxWorld(this._options.upNode, Scratch.local).getTranslationToRef(up);
+                    up.subtractInPlace(Scratch.origin);
+                }
+                else {
+                    up.copyFrom(this._options.sceneUp);
+                }
+                break;
+            case 2: // copy the up vector from the up node's orientation
+                if (this._options.upNode) {
+                    this._fbxWorld(this._options.upNode, Scratch.local).decompose(Scratch.decomposedScale, Scratch.decomposedRotation, Scratch.translation);
+                    up.set(c.worldUpVector[0], c.worldUpVector[1], c.worldUpVector[2]);
+                    up.rotateByQuaternionToRef(Scratch.decomposedRotation, up);
+                }
+                else {
+                    up.copyFrom(this._options.sceneUp);
+                }
+                break;
+            case 3: // explicit world vector
+                up.set(c.worldUpVector[0], c.worldUpVector[1], c.worldUpVector[2]);
+                break;
+            case 4: // none: keep the current roll by using the node's current up
+                Scratch.localValue.set(c.upVector[0], c.upVector[1], c.upVector[2]);
+                Vector3.TransformNormalToRef(Scratch.localValue, nodeWorld, up);
+                break;
+            default: // scene up
+                up.copyFrom(this._options.sceneUp);
+                break;
+        }
+        if (up.lengthSquared() < 1e-20 || Math.abs(Vector3.Dot(up.normalizeToRef(Scratch.localValue), Scratch.forward)) > 0.9999) {
+            // Degenerate up: pick any perpendicular vector
+            if (Math.abs(Scratch.forward.y) < 0.9) {
+                up.set(0, 1, 0);
+            }
+            else {
+                up.set(1, 0, 0);
+            }
+        }
+        // World basis (forward, up, side); the local basis (aimVector, upVector, side) is fixed per constraint.
+        if (!FBXConstraintBehavior._OrthonormalBasisToRef(Scratch.forward, up, Scratch.mA)) {
+            return;
+        }
+        // rotation R with R(localBasis) = worldBasis: R = localBasis^T * worldBasis (row-vector convention)
+        this._localBasisTransposed.multiplyToRef(Scratch.mA, Scratch.mB);
+        this._offsetRotation.multiplyToRef(Scratch.mB, Scratch.mC);
+        Scratch.mC.multiplyToRef(Scratch.invParent, Scratch.mD);
+        Scratch.mD.decompose(Scratch.decomposedScale, Scratch.decomposedRotation, Scratch.translation);
+        this._applyRotation(node, Scratch.decomposedRotation, c.affectRotation);
+    }
+    /**
+     * Builds a rotation matrix whose rows are `first`, `second` made orthogonal to it, and their cross product.
+     * @param first - primary axis
+     * @param second - secondary axis
+     * @param out - matrix receiving the basis
+     * @returns false when the axes are parallel or degenerate (`out` is then unchanged)
+     */
+    static _OrthonormalBasisToRef(first, second, out) {
+        const a = Scratch.axisA;
+        const b = Scratch.axisB;
+        const cr = Scratch.axisC;
+        first.normalizeToRef(a);
+        second.subtractToRef(a.scaleToRef(Vector3.Dot(a, second), b), b);
+        if (a.lengthSquared() < 1e-20 || b.lengthSquared() < 1e-20) {
+            return false;
+        }
+        b.normalize();
+        Vector3.CrossToRef(a, b, cr);
+        Matrix.FromValuesToRef(a.x, a.y, a.z, 0, b.x, b.y, b.z, 0, cr.x, cr.y, cr.z, 0, 0, 0, 0, 1, out);
+        return true;
+    }
+}
+//# sourceMappingURL=fbxConstraintBehavior.js.map

package/FBX/fbxConstraintBehavior.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fbxConstraintBehavior.js","sourceRoot":"","sources":["../../../../dev/loaders/src/FBX/fbxConstraintBehavior.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAG1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAE3D,MAAM,OAAO,GAAG,IAAI,CAAC,EAAE,GAAG,GAAG,CAAC;AAwB9B,sGAAsG;AACtG,MAAM,OAAO,GAAG;IACZ,OAAO,EAAE,IAAI,MAAM,EAAE;IACrB,MAAM,EAAE,IAAI,MAAM,EAAE;IACpB,SAAS,EAAE,IAAI,MAAM,EAAE;IACvB,KAAK,EAAE,IAAI,MAAM,EAAE;IACnB,KAAK,EAAE,IAAI,MAAM,EAAE;IACnB,EAAE,EAAE,IAAI,MAAM,EAAE;IAChB,EAAE,EAAE,IAAI,MAAM,EAAE;IAChB,EAAE,EAAE,IAAI,MAAM,EAAE;IAChB,EAAE,EAAE,IAAI,MAAM,EAAE;IAChB,QAAQ,EAAE,IAAI,OAAO,EAAE;IACvB,KAAK,EAAE,IAAI,OAAO,EAAE;IACpB,WAAW,EAAE,IAAI,OAAO,EAAE;IAC1B,eAAe,EAAE,IAAI,OAAO,EAAE;IAC9B,UAAU,EAAE,IAAI,OAAO,EAAE;IACzB,EAAE,EAAE,IAAI,OAAO,EAAE;IACjB,OAAO,EAAE,IAAI,OAAO,EAAE;IACtB,MAAM,EAAE,IAAI,OAAO,EAAE;IACrB,KAAK,EAAE,IAAI,OAAO,EAAE;IACpB,KAAK,EAAE,IAAI,OAAO,EAAE;IACpB,KAAK,EAAE,IAAI,OAAO,EAAE;IACpB,MAAM,EAAE,IAAI,OAAO,EAAE;IACrB,MAAM,EAAE,IAAI,OAAO,EAAE;IACrB,QAAQ,EAAE,IAAI,UAAU,EAAE;IAC1B,kBAAkB,EAAE,IAAI,UAAU,EAAE;IACpC,MAAM,EAAE,IAAI,UAAU,EAAE;CAC3B,CAAC;AAEF,MAAM,OAAO,GAAG,IAAI,OAAO,EAA8B,CAAC;AAE1D;;;;GAIG;AACH,MAAM,OAAO,mBAAmB;IAS5B,YAAoB,KAAY;QAPf,eAAU,GAA4B,EAAE,CAAC;QAClD,aAAQ,GAA4B,EAAE,CAAC;QACvC,YAAO,GAA4B,EAAE,CAAC;QACtC,WAAM,GAAG,KAAK,CAAC;QACf,sBAAiB,GAA8B,IAAI,CAAC;QACpD,qBAAgB,GAA8B,IAAI,CAAC;QAGvD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACxB,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,GAAG,CAAC,KAAY;QAC1B,OAAO,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,WAAW,CAAC,KAAY;QAClC,IAAI,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAChC,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,MAAM,GAAG,IAAI,mBAAmB,CAAC,KAAK,CAAC,CAAC;YACxC,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAC/B,CAAC;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,uGAAuG;IACvG,IAAW,WAAW;QAClB,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED;;;OAGG;IACH,IAAW,iBAAiB;QACxB,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED;;;OAGG;IACI,QAAQ,CAAC,QAA+B;QAC3C,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACzC,OAAO;QACX,CAAC;QACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC/B,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC1B,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,MAAM,CAAC,4BAA4B,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;YAC/F,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,MAAM,CAAC,2BAA2B,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QAC5F,CAAC;IACL,CAAC;IAED;;;OAGG;IACI,UAAU,CAAC,QAA+B;QAC7C,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAChD,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACZ,OAAO;QACX,CAAC;QACD,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/B,IAAI,CAAC,MAAM,CAAC,4BAA4B,CAAC,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;YACxE,IAAI,CAAC,MAAM,CAAC,2BAA2B,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;YACtE,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;YAC9B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;YAC7B,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAChC,CAAC;IACL,CAAC;IAED,+EAA+E;IACxE,eAAe;QAClB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;IACvB,CAAC;IAED;;;OAGG;IACI,UAAU;QACb,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACrC,QAAQ,CAAC,WAAW,EAAE,CAAC;QAC3B,CAAC;IACL,CAAC;IAED;;;OAGG;IACI,KAAK;QACR,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACrC,QAAQ,CAAC,WAAW,EAAE,CAAC;QAC3B,CAAC;QACD,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnC,QAAQ,CAAC,QAAQ,EAAE,CAAC;QACxB,CAAC;IACL,CAAC;IAEO,YAAY;QAChB,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACf,OAAO;QACX,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC;QAClC,MAAM,KAAK,GAAG,SAAS,CAAC,MAAM,CAAC;QAC/B,8EAA8E;QAC9E,MAAM,YAAY,GAAe,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;QACzD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7B,MAAM,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,eAAe,EAAE,CAAC;YAC7C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC7B,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;oBACV,SAAS;gBACb,CAAC;gBACD,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC;gBACzC,IAAI,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,mBAAmB,CAAC,iBAAiB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC;oBACtF,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAC5B,CAAC;YACL,CAAC;QACL,CAAC;QACD,oFAAoF;QACpF,MAAM,SAAS,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC1D,MAAM,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;QACxC,MAAM,OAAO,GAA4B,EAAE,CAAC;QAC5C,IAAI,UAAU,GAAG,IAAI,CAAC;QACtB,OAAO,UAAU,EAAE,CAAC;YAChB,UAAU,GAAG,KAAK,CAAC;YACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC7B,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;oBAC9B,SAAS;gBACb,CAAC;gBACD,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;gBACf,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC3B,UAAU,GAAG,IAAI,CAAC;gBAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC7B,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;wBAC9C,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;oBACnB,CAAC;gBACL,CAAC;YACL,CAAC;QACL,CAAC;QACD,MAAM,MAAM,GAA4B,EAAE,CAAC;QAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7B,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;gBACX,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC1B,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/B,CAAC;QACL,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IAC1B,CAAC;IAEO,MAAM,CAAC,iBAAiB,CAAC,QAAuB,EAAE,IAAoB;QAC1E,IAAI,OAAO,GAAmB,IAAI,CAAC;QACnC,OAAO,OAAO,EAAE,CAAC;YACb,IAAI,OAAO,KAAK,QAAQ,EAAE,CAAC;gBACvB,OAAO,IAAI,CAAC;YAChB,CAAC;YACD,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;QAC7B,CAAC;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;CACJ;AAED,8FAA8F;AAC9F,MAAM,OAAO,qBAAqB;IAgB9B;;;;OAIG;IACH;IACI,8CAA8C;IAC9B,UAA6B,EAC5B,QAAsC;QADvC,eAAU,GAAV,UAAU,CAAmB;QAC5B,aAAQ,GAAR,QAAQ,CAA8B;QArB3D,uCAAuC;QAChC,iBAAY,GAA4B,IAAI,CAAC;QACpD,gEAAgE;QACzD,YAAO,GAAG,IAAI,CAAC;QAMtB,uHAAuH;QACtG,UAAK,GAAG,EAAE,QAAQ,EAAE,IAAI,OAAO,EAAE,EAAE,QAAQ,EAAE,IAAI,UAAU,EAAE,EAAE,OAAO,EAAE,IAAI,OAAO,EAAE,EAAE,CAAC;QACjG,aAAQ,GAAG,KAAK,CAAC;QAYrB,IAAI,CAAC,IAAI,GAAG,iBAAiB,UAAU,CAAC,IAAI,EAAE,CAAC;QAC/C,IAAI,CAAC,kBAAkB,GAAG,IAAI,OAAO,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;QACzI,IAAI,CAAC,eAAe,GAAG,gBAAgB,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,EAAE,UAAU,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,EAAE,UAAU,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC;QAChK,IAAI,CAAC,YAAY,GAAG,IAAI,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QACjH,MAAM,UAAU,GAAG,IAAI,MAAM,EAAE,CAAC;QAChC,IAAI,CAAC,qBAAqB,GAAG,qBAAqB,CAAC,sBAAsB,CACrE,IAAI,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EACtF,IAAI,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EACnF,UAAU,CACb;YACG,CAAC,CAAC,UAAU,CAAC,SAAS,EAAE;YACxB,CAAC,CAAC,IAAI,CAAC;IACf,CAAC;IAED,4BAA4B;IACrB,IAAI,KAAU,CAAC;IAEtB;;;;OAIG;IACI,MAAM,CAAC,MAAqB;QAC/B,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC;QAC3B,mBAAmB,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAClE,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,QAAQ,EAAE,CAAC;IACpB,CAAC;IAED,0EAA0E;IACnE,MAAM;QACT,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;QAC5E,CAAC;QACD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACI,WAAW;QACd,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC;QAC/B,IAAI,CAAC,IAAI,EAAE,CAAC;YACR,OAAO;QACX,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC3B,IAAI,CAAC,kBAAkB,GAAG,UAAU,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACxE,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC5C,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACtD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC1C,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;IACzB,CAAC;IAED;;;OAGG;IACI,WAAW;QACd,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC;QAC/B,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC1B,OAAO;QACX,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAC5C,IAAI,CAAC,kBAAmB,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACvD,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC9C,CAAC;IAED;;;OAGG;IACI,eAAe;QAClB,MAAM,KAAK,GAAqB,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACzE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACjC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAChE,OAAO,KAAK,CAAC;IACjB,CAAC;IAED;;;OAGG;IACI,QAAQ;QACX,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC;QAC/B,MAAM,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC;QAC1B,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC7F,OAAO;QACX,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACjB,IAAI,CAAC,WAAW,EAAE,CAAC;QACvB,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACzE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAiC,CAAC;QACtD,IAAI,MAAM,IAAI,OAAO,MAAM,CAAC,kBAAkB,KAAK,UAAU,EAAE,CAAC;YAC5D,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QAC3C,CAAC;aAAM,CAAC;YACJ,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACzC,CAAC;QACD,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAE9C,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;YACb,KAAK,UAAU;gBACX,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;gBAC1B,MAAM;YACV,KAAK,UAAU;gBACX,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;gBAC1B,MAAM;YACV,KAAK,OAAO;gBACR,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;gBACvB,MAAM;YACV,KAAK,QAAQ;gBACT,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;gBACxB,MAAM;YACV,KAAK,KAAK;gBACN,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;gBACrB,MAAM;YACV;gBACI,MAAM;QACd,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACK,SAAS,CAAC,IAAmB,EAAE,GAAW;QAC9C,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;QAClE,OAAO,GAAG,CAAC;IACf,CAAC;IAED;;;;;;OAMG;IACK,aAAa,CAAC,QAAiB,EAAE,QAAoB,EAAE,KAAc;QACzE,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACtB,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACnB,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACzB,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;YACzC,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;gBACrB,SAAS;YACb,CAAC;YACD,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;YACvF,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,eAAe,EAAE,OAAO,CAAC,kBAAkB,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;YAClG,MAAM,IAAI,GAAG,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;YACnC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,WAAW,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;YACrE,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;YACtE,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;gBACd,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;YAClD,CAAC;iBAAM,CAAC;gBACJ,UAAU,CAAC,UAAU,CAAC,QAAQ,EAAE,OAAO,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,GAAG,IAAI,EAAE,QAAQ,CAAC,CAAC;YAChG,CAAC;YACD,KAAK,GAAG,IAAI,CAAC;QACjB,CAAC;QACD,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACZ,QAAQ,CAAC,YAAY,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC;YACjC,KAAK,CAAC,YAAY,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC;QAClC,CAAC;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IAEO,cAAc,CAAC,IAAa,EAAE,OAAgB,EAAE,IAAwB,EAAE,GAAY;QAC1F,MAAM,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;QACjC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC9K,CAAC;IAEO,cAAc,CAAC,IAAmB,EAAE,YAAwB,EAAE,IAAwB;QAC1F,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;QACjC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC9B,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;QAC9B,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACnC,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YACxC,YAAY,CAAC,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAChD,UAAU,CAAC,oBAAoB,CAC3B,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAC7C,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAC7C,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAC7C,MAAM,CACT,CAAC;QACN,CAAC;QACD,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7B,UAAU,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACxE,CAAC;QACD,IAAI,CAAC,kBAAmB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAEO,cAAc,CAAC,IAAmB,EAAE,YAAqB;QAC7D,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC7G,CAAC;IAEO,aAAa,CAAC,IAAmB,EAAE,YAAqB;QAC5D,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACrG,CAAC;IAEO,cAAc,CAAC,IAAmB;QACtC,IAAI,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9E,OAAO;QACX,CAAC;QACD,OAAO,CAAC,yBAAyB,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;QAC3F,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACvD,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAClD,CAAC;IAEO,cAAc,CAAC,IAAmB;QACtC,IAAI,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9E,OAAO;QACX,CAAC;QACD,MAAM,CAAC,mBAAmB,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;QACzD,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;QAC3D,OAAO,CAAC,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;QACxD,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,eAAe,EAAE,OAAO,CAAC,kBAAkB,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;QAC/F,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,kBAAkB,EAAE,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;IAC1F,CAAC;IAEO,WAAW,CAAC,IAAmB;QACnC,IAAI,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9E,OAAO;QACX,CAAC;QACD,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,eAAe,EAAE,OAAO,CAAC,kBAAkB,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;QACnG,MAAM,WAAW,GAAG,OAAO,CAAC,eAAe,CAAC;QAC5C,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;QAC5B,OAAO,CAAC,UAAU,CAAC,GAAG,CAClB,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,EAC/E,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,EAC/E,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAClF,CAAC;QACF,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IACjD,CAAC;IAEO,YAAY,CAAC,IAAmB;QACpC,IAAI,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9E,OAAO;QACX,CAAC;QACD,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;QACnF,OAAO,CAAC,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;QACxD,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,eAAe,EAAE,OAAO,CAAC,kBAAkB,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;QAC/F,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;QAC/C,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,kBAAkB,EAAE,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;QACtF,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IACtD,CAAC;IAEO,SAAS,CAAC,IAAmB;QACjC,MAAM,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,qBAAqB,IAAI,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YAC7G,OAAO;QACX,CAAC;QACD,4EAA4E;QAC5E,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;QACtD,SAAS,CAAC,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC9C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;QAChE,IAAI,OAAO,CAAC,OAAO,CAAC,aAAa,EAAE,GAAG,KAAK,EAAE,CAAC;YAC1C,OAAO;QACX,CAAC;QACD,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;QAE5B,8BAA8B;QAC9B,MAAM,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC;QACtB,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;YACpB,KAAK,CAAC,EAAE,mCAAmC;gBACvC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;oBACvB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC;oBAC5E,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;gBACvC,CAAC;qBAAM,CAAC;oBACJ,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;gBACvC,CAAC;gBACD,MAAM;YACV,KAAK,CAAC,EAAE,oDAAoD;gBACxD,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;oBACvB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,eAAe,EAAE,OAAO,CAAC,kBAAkB,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;oBACxI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;oBACnE,EAAE,CAAC,uBAAuB,CAAC,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC,CAAC;gBAC/D,CAAC;qBAAM,CAAC;oBACJ,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;gBACvC,CAAC;gBACD,MAAM;YACV,KAAK,CAAC,EAAE,wBAAwB;gBAC5B,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;gBACnE,MAAM;YACV,KAAK,CAAC,EAAE,6DAA6D;gBACjE,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;gBACpE,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,UAAU,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC;gBAChE,MAAM;YACV,SAAS,WAAW;gBAChB,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;gBACnC,MAAM;QACd,CAAC;QACD,IAAI,EAAE,CAAC,aAAa,EAAE,GAAG,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,cAAc,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,MAAM,EAAE,CAAC;YACvH,+CAA+C;YAC/C,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC;gBACpC,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;YACpB,CAAC;iBAAM,CAAC;gBACJ,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;YACpB,CAAC;QACL,CAAC;QAED,wGAAwG;QACxG,IAAI,CAAC,qBAAqB,CAAC,sBAAsB,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC;YACjF,OAAO;QACX,CAAC;QACD,oGAAoG;QACpG,IAAI,CAAC,qBAAqB,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;QACjE,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;QAC3D,OAAO,CAAC,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;QACxD,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,eAAe,EAAE,OAAO,CAAC,kBAAkB,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;QAC/F,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAC,cAAc,CAAC,CAAC;IAC5E,CAAC;IAED;;;;;;OAMG;IACK,MAAM,CAAC,sBAAsB,CAAC,KAAc,EAAE,MAAe,EAAE,GAAW;QAC9E,MAAM,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC;QACxB,MAAM,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC;QACxB,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC;QACzB,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;QACxB,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACjE,IAAI,CAAC,CAAC,aAAa,EAAE,GAAG,KAAK,IAAI,CAAC,CAAC,aAAa,EAAE,GAAG,KAAK,EAAE,CAAC;YACzD,OAAO,KAAK,CAAC;QACjB,CAAC;QACD,CAAC,CAAC,SAAS,EAAE,CAAC;QACd,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QAC7B,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;QACjG,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ","sourcesContent":["/* eslint-disable @typescript-eslint/naming-convention */\n/**\n * Runtime evaluation of FBX constraints. An `FBXConstraintBehavior` is attached to each constrained node; all\n * behaviors of a scene register with one `FBXConstraintSolver`, which solves them in dependency order (a constraint\n * whose target or parent is driven by another constraint is solved after it) and reuses scratch objects, so solving\n * allocates nothing per frame.\n *\n * The solver brackets the scene's animation phase: before animations run it writes each node's unconstrained\n * transform back, after they ran it captures the result as the new unconstrained transform and solves. A partial\n * weight therefore always blends from what animation (or nothing) produced this frame, never from the previous\n * solve's output, so a 50% weight stays a 50% blend instead of converging on the target.\n *\n * All maths happen in FBX space, i.e. relative to the loader's root node, so the handedness conversion applied\n * at the root never enters the solve.\n */\nimport { type Behavior } from \"core/Behaviors/behavior\";\nimport { type Nullable } from \"core/types\";\nimport { type Node } from \"core/node\";\nimport { type Observer } from \"core/Misc/observable\";\nimport { type Scene } from \"core/scene\";\nimport { Matrix, Quaternion, Vector3 } from \"core/Maths/math.vector.pure\";\nimport { type TransformNode } from \"core/Meshes/transformNode.pure\";\nimport { type FBXConstraintData } from \"./interpreter/constraints\";\nimport { eulerToMatrixXYZ } from \"./interpreter/transform\";\n\nconst DEG2RAD = Math.PI / 180;\n\n/** Resolved target of a constraint. */\nexport interface FBXConstraintBehaviorTarget {\n    /** Target node */\n    node: TransformNode;\n    /** Normalized target weight (0..1) */\n    weight: number;\n    /** Offset matrix for parent constraints (in the target's space) */\n    offset: Matrix;\n}\n\n/** Options resolved by the loader when creating the behavior. */\nexport interface FBXConstraintBehaviorOptions {\n    /** Root of the loaded asset; world matrices are made relative to it */\n    root: TransformNode;\n    /** Resolved targets of the constraint, in file order */\n    targets: FBXConstraintBehaviorTarget[];\n    /** World up object of an aim constraint, when it has one */\n    upNode: Nullable<TransformNode>;\n    /** Scene up axis in FBX space */\n    sceneUp: Vector3;\n}\n\n/** Scratch objects shared by every solve; the solver runs on one thread, one constraint at a time. */\nconst Scratch = {\n    invRoot: new Matrix(),\n    parent: new Matrix(),\n    invParent: new Matrix(),\n    world: new Matrix(),\n    local: new Matrix(),\n    mA: new Matrix(),\n    mB: new Matrix(),\n    mC: new Matrix(),\n    mD: new Matrix(),\n    position: new Vector3(),\n    scale: new Vector3(),\n    translation: new Vector3(),\n    decomposedScale: new Vector3(),\n    localValue: new Vector3(),\n    up: new Vector3(),\n    forward: new Vector3(),\n    origin: new Vector3(),\n    axisA: new Vector3(),\n    axisB: new Vector3(),\n    axisC: new Vector3(),\n    eulerA: new Vector3(),\n    eulerB: new Vector3(),\n    rotation: new Quaternion(),\n    decomposedRotation: new Quaternion(),\n    result: new Quaternion(),\n};\n\nconst Solvers = new WeakMap<Scene, FBXConstraintSolver>();\n\n/**\n * Solves every FBX constraint of a scene once per frame, in dependency order, from the scene's animation phase\n * observers (`beginFrame` before animations, `solve` after them). Created on demand by the first\n * `FBXConstraintBehavior` attached in the scene and removed with the last one.\n */\nexport class FBXConstraintSolver {\n    private readonly _scene: Scene;\n    private readonly _behaviors: FBXConstraintBehavior[] = [];\n    private _ordered: FBXConstraintBehavior[] = [];\n    private _cyclic: FBXConstraintBehavior[] = [];\n    private _dirty = false;\n    private _beforeAnimations: Nullable<Observer<Scene>> = null;\n    private _afterAnimations: Nullable<Observer<Scene>> = null;\n\n    private constructor(scene: Scene) {\n        this._scene = scene;\n    }\n\n    /**\n     * Solver of a scene, if any constraint behavior is attached in it.\n     * @param scene - Scene to look up\n     * @returns The solver, or undefined\n     */\n    public static Get(scene: Scene): FBXConstraintSolver | undefined {\n        return Solvers.get(scene);\n    }\n\n    /**\n     * Solver of a scene, created when missing.\n     * @param scene - Scene to look up\n     * @returns The solver\n     */\n    public static GetOrCreate(scene: Scene): FBXConstraintSolver {\n        let solver = Solvers.get(scene);\n        if (!solver) {\n            solver = new FBXConstraintSolver(scene);\n            Solvers.set(scene, solver);\n        }\n        return solver;\n    }\n\n    /** Registered behaviors in solve order (a target's constraint before the constraints that read it). */\n    public get constraints(): readonly FBXConstraintBehavior[] {\n        this._ensureOrder();\n        return this._ordered;\n    }\n\n    /**\n     * Behaviors that take part in a dependency cycle (A targets B while B targets A). They are solved after all\n     * acyclic constraints, in registration order, so each sees the other's result from the previous solve.\n     */\n    public get cyclicConstraints(): readonly FBXConstraintBehavior[] {\n        this._ensureOrder();\n        return this._cyclic;\n    }\n\n    /**\n     * Adds a behavior to the solve set.\n     * @param behavior - Behavior to add\n     */\n    public register(behavior: FBXConstraintBehavior): void {\n        if (this._behaviors.indexOf(behavior) >= 0) {\n            return;\n        }\n        this._behaviors.push(behavior);\n        this._dirty = true;\n        if (!this._beforeAnimations) {\n            this._beforeAnimations = this._scene.onBeforeAnimationsObservable.add(() => this.beginFrame());\n            this._afterAnimations = this._scene.onAfterAnimationsObservable.add(() => this.solve());\n        }\n    }\n\n    /**\n     * Removes a behavior from the solve set; the solver disposes itself with the last one.\n     * @param behavior - Behavior to remove\n     */\n    public unregister(behavior: FBXConstraintBehavior): void {\n        const index = this._behaviors.indexOf(behavior);\n        if (index < 0) {\n            return;\n        }\n        this._behaviors.splice(index, 1);\n        this._dirty = true;\n        if (this._behaviors.length === 0) {\n            this._scene.onBeforeAnimationsObservable.remove(this._beforeAnimations);\n            this._scene.onAfterAnimationsObservable.remove(this._afterAnimations);\n            this._beforeAnimations = null;\n            this._afterAnimations = null;\n            Solvers.delete(this._scene);\n        }\n    }\n\n    /** Marks the solve order stale, e.g. after re-parenting a constrained node. */\n    public invalidateOrder(): void {\n        this._dirty = true;\n    }\n\n    /**\n     * Start of a frame, before animations run: every constrained node gets its unconstrained transform back, so\n     * that animation either overwrites it or leaves it untouched.\n     */\n    public beginFrame(): void {\n        for (const behavior of this._behaviors) {\n            behavior.restoreBase();\n        }\n    }\n\n    /**\n     * End of the animation phase: takes every constrained node's current transform as its unconstrained value,\n     * then solves every registered constraint once, in dependency order.\n     */\n    public solve(): void {\n        this._ensureOrder();\n        for (const behavior of this._behaviors) {\n            behavior.captureBase();\n        }\n        for (const behavior of this._ordered) {\n            behavior.evaluate();\n        }\n    }\n\n    private _ensureOrder(): void {\n        if (!this._dirty) {\n            return;\n        }\n        this._dirty = false;\n        const behaviors = this._behaviors;\n        const count = behaviors.length;\n        // dependencies[i] lists the behaviors that must be solved before behaviors[i]\n        const dependencies: number[][] = behaviors.map(() => []);\n        for (let i = 0; i < count; i++) {\n            const reads = behaviors[i].dependencyNodes();\n            for (let j = 0; j < count; j++) {\n                if (i === j) {\n                    continue;\n                }\n                const driven = behaviors[j].attachedNode;\n                if (driven && reads.some((node) => FBXConstraintSolver._IsAncestorOrSelf(driven, node))) {\n                    dependencies[i].push(j);\n                }\n            }\n        }\n        // Kahn's algorithm; whatever is left when no free behavior remains sits on a cycle.\n        const remaining = dependencies.map((deps) => deps.length);\n        const done = behaviors.map(() => false);\n        const ordered: FBXConstraintBehavior[] = [];\n        let progressed = true;\n        while (progressed) {\n            progressed = false;\n            for (let i = 0; i < count; i++) {\n                if (done[i] || remaining[i] > 0) {\n                    continue;\n                }\n                done[i] = true;\n                ordered.push(behaviors[i]);\n                progressed = true;\n                for (let k = 0; k < count; k++) {\n                    if (!done[k] && dependencies[k].indexOf(i) >= 0) {\n                        remaining[k]--;\n                    }\n                }\n            }\n        }\n        const cyclic: FBXConstraintBehavior[] = [];\n        for (let i = 0; i < count; i++) {\n            if (!done[i]) {\n                cyclic.push(behaviors[i]);\n                ordered.push(behaviors[i]);\n            }\n        }\n        this._ordered = ordered;\n        this._cyclic = cyclic;\n    }\n\n    private static _IsAncestorOrSelf(ancestor: TransformNode, node: Nullable<Node>): boolean {\n        let current: Nullable<Node> = node;\n        while (current) {\n            if (current === ancestor) {\n                return true;\n            }\n            current = current.parent;\n        }\n        return false;\n    }\n}\n\n/** Babylon behavior evaluating an FBX aim, parent, position, rotation or scale constraint. */\nexport class FBXConstraintBehavior implements Behavior<TransformNode> {\n    /** Behavior name (`fbxConstraint:` followed by the constraint name) */\n    public readonly name: string;\n    /** Node the behavior is attached to */\n    public attachedNode: Nullable<TransformNode> = null;\n    /** Set to false to pause the constraint without detaching it */\n    public enabled = true;\n\n    private readonly _offsetTranslation: Vector3;\n    private readonly _offsetRotation: Matrix;\n    private readonly _offsetScale: Vector3;\n    private readonly _localBasisTransposed: Nullable<Matrix>;\n    /** Unconstrained transform of the current frame (what animation produced), blended towards the constraint's result. */\n    private readonly _base = { position: new Vector3(), rotation: new Quaternion(), scaling: new Vector3() };\n    private _hasBase = false;\n\n    /**\n     * Creates the behavior.\n     * @param constraint - Constraint data extracted from the file\n     * @param _options - Resolved targets and scene information\n     */\n    public constructor(\n        /** Constraint data extracted from the file */\n        public readonly constraint: FBXConstraintData,\n        private readonly _options: FBXConstraintBehaviorOptions\n    ) {\n        this.name = `fbxConstraint:${constraint.name}`;\n        this._offsetTranslation = new Vector3(constraint.offsetTranslation[0], constraint.offsetTranslation[1], constraint.offsetTranslation[2]);\n        this._offsetRotation = eulerToMatrixXYZ(constraint.offsetRotation[0] * DEG2RAD, constraint.offsetRotation[1] * DEG2RAD, constraint.offsetRotation[2] * DEG2RAD);\n        this._offsetScale = new Vector3(constraint.offsetScale[0], constraint.offsetScale[1], constraint.offsetScale[2]);\n        const localBasis = new Matrix();\n        this._localBasisTransposed = FBXConstraintBehavior._OrthonormalBasisToRef(\n            new Vector3(constraint.aimVector[0], constraint.aimVector[1], constraint.aimVector[2]),\n            new Vector3(constraint.upVector[0], constraint.upVector[1], constraint.upVector[2]),\n            localBasis\n        )\n            ? localBasis.transpose()\n            : null;\n    }\n\n    /** Nothing to initialize */\n    public init(): void {}\n\n    /**\n     * Registers the behavior with the scene's solver, takes the node's current transform as the unconstrained\n     * value and solves the constraint once.\n     * @param target - Node to constrain\n     */\n    public attach(target: TransformNode): void {\n        this.attachedNode = target;\n        FBXConstraintSolver.GetOrCreate(target.getScene()).register(this);\n        this.captureBase();\n        this.evaluate();\n    }\n\n    /** Unregisters the behavior; the node keeps its last solved transform. */\n    public detach(): void {\n        if (this.attachedNode) {\n            FBXConstraintSolver.Get(this.attachedNode.getScene())?.unregister(this);\n        }\n        this.attachedNode = null;\n        this._hasBase = false;\n    }\n\n    /**\n     * Takes the node's current transform as the unconstrained value the next solve blends from. The solver calls\n     * this after the scene's animations ran; call it yourself after writing a transform by hand.\n     */\n    public captureBase(): void {\n        const node = this.attachedNode;\n        if (!node) {\n            return;\n        }\n        if (!node.rotationQuaternion) {\n            node.rotationQuaternion = Quaternion.FromEulerVector(node.rotation);\n        }\n        this._base.position.copyFrom(node.position);\n        this._base.rotation.copyFrom(node.rotationQuaternion);\n        this._base.scaling.copyFrom(node.scaling);\n        this._hasBase = true;\n    }\n\n    /**\n     * Writes the unconstrained transform back to the node. The solver calls this before the scene's animations\n     * run, so a node nothing animates keeps its unconstrained value between frames instead of the solved one.\n     */\n    public restoreBase(): void {\n        const node = this.attachedNode;\n        if (!node || !this._hasBase) {\n            return;\n        }\n        node.position.copyFrom(this._base.position);\n        node.rotationQuaternion!.copyFrom(this._base.rotation);\n        node.scaling.copyFrom(this._base.scaling);\n    }\n\n    /**\n     * Nodes whose world transform the solve reads: the targets, the up node and the constrained node's parent.\n     * @returns The nodes, used by the solver to order constraints\n     */\n    public dependencyNodes(): Nullable<Node>[] {\n        const nodes: Nullable<Node>[] = this._options.targets.map((t) => t.node);\n        nodes.push(this._options.upNode);\n        nodes.push(this.attachedNode ? this.attachedNode.parent : null);\n        return nodes;\n    }\n\n    /**\n     * Solves the constraint from the captured unconstrained transform and writes the node's local transform.\n     * Blends are relative to the value captured by `captureBase`, not to whatever the node holds now.\n     */\n    public evaluate(): void {\n        const node = this.attachedNode;\n        const c = this.constraint;\n        if (!node || !this.enabled || !c.active || c.weight <= 0 || this._options.targets.length === 0) {\n            return;\n        }\n        if (!this._hasBase) {\n            this.captureBase();\n        }\n        this._options.root.computeWorldMatrix(true).invertToRef(Scratch.invRoot);\n        const parent = node.parent as Nullable<TransformNode>;\n        if (parent && typeof parent.computeWorldMatrix === \"function\") {\n            this._fbxWorld(parent, Scratch.parent);\n        } else {\n            Matrix.IdentityToRef(Scratch.parent);\n        }\n        Scratch.parent.invertToRef(Scratch.invParent);\n\n        switch (c.type) {\n            case \"position\":\n                this._solvePosition(node);\n                break;\n            case \"rotation\":\n                this._solveRotation(node);\n                break;\n            case \"scale\":\n                this._solveScale(node);\n                break;\n            case \"parent\":\n                this._solveParent(node);\n                break;\n            case \"aim\":\n                this._solveAim(node);\n                break;\n            default:\n                break;\n        }\n    }\n\n    /**\n     * World matrix of a node relative to the asset root (FBX space).\n     * @param node - node to evaluate\n     * @param out - matrix receiving the result\n     * @returns `out`\n     */\n    private _fbxWorld(node: TransformNode, out: Matrix): Matrix {\n        node.computeWorldMatrix(true).multiplyToRef(Scratch.invRoot, out);\n        return out;\n    }\n\n    /**\n     * Weighted blend of the targets' world transforms (relative to the root).\n     * @param position - Receives the blended translation\n     * @param rotation - Receives the blended rotation\n     * @param scale - Receives the blended scale\n     * @returns The total target weight, 0 when no target contributes\n     */\n    private _blendTargets(position: Vector3, rotation: Quaternion, scale: Vector3): number {\n        position.set(0, 0, 0);\n        scale.set(0, 0, 0);\n        rotation.set(0, 0, 0, 1);\n        let total = 0;\n        for (const target of this._options.targets) {\n            if (target.weight <= 0) {\n                continue;\n            }\n            target.offset.multiplyToRef(this._fbxWorld(target.node, Scratch.world), Scratch.local);\n            Scratch.local.decompose(Scratch.decomposedScale, Scratch.decomposedRotation, Scratch.translation);\n            const next = total + target.weight;\n            position.addInPlace(Scratch.translation.scaleInPlace(target.weight));\n            scale.addInPlace(Scratch.decomposedScale.scaleInPlace(target.weight));\n            if (total === 0) {\n                rotation.copyFrom(Scratch.decomposedRotation);\n            } else {\n                Quaternion.SlerpToRef(rotation, Scratch.decomposedRotation, target.weight / next, rotation);\n            }\n            total = next;\n        }\n        if (total > 0) {\n            position.scaleInPlace(1 / total);\n            scale.scaleInPlace(1 / total);\n        }\n        return total;\n    }\n\n    private _applyWeighted(base: Vector3, desired: Vector3, mask: readonly boolean[], out: Vector3): void {\n        const w = this.constraint.weight;\n        out.set(mask[0] ? base.x + (desired.x - base.x) * w : base.x, mask[1] ? base.y + (desired.y - base.y) * w : base.y, mask[2] ? base.z + (desired.z - base.z) * w : base.z);\n    }\n\n    private _applyRotation(node: TransformNode, desiredLocal: Quaternion, mask: readonly boolean[]): void {\n        const base = this._base.rotation;\n        const result = Scratch.result;\n        result.copyFrom(desiredLocal);\n        if (!(mask[0] && mask[1] && mask[2])) {\n            base.toEulerAnglesToRef(Scratch.eulerA);\n            desiredLocal.toEulerAnglesToRef(Scratch.eulerB);\n            Quaternion.FromEulerAnglesToRef(\n                mask[0] ? Scratch.eulerB.x : Scratch.eulerA.x,\n                mask[1] ? Scratch.eulerB.y : Scratch.eulerA.y,\n                mask[2] ? Scratch.eulerB.z : Scratch.eulerA.z,\n                result\n            );\n        }\n        if (this.constraint.weight < 1) {\n            Quaternion.SlerpToRef(base, result, this.constraint.weight, result);\n        }\n        node.rotationQuaternion!.copyFrom(result);\n    }\n\n    private _writePosition(node: TransformNode, desiredLocal: Vector3): void {\n        this._applyWeighted(this._base.position, desiredLocal, this.constraint.affectTranslation, node.position);\n    }\n\n    private _writeScaling(node: TransformNode, desiredLocal: Vector3): void {\n        this._applyWeighted(this._base.scaling, desiredLocal, this.constraint.affectScale, node.scaling);\n    }\n\n    private _solvePosition(node: TransformNode): void {\n        if (this._blendTargets(Scratch.position, Scratch.rotation, Scratch.scale) === 0) {\n            return;\n        }\n        Vector3.TransformCoordinatesToRef(Scratch.position, Scratch.invParent, Scratch.localValue);\n        Scratch.localValue.addInPlace(this._offsetTranslation);\n        this._writePosition(node, Scratch.localValue);\n    }\n\n    private _solveRotation(node: TransformNode): void {\n        if (this._blendTargets(Scratch.position, Scratch.rotation, Scratch.scale) === 0) {\n            return;\n        }\n        Matrix.FromQuaternionToRef(Scratch.rotation, Scratch.mA);\n        this._offsetRotation.multiplyToRef(Scratch.mA, Scratch.mB);\n        Scratch.mB.multiplyToRef(Scratch.invParent, Scratch.mC);\n        Scratch.mC.decompose(Scratch.decomposedScale, Scratch.decomposedRotation, Scratch.translation);\n        this._applyRotation(node, Scratch.decomposedRotation, this.constraint.affectRotation);\n    }\n\n    private _solveScale(node: TransformNode): void {\n        if (this._blendTargets(Scratch.position, Scratch.rotation, Scratch.scale) === 0) {\n            return;\n        }\n        Scratch.parent.decompose(Scratch.decomposedScale, Scratch.decomposedRotation, Scratch.translation);\n        const parentScale = Scratch.decomposedScale;\n        const scale = Scratch.scale;\n        Scratch.localValue.set(\n            (parentScale.x !== 0 ? scale.x / parentScale.x : scale.x) * this._offsetScale.x,\n            (parentScale.y !== 0 ? scale.y / parentScale.y : scale.y) * this._offsetScale.y,\n            (parentScale.z !== 0 ? scale.z / parentScale.z : scale.z) * this._offsetScale.z\n        );\n        this._writeScaling(node, Scratch.localValue);\n    }\n\n    private _solveParent(node: TransformNode): void {\n        if (this._blendTargets(Scratch.position, Scratch.rotation, Scratch.scale) === 0) {\n            return;\n        }\n        Matrix.ComposeToRef(Scratch.scale, Scratch.rotation, Scratch.position, Scratch.mA);\n        Scratch.mA.multiplyToRef(Scratch.invParent, Scratch.mB);\n        Scratch.mB.decompose(Scratch.decomposedScale, Scratch.decomposedRotation, Scratch.translation);\n        this._writePosition(node, Scratch.translation);\n        this._applyRotation(node, Scratch.decomposedRotation, this.constraint.affectRotation);\n        this._writeScaling(node, Scratch.decomposedScale);\n    }\n\n    private _solveAim(node: TransformNode): void {\n        const c = this.constraint;\n        if (!this._localBasisTransposed || this._blendTargets(Scratch.position, Scratch.rotation, Scratch.scale) === 0) {\n            return;\n        }\n        // The node's own world position (after animation) is the origin of the aim.\n        const nodeWorld = this._fbxWorld(node, Scratch.world);\n        nodeWorld.getTranslationToRef(Scratch.origin);\n        Scratch.position.subtractToRef(Scratch.origin, Scratch.forward);\n        if (Scratch.forward.lengthSquared() < 1e-20) {\n            return;\n        }\n        Scratch.forward.normalize();\n\n        // Up direction in world space\n        const up = Scratch.up;\n        switch (c.worldUpType) {\n            case 1: // aim the up vector at the up node\n                if (this._options.upNode) {\n                    this._fbxWorld(this._options.upNode, Scratch.local).getTranslationToRef(up);\n                    up.subtractInPlace(Scratch.origin);\n                } else {\n                    up.copyFrom(this._options.sceneUp);\n                }\n                break;\n            case 2: // copy the up vector from the up node's orientation\n                if (this._options.upNode) {\n                    this._fbxWorld(this._options.upNode, Scratch.local).decompose(Scratch.decomposedScale, Scratch.decomposedRotation, Scratch.translation);\n                    up.set(c.worldUpVector[0], c.worldUpVector[1], c.worldUpVector[2]);\n                    up.rotateByQuaternionToRef(Scratch.decomposedRotation, up);\n                } else {\n                    up.copyFrom(this._options.sceneUp);\n                }\n                break;\n            case 3: // explicit world vector\n                up.set(c.worldUpVector[0], c.worldUpVector[1], c.worldUpVector[2]);\n                break;\n            case 4: // none: keep the current roll by using the node's current up\n                Scratch.localValue.set(c.upVector[0], c.upVector[1], c.upVector[2]);\n                Vector3.TransformNormalToRef(Scratch.localValue, nodeWorld, up);\n                break;\n            default: // scene up\n                up.copyFrom(this._options.sceneUp);\n                break;\n        }\n        if (up.lengthSquared() < 1e-20 || Math.abs(Vector3.Dot(up.normalizeToRef(Scratch.localValue), Scratch.forward)) > 0.9999) {\n            // Degenerate up: pick any perpendicular vector\n            if (Math.abs(Scratch.forward.y) < 0.9) {\n                up.set(0, 1, 0);\n            } else {\n                up.set(1, 0, 0);\n            }\n        }\n\n        // World basis (forward, up, side); the local basis (aimVector, upVector, side) is fixed per constraint.\n        if (!FBXConstraintBehavior._OrthonormalBasisToRef(Scratch.forward, up, Scratch.mA)) {\n            return;\n        }\n        // rotation R with R(localBasis) = worldBasis: R = localBasis^T * worldBasis (row-vector convention)\n        this._localBasisTransposed.multiplyToRef(Scratch.mA, Scratch.mB);\n        this._offsetRotation.multiplyToRef(Scratch.mB, Scratch.mC);\n        Scratch.mC.multiplyToRef(Scratch.invParent, Scratch.mD);\n        Scratch.mD.decompose(Scratch.decomposedScale, Scratch.decomposedRotation, Scratch.translation);\n        this._applyRotation(node, Scratch.decomposedRotation, c.affectRotation);\n    }\n\n    /**\n     * Builds a rotation matrix whose rows are `first`, `second` made orthogonal to it, and their cross product.\n     * @param first - primary axis\n     * @param second - secondary axis\n     * @param out - matrix receiving the basis\n     * @returns false when the axes are parallel or degenerate (`out` is then unchanged)\n     */\n    private static _OrthonormalBasisToRef(first: Vector3, second: Vector3, out: Matrix): boolean {\n        const a = Scratch.axisA;\n        const b = Scratch.axisB;\n        const cr = Scratch.axisC;\n        first.normalizeToRef(a);\n        second.subtractToRef(a.scaleToRef(Vector3.Dot(a, second), b), b);\n        if (a.lengthSquared() < 1e-20 || b.lengthSquared() < 1e-20) {\n            return false;\n        }\n        b.normalize();\n        Vector3.CrossToRef(a, b, cr);\n        Matrix.FromValuesToRef(a.x, a.y, a.z, 0, b.x, b.y, b.z, 0, cr.x, cr.y, cr.z, 0, 0, 0, 0, 1, out);\n        return true;\n    }\n}\n"]}