reze-engine 0.50.6 → 0.50.7

package/dist/_dbg-loader.mjs

@@ -0,0 +1,1100 @@
+import { Model, } from "./model";
+import { Mat4, Vec3 } from "./math";
+import { RigidbodyType } from "./physics";
+import { createFetchAssetReader } from "./asset-reader";
+export class PmxLoader {
+    constructor(buffer) {
+        this.offset = 0;
+        this.encoding = 0;
+        this.additionalVec4Count = 0;
+        this.vertexIndexSize = 0;
+        this.textureIndexSize = 0;
+        this.materialIndexSize = 0;
+        this.boneIndexSize = 0;
+        this.morphIndexSize = 0;
+        this.rigidBodyIndexSize = 0;
+        this.textures = [];
+        this.materials = [];
+        this.bones = [];
+        this.inverseBindMatrices = null;
+        this.joints0 = null;
+        this.weights0 = null;
+        this.morphs = [];
+        this.vertexCount = 0;
+        this.rigidbodies = [];
+        this.joints = [];
+        this.warnings = [];
+        this.view = new DataView(buffer);
+    }
+    // Parse problems are non-fatal (the mesh may still render), but they must
+    // be queryable afterwards — a rig whose rigidbody section failed to parse
+    // silently loses physics, and console.warn alone drowns in browser log
+    // limits. Collected warnings ship on the Model (getLoadWarnings()).
+    warn(message, error) {
+        const full = error instanceof Error ? `${message}: ${error.message}` : message;
+        this.warnings.push(full);
+        console.warn(message, error ?? "");
+    }
+    static async load(url) {
+        return PmxLoader.loadFromReader(createFetchAssetReader(), url);
+    }
+    static loadFromBuffer(buffer) {
+        return new PmxLoader(buffer).parse();
+    }
+    static async loadFromReader(reader, pmxLogicalPath) {
+        const buffer = await reader.readBinary(pmxLogicalPath);
+        return PmxLoader.loadFromBuffer(buffer);
+    }
+    parse() {
+        this.parseHeader();
+        const { positions, normals, uvs } = this.parseVertices();
+        this.vertexCount = positions.length / 3;
+        const indices = this.parseIndices();
+        this.parseTextures();
+        this.parseMaterials();
+        this.parseBones();
+        // Parse morphs and display frames before parsing rigidbodies
+        this.parseMorphs();
+        this.skipDisplayFrames();
+        this.parseRigidbodies();
+        this.parseJoints();
+        this.computeInverseBind();
+        return this.toModel(positions, normals, uvs, indices);
+    }
+    parseHeader() {
+        // The signature is four bytes. PMX 2.x writes "PMX ", but exporters in the
+        // wild also write "Pmx " — and a strict uppercase compare rejected those
+        // models outright. Compare case-insensitively and name what was actually
+        // found when it is something else, so a PMD (the older format, signature
+        // "Pmd") says so instead of "not a PMX file".
+        const signature = this.getString(4);
+        if (signature.slice(0, 3).toUpperCase() !== "PMX") {
+            const head = signature.slice(0, 3).toUpperCase();
+            if (head === "PMD") {
+                throw new Error("This is a PMD file (MMD's older format). Convert it to PMX in PMXEditor first.");
+            }
+            throw new Error(`Not a PMX file (signature "${signature.replace(/[^\x20-\x7e]/g, "?")}")`);
+        }
+        // PMX: version (float32)
+        const version = this.getFloat32();
+        if (version < 2.0 || version > 2.2) {
+            // Continue, but warn for unexpected version
+            this.warn(`PMX version ${version} may not be fully supported`);
+        }
+        // PMX: globals count (uint8) followed by that many bytes describing encoding and index sizes
+        const globalsCount = this.getUint8();
+        // Validate globalsCount (must be at least 8 for PMX 2.x)
+        if (globalsCount < 8) {
+            throw new Error(`Invalid globalsCount: ${globalsCount}, expected at least 8`);
+        }
+        // Read globals (first 8 bytes are standard for PMX 2.x)
+        this.encoding = this.getUint8(); // 0:utf16le, 1:utf8
+        this.additionalVec4Count = this.getUint8();
+        this.vertexIndexSize = this.getUint8();
+        this.textureIndexSize = this.getUint8();
+        this.materialIndexSize = this.getUint8();
+        this.boneIndexSize = this.getUint8();
+        this.morphIndexSize = this.getUint8();
+        this.rigidBodyIndexSize = this.getUint8();
+        // Skip any extra globals beyond the first 8 (for future format extensions)
+        if (globalsCount > 8) {
+            for (let i = 8; i < globalsCount; i++) {
+                this.getUint8();
+            }
+        }
+        this.decoder = new TextDecoder(this.encoding === 0 ? "utf-16le" : "utf-8");
+        // Skip model info (4 text fields)
+        this.getText();
+        this.getText();
+        this.getText();
+        this.getText();
+    }
+    parseVertices() {
+        const count = this.getInt32();
+        const positions = [];
+        const normals = [];
+        const uvs = [];
+        // Prepare skinning arrays (4 influences per vertex)
+        const joints = new Uint16Array(count * 4);
+        const weights = new Uint8Array(count * 4); // UNORM8, will be normalized to 255
+        for (let i = 0; i < count; i++) {
+            const px = this.getFloat32();
+            const py = this.getFloat32();
+            const pz = this.getFloat32();
+            positions.push(px, py, pz);
+            const nx = this.getFloat32();
+            const ny = this.getFloat32();
+            const nz = this.getFloat32();
+            normals.push(nx, ny, nz);
+            const u = this.getFloat32();
+            const v = this.getFloat32();
+            // PMX UVs are in the same orientation as WebGPU sampling; no flip
+            uvs.push(u, v);
+            this.offset += this.additionalVec4Count * 16;
+            const type = this.getUint8();
+            const base = i * 4;
+            // Initialize defaults
+            joints[base] = 0;
+            joints[base + 1] = 0;
+            joints[base + 2] = 0;
+            joints[base + 3] = 0;
+            weights[base] = 255;
+            weights[base + 1] = 0;
+            weights[base + 2] = 0;
+            weights[base + 3] = 0;
+            if (type === 0) {
+                // BDEF1
+                const j0 = this.getNonVertexIndex(this.boneIndexSize);
+                joints[base] = j0 >= 0 ? j0 : 0;
+                // weight stays [255,0,0,0]
+            }
+            else if (type === 1 || type === 3) {
+                // BDEF2 or SDEF (treated as BDEF2)
+                const j0 = this.getNonVertexIndex(this.boneIndexSize);
+                const j1 = this.getNonVertexIndex(this.boneIndexSize);
+                const w0f = this.getFloat32();
+                const w0 = Math.max(0, Math.min(255, Math.round(w0f * 255)));
+                const w1 = Math.max(0, Math.min(255, 255 - w0));
+                joints[base] = j0 >= 0 ? j0 : 0;
+                joints[base + 1] = j1 >= 0 ? j1 : 0;
+                weights[base] = w0;
+                weights[base + 1] = w1;
+                // SDEF has extra 3 vec3 (C, R0, R1)
+                if (type === 3) {
+                    this.offset += 36; // 9 floats * 4 bytes
+                }
+            }
+            else if (type === 2 || type === 4) {
+                // BDEF4 or QDEF (treat as LBS4)
+                let sum = 0;
+                for (let k = 0; k < 4; k++) {
+                    const j = this.getNonVertexIndex(this.boneIndexSize);
+                    joints[base + k] = j >= 0 ? j : 0;
+                }
+                const wf = [this.getFloat32(), this.getFloat32(), this.getFloat32(), this.getFloat32()];
+                const ws = wf.map((x) => Math.max(0, Math.min(1, x)));
+                const w8 = ws.map((x) => Math.round(x * 255));
+                sum = w8[0] + w8[1] + w8[2] + w8[3];
+                if (sum === 0) {
+                    weights[base] = 255;
+                }
+                else {
+                    // Normalize to 255
+                    const scale = 255 / sum;
+                    let accum = 0;
+                    for (let k = 0; k < 3; k++) {
+                        const v = Math.max(0, Math.min(255, Math.round(w8[k] * scale)));
+                        weights[base + k] = v;
+                        accum += v;
+                    }
+                    weights[base + 3] = Math.max(0, Math.min(255, 255 - accum));
+                }
+            }
+            else {
+                throw new Error(`Invalid bone weight type: ${type}`);
+            }
+            this.offset += 4; // edge scale
+        }
+        this.joints0 = joints;
+        this.weights0 = weights;
+        return { positions, normals, uvs };
+    }
+    // (removed) skipBoneWeight – replaced by inline parsing
+    parseIndices() {
+        const count = this.getInt32();
+        const indices = [];
+        for (let i = 0; i < count; i++) {
+            indices.push(this.getIndex(this.vertexIndexSize));
+        }
+        return indices;
+    }
+    parseTextures() {
+        try {
+            const count = this.getInt32();
+            this.textures = [];
+            for (let i = 0; i < count; i++) {
+                const textureName = this.getText();
+                this.textures.push({
+                    path: textureName,
+                    name: textureName.split("/").pop() || textureName, // Extract filename
+                });
+            }
+        }
+        catch (error) {
+            console.error("Error parsing textures:", error);
+            this.textures = [];
+        }
+    }
+    parseMaterials() {
+        try {
+            const count = this.getInt32();
+            this.materials = [];
+            for (let i = 0; i < count; i++) {
+                const name = this.getText();
+                this.getText(); // englishName (skip)
+                const diffuse = [this.getFloat32(), this.getFloat32(), this.getFloat32(), this.getFloat32()];
+                const specular = [this.getFloat32(), this.getFloat32(), this.getFloat32()];
+                const shininess = this.getFloat32();
+                const ambient = [this.getFloat32(), this.getFloat32(), this.getFloat32()];
+                const flag = this.getUint8();
+                // edgeColor vec4
+                const edgeColor = [
+                    this.getFloat32(),
+                    this.getFloat32(),
+                    this.getFloat32(),
+                    this.getFloat32(),
+                ];
+                // edgeSize float (outline width in PMX units; engine scales by camera distance for stable screen thickness)
+                const edgeSize = this.getFloat32();
+                const textureIndex = this.getNonVertexIndex(this.textureIndexSize);
+                const sphereTextureIndex = this.getNonVertexIndex(this.textureIndexSize);
+                const sphereTextureMode = this.getUint8();
+                const isSharedToonTexture = this.getUint8() === 1;
+                const toonTextureIndex = isSharedToonTexture ? this.getUint8() : this.getNonVertexIndex(this.textureIndexSize);
+                this.getText(); // comment (skip)
+                const vertexCount = this.getInt32();
+                // PMX material flag bits:
+                // Bit 0 (0x01): Double-sided rendering
+                // Bit 4 (0x10): Edge drawing (outline)
+                const mat = {
+                    name,
+                    diffuse,
+                    specular,
+                    ambient,
+                    shininess,
+                    diffuseTextureIndex: textureIndex,
+                    normalTextureIndex: -1, // Not used in basic PMX
+                    sphereTextureIndex,
+                    sphereMode: sphereTextureMode,
+                    toonTextureIndex,
+                    sharedToon: isSharedToonTexture,
+                    edgeFlag: flag,
+                    edgeColor,
+                    edgeSize,
+                    vertexCount,
+                };
+                this.materials.push(mat);
+            }
+        }
+        catch (error) {
+            console.error("Error parsing materials:", error);
+            this.materials = [];
+        }
+    }
+    parseBones() {
+        try {
+            const count = this.getInt32();
+            const bones = [];
+            const abs = new Array(count);
+            // PMX 2.x bone flags (best-effort common masks)
+            const FLAG_TAIL_IS_BONE = 0x0001;
+            const FLAG_IK = 0x0020;
+            const FLAG_APPEND_ROTATE = 0x0100;
+            const FLAG_APPEND_MOVE = 0x0200;
+            const FLAG_AXIS_LIMIT = 0x0400;
+            const FLAG_LOCAL_AXIS = 0x0800;
+            const FLAG_EXTERNAL_PARENT = 0x2000;
+            for (let i = 0; i < count; i++) {
+                const name = this.getText();
+                this.getText(); // englishName (skip)
+                // PMX is left-handed, engine is now left-handed - no conversion needed
+                const x = this.getFloat32();
+                const y = this.getFloat32();
+                const z = this.getFloat32();
+                const parentIndex = this.getNonVertexIndex(this.boneIndexSize);
+                const deformLayer = this.getInt32(); // 変形階層
+                const flags = this.getUint16();
+                // Tail: bone index or offset vector3
+                if ((flags & FLAG_TAIL_IS_BONE) !== 0) {
+                    this.getNonVertexIndex(this.boneIndexSize);
+                }
+                else {
+                    // tail offset vec3
+                    this.getFloat32();
+                    this.getFloat32();
+                    this.getFloat32();
+                }
+                // Append transform (inherit/ratio)
+                let appendParent = undefined;
+                let appendRatio = undefined;
+                let appendRotate = false;
+                let appendMove = false;
+                if ((flags & (FLAG_APPEND_ROTATE | FLAG_APPEND_MOVE)) !== 0) {
+                    appendParent = this.getNonVertexIndex(this.boneIndexSize); // append parent
+                    appendRatio = this.getFloat32(); // ratio
+                    appendRotate = (flags & FLAG_APPEND_ROTATE) !== 0;
+                    appendMove = (flags & FLAG_APPEND_MOVE) !== 0;
+                }
+                // Axis limit (軸制限)
+                let fixedAxis = undefined;
+                if ((flags & FLAG_AXIS_LIMIT) !== 0) {
+                    fixedAxis = [this.getFloat32(), this.getFloat32(), this.getFloat32()];
+                }
+                // Local axis (two vectors x and z)
+                if ((flags & FLAG_LOCAL_AXIS) !== 0) {
+                    // local axis X
+                    this.getFloat32();
+                    this.getFloat32();
+                    this.getFloat32();
+                    // local axis Z
+                    this.getFloat32();
+                    this.getFloat32();
+                    this.getFloat32();
+                }
+                // External parent transform
+                if ((flags & FLAG_EXTERNAL_PARENT) !== 0) {
+                    this.getInt32();
+                }
+                // IK block
+                let ikTargetIndex = undefined;
+                let ikIteration = undefined;
+                let ikLimitAngle = undefined;
+                let ikLinks = undefined;
+                if ((flags & FLAG_IK) !== 0) {
+                    ikTargetIndex = this.getNonVertexIndex(this.boneIndexSize); // target
+                    ikIteration = this.getInt32(); // iteration
+                    ikLimitAngle = this.getFloat32(); // rotationConstraint
+                    const linksCount = this.getInt32();
+                    ikLinks = [];
+                    for (let li = 0; li < linksCount; li++) {
+                        const linkBoneIndex = this.getNonVertexIndex(this.boneIndexSize); // link target
+                        const hasLimit = this.getUint8() === 1;
+                        let minAngle = undefined;
+                        let maxAngle = undefined;
+                        if (hasLimit) {
+                            // min and max angles (vec3 each)
+                            const minX = this.getFloat32();
+                            const minY = this.getFloat32();
+                            const minZ = this.getFloat32();
+                            const maxX = this.getFloat32();
+                            const maxY = this.getFloat32();
+                            const maxZ = this.getFloat32();
+                            minAngle = new Vec3(minX, minY, minZ);
+                            maxAngle = new Vec3(maxX, maxY, maxZ);
+                        }
+                        ikLinks.push({
+                            boneIndex: linkBoneIndex,
+                            hasLimit,
+                            minAngle,
+                            maxAngle,
+                        });
+                    }
+                }
+                // Stash minimal bone info; append data will be merged later
+                abs[i] = {
+                    name,
+                    parent: parentIndex,
+                    x,
+                    y,
+                    z,
+                    appendParent,
+                    appendRatio,
+                    appendRotate,
+                    appendMove,
+                    fixedAxis,
+                    deformLayer,
+                    ikTargetIndex,
+                    ikIteration,
+                    ikLimitAngle,
+                    ikLinks,
+                };
+            }
+            for (let i = 0; i < count; i++) {
+                const a = abs[i];
+                const boneData = {
+                    name: a.name,
+                    parentIndex: a.parent,
+                    bindTranslation: a.parent >= 0 && a.parent < count
+                        ? [a.x - abs[a.parent].x, a.y - abs[a.parent].y, a.z - abs[a.parent].z]
+                        : [a.x, a.y, a.z],
+                    children: [], // Will be populated later when building skeleton
+                    appendParentIndex: a.appendParent,
+                    appendRatio: a.appendRatio,
+                    appendRotate: a.appendRotate,
+                    appendMove: a.appendMove,
+                    fixedAxis: a.fixedAxis,
+                    deformLayer: a.deformLayer,
+                    ikTargetIndex: a.ikTargetIndex,
+                    ikIteration: a.ikIteration,
+                    ikLimitAngle: a.ikLimitAngle,
+                    ikLinks: a.ikLinks,
+                };
+                bones.push(boneData);
+            }
+            this.bones = bones;
+        }
+        catch (e) {
+            this.warn("Error parsing bones:", e);
+            this.bones = [];
+        }
+    }
+    parseMorphs() {
+        try {
+            // Check if we have enough bytes to read the count
+            if (this.offset + 4 > this.view.buffer.byteLength) {
+                this.morphs = [];
+                return;
+            }
+            const count = this.getInt32();
+            if (count < 0 || count > 100000) {
+                // Suspicious count, likely corrupted
+                this.warn(`Suspicious morph count: ${count}`);
+                this.morphs = [];
+                return;
+            }
+            this.morphs = [];
+            for (let i = 0; i < count; i++) {
+                // Check bounds before reading each morph
+                if (this.offset >= this.view.buffer.byteLength) {
+                    break;
+                }
+                try {
+                    const name = this.getText();
+                    this.getText(); // englishName (skip)
+                    this.getUint8(); // panelType (skip)
+                    const morphType = this.getUint8();
+                    const offsetCount = this.getInt32();
+                    (globalThis.__DECL ||= []).push([name, morphType, offsetCount]);
+                    const morph = {
+                        name,
+                        type: morphType,
+                        vertexOffsets: [],
+                        groupReferences: [],
+                    };
+                    // Allocated only for the type that uses them, so `morph.boneOffsets`
+                    // being undefined means "not that kind of morph" rather than "empty".
+                    if (morphType === 2)
+                        morph.boneOffsets = [];
+                    else if (morphType >= 3 && morphType <= 7)
+                        morph.uvOffsets = [];
+                    else if (morphType === 8)
+                        morph.materialOffsets = [];
+                    // Parse vertex morphs (type 1)
+                    if (morphType === 1) {
+                        for (let j = 0; j < offsetCount; j++) {
+                            if (this.offset >= this.view.buffer.byteLength) {
+                                break;
+                            }
+                            const vertexIndex = this.getIndex(this.vertexIndexSize);
+                            const x = this.getFloat32();
+                            const y = this.getFloat32();
+                            const z = this.getFloat32();
+                            if (!(vertexIndex >= 0 && vertexIndex < this.vertexCount)) (globalThis.__OOR ||= []).push([name, vertexIndex]);
+                            if (vertexIndex >= 0 && vertexIndex < this.vertexCount) {
+                                morph.vertexOffsets.push({
+                                    vertexIndex,
+                                    positionOffset: [x, y, z],
+                                });
+                            }
+                        }
+                    }
+                    else if (morphType === 0) {
+                        // Parse group morphs
+                        for (let j = 0; j < offsetCount; j++) {
+                            if (this.offset >= this.view.buffer.byteLength) {
+                                break;
+                            }
+                            const morphIndex = this.getNonVertexIndex(this.morphIndexSize);
+                            const ratio = this.getFloat32();
+                            if (morphIndex >= 0) {
+                                morph.groupReferences.push({
+                                    morphIndex,
+                                    ratio,
+                                });
+                            }
+                        }
+                    }
+                    else {
+                        // Bone, UV and material morphs are kept; flip and impulse (PMX 2.1)
+                        // are still read past — nothing in the wild uses them, and impulse
+                        // would need to drive rigidbodies.
+                        for (let j = 0; j < offsetCount; j++) {
+                            if (this.offset >= this.view.buffer.byteLength) {
+                                break;
+                            }
+                            if (morphType === 2) {
+                                // Bone morph
+                                const boneIndex = this.getNonVertexIndex(this.boneIndexSize);
+                                const tx = this.getFloat32();
+                                const ty = this.getFloat32();
+                                const tz = this.getFloat32();
+                                const rx = this.getFloat32();
+                                const ry = this.getFloat32();
+                                const rz = this.getFloat32();
+                                const rw = this.getFloat32();
+                                if (boneIndex >= 0) {
+                                    const offset = {
+                                        boneIndex,
+                                        translation: [tx, ty, tz],
+                                        rotation: [rx, ry, rz, rw],
+                                    };
+                                    morph.boneOffsets.push(offset);
+                                }
+                            }
+                            else if (morphType >= 3 && morphType <= 7) {
+                                // UV morph + additional UV channels 1-4; offset is always a Float4 per spec
+                                const vertexIndex = this.getIndex(this.vertexIndexSize);
+                                const x = this.getFloat32();
+                                const y = this.getFloat32();
+                                const z = this.getFloat32();
+                                const w = this.getFloat32();
+                                if (vertexIndex >= 0 && vertexIndex < this.vertexCount) {
+                                    const offset = { vertexIndex, offset: [x, y, z, w] };
+                                    morph.uvOffsets.push(offset);
+                                }
+                            }
+                            else if (morphType === 8) {
+                                // Material morph
+                                const materialIndex = this.getNonVertexIndex(this.materialIndexSize);
+                                const offsetType = this.getUint8();
+                                const diffuseR = this.getFloat32();
+                                const diffuseG = this.getFloat32();
+                                const diffuseB = this.getFloat32();
+                                const diffuseA = this.getFloat32();
+                                const specularR = this.getFloat32();
+                                const specularG = this.getFloat32();
+                                const specularB = this.getFloat32();
+                                const shininess = this.getFloat32();
+                                const ambientR = this.getFloat32();
+                                const ambientG = this.getFloat32();
+                                const ambientB = this.getFloat32();
+                                const edgeR = this.getFloat32();
+                                const edgeG = this.getFloat32();
+                                const edgeB = this.getFloat32();
+                                const edgeA = this.getFloat32();
+                                const edgeSize = this.getFloat32();
+                                const texR = this.getFloat32();
+                                const texG = this.getFloat32();
+                                const texB = this.getFloat32();
+                                const texA = this.getFloat32();
+                                const sphR = this.getFloat32();
+                                const sphG = this.getFloat32();
+                                const sphB = this.getFloat32();
+                                const sphA = this.getFloat32();
+                                const toonR = this.getFloat32();
+                                const toonG = this.getFloat32();
+                                const toonB = this.getFloat32();
+                                const toonA = this.getFloat32();
+                                // -1 is legal and means "every material" — kept as-is so the
+                                // applier can fan it out without a second convention.
+                                if (materialIndex >= -1) {
+                                    const offset = {
+                                        materialIndex,
+                                        offsetType,
+                                        diffuse: [diffuseR, diffuseG, diffuseB, diffuseA],
+                                        specular: [specularR, specularG, specularB],
+                                        shininess,
+                                        ambient: [ambientR, ambientG, ambientB],
+                                        edgeColor: [edgeR, edgeG, edgeB, edgeA],
+                                        edgeSize,
+                                        textureCoeff: [texR, texG, texB, texA],
+                                        sphereCoeff: [sphR, sphG, sphB, sphA],
+                                        toonCoeff: [toonR, toonG, toonB, toonA],
+                                    };
+                                    morph.materialOffsets.push(offset);
+                                }
+                            }
+                            else if (morphType === 9) {
+                                // Flip morph (PMX 2.1): same layout as group morph
+                                this.getNonVertexIndex(this.morphIndexSize); // morphIndex
+                                this.getFloat32(); // ratio
+                            }
+                            else if (morphType === 10) {
+                                // Impulse morph (PMX 2.1)
+                                this.getNonVertexIndex(this.rigidBodyIndexSize); // rigidbodyIndex
+                                this.getUint8(); // local flag
+                                this.getFloat32(); // velocity x
+                                this.getFloat32(); // velocity y
+                                this.getFloat32(); // velocity z
+                                this.getFloat32(); // torque x
+                                this.getFloat32(); // torque y
+                                this.getFloat32(); // torque z
+                            }
+                        }
+                    }
+                    this.morphs.push(morph);
+                }
+                catch (e) {
+                    // If we fail to read a morph, skip it
+                    this.warn(`Error reading morph ${i}:`, e);
+                }
+            }
+        }
+        catch (e) {
+            this.warn("Error parsing morphs:", e);
+            this.morphs = [];
+        }
+    }
+    skipDisplayFrames() {
+        try {
+            // Check if we have enough bytes to read the count
+            if (this.offset + 4 > this.view.buffer.byteLength) {
+                return false;
+            }
+            const count = this.getInt32();
+            if (count < 0 || count > 100000) {
+                // Suspicious count, likely corrupted - restore offset
+                this.offset -= 4;
+                return false;
+            }
+            for (let i = 0; i < count; i++) {
+                // Check bounds before reading each frame
+                if (this.offset >= this.view.buffer.byteLength) {
+                    return false;
+                }
+                try {
+                    this.getText(); // name
+                    this.getText(); // englishName
+                    this.getUint8(); // flag
+                    const elementCount = this.getInt32();
+                    for (let j = 0; j < elementCount; j++) {
+                        if (this.offset >= this.view.buffer.byteLength) {
+                            return false;
+                        }
+                        const elementType = this.getUint8();
+                        if (elementType === 0) {
+                            // Bone frame
+                            this.getNonVertexIndex(this.boneIndexSize);
+                        }
+                        else if (elementType === 1) {
+                            // Morph frame
+                            this.getNonVertexIndex(this.morphIndexSize);
+                        }
+                    }
+                }
+                catch (e) {
+                    // If we fail to read a frame, stop skipping
+                    this.warn(`Error reading display frame ${i}:`, e);
+                    return false;
+                }
+            }
+            return true;
+        }
+        catch (e) {
+            this.warn("Error skipping display frames:", e);
+            return false;
+        }
+    }
+    parseRigidbodies() {
+        try {
+            // Note: morphs and display frames are already skipped in parse() before calling this
+            // Check bounds before reading rigidbody count
+            if (this.offset + 4 > this.view.buffer.byteLength) {
+                this.warn("Not enough bytes for rigidbody count");
+                this.rigidbodies = [];
+                return;
+            }
+            const count = this.getInt32();
+            if (count < 0 || count > 10000) {
+                // Suspicious count
+                this.warn(`Suspicious rigidbody count: ${count}`);
+                this.rigidbodies = [];
+                return;
+            }
+            this.rigidbodies = [];
+            for (let i = 0; i < count; i++) {
+                try {
+                    // Check bounds before reading each rigidbody
+                    if (this.offset >= this.view.buffer.byteLength) {
+                        this.warn(`Reached end of buffer while reading rigidbody ${i} of ${count}`);
+                        break;
+                    }
+                    const name = this.getText();
+                    const englishName = this.getText();
+                    const boneIndex = this.getNonVertexIndex(this.boneIndexSize);
+                    const group = this.getUint8();
+                    const collisionMask = this.getUint16();
+                    const shape = this.getUint8(); // 0=sphere, 1=box, 2=capsule
+                    // Size parameters (depends on shape)
+                    const sizeX = this.getFloat32();
+                    const sizeY = this.getFloat32();
+                    const sizeZ = this.getFloat32();
+                    const posX = this.getFloat32();
+                    const posY = this.getFloat32();
+                    const posZ = this.getFloat32();
+                    // Rotation (Euler angles in RADIANS in PMX file - PMX Editor displays them as degrees for convenience)
+                    // ZXY order (left-handed system)
+                    const rotX = this.getFloat32();
+                    const rotY = this.getFloat32();
+                    const rotZ = this.getFloat32();
+                    // Physical properties
+                    const mass = this.getFloat32();
+                    const linearDamping = this.getFloat32();
+                    const angularDamping = this.getFloat32();
+                    const restitution = this.getFloat32();
+                    const friction = this.getFloat32();
+                    // PMX physics mode: 0 = follow bone, 1 = physics,
+                    // 2 = physics + bone-position alignment. Mode 2 is dynamic — it
+                    // must NOT be cast onto RigidbodyType (2 = Kinematic there, which
+                    // freezes the body to its bone and kills physics for most modern
+                    // cloth rigs and every 胸_回転 breast body).
+                    const mode = this.getUint8();
+                    this.rigidbodies.push({
+                        name,
+                        englishName,
+                        boneIndex,
+                        group,
+                        collisionMask,
+                        shape: shape,
+                        size: new Vec3(sizeX, sizeY, sizeZ),
+                        shapePosition: new Vec3(posX, posY, posZ),
+                        shapeRotation: new Vec3(rotX, rotY, rotZ),
+                        mass,
+                        linearDamping,
+                        angularDamping,
+                        restitution,
+                        friction,
+                        type: mode === 0 ? RigidbodyType.Static : RigidbodyType.Dynamic,
+                        aligned: mode === 2,
+                        bodyOffsetMatrixInverse: Mat4.identity(),
+                    });
+                }
+                catch (e) {
+                    this.warn(`Error reading rigidbody ${i} of ${count}:`, e);
+                    // Stop parsing if we encounter an error
+                    break;
+                }
+            }
+        }
+        catch (e) {
+            this.warn("Error parsing rigidbodies:", e);
+            this.rigidbodies = [];
+        }
+    }
+    parseJoints() {
+        try {
+            // Check bounds before reading joint count
+            if (this.offset + 4 > this.view.buffer.byteLength) {
+                this.warn("Not enough bytes for joint count");
+                this.joints = [];
+                return;
+            }
+            const count = this.getInt32();
+            if (count < 0 || count > 10000) {
+                this.warn(`Suspicious joint count: ${count}`);
+                this.joints = [];
+                return;
+            }
+            this.joints = [];
+            for (let i = 0; i < count; i++) {
+                try {
+                    // Check bounds before reading each joint
+                    if (this.offset >= this.view.buffer.byteLength) {
+                        this.warn(`Reached end of buffer while reading joint ${i} of ${count}`);
+                        break;
+                    }
+                    const name = this.getText();
+                    const englishName = this.getText();
+                    const type = this.getUint8();
+                    // Rigidbody indices use rigidBodyIndexSize (not boneIndexSize)
+                    const rigidbodyIndexA = this.getNonVertexIndex(this.rigidBodyIndexSize);
+                    const rigidbodyIndexB = this.getNonVertexIndex(this.rigidBodyIndexSize);
+                    const posX = this.getFloat32();
+                    const posY = this.getFloat32();
+                    const posZ = this.getFloat32();
+                    // Rotation (Euler angles in RADIANS in PMX file - PMX Editor displays them as degrees for convenience)
+                    // ZXY order (left-handed system)
+                    const rotX = this.getFloat32();
+                    const rotY = this.getFloat32();
+                    const rotZ = this.getFloat32();
+                    const posMinX = this.getFloat32();
+                    const posMinY = this.getFloat32();
+                    const posMinZ = this.getFloat32();
+                    const posMaxX = this.getFloat32();
+                    const posMaxY = this.getFloat32();
+                    const posMaxZ = this.getFloat32();
+                    // Rotation constraints (in RADIANS in PMX file)
+                    const rotMinX = this.getFloat32();
+                    const rotMinY = this.getFloat32();
+                    const rotMinZ = this.getFloat32();
+                    const rotMaxX = this.getFloat32();
+                    const rotMaxY = this.getFloat32();
+                    const rotMaxZ = this.getFloat32();
+                    // Spring parameters
+                    const springPosX = this.getFloat32();
+                    const springPosY = this.getFloat32();
+                    const springPosZ = this.getFloat32();
+                    // Spring rotation (stiffness values in PMX file)
+                    const springRotX = this.getFloat32();
+                    const springRotY = this.getFloat32();
+                    const springRotZ = this.getFloat32();
+                    // Store rotations and springs as Vec3 (Euler angles), not Quat
+                    this.joints.push({
+                        name,
+                        englishName,
+                        type,
+                        rigidbodyIndexA,
+                        rigidbodyIndexB,
+                        position: new Vec3(posX, posY, posZ),
+                        rotation: new Vec3(rotX, rotY, rotZ), // Store as Vec3 (Euler angles)
+                        positionMin: new Vec3(posMinX, posMinY, posMinZ),
+                        positionMax: new Vec3(posMaxX, posMaxY, posMaxZ),
+                        rotationMin: new Vec3(rotMinX, rotMinY, rotMinZ), // Store as Vec3 (Euler angles)
+                        rotationMax: new Vec3(rotMaxX, rotMaxY, rotMaxZ), // Store as Vec3 (Euler angles)
+                        springPosition: new Vec3(springPosX, springPosY, springPosZ),
+                        springRotation: new Vec3(springRotX, springRotY, springRotZ), // Store as Vec3 (stiffness values)
+                    });
+                }
+                catch (e) {
+                    this.warn(`Error reading joint ${i} of ${count}:`, e);
+                    // Stop parsing if we encounter an error
+                    break;
+                }
+            }
+        }
+        catch (e) {
+            this.warn("Error parsing joints:", e);
+            this.joints = [];
+        }
+    }
+    computeInverseBind() {
+        if (!this.bones || this.bones.length === 0) {
+            this.inverseBindMatrices = new Float32Array(0);
+            return;
+        }
+        const n = this.bones.length;
+        const world = new Array(n).fill(null);
+        const inv = new Float32Array(n * 16);
+        const computeWorld = (i) => {
+            if (world[i])
+                return world[i];
+            const bone = this.bones[i];
+            const local = Mat4.identity().translateInPlace(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2]);
+            let w;
+            if (bone.parentIndex >= 0 && bone.parentIndex < n) {
+                w = computeWorld(bone.parentIndex).multiply(local);
+            }
+            else {
+                w = local;
+            }
+            world[i] = w;
+            return w;
+        };
+        for (let i = 0; i < n; i++) {
+            const w = computeWorld(i);
+            const invm = Mat4.identity().translateInPlace(-w.values[12], -w.values[13], -w.values[14]);
+            inv.set(invm.values, i * 16);
+        }
+        this.inverseBindMatrices = inv;
+    }
+    toModel(positions, normals, uvs, indices) {
+        // Create indexed vertex buffer
+        // Format: [x,y,z, nx,ny,nz, u,v, x,y,z, ...]
+        const vertexData = new Float32Array(this.vertexCount * 8);
+        for (let i = 0; i < this.vertexCount; i++) {
+            const pi = i * 3;
+            const ui = i * 2;
+            const vi = i * 8;
+            vertexData[vi] = positions[pi];
+            vertexData[vi + 1] = positions[pi + 1];
+            vertexData[vi + 2] = positions[pi + 2];
+            vertexData[vi + 3] = normals[pi];
+            vertexData[vi + 4] = normals[pi + 1];
+            vertexData[vi + 5] = normals[pi + 2];
+            vertexData[vi + 6] = uvs[ui];
+            vertexData[vi + 7] = uvs[ui + 1];
+        }
+        // Create index buffer
+        const indexData = new Uint32Array(indices);
+        // Create skeleton (required)
+        const skeleton = {
+            bones: this.bones.length > 0 ? this.bones : [],
+            inverseBindMatrices: this.inverseBindMatrices || new Float32Array(0),
+        };
+        let skinning;
+        if (this.joints0 && this.weights0) {
+            // Clamp joints to valid range now that we know bone count, and renormalize weights
+            const boneCount = this.bones.length;
+            const joints = this.joints0;
+            const weights = this.weights0;
+            for (let i = 0; i < joints.length; i += 4) {
+                // First pass: identify and zero out invalid joints, collect valid weight sum
+                let validWeightSum = 0;
+                let validCount = 0;
+                for (let k = 0; k < 4; k++) {
+                    const j = joints[i + k];
+                    if (j < 0 || j >= boneCount) {
+                        // Invalid joint: zero the weight but keep joint index for debugging
+                        weights[i + k] = 0;
+                        // Optionally clamp to valid range
+                        if (j < 0) {
+                            joints[i + k] = 0;
+                        }
+                        else {
+                            joints[i + k] = boneCount > 0 ? boneCount - 1 : 0;
+                        }
+                    }
+                    else {
+                        validWeightSum += weights[i + k];
+                        validCount++;
+                    }
+                }
+                // If no valid weights, assign all weight to first bone (bone 0)
+                if (validWeightSum === 0 || validCount === 0) {
+                    weights[i] = 255;
+                    weights[i + 1] = 0;
+                    weights[i + 2] = 0;
+                    weights[i + 3] = 0;
+                    joints[i] = boneCount > 0 ? 0 : 0;
+                    joints[i + 1] = 0;
+                    joints[i + 2] = 0;
+                    joints[i + 3] = 0;
+                }
+                else if (validWeightSum !== 255) {
+                    // Normalize valid weights to sum to exactly 255
+                    const scale = 255 / validWeightSum;
+                    let accum = 0;
+                    for (let k = 0; k < 3; k++) {
+                        if (joints[i + k] >= 0 && joints[i + k] < boneCount) {
+                            const v = Math.max(0, Math.min(255, Math.round(weights[i + k] * scale)));
+                            weights[i + k] = v;
+                            accum += v;
+                        }
+                        else {
+                            weights[i + k] = 0;
+                        }
+                    }
+                    // Handle the 4th weight
+                    if (joints[i + 3] >= 0 && joints[i + 3] < boneCount) {
+                        weights[i + 3] = Math.max(0, Math.min(255, 255 - accum));
+                    }
+                    else {
+                        weights[i + 3] = 0;
+                        // Redistribute the remainder to the last valid weight
+                        if (accum < 255) {
+                            for (let k = 2; k >= 0; k--) {
+                                if (joints[i + k] >= 0 && joints[i + k] < boneCount && weights[i + k] > 0) {
+                                    weights[i + k] = Math.min(255, weights[i + k] + (255 - accum));
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    // Final safety check: ensure sum is exactly 255
+                    const finalSum = weights[i] + weights[i + 1] + weights[i + 2] + weights[i + 3];
+                    if (finalSum !== 255) {
+                        const diff = 255 - finalSum;
+                        // Add/subtract difference to/from the largest valid weight
+                        let maxIdx = 0;
+                        let maxWeight = weights[i];
+                        for (let k = 1; k < 4; k++) {
+                            if (weights[i + k] > maxWeight && joints[i + k] >= 0 && joints[i + k] < boneCount) {
+                                maxWeight = weights[i + k];
+                                maxIdx = k;
+                            }
+                        }
+                        if (joints[i + maxIdx] >= 0 && joints[i + maxIdx] < boneCount) {
+                            weights[i + maxIdx] = Math.max(0, Math.min(255, weights[i + maxIdx] + diff));
+                        }
+                    }
+                }
+            }
+            skinning = { joints, weights };
+        }
+        else {
+            // Create default skinning (single bone per vertex)
+            const joints = new Uint16Array(this.vertexCount * 4);
+            const weights = new Uint8Array(this.vertexCount * 4);
+            for (let i = 0; i < this.vertexCount; i++) {
+                joints[i * 4] = 0;
+                weights[i * 4] = 255;
+            }
+            skinning = { joints, weights };
+        }
+        // Morphs are applied from the sparse per-morph vertexOffsets lists (see
+        // Model.applyMorphs); no dense morphCount*vertexCount buffer is needed.
+        const morphing = {
+            morphs: this.morphs,
+        };
+        return new Model(vertexData, indexData, this.textures, this.materials, skeleton, skinning, morphing, this.rigidbodies, this.joints, this.warnings);
+    }
+    getUint8() {
+        if (this.offset >= this.view.buffer.byteLength) {
+            throw new RangeError(`Offset ${this.offset} exceeds buffer bounds ${this.view.buffer.byteLength}`);
+        }
+        return this.view.getUint8(this.offset++);
+    }
+    getUint16() {
+        if (this.offset + 2 > this.view.buffer.byteLength) {
+            throw new RangeError(`Offset ${this.offset} + 2 exceeds buffer bounds ${this.view.buffer.byteLength}`);
+        }
+        const v = this.view.getUint16(this.offset, true);
+        this.offset += 2;
+        return v;
+    }
+    // Vertex index: 1->uint8, 2->uint16, 4->int32
+    getVertexIndex(size) {
+        if (size === 1)
+            return this.getUint8();
+        if (size === 2) {
+            const v = this.view.getUint16(this.offset, true);
+            this.offset += 2;
+            return v;
+        }
+        return this.getInt32();
+    }
+    // Non-vertex indices (texture/material/bone/morph/rigid): 1->int8, 2->int16, 4->int32
+    getNonVertexIndex(size) {
+        if (size === 1) {
+            const v = this.view.getInt8(this.offset);
+            this.offset += 1;
+            return v;
+        }
+        if (size === 2) {
+            const v = this.view.getInt16(this.offset, true);
+            this.offset += 2;
+            return v;
+        }
+        return this.getInt32();
+    }
+    getInt32() {
+        if (this.offset + 4 > this.view.buffer.byteLength) {
+            throw new RangeError(`Offset ${this.offset} + 4 exceeds buffer bounds ${this.view.buffer.byteLength}`);
+        }
+        const v = this.view.getInt32(this.offset, true);
+        this.offset += 4;
+        return v;
+    }
+    getFloat32() {
+        if (this.offset + 4 > this.view.buffer.byteLength) {
+            throw new RangeError(`Offset ${this.offset} + 4 exceeds buffer bounds ${this.view.buffer.byteLength}`);
+        }
+        const v = this.view.getFloat32(this.offset, true);
+        this.offset += 4;
+        return v;
+    }
+    getString(len) {
+        // byteOffset matters: a DataView built over a slice of a larger buffer has
+        // its own origin, and reading the raw buffer without it lands elsewhere.
+        const bytes = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, len);
+        this.offset += len;
+        return String.fromCharCode(...bytes);
+    }
+    getText() {
+        const len = this.getInt32();
+        if (len <= 0)
+            return "";
+        // No arbitrary length ceiling. A model's comment field carries credits and
+        // terms of use and routinely runs past a thousand bytes — roughly five
+        // hundred characters in UTF-16 — so a "this looks too long" heuristic
+        // rejected perfectly ordinary models from several distributors. The bounds
+        // check below is the real guard: a length that would read past the end of
+        // the file is corrupt, and any length that fits is the author's business.
+        // Ensure we don't read beyond buffer bounds
+        if (this.offset + len > this.view.byteLength) {
+            throw new RangeError(`String length ${len} exceeds buffer bounds at offset ${this.offset - 4}`);
+        }
+        let bytes = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, len);
+        this.offset += len;
+        // UTF-16 needs whole code units. A stray odd length (seen from a few
+        // exporters) made TextDecoder emit a replacement char and, worse, shifted
+        // nothing — better to drop the orphan byte than to carry it into the name.
+        if (this.encoding === 0 && len % 2 === 1)
+            bytes = bytes.subarray(0, len - 1);
+        return this.decoder.decode(bytes);
+    }
+    getIndex(size) {
+        // Backward-compat helper: defaults to vertex index behavior
+        return this.getVertexIndex(size);
+    }
+}