reze-engine 0.2.18 → 0.3.0

package/dist/model.js

@@ -1,7 +1,24 @@
-import { Mat4, Quat, easeInOut } from "./math";
+import { Mat4, Quat, Vec3, easeInOut } from "./math";
+import { IKSolverSystem } from "./ik-solver";
 const VERTEX_STRIDE = 8;
+// Euler rotation order for angle constraints
+export var EulerRotationOrder;
+(function (EulerRotationOrder) {
+    EulerRotationOrder[EulerRotationOrder["YXZ"] = 0] = "YXZ";
+    EulerRotationOrder[EulerRotationOrder["ZYX"] = 1] = "ZYX";
+    EulerRotationOrder[EulerRotationOrder["XZY"] = 2] = "XZY";
+})(EulerRotationOrder || (EulerRotationOrder = {}));
+// Solve axis optimization
+export var SolveAxis;
+(function (SolveAxis) {
+    SolveAxis[SolveAxis["None"] = 0] = "None";
+    SolveAxis[SolveAxis["Fixed"] = 1] = "Fixed";
+    SolveAxis[SolveAxis["X"] = 2] = "X";
+    SolveAxis[SolveAxis["Y"] = 3] = "Y";
+    SolveAxis[SolveAxis["Z"] = 4] = "Z";
+})(SolveAxis || (SolveAxis = {}));
 export class Model {
-    constructor(vertexData, indexData, textures, materials, skeleton, skinning, rigidbodies = [], joints = []) {
+    constructor(vertexData, indexData, textures, materials, skeleton, skinning, morphing, rigidbodies = [], joints = []) {
         this.textures = [];
         this.materials = [];
         // Physics data from PMX
@@ -10,6 +27,8 @@ export class Model {
         // Cached identity matrices to avoid allocations in computeWorldMatrices
         this.cachedIdentityMat1 = Mat4.identity();
         this.cachedIdentityMat2 = Mat4.identity();
+        // Store base vertex data (original positions before morphing)
+        this.baseVertexData = new Float32Array(vertexData);
         this.vertexData = vertexData;
         this.vertexCount = vertexData.length / VERTEX_STRIDE;
         this.indexData = indexData;
@@ -17,6 +36,7 @@ export class Model {
         this.materials = materials;
         this.skeleton = skeleton;
         this.skinning = skinning;
+        this.morphing = morphing;
         this.rigidbodies = rigidbodies;
         this.joints = joints;
         if (this.skeleton.bones.length == 0) {
@@ -24,6 +44,10 @@ export class Model {
         }
         this.initializeRuntimeSkeleton();
         this.initializeRotTweenBuffers();
+        this.initializeTransTweenBuffers();
+        this.initializeRuntimeMorph();
+        this.initializeMorphTweenBuffers();
+        this.applyMorphs(); // Apply initial morphs (all weights are 0, so no change)
     }
     initializeRuntimeSkeleton() {
         const boneCount = this.skeleton.bones.length;
@@ -47,6 +71,51 @@ export class Model {
                 rotations[qi + 3] = 1;
             }
         }
+        // Initialize IK runtime state
+        this.initializeIKRuntime();
+    }
+    initializeIKRuntime() {
+        const boneCount = this.skeleton.bones.length;
+        const bones = this.skeleton.bones;
+        // Initialize IK chain info for all bones (will be populated for IK chain bones)
+        const ikChainInfo = new Array(boneCount);
+        for (let i = 0; i < boneCount; i++) {
+            ikChainInfo[i] = {
+                ikRotation: new Quat(0, 0, 0, 1),
+                localRotation: new Quat(0, 0, 0, 1),
+            };
+        }
+        // Build IK solvers from bone data
+        const ikSolvers = [];
+        let solverIndex = 0;
+        for (let i = 0; i < boneCount; i++) {
+            const bone = bones[i];
+            if (bone.ikTargetIndex !== undefined && bone.ikLinks && bone.ikLinks.length > 0) {
+                // Check if all links are affected by physics (for optimization)
+                let canSkipWhenPhysicsEnabled = true;
+                for (const link of bone.ikLinks) {
+                    // For now, assume no bones are physics-controlled (can be enhanced later)
+                    // If a bone has a rigidbody attached, it's physics-controlled
+                    const hasPhysics = this.rigidbodies.some((rb) => rb.boneIndex === link.boneIndex);
+                    if (!hasPhysics) {
+                        canSkipWhenPhysicsEnabled = false;
+                        break;
+                    }
+                }
+                const solver = {
+                    index: solverIndex++,
+                    ikBoneIndex: i,
+                    targetBoneIndex: bone.ikTargetIndex,
+                    iterationCount: bone.ikIteration ?? 1,
+                    limitAngle: bone.ikLimitAngle ?? Math.PI,
+                    links: bone.ikLinks,
+                    canSkipWhenPhysicsEnabled,
+                };
+                ikSolvers.push(solver);
+            }
+        }
+        this.runtimeSkeleton.ikChainInfo = ikChainInfo;
+        this.runtimeSkeleton.ikSolvers = ikSolvers;
     }
     initializeRotTweenBuffers() {
         const n = this.skeleton.bones.length;
@@ -58,6 +127,36 @@ export class Model {
             durationMs: new Float32Array(n),
         };
     }
+    initializeTransTweenBuffers() {
+        const n = this.skeleton.bones.length;
+        this.transTweenState = {
+            active: new Uint8Array(n),
+            startVec: new Float32Array(n * 3),
+            targetVec: new Float32Array(n * 3),
+            startTimeMs: new Float32Array(n),
+            durationMs: new Float32Array(n),
+        };
+    }
+    initializeMorphTweenBuffers() {
+        const n = this.morphing.morphs.length;
+        this.morphTweenState = {
+            active: new Uint8Array(n),
+            startWeight: new Float32Array(n),
+            targetWeight: new Float32Array(n),
+            startTimeMs: new Float32Array(n),
+            durationMs: new Float32Array(n),
+        };
+    }
+    initializeRuntimeMorph() {
+        const morphCount = this.morphing.morphs.length;
+        this.runtimeMorph = {
+            nameIndex: this.morphing.morphs.reduce((acc, morph, index) => {
+                acc[morph.name] = index;
+                return acc;
+            }, {}),
+            weights: new Float32Array(morphCount),
+        };
+    }
     updateRotationTweens() {
         const state = this.rotTweenState;
         const now = performance.now();
@@ -82,6 +181,48 @@ export class Model {
                 state.active[i] = 0;
         }
     }
+    updateTranslationTweens() {
+        const state = this.transTweenState;
+        const now = performance.now();
+        const translations = this.runtimeSkeleton.localTranslations;
+        const boneCount = this.skeleton.bones.length;
+        for (let i = 0; i < boneCount; i++) {
+            if (state.active[i] !== 1)
+                continue;
+            const startMs = state.startTimeMs[i];
+            const durMs = Math.max(1, state.durationMs[i]);
+            const t = Math.max(0, Math.min(1, (now - startMs) / durMs));
+            const e = easeInOut(t);
+            const ti = i * 3;
+            translations[ti] = state.startVec[ti] + (state.targetVec[ti] - state.startVec[ti]) * e;
+            translations[ti + 1] = state.startVec[ti + 1] + (state.targetVec[ti + 1] - state.startVec[ti + 1]) * e;
+            translations[ti + 2] = state.startVec[ti + 2] + (state.targetVec[ti + 2] - state.startVec[ti + 2]) * e;
+            if (t >= 1)
+                state.active[i] = 0;
+        }
+    }
+    updateMorphWeightTweens() {
+        const state = this.morphTweenState;
+        const now = performance.now();
+        const weights = this.runtimeMorph.weights;
+        const morphCount = this.morphing.morphs.length;
+        let hasActiveTweens = false;
+        for (let i = 0; i < morphCount; i++) {
+            if (state.active[i] !== 1)
+                continue;
+            hasActiveTweens = true;
+            const startMs = state.startTimeMs[i];
+            const durMs = Math.max(1, state.durationMs[i]);
+            const t = Math.max(0, Math.min(1, (now - startMs) / durMs));
+            const e = easeInOut(t);
+            weights[i] = state.startWeight[i] + (state.targetWeight[i] - state.startWeight[i]) * e;
+            if (t >= 1) {
+                weights[i] = state.targetWeight[i];
+                state.active[i] = 0;
+            }
+        }
+        return hasActiveTweens;
+    }
     // Get interleaved vertex data for GPU upload
     // Format: [x,y,z, nx,ny,nz, u,v, x,y,z, nx,ny,nz, u,v, ...]
     getVertices() {
@@ -117,6 +258,13 @@ export class Model {
     getJoints() {
         return this.joints;
     }
+    // Accessors for morphing
+    getMorphing() {
+        return this.morphing;
+    }
+    getMorphWeights() {
+        return this.runtimeMorph.weights;
+    }
     // ------- Bone helpers (public API) -------
     getBoneNames() {
         return this.skeleton.bones.map((b) => b.name);
@@ -176,15 +324,216 @@ export class Model {
             state.active[idx] = 1;
         }
     }
+    // Move bones using VMD-style relative translations (relative to bind pose world position)
+    // This is the default behavior for VMD animations
+    moveBones(names, relativeTranslations, durationMs) {
+        const state = this.transTweenState;
+        const now = performance.now();
+        const dur = durationMs && durationMs > 0 ? durationMs : 0;
+        const localRot = this.runtimeSkeleton.localRotations;
+        // Compute bind pose world positions for all bones
+        const skeleton = this.skeleton;
+        const computeBindPoseWorldPosition = (idx) => {
+            const bone = skeleton.bones[idx];
+            const bindPos = new Vec3(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2]);
+            if (bone.parentIndex >= 0 && bone.parentIndex < skeleton.bones.length) {
+                const parentWorldPos = computeBindPoseWorldPosition(bone.parentIndex);
+                return parentWorldPos.add(bindPos);
+            }
+            else {
+                return bindPos;
+            }
+        };
+        for (let i = 0; i < names.length; i++) {
+            const name = names[i];
+            const idx = this.runtimeSkeleton.nameIndex[name] ?? -1;
+            if (idx < 0 || idx >= this.skeleton.bones.length)
+                continue;
+            const bone = this.skeleton.bones[idx];
+            const ti = idx * 3;
+            const qi = idx * 4;
+            const translations = this.runtimeSkeleton.localTranslations;
+            const vmdRelativeTranslation = relativeTranslations[i];
+            // VMD translation is relative to bind pose world position
+            // targetWorldPos = bindPoseWorldPos + vmdRelativeTranslation
+            const bindPoseWorldPos = computeBindPoseWorldPosition(idx);
+            const targetWorldPos = bindPoseWorldPos.add(vmdRelativeTranslation);
+            // Convert target world position to local translation
+            // We need parent's bind pose world position to transform to parent space
+            let parentBindPoseWorldPos;
+            if (bone.parentIndex >= 0) {
+                parentBindPoseWorldPos = computeBindPoseWorldPosition(bone.parentIndex);
+            }
+            else {
+                parentBindPoseWorldPos = new Vec3(0, 0, 0);
+            }
+            // Transform target world position to parent's local space
+            // In bind pose, parent's world matrix is just a translation
+            const parentSpacePos = targetWorldPos.subtract(parentBindPoseWorldPos);
+            // Subtract bindTranslation to get position after bind translation
+            const afterBindTranslation = parentSpacePos.subtract(new Vec3(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2]));
+            // Apply inverse rotation to get local translation
+            const localRotation = new Quat(localRot[qi], localRot[qi + 1], localRot[qi + 2], localRot[qi + 3]);
+            const invRotation = localRotation.conjugate().normalize();
+            const rotationMat = Mat4.fromQuat(invRotation.x, invRotation.y, invRotation.z, invRotation.w);
+            const rm = rotationMat.values;
+            const localTranslation = new Vec3(rm[0] * afterBindTranslation.x + rm[4] * afterBindTranslation.y + rm[8] * afterBindTranslation.z, rm[1] * afterBindTranslation.x + rm[5] * afterBindTranslation.y + rm[9] * afterBindTranslation.z, rm[2] * afterBindTranslation.x + rm[6] * afterBindTranslation.y + rm[10] * afterBindTranslation.z);
+            const [tx, ty, tz] = [localTranslation.x, localTranslation.y, localTranslation.z];
+            if (dur === 0) {
+                translations[ti] = tx;
+                translations[ti + 1] = ty;
+                translations[ti + 2] = tz;
+                state.active[idx] = 0;
+                continue;
+            }
+            let sx = translations[ti];
+            let sy = translations[ti + 1];
+            let sz = translations[ti + 2];
+            if (state.active[idx] === 1) {
+                const startMs = state.startTimeMs[idx];
+                const prevDur = Math.max(1, state.durationMs[idx]);
+                const t = Math.max(0, Math.min(1, (now - startMs) / prevDur));
+                const e = easeInOut(t);
+                sx = state.startVec[ti] + (state.targetVec[ti] - state.startVec[ti]) * e;
+                sy = state.startVec[ti + 1] + (state.targetVec[ti + 1] - state.startVec[ti + 1]) * e;
+                sz = state.startVec[ti + 2] + (state.targetVec[ti + 2] - state.startVec[ti + 2]) * e;
+            }
+            state.startVec[ti] = sx;
+            state.startVec[ti + 1] = sy;
+            state.startVec[ti + 2] = sz;
+            state.targetVec[ti] = tx;
+            state.targetVec[ti + 1] = ty;
+            state.targetVec[ti + 2] = tz;
+            state.startTimeMs[idx] = now;
+            state.durationMs[idx] = dur;
+            state.active[idx] = 1;
+        }
+    }
     getBoneWorldMatrices() {
         return this.runtimeSkeleton.worldMatrices;
     }
     getBoneInverseBindMatrices() {
         return this.skeleton.inverseBindMatrices;
     }
+    getMorphNames() {
+        return this.morphing.morphs.map((m) => m.name);
+    }
+    setMorphWeight(name, weight, durationMs) {
+        const idx = this.runtimeMorph.nameIndex[name] ?? -1;
+        if (idx < 0 || idx >= this.runtimeMorph.weights.length)
+            return;
+        const clampedWeight = Math.max(0, Math.min(1, weight));
+        const dur = durationMs && durationMs > 0 ? durationMs : 0;
+        if (dur === 0) {
+            // Instant change
+            this.runtimeMorph.weights[idx] = clampedWeight;
+            this.morphTweenState.active[idx] = 0;
+            this.applyMorphs();
+            return;
+        }
+        // Animated change
+        const state = this.morphTweenState;
+        const now = performance.now();
+        const currentWeight = this.runtimeMorph.weights[idx];
+        // If already tweening, start from current interpolated value
+        let startWeight = currentWeight;
+        if (state.active[idx] === 1) {
+            const startMs = state.startTimeMs[idx];
+            const prevDur = Math.max(1, state.durationMs[idx]);
+            const t = Math.max(0, Math.min(1, (now - startMs) / prevDur));
+            const e = easeInOut(t);
+            startWeight = state.startWeight[idx] + (state.targetWeight[idx] - state.startWeight[idx]) * e;
+        }
+        state.startWeight[idx] = startWeight;
+        state.targetWeight[idx] = clampedWeight;
+        state.startTimeMs[idx] = now;
+        state.durationMs[idx] = dur;
+        state.active[idx] = 1;
+        // Immediately apply morphs with current weight
+        this.runtimeMorph.weights[idx] = startWeight;
+        this.applyMorphs();
+    }
+    applyMorphs() {
+        // Reset vertex data to base positions
+        this.vertexData.set(this.baseVertexData);
+        const vertexCount = this.vertexCount;
+        const morphCount = this.morphing.morphs.length;
+        const weights = this.runtimeMorph.weights;
+        // First pass: Compute effective weights for all morphs (handling group morphs)
+        const effectiveWeights = new Float32Array(morphCount);
+        effectiveWeights.set(weights); // Start with direct weights
+        // Apply group morphs: group morph weight * ratio affects referenced morphs
+        for (let morphIdx = 0; morphIdx < morphCount; morphIdx++) {
+            const morph = this.morphing.morphs[morphIdx];
+            if (morph.type === 0 && morph.groupReferences) {
+                const groupWeight = weights[morphIdx];
+                if (groupWeight > 0.0001) {
+                    for (const ref of morph.groupReferences) {
+                        if (ref.morphIndex >= 0 && ref.morphIndex < morphCount) {
+                            // Add group morph's contribution to the referenced morph
+                            effectiveWeights[ref.morphIndex] += groupWeight * ref.ratio;
+                        }
+                    }
+                }
+            }
+        }
+        // Clamp effective weights to [0, 1]
+        for (let i = 0; i < morphCount; i++) {
+            effectiveWeights[i] = Math.max(0, Math.min(1, effectiveWeights[i]));
+        }
+        // Second pass: Apply vertex morphs with their effective weights
+        for (let morphIdx = 0; morphIdx < morphCount; morphIdx++) {
+            const effectiveWeight = effectiveWeights[morphIdx];
+            if (effectiveWeight === 0 || effectiveWeight < 0.0001)
+                continue;
+            const morph = this.morphing.morphs[morphIdx];
+            if (morph.type !== 1)
+                continue; // Only process vertex morphs
+            // For vertex morphs, iterate through vertices that have offsets
+            for (const vertexOffset of morph.vertexOffsets) {
+                const vIdx = vertexOffset.vertexIndex;
+                if (vIdx < 0 || vIdx >= vertexCount)
+                    continue;
+                // Get morph offset for this vertex
+                const offsetX = vertexOffset.positionOffset[0];
+                const offsetY = vertexOffset.positionOffset[1];
+                const offsetZ = vertexOffset.positionOffset[2];
+                // Skip if offset is zero
+                if (Math.abs(offsetX) < 0.0001 && Math.abs(offsetY) < 0.0001 && Math.abs(offsetZ) < 0.0001) {
+                    continue;
+                }
+                // Apply weighted offset to vertex position (positions are at stride 0, 8, 16, ...)
+                const vertexIdx = vIdx * VERTEX_STRIDE;
+                this.vertexData[vertexIdx] += offsetX * effectiveWeight;
+                this.vertexData[vertexIdx + 1] += offsetY * effectiveWeight;
+                this.vertexData[vertexIdx + 2] += offsetZ * effectiveWeight;
+            }
+        }
+    }
     evaluatePose() {
         this.updateRotationTweens();
+        this.updateTranslationTweens();
+        const hasActiveMorphTweens = this.updateMorphWeightTweens();
+        if (hasActiveMorphTweens) {
+            this.applyMorphs();
+        }
+        // Compute initial world matrices (needed for IK solving)
+        this.computeWorldMatrices();
+        // Solve IK chains (modifies localRotations)
+        this.solveIKChains();
+        // Recompute world matrices with IK rotations applied
         this.computeWorldMatrices();
+        return hasActiveMorphTweens;
+    }
+    solveIKChains() {
+        const ikSolvers = this.runtimeSkeleton.ikSolvers;
+        if (!ikSolvers || ikSolvers.length === 0)
+            return;
+        const ikChainInfo = this.runtimeSkeleton.ikChainInfo;
+        if (!ikChainInfo)
+            return;
+        IKSolverSystem.solve(ikSolvers, this.skeleton.bones, this.runtimeSkeleton.localRotations, this.runtimeSkeleton.localTranslations, this.runtimeSkeleton.worldMatrices, ikChainInfo, false // usePhysics - can be enhanced later
+        );
     }
     computeWorldMatrices() {
         const bones = this.skeleton.bones;
@@ -242,11 +591,15 @@ export class Model {
                     }
                 }
             }
-            // Build local matrix: identity + bind translation, then rotation, then append translation
+            // Build local matrix: identity + bind translation, then rotation, then local translation, then append translation
+            const ti = i * 3;
+            const localTx = localTrans[ti] + addLocalTx;
+            const localTy = localTrans[ti + 1] + addLocalTy;
+            const localTz = localTrans[ti + 2] + addLocalTz;
             this.cachedIdentityMat1
                 .setIdentity()
                 .translateInPlace(b.bindTranslation[0], b.bindTranslation[1], b.bindTranslation[2]);
-            this.cachedIdentityMat2.setIdentity().translateInPlace(addLocalTx, addLocalTy, addLocalTz);
+            this.cachedIdentityMat2.setIdentity().translateInPlace(localTx, localTy, localTz);
             const localM = this.cachedIdentityMat1.multiply(rotateM).multiply(this.cachedIdentityMat2);
             const worldOffset = i * 16;
             if (b.parentIndex >= 0) {

package/dist/pmx-loader.d.ts

@@ -17,6 +17,8 @@ export declare class PmxLoader {
     private inverseBindMatrices;
     private joints0;
     private weights0;
+    private morphs;
+    private vertexCount;
     private rigidbodies;
     private joints;
     private constructor();
@@ -28,7 +30,7 @@ export declare class PmxLoader {
     private parseTextures;
     private parseMaterials;
     private parseBones;
-    private skipMorphs;
+    private parseMorphs;
     private skipDisplayFrames;
     private parseRigidbodies;
     private parseJoints;

package/dist/pmx-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pmx-loader.d.ts","sourceRoot":"","sources":["../src/pmx-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAA+C,MAAM,SAAS,CAAA;AAI5E,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,QAAQ,CAAI;IACpB,OAAO,CAAC,mBAAmB,CAAI;IAC/B,OAAO,CAAC,eAAe,CAAI;IAC3B,OAAO,CAAC,gBAAgB,CAAI;IAC5B,OAAO,CAAC,iBAAiB,CAAI;IAC7B,OAAO,CAAC,aAAa,CAAI;IACzB,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,kBAAkB,CAAI;IAC9B,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,mBAAmB,CAA4B;IACvD,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,QAAQ,CAA0B;IAC1C,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,MAAM,CAAc;IAE5B,OAAO;WAIM,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAK9C,OAAO,CAAC,KAAK;IAgBb,OAAO,CAAC,WAAW;IA+CnB,OAAO,CAAC,aAAa;IA+FrB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,cAAc;IAyFtB,OAAO,CAAC,UAAU;IA2IlB,OAAO,CAAC,UAAU;IAyGlB,OAAO,CAAC,iBAAiB;IAgDzB,OAAO,CAAC,gBAAgB;IAyFxB,OAAO,CAAC,WAAW;IAmGnB,OAAO,CAAC,kBAAkB;IAmC1B,OAAO,CAAC,OAAO;IA2If,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,SAAS;IAUjB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,OAAO;IAmBf,OAAO,CAAC,QAAQ;CAIjB"}
+{"version":3,"file":"pmx-loader.d.ts","sourceRoot":"","sources":["../src/pmx-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAWN,MAAM,SAAS,CAAA;AAIhB,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,QAAQ,CAAI;IACpB,OAAO,CAAC,mBAAmB,CAAI;IAC/B,OAAO,CAAC,eAAe,CAAI;IAC3B,OAAO,CAAC,gBAAgB,CAAI;IAC5B,OAAO,CAAC,iBAAiB,CAAI;IAC7B,OAAO,CAAC,aAAa,CAAI;IACzB,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,kBAAkB,CAAI;IAC9B,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,mBAAmB,CAA4B;IACvD,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,QAAQ,CAA0B;IAC1C,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,WAAW,CAAY;IAC/B,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,MAAM,CAAc;IAE5B,OAAO;WAIM,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAK9C,OAAO,CAAC,KAAK;IAiBb,OAAO,CAAC,WAAW;IA+CnB,OAAO,CAAC,aAAa;IA+FrB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,cAAc;IAyFtB,OAAO,CAAC,UAAU;IAsKlB,OAAO,CAAC,WAAW;IA+InB,OAAO,CAAC,iBAAiB;IAgDzB,OAAO,CAAC,gBAAgB;IAyFxB,OAAO,CAAC,WAAW;IAmGnB,OAAO,CAAC,kBAAkB;IAmC1B,OAAO,CAAC,OAAO;IAkLf,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,SAAS;IAUjB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,OAAO;IAmBf,OAAO,CAAC,QAAQ;CAIjB"}