reze-engine 0.1.0

package/dist/model.js

@@ -0,0 +1,416 @@
+const VERTEX_STRIDE = 8;
+import { Mat4, Vec3, Quat } from "./math";
+export class Model {
+    constructor(vertexData, indexData, textures, materials, skeleton, skinning, rigidbodies = [], joints = []) {
+        this.textures = [];
+        this.materials = [];
+        // Physics data from PMX
+        this.rigidbodies = [];
+        this.joints = [];
+        // Cached identity matrices to avoid allocations in computeWorldMatrices
+        this.cachedIdentityMat1 = Mat4.identity();
+        this.cachedIdentityMat2 = Mat4.identity();
+        this.vertexData = vertexData;
+        this.vertexCount = vertexData.length / VERTEX_STRIDE;
+        this.indexData = indexData;
+        this.textures = textures;
+        this.materials = materials;
+        this.skeleton = skeleton;
+        this.skinning = skinning;
+        this.rigidbodies = rigidbodies;
+        this.joints = joints;
+        // Initialize runtime skeleton pose state
+        const boneCount = skeleton.bones.length;
+        this.runtimeSkeleton = {
+            localRotations: new Float32Array(boneCount * 4),
+            localTranslations: new Float32Array(boneCount * 3),
+            worldMatrices: new Float32Array(boneCount * 16),
+            nameIndex: {}, // Will be populated by buildBoneLookups()
+            computedBones: new Array(boneCount).fill(false),
+        };
+        if (this.skeleton.bones.length > 0) {
+            this.buildBoneLookups();
+            this.initializeRuntimePose();
+            this.initializeRotTweenBuffers();
+        }
+    }
+    // Build caches for O(1) bone lookups and populate children arrays
+    // Called during model initialization
+    buildBoneLookups() {
+        const nameToIndex = {};
+        // Initialize children arrays for all bones and build name index
+        for (let i = 0; i < this.skeleton.bones.length; i++) {
+            this.skeleton.bones[i].children = [];
+            nameToIndex[this.skeleton.bones[i].name] = i;
+        }
+        // Build parent->children relationships
+        for (let i = 0; i < this.skeleton.bones.length; i++) {
+            const bone = this.skeleton.bones[i];
+            const parentIdx = bone.parentIndex;
+            if (parentIdx >= 0 && parentIdx < this.skeleton.bones.length) {
+                this.skeleton.bones[parentIdx].children.push(i);
+            }
+        }
+        this.runtimeSkeleton.nameIndex = nameToIndex;
+    }
+    initializeRotTweenBuffers() {
+        const n = this.skeleton.bones.length;
+        this.rotTweenState = {
+            active: new Uint8Array(n),
+            startQuat: new Float32Array(n * 4),
+            targetQuat: new Float32Array(n * 4),
+            startTimeMs: new Float32Array(n),
+            durationMs: new Float32Array(n),
+        };
+    }
+    static easeInOut(t) {
+        return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+    }
+    static slerp(aX, aY, aZ, aW, bX, bY, bZ, bW, t) {
+        let cos = aX * bX + aY * bY + aZ * bZ + aW * bW;
+        let bx = bX, by = bY, bz = bZ, bw = bW;
+        if (cos < 0) {
+            cos = -cos;
+            bx = -bx;
+            by = -by;
+            bz = -bz;
+            bw = -bw;
+        }
+        if (cos > 0.9995) {
+            const x = aX + t * (bx - aX);
+            const y = aY + t * (by - aY);
+            const z = aZ + t * (bz - aZ);
+            const w = aW + t * (bw - aW);
+            const invLen = 1 / Math.hypot(x, y, z, w);
+            return [x * invLen, y * invLen, z * invLen, w * invLen];
+        }
+        const theta0 = Math.acos(cos);
+        const sinTheta0 = Math.sin(theta0);
+        const theta = theta0 * t;
+        const s0 = Math.sin(theta0 - theta) / sinTheta0;
+        const s1 = Math.sin(theta) / sinTheta0;
+        return [s0 * aX + s1 * bx, s0 * aY + s1 * by, s0 * aZ + s1 * bz, s0 * aW + s1 * bw];
+    }
+    updateRotationTweens() {
+        const state = this.rotTweenState;
+        const now = performance.now();
+        const rotations = this.runtimeSkeleton.localRotations;
+        for (let i = 0; i < this.skeleton.bones.length; 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 = Model.easeInOut(t);
+            const qi = i * 4;
+            const [x, y, z, w] = Model.slerp(state.startQuat[qi], state.startQuat[qi + 1], state.startQuat[qi + 2], state.startQuat[qi + 3], state.targetQuat[qi], state.targetQuat[qi + 1], state.targetQuat[qi + 2], state.targetQuat[qi + 3], e);
+            rotations[qi] = x;
+            rotations[qi + 1] = y;
+            rotations[qi + 2] = z;
+            rotations[qi + 3] = w;
+            if (t >= 1)
+                state.active[i] = 0;
+        }
+    }
+    // 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() {
+        return this.vertexData;
+    }
+    // Get texture information
+    getTextures() {
+        return this.textures;
+    }
+    // Get material information
+    getMaterials() {
+        return this.materials;
+    }
+    // Get diffuse texture path for a material
+    getDiffuseTexturePath(materialIndex) {
+        if (materialIndex < 0 || materialIndex >= this.materials.length)
+            return null;
+        const material = this.materials[materialIndex];
+        if (material.diffuseTextureIndex < 0 || material.diffuseTextureIndex >= this.textures.length)
+            return null;
+        return this.textures[material.diffuseTextureIndex].path;
+    }
+    // Get vertex count
+    getVertexCount() {
+        return this.vertexCount;
+    }
+    // Get index data for GPU upload
+    getIndices() {
+        return this.indexData;
+    }
+    // Accessors for skeleton/skinning
+    getSkeleton() {
+        return this.skeleton;
+    }
+    getSkinning() {
+        return this.skinning;
+    }
+    // Accessors for physics data
+    getRigidbodies() {
+        return this.rigidbodies;
+    }
+    getJoints() {
+        return this.joints;
+    }
+    initializeRuntimePose() {
+        const rotations = this.runtimeSkeleton.localRotations;
+        for (let i = 0; i < this.skeleton.bones.length; i++) {
+            const qi = i * 4;
+            if (rotations[qi + 3] === 0) {
+                rotations[qi] = 0;
+                rotations[qi + 1] = 0;
+                rotations[qi + 2] = 0;
+                rotations[qi + 3] = 1;
+            }
+        }
+    }
+    // ------- Bone helpers (public API) -------
+    getBoneCount() {
+        return this.skeleton.bones.length;
+    }
+    getBoneNames() {
+        return this.skeleton.bones.map((b) => b.name);
+    }
+    getBoneIndexByName(name) {
+        return this.runtimeSkeleton.nameIndex[name] ?? -1;
+    }
+    getBoneName(index) {
+        if (index < 0 || index >= this.skeleton.bones.length)
+            return undefined;
+        return this.skeleton.bones[index].name;
+    }
+    getBoneLocal(index) {
+        if (index < 0 || index >= this.skeleton.bones.length)
+            return undefined;
+        const qi = index * 4;
+        const ti = index * 3;
+        const rot = this.runtimeSkeleton.localRotations;
+        const trans = this.runtimeSkeleton.localTranslations;
+        return {
+            rotation: new Quat(rot[qi], rot[qi + 1], rot[qi + 2], rot[qi + 3]),
+            translation: new Vec3(trans[ti], trans[ti + 1], trans[ti + 2]),
+        };
+    }
+    rotateBones(indicesOrNames, quats, durationMs) {
+        const state = this.rotTweenState;
+        const normalized = quats.map((q) => q.normalize());
+        const now = performance.now();
+        const dur = durationMs && durationMs > 0 ? durationMs : 0;
+        for (let i = 0; i < indicesOrNames.length; i++) {
+            const input = indicesOrNames[i];
+            let idx;
+            if (typeof input === "number") {
+                idx = input;
+            }
+            else {
+                const resolved = this.getBoneIndexByName(input);
+                if (resolved < 0)
+                    continue;
+                idx = resolved;
+            }
+            if (idx < 0 || idx >= this.skeleton.bones.length)
+                continue;
+            const qi = idx * 4;
+            const rotations = this.runtimeSkeleton.localRotations;
+            const [tx, ty, tz, tw] = normalized[i].toArray();
+            if (dur === 0) {
+                rotations[qi] = tx;
+                rotations[qi + 1] = ty;
+                rotations[qi + 2] = tz;
+                rotations[qi + 3] = tw;
+                state.active[idx] = 0;
+                continue;
+            }
+            let sx = rotations[qi];
+            let sy = rotations[qi + 1];
+            let sz = rotations[qi + 2];
+            let sw = rotations[qi + 3];
+            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 = Model.easeInOut(t);
+                const [cx, cy, cz, cw] = Model.slerp(state.startQuat[qi], state.startQuat[qi + 1], state.startQuat[qi + 2], state.startQuat[qi + 3], state.targetQuat[qi], state.targetQuat[qi + 1], state.targetQuat[qi + 2], state.targetQuat[qi + 3], e);
+                sx = cx;
+                sy = cy;
+                sz = cz;
+                sw = cw;
+            }
+            state.startQuat[qi] = sx;
+            state.startQuat[qi + 1] = sy;
+            state.startQuat[qi + 2] = sz;
+            state.startQuat[qi + 3] = sw;
+            state.targetQuat[qi] = tx;
+            state.targetQuat[qi + 1] = ty;
+            state.targetQuat[qi + 2] = tz;
+            state.targetQuat[qi + 3] = tw;
+            state.startTimeMs[idx] = now;
+            state.durationMs[idx] = dur;
+            state.active[idx] = 1;
+        }
+    }
+    setBoneRotation(indexOrName, quat) {
+        const index = typeof indexOrName === "number" ? indexOrName : this.getBoneIndexByName(indexOrName);
+        if (index < 0 || index >= this.skeleton.bones.length)
+            return;
+        const qi = index * 4;
+        const rot = this.runtimeSkeleton.localRotations;
+        rot[qi] = quat.x;
+        rot[qi + 1] = quat.y;
+        rot[qi + 2] = quat.z;
+        rot[qi + 3] = quat.w;
+    }
+    setBoneTranslation(indexOrName, t) {
+        const index = typeof indexOrName === "number" ? indexOrName : this.getBoneIndexByName(indexOrName);
+        if (index < 0 || index >= this.skeleton.bones.length)
+            return;
+        const ti = index * 3;
+        const trans = this.runtimeSkeleton.localTranslations;
+        trans[ti] = t.x;
+        trans[ti + 1] = t.y;
+        trans[ti + 2] = t.z;
+    }
+    resetBone(index) {
+        const qi = index * 4;
+        const ti = index * 3;
+        const rot = this.runtimeSkeleton.localRotations;
+        const trans = this.runtimeSkeleton.localTranslations;
+        rot[qi] = 0;
+        rot[qi + 1] = 0;
+        rot[qi + 2] = 0;
+        rot[qi + 3] = 1;
+        trans[ti] = 0;
+        trans[ti + 1] = 0;
+        trans[ti + 2] = 0;
+    }
+    resetAllBones() {
+        const rot = this.runtimeSkeleton.localRotations;
+        const trans = this.runtimeSkeleton.localTranslations;
+        const count = this.getBoneCount();
+        for (let i = 0; i < count; i++) {
+            const qi = i * 4;
+            const ti = i * 3;
+            rot[qi] = 0;
+            rot[qi + 1] = 0;
+            rot[qi + 2] = 0;
+            rot[qi + 3] = 1;
+            trans[ti] = 0;
+            trans[ti + 1] = 0;
+            trans[ti + 2] = 0;
+        }
+    }
+    getBoneWorldMatrix(index) {
+        this.evaluatePose();
+        const start = index * 16;
+        return this.runtimeSkeleton.worldMatrices.subarray(start, start + 16);
+    }
+    getBoneWorldMatrices() {
+        return this.runtimeSkeleton.worldMatrices;
+    }
+    getBoneInverseBindMatrices() {
+        return this.skeleton.inverseBindMatrices;
+    }
+    getBoneWorldPosition(index) {
+        this.evaluatePose();
+        const matIdx = index * 16;
+        const mat = this.runtimeSkeleton.worldMatrices;
+        return new Vec3(mat[matIdx + 12], mat[matIdx + 13], mat[matIdx + 14]);
+    }
+    getBoneWorldRotation(index) {
+        this.evaluatePose();
+        const start = index * 16;
+        return Mat4.toQuatFromArray(this.runtimeSkeleton.worldMatrices, start);
+    }
+    getBoneInverseBindMatrix(index) {
+        if (index < 0 || index >= this.skeleton.bones.length)
+            return undefined;
+        const start = index * 16;
+        return new Mat4(this.skeleton.inverseBindMatrices.subarray(start, start + 16));
+    }
+    getLocalRotations() {
+        return this.runtimeSkeleton.localRotations;
+    }
+    evaluatePose() {
+        this.updateRotationTweens();
+        this.computeWorldMatrices();
+    }
+    computeWorldMatrices() {
+        const bones = this.skeleton.bones;
+        const localRot = this.runtimeSkeleton.localRotations;
+        const localTrans = this.runtimeSkeleton.localTranslations;
+        const worldBuf = this.runtimeSkeleton.worldMatrices;
+        const computed = this.runtimeSkeleton.computedBones.fill(false);
+        const boneCount = bones.length;
+        if (boneCount === 0)
+            return;
+        const computeWorld = (i) => {
+            if (computed[i])
+                return;
+            const b = bones[i];
+            if (b.parentIndex >= boneCount) {
+                console.warn(`[RZM] bone ${i} parent out of range: ${b.parentIndex}`);
+            }
+            const qi = i * 4;
+            let rotateM = Mat4.fromQuat(localRot[qi], localRot[qi + 1], localRot[qi + 2], localRot[qi + 3]);
+            let addLocalTx = 0, addLocalTy = 0, addLocalTz = 0;
+            // Optimized append rotation check - only check necessary conditions
+            const appendParentIdx = b.appendParentIndex;
+            const hasAppend = b.appendRotate && appendParentIdx !== undefined && appendParentIdx >= 0 && appendParentIdx < boneCount;
+            if (hasAppend) {
+                const ratio = b.appendRatio === undefined ? 1 : Math.max(-1, Math.min(1, b.appendRatio));
+                const hasRatio = Math.abs(ratio) > 1e-6;
+                if (hasRatio) {
+                    const apQi = appendParentIdx * 4;
+                    const apTi = appendParentIdx * 3;
+                    if (b.appendRotate) {
+                        let ax = localRot[apQi];
+                        let ay = localRot[apQi + 1];
+                        let az = localRot[apQi + 2];
+                        const aw = localRot[apQi + 3];
+                        const absRatio = ratio < 0 ? -ratio : ratio;
+                        if (ratio < 0) {
+                            ax = -ax;
+                            ay = -ay;
+                            az = -az;
+                        }
+                        const [rx, ry, rz, rw] = Model.slerp(0, 0, 0, 1, ax, ay, az, aw, absRatio);
+                        rotateM = Mat4.fromQuat(rx, ry, rz, rw).multiply(rotateM);
+                    }
+                    if (b.appendMove) {
+                        const appendRatio = b.appendRatio ?? 1;
+                        addLocalTx = localTrans[apTi] * appendRatio;
+                        addLocalTy = localTrans[apTi + 1] * appendRatio;
+                        addLocalTz = localTrans[apTi + 2] * appendRatio;
+                    }
+                }
+            }
+            // Build local matrix: identity + bind translation, then rotation, then append translation
+            this.cachedIdentityMat1
+                .setIdentity()
+                .translateInPlace(b.bindTranslation[0], b.bindTranslation[1], b.bindTranslation[2]);
+            this.cachedIdentityMat2.setIdentity().translateInPlace(addLocalTx, addLocalTy, addLocalTz);
+            const localM = this.cachedIdentityMat1.multiply(rotateM).multiply(this.cachedIdentityMat2);
+            const worldOffset = i * 16;
+            if (b.parentIndex >= 0) {
+                const p = b.parentIndex;
+                if (!computed[p])
+                    computeWorld(p);
+                const parentOffset = p * 16;
+                // Use cachedIdentityMat2 as temporary buffer for parent * local multiplication
+                Mat4.multiplyArrays(worldBuf, parentOffset, localM.values, 0, this.cachedIdentityMat2.values, 0);
+                worldBuf.subarray(worldOffset, worldOffset + 16).set(this.cachedIdentityMat2.values);
+            }
+            else {
+                worldBuf.subarray(worldOffset, worldOffset + 16).set(localM.values);
+            }
+            computed[i] = true;
+        };
+        // Process all bones (recursion handles dependencies automatically)
+        for (let i = 0; i < boneCount; i++)
+            computeWorld(i);
+    }
+}

package/dist/physics.d.ts

@@ -0,0 +1,82 @@
+import { Quat, Vec3, Mat4 } from "./math";
+export declare enum RigidbodyShape {
+    Sphere = 0,
+    Box = 1,
+    Capsule = 2
+}
+export declare enum RigidbodyType {
+    Static = 0,
+    Dynamic = 1,
+    Kinematic = 2
+}
+export interface Rigidbody {
+    name: string;
+    englishName: string;
+    boneIndex: number;
+    group: number;
+    collisionMask: number;
+    shape: RigidbodyShape;
+    size: Vec3;
+    shapePosition: Vec3;
+    shapeRotation: Vec3;
+    mass: number;
+    linearDamping: number;
+    angularDamping: number;
+    restitution: number;
+    friction: number;
+    type: RigidbodyType;
+    bodyOffsetMatrixInverse: Mat4;
+    bodyOffsetMatrix?: Mat4;
+}
+export interface Joint {
+    name: string;
+    englishName: string;
+    type: number;
+    rigidbodyIndexA: number;
+    rigidbodyIndexB: number;
+    position: Vec3;
+    rotation: Vec3;
+    positionMin: Vec3;
+    positionMax: Vec3;
+    rotationMin: Vec3;
+    rotationMax: Vec3;
+    springPosition: Vec3;
+    springRotation: Vec3;
+}
+export declare class Physics {
+    private rigidbodies;
+    private joints;
+    private gravity;
+    private ammoInitialized;
+    private ammoPromise;
+    private ammo;
+    private dynamicsWorld;
+    private ammoRigidbodies;
+    private ammoConstraints;
+    private rigidbodiesInitialized;
+    private jointsCreated;
+    private firstFrame;
+    private forceDisableOffsetForConstraintFrame;
+    private zeroVector;
+    constructor(rigidbodies: Rigidbody[], joints?: Joint[]);
+    private initAmmo;
+    setGravity(gravity: Vec3): void;
+    getGravity(): Vec3;
+    getRigidbodies(): Rigidbody[];
+    getJoints(): Joint[];
+    getRigidbodyTransforms(): Array<{
+        position: Vec3;
+        rotation: Quat;
+    }>;
+    private createAmmoWorld;
+    private createAmmoRigidbodies;
+    private createAmmoJoints;
+    private normalizeAngle;
+    step(dt: number, boneWorldMatrices: Float32Array, boneInverseBindMatrices: Float32Array): void;
+    private computeBodyOffsets;
+    private positionBodiesFromBones;
+    private syncFromBones;
+    private stepAmmoPhysics;
+    private applyAmmoRigidbodiesToBones;
+}
+//# sourceMappingURL=physics.d.ts.map

package/dist/physics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"physics.d.ts","sourceRoot":"","sources":["../src/physics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAIzC,oBAAY,cAAc;IACxB,MAAM,IAAI;IACV,GAAG,IAAI;IACP,OAAO,IAAI;CACZ;AAED,oBAAY,aAAa;IACvB,MAAM,IAAI;IACV,OAAO,IAAI;IACX,SAAS,IAAI;CACd;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,cAAc,CAAA;IACrB,IAAI,EAAE,IAAI,CAAA;IACV,aAAa,EAAE,IAAI,CAAA;IACnB,aAAa,EAAE,IAAI,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,aAAa,CAAA;IACnB,uBAAuB,EAAE,IAAI,CAAA;IAC7B,gBAAgB,CAAC,EAAE,IAAI,CAAA;CACxB;AAED,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,eAAe,EAAE,MAAM,CAAA;IACvB,eAAe,EAAE,MAAM,CAAA;IACvB,QAAQ,EAAE,IAAI,CAAA;IACd,QAAQ,EAAE,IAAI,CAAA;IACd,WAAW,EAAE,IAAI,CAAA;IACjB,WAAW,EAAE,IAAI,CAAA;IACjB,WAAW,EAAE,IAAI,CAAA;IACjB,WAAW,EAAE,IAAI,CAAA;IACjB,cAAc,EAAE,IAAI,CAAA;IACpB,cAAc,EAAE,IAAI,CAAA;CACrB;AAED,qBAAa,OAAO;IAClB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,WAAW,CAAqC;IACxD,OAAO,CAAC,IAAI,CAA4B;IAExC,OAAO,CAAC,aAAa,CAAY;IAEjC,OAAO,CAAC,eAAe,CAAY;IAEnC,OAAO,CAAC,eAAe,CAAY;IACnC,OAAO,CAAC,sBAAsB,CAAQ;IACtC,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,UAAU,CAAO;IACzB,OAAO,CAAC,oCAAoC,CAAO;IAEnD,OAAO,CAAC,UAAU,CAAY;gBAElB,WAAW,EAAE,SAAS,EAAE,EAAE,MAAM,GAAE,KAAK,EAAO;YAM5C,QAAQ;IAatB,UAAU,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAU/B,UAAU,IAAI,IAAI;IAIlB,cAAc,IAAI,SAAS,EAAE;IAI7B,SAAS,IAAI,KAAK,EAAE;IAIpB,sBAAsB,IAAI,KAAK,CAAC;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE,CAAC;IA6CnE,OAAO,CAAC,eAAe;IAwBvB,OAAO,CAAC,qBAAqB;IA+F7B,OAAO,CAAC,gBAAgB;IA0KxB,OAAO,CAAC,cAAc;IActB,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE,YAAY,EAAE,uBAAuB,EAAE,YAAY,GAAG,IAAI;IAsC9F,OAAO,CAAC,kBAAkB;IA2B1B,OAAO,CAAC,uBAAuB;IAkD/B,OAAO,CAAC,aAAa;IAwDrB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,2BAA2B;CAqCpC"}