reze-engine 0.3.12 → 0.3.13

package/dist/rzm-writer.js

@@ -0,0 +1,701 @@
+/**
+ * RZM (Reze Model) Binary Format Writer
+ *
+ * Format Structure:
+ * - Header (32 bytes)
+ *   - Magic: "RZM\0" (4 bytes)
+ *   - Version: uint32 (1)
+ *   - File size: uint64
+ *   - Section count: uint32
+ *   - Reserved: 16 bytes
+ *
+ * - Section Table (variable)
+ *   - For each section: type (uint32), offset (uint64), size (uint64)
+ *
+ * - Sections (in order):
+ *   - GEOMETRY: vertices, indices
+ *   - SKELETON: bones, inverse bind matrices
+ *   - SKINNING: joints, weights
+ *   - MORPHING: morphs, offsets buffer
+ *   - MATERIALS: material data
+ *   - TEXTURES: texture metadata + embedded image data
+ *   - PHYSICS: rigidbodies, joints
+ */
+var SectionType;
+(function (SectionType) {
+    SectionType[SectionType["GEOMETRY"] = 1] = "GEOMETRY";
+    SectionType[SectionType["SKELETON"] = 2] = "SKELETON";
+    SectionType[SectionType["SKINNING"] = 3] = "SKINNING";
+    SectionType[SectionType["MORPHING"] = 4] = "MORPHING";
+    SectionType[SectionType["MATERIALS"] = 5] = "MATERIALS";
+    SectionType[SectionType["TEXTURES"] = 6] = "TEXTURES";
+    SectionType[SectionType["PHYSICS"] = 7] = "PHYSICS";
+})(SectionType || (SectionType = {}));
+export class RzmWriter {
+    constructor() {
+        this.sections = [];
+        this.currentOffset = 0;
+    }
+    /**
+     * Convert a Model to RZM binary format
+     * @param model The model to convert
+     * @param textureData Map of texture paths to their binary data (PNG/JPEG bytes)
+     * @returns RZM binary data as ArrayBuffer
+     */
+    static async write(model, textureData) {
+        const writer = new RzmWriter();
+        await writer.writeModel(model, textureData);
+        return writer.finalize();
+    }
+    async writeModel(model, textureData) {
+        // Calculate header + section table size
+        const textures = model.getTextures();
+        const sectionCount = 7; // All sections are always present
+        const sectionTableSize = sectionCount * RzmWriter.SECTION_TABLE_ENTRY_SIZE;
+        this.currentOffset = RzmWriter.HEADER_SIZE + sectionTableSize;
+        // Write all sections
+        this.writeGeometry(model);
+        this.writeSkeleton(model);
+        this.writeSkinning(model);
+        this.writeMorphing(model);
+        this.writeMaterials(model);
+        await this.writeTextures(model, textureData);
+        this.writePhysics(model);
+    }
+    writeGeometry(model) {
+        const vertices = model.getVertices();
+        const indices = model.getIndices();
+        // Layout: vertexCount (uint32), vertexData (Float32Array), indexCount (uint32), indexData (Uint32Array)
+        const vertexBytes = new Uint8Array(vertices.buffer);
+        const indexBytes = new Uint8Array(indices.buffer);
+        const size = 4 + vertexBytes.length + 4 + indexBytes.length;
+        const data = new Uint8Array(size);
+        const view = new DataView(data.buffer);
+        let offset = 0;
+        view.setUint32(offset, vertices.length / 8, true); // vertexCount (8 floats per vertex)
+        offset += 4;
+        data.set(vertexBytes, offset);
+        offset += vertexBytes.length;
+        view.setUint32(offset, indices.length, true); // indexCount
+        offset += 4;
+        data.set(indexBytes, offset);
+        this.addSection(SectionType.GEOMETRY, data);
+    }
+    writeSkeleton(model) {
+        const skeleton = model.getSkeleton();
+        const bones = skeleton.bones;
+        const inverseBindMatrices = skeleton.inverseBindMatrices;
+        // Layout: boneCount (uint32), bones[], inverseBindMatrices (Float32Array)
+        // Each bone: nameLen (uint32), name (utf8), parentIndex (int32), bindTranslation (3x float32),
+        //            appendParentIndex (int32, -1 if none), appendRatio (float32), appendRotate (uint8), appendMove (uint8),
+        //            ikTargetIndex (int32, -1 if none), ikIteration (int32), ikLimitAngle (float32),
+        //            ikLinkCount (uint32), ikLinks[]
+        // Each IK link: boneIndex (int32), hasLimit (uint8), minAngle (3x float32, if hasLimit), maxAngle (3x float32, if hasLimit)
+        const boneData = [];
+        let totalSize = 4; // boneCount
+        for (const bone of bones) {
+            const nameBytes = new TextEncoder().encode(bone.name);
+            const boneSize = 4 + nameBytes.length + 4 + 12 + 4 + 4 + 1 + 1 + 4 + 4 + 4 + 4; // base size
+            const boneBuffer = new Uint8Array(boneSize);
+            const boneView = new DataView(boneBuffer.buffer);
+            let off = 0;
+            boneView.setUint32(off, nameBytes.length, true);
+            off += 4;
+            boneBuffer.set(nameBytes, off);
+            off += nameBytes.length;
+            boneView.setInt32(off, bone.parentIndex ?? -1, true);
+            off += 4;
+            boneView.setFloat32(off, bone.bindTranslation[0], true);
+            off += 4;
+            boneView.setFloat32(off, bone.bindTranslation[1], true);
+            off += 4;
+            boneView.setFloat32(off, bone.bindTranslation[2], true);
+            off += 4;
+            boneView.setInt32(off, bone.appendParentIndex ?? -1, true);
+            off += 4;
+            boneView.setFloat32(off, bone.appendRatio ?? 0, true);
+            off += 4;
+            boneView.setUint8(off, bone.appendRotate ? 1 : 0);
+            off += 1;
+            boneView.setUint8(off, bone.appendMove ? 1 : 0);
+            off += 1;
+            boneView.setInt32(off, bone.ikTargetIndex ?? -1, true);
+            off += 4;
+            boneView.setInt32(off, bone.ikIteration ?? 0, true);
+            off += 4;
+            boneView.setFloat32(off, bone.ikLimitAngle ?? 0, true);
+            off += 4;
+            // IK links
+            const ikLinks = bone.ikLinks || [];
+            boneView.setUint32(off, ikLinks.length, true);
+            off += 4;
+            // Extend buffer for IK links
+            const ikLinkSize = ikLinks.length * (4 + 1 + (ikLinks.some((l) => l.hasLimit) ? 24 : 0));
+            const extendedBuffer = new Uint8Array(boneSize + ikLinkSize);
+            extendedBuffer.set(boneBuffer, 0);
+            const extendedView = new DataView(extendedBuffer.buffer);
+            for (const link of ikLinks) {
+                extendedView.setInt32(off, link.boneIndex, true);
+                off += 4;
+                extendedView.setUint8(off, link.hasLimit ? 1 : 0);
+                off += 1;
+                if (link.hasLimit && link.minAngle && link.maxAngle) {
+                    extendedView.setFloat32(off, link.minAngle.x, true);
+                    off += 4;
+                    extendedView.setFloat32(off, link.minAngle.y, true);
+                    off += 4;
+                    extendedView.setFloat32(off, link.minAngle.z, true);
+                    off += 4;
+                    extendedView.setFloat32(off, link.maxAngle.x, true);
+                    off += 4;
+                    extendedView.setFloat32(off, link.maxAngle.y, true);
+                    off += 4;
+                    extendedView.setFloat32(off, link.maxAngle.z, true);
+                    off += 4;
+                }
+            }
+            boneData.push(extendedBuffer);
+            totalSize += extendedBuffer.length;
+        }
+        // Inverse bind matrices
+        const invBindBytes = new Uint8Array(inverseBindMatrices.buffer);
+        totalSize += invBindBytes.length;
+        // Combine all data
+        const data = new Uint8Array(totalSize);
+        const view = new DataView(data.buffer);
+        let offset = 0;
+        view.setUint32(offset, bones.length, true);
+        offset += 4;
+        for (const boneBuffer of boneData) {
+            data.set(boneBuffer, offset);
+            offset += boneBuffer.length;
+        }
+        data.set(invBindBytes, offset);
+        this.addSection(SectionType.SKELETON, data);
+    }
+    writeSkinning(model) {
+        const skinning = model.getSkinning();
+        const joints = skinning.joints;
+        const weights = skinning.weights;
+        // Layout: joints (Uint16Array), weights (Uint8Array)
+        const jointsBytes = new Uint8Array(joints.buffer);
+        const weightsBytes = new Uint8Array(weights.buffer);
+        const size = 4 + jointsBytes.length + 4 + weightsBytes.length;
+        const data = new Uint8Array(size);
+        const view = new DataView(data.buffer);
+        let offset = 0;
+        view.setUint32(offset, joints.length, true);
+        offset += 4;
+        data.set(jointsBytes, offset);
+        offset += jointsBytes.length;
+        view.setUint32(offset, weights.length, true);
+        offset += 4;
+        data.set(weightsBytes, offset);
+        this.addSection(SectionType.SKINNING, data);
+    }
+    writeMorphing(model) {
+        const morphing = model.getMorphing();
+        const morphs = morphing.morphs;
+        const offsetsBuffer = morphing.offsetsBuffer;
+        // Layout: morphCount (uint32), morphs[], offsetsBuffer (Float32Array)
+        // Each morph: nameLen (uint32), name (utf8), type (uint8), vertexOffsetCount (uint32), vertexOffsets[],
+        //             groupRefCount (uint32), groupRefs[]
+        // Each vertex offset: vertexIndex (uint32), positionOffset (3x float32)
+        // Each group ref: morphIndex (int32), ratio (float32)
+        const morphData = [];
+        let totalSize = 4; // morphCount
+        for (const morph of morphs) {
+            const nameBytes = new TextEncoder().encode(morph.name);
+            let morphSize = 4 + nameBytes.length + 1 + 4; // nameLen + name + type + vertexOffsetCount
+            // Vertex offsets
+            const vertexOffsets = morph.vertexOffsets || [];
+            morphSize += vertexOffsets.length * (4 + 12); // vertexIndex + positionOffset
+            // Group references
+            const groupRefs = morph.groupReferences || [];
+            morphSize += 4 + groupRefs.length * (4 + 4); // groupRefCount + (morphIndex + ratio)
+            const morphBuffer = new Uint8Array(morphSize);
+            const morphView = new DataView(morphBuffer.buffer);
+            let off = 0;
+            morphView.setUint32(off, nameBytes.length, true);
+            off += 4;
+            morphBuffer.set(nameBytes, off);
+            off += nameBytes.length;
+            morphView.setUint8(off, morph.type);
+            off += 1;
+            morphView.setUint32(off, vertexOffsets.length, true);
+            off += 4;
+            for (const vo of vertexOffsets) {
+                morphView.setUint32(off, vo.vertexIndex, true);
+                off += 4;
+                morphView.setFloat32(off, vo.positionOffset[0], true);
+                off += 4;
+                morphView.setFloat32(off, vo.positionOffset[1], true);
+                off += 4;
+                morphView.setFloat32(off, vo.positionOffset[2], true);
+                off += 4;
+            }
+            morphView.setUint32(off, groupRefs.length, true);
+            off += 4;
+            for (const gr of groupRefs) {
+                morphView.setInt32(off, gr.morphIndex, true);
+                off += 4;
+                morphView.setFloat32(off, gr.ratio, true);
+                off += 4;
+            }
+            morphData.push(morphBuffer);
+            totalSize += morphBuffer.length;
+        }
+        // Offsets buffer
+        const offsetsBytes = new Uint8Array(offsetsBuffer.buffer);
+        totalSize += offsetsBytes.length;
+        // Combine all data
+        const data = new Uint8Array(totalSize);
+        const view = new DataView(data.buffer);
+        let offset = 0;
+        view.setUint32(offset, morphs.length, true);
+        offset += 4;
+        for (const morphBuffer of morphData) {
+            data.set(morphBuffer, offset);
+            offset += morphBuffer.length;
+        }
+        data.set(offsetsBytes, offset);
+        this.addSection(SectionType.MORPHING, data);
+    }
+    writeMaterials(model) {
+        const materials = model.getMaterials();
+        // Layout: materialCount (uint32), materials[]
+        // Each material: nameLen (uint32), name (utf8), diffuse (4x float32), specular (3x float32),
+        //                shininess (float32), ambient (3x float32), diffuseTextureIndex (int32),
+        //                normalTextureIndex (int32), sphereTextureIndex (int32), sphereMode (uint8),
+        //                toonTextureIndex (int32), edgeFlag (uint8), edgeColor (4x float32),
+        //                edgeSize (float32), vertexCount (uint32), isEye (uint8), isFace (uint8), isHair (uint8)
+        const materialData = [];
+        let totalSize = 4; // materialCount
+        for (const mat of materials) {
+            const nameBytes = new TextEncoder().encode(mat.name);
+            const size = 4 + nameBytes.length + 4 * 4 + 3 * 4 + 4 + 3 * 4 + 4 + 4 + 4 + 1 + 4 + 1 + 4 * 4 + 4 + 4 + 1 + 1 + 1;
+            const buffer = new Uint8Array(size);
+            const view = new DataView(buffer.buffer);
+            let off = 0;
+            view.setUint32(off, nameBytes.length, true);
+            off += 4;
+            buffer.set(nameBytes, off);
+            off += nameBytes.length;
+            view.setFloat32(off, mat.diffuse[0], true);
+            off += 4;
+            view.setFloat32(off, mat.diffuse[1], true);
+            off += 4;
+            view.setFloat32(off, mat.diffuse[2], true);
+            off += 4;
+            view.setFloat32(off, mat.diffuse[3], true);
+            off += 4;
+            view.setFloat32(off, mat.specular[0], true);
+            off += 4;
+            view.setFloat32(off, mat.specular[1], true);
+            off += 4;
+            view.setFloat32(off, mat.specular[2], true);
+            off += 4;
+            view.setFloat32(off, mat.shininess, true);
+            off += 4;
+            view.setFloat32(off, mat.ambient[0], true);
+            off += 4;
+            view.setFloat32(off, mat.ambient[1], true);
+            off += 4;
+            view.setFloat32(off, mat.ambient[2], true);
+            off += 4;
+            view.setInt32(off, mat.diffuseTextureIndex, true);
+            off += 4;
+            view.setInt32(off, mat.normalTextureIndex, true);
+            off += 4;
+            view.setInt32(off, mat.sphereTextureIndex, true);
+            off += 4;
+            view.setUint8(off, mat.sphereMode);
+            off += 1;
+            view.setInt32(off, mat.toonTextureIndex, true);
+            off += 4;
+            view.setUint8(off, mat.edgeFlag);
+            off += 1;
+            view.setFloat32(off, mat.edgeColor[0], true);
+            off += 4;
+            view.setFloat32(off, mat.edgeColor[1], true);
+            off += 4;
+            view.setFloat32(off, mat.edgeColor[2], true);
+            off += 4;
+            view.setFloat32(off, mat.edgeColor[3], true);
+            off += 4;
+            view.setFloat32(off, mat.edgeSize, true);
+            off += 4;
+            view.setUint32(off, mat.vertexCount, true);
+            off += 4;
+            view.setUint8(off, mat.isEye ? 1 : 0);
+            off += 1;
+            view.setUint8(off, mat.isFace ? 1 : 0);
+            off += 1;
+            view.setUint8(off, mat.isHair ? 1 : 0);
+            off += 1;
+            materialData.push(buffer);
+            totalSize += buffer.length;
+        }
+        const data = new Uint8Array(totalSize);
+        const view = new DataView(data.buffer);
+        let offset = 0;
+        view.setUint32(offset, materials.length, true);
+        offset += 4;
+        for (const buffer of materialData) {
+            data.set(buffer, offset);
+            offset += buffer.length;
+        }
+        this.addSection(SectionType.MATERIALS, data);
+    }
+    async writeTextures(model, textureData) {
+        const textures = model.getTextures();
+        // Layout: textureCount (uint32), textures[]
+        // Each texture: nameLen (uint32), name (utf8), pathLen (uint32), path (utf8),
+        //               width (uint32), height (uint32), format (uint8), dataSize (uint32), data (bytes)
+        const textureDataArray = [];
+        let totalSize = 4; // textureCount
+        for (const texture of textures) {
+            const nameBytes = new TextEncoder().encode(texture.name);
+            const pathBytes = new TextEncoder().encode(texture.path);
+            // Try to get texture data
+            const data = textureData.get(texture.path) || textureData.get(texture.name);
+            if (!data) {
+                console.warn(`[RzmWriter] Texture data not found for: ${texture.path}`);
+                // Create empty texture entry
+                const size = 4 + nameBytes.length + 4 + pathBytes.length + 4 + 4 + 1 + 4;
+                const buffer = new Uint8Array(size);
+                const view = new DataView(buffer.buffer);
+                let off = 0;
+                view.setUint32(off, nameBytes.length, true);
+                off += 4;
+                buffer.set(nameBytes, off);
+                off += nameBytes.length;
+                view.setUint32(off, pathBytes.length, true);
+                off += 4;
+                buffer.set(pathBytes, off);
+                off += pathBytes.length;
+                view.setUint32(off, 0, true); // width
+                off += 4;
+                view.setUint32(off, 0, true); // height
+                off += 4;
+                view.setUint8(off, 0); // format (0 = unknown)
+                off += 1;
+                view.setUint32(off, 0, true); // dataSize
+                off += 4;
+                textureDataArray.push(buffer);
+                totalSize += buffer.length;
+                continue;
+            }
+            // Decode image to get dimensions
+            // For now, we'll store the raw bytes and dimensions will be determined by loader
+            // Format: 0 = PNG, 1 = JPEG, 2 = WebP, 3 = raw RGBA
+            let format = 0;
+            if (texture.path.toLowerCase().endsWith(".jpg") || texture.path.toLowerCase().endsWith(".jpeg")) {
+                format = 1;
+            }
+            else if (texture.path.toLowerCase().endsWith(".webp")) {
+                format = 2;
+            }
+            else if (texture.path.toLowerCase().endsWith(".png")) {
+                format = 0;
+            }
+            else {
+                format = 3; // Assume raw RGBA
+            }
+            // Try to decode to get dimensions
+            let width = 0;
+            let height = 0;
+            try {
+                const blob = new Blob([data]);
+                const imageBitmap = await createImageBitmap(blob);
+                width = imageBitmap.width;
+                height = imageBitmap.height;
+                imageBitmap.close();
+            }
+            catch (e) {
+                console.warn(`[RzmWriter] Failed to decode image for dimensions: ${texture.path}`, e);
+            }
+            const dataBytes = new Uint8Array(data);
+            const size = 4 + nameBytes.length + 4 + pathBytes.length + 4 + 4 + 1 + 4 + dataBytes.length;
+            const buffer = new Uint8Array(size);
+            const view = new DataView(buffer.buffer);
+            let off = 0;
+            view.setUint32(off, nameBytes.length, true);
+            off += 4;
+            buffer.set(nameBytes, off);
+            off += nameBytes.length;
+            view.setUint32(off, pathBytes.length, true);
+            off += 4;
+            buffer.set(pathBytes, off);
+            off += pathBytes.length;
+            view.setUint32(off, width, true);
+            off += 4;
+            view.setUint32(off, height, true);
+            off += 4;
+            view.setUint8(off, format);
+            off += 1;
+            view.setUint32(off, dataBytes.length, true);
+            off += 4;
+            buffer.set(dataBytes, off);
+            textureDataArray.push(buffer);
+            totalSize += buffer.length;
+        }
+        const data = new Uint8Array(totalSize);
+        const view = new DataView(data.buffer);
+        let offset = 0;
+        view.setUint32(offset, textures.length, true);
+        offset += 4;
+        for (const buffer of textureDataArray) {
+            data.set(buffer, offset);
+            offset += buffer.length;
+        }
+        this.addSection(SectionType.TEXTURES, data);
+    }
+    writePhysics(model) {
+        const rigidbodies = model.getRigidbodies();
+        const joints = model.getJoints();
+        // Layout: rigidbodyCount (uint32), rigidbodies[], jointCount (uint32), joints[]
+        // Each rigidbody: nameLen (uint32), name (utf8), englishNameLen (uint32), englishName (utf8),
+        //                 boneIndex (int32), group (uint8), collisionMask (uint16), shape (uint8),
+        //                 size (3x float32), shapePosition (3x float32), shapeRotation (3x float32),
+        //                 mass (float32), linearDamping (float32), angularDamping (float32),
+        //                 restitution (float32), friction (float32), type (uint8)
+        // Each joint: nameLen (uint32), name (utf8), englishNameLen (uint32), englishName (utf8),
+        //             type (uint8), rigidbodyIndexA (int32), rigidbodyIndexB (int32),
+        //             position (3x float32), rotation (3x float32),
+        //             positionMin (3x float32), positionMax (3x float32),
+        //             rotationMin (3x float32), rotationMax (3x float32),
+        //             springPosition (3x float32), springRotation (3x float32)
+        const rigidbodyData = [];
+        let totalSize = 4; // rigidbodyCount
+        for (const rb of rigidbodies) {
+            const nameBytes = new TextEncoder().encode(rb.name);
+            const englishNameBytes = new TextEncoder().encode(rb.englishName);
+            // Calculate size: nameLen(4) + name + englishNameLen(4) + englishName + boneIndex(4) + group(1) +
+            // collisionMask(2) + shape(1) + size(12) + shapePosition(12) + shapeRotation(12) +
+            // mass(4) + linearDamping(4) + angularDamping(4) + restitution(4) + friction(4) + type(1)
+            const fixedSize = 4 + 4 + 4 + 1 + 2 + 1 + 12 + 12 + 12 + 4 + 4 + 4 + 4 + 4 + 1; // 73 bytes
+            const size = fixedSize + nameBytes.length + englishNameBytes.length;
+            // Create ArrayBuffer directly to ensure correct size
+            const arrayBuffer = new ArrayBuffer(size);
+            const buffer = new Uint8Array(arrayBuffer);
+            const view = new DataView(arrayBuffer);
+            let off = 0;
+            view.setUint32(off, nameBytes.length, true);
+            off += 4;
+            buffer.set(nameBytes, off);
+            off += nameBytes.length;
+            view.setUint32(off, englishNameBytes.length, true);
+            off += 4;
+            buffer.set(englishNameBytes, off);
+            off += englishNameBytes.length;
+            view.setInt32(off, rb.boneIndex, true);
+            off += 4;
+            view.setUint8(off, rb.group);
+            off += 1;
+            view.setUint16(off, rb.collisionMask, true);
+            off += 2;
+            view.setUint8(off, rb.shape);
+            off += 1;
+            view.setFloat32(off, rb.size.x, true);
+            off += 4;
+            view.setFloat32(off, rb.size.y, true);
+            off += 4;
+            view.setFloat32(off, rb.size.z, true);
+            off += 4;
+            // Bounds check before writing
+            if (off + 4 > buffer.byteLength) {
+                throw new Error(`Rigidbody buffer overflow at shapePosition.x: off=${off}, bufferSize=${buffer.byteLength}, calculatedSize=${size}, name="${rb.name}"`);
+            }
+            view.setFloat32(off, rb.shapePosition.x, true);
+            off += 4;
+            if (off + 4 > buffer.byteLength) {
+                throw new Error(`Rigidbody buffer overflow at shapePosition.y: off=${off}, bufferSize=${buffer.byteLength}, calculatedSize=${size}, name="${rb.name}"`);
+            }
+            view.setFloat32(off, rb.shapePosition.y, true);
+            off += 4;
+            if (off + 4 > buffer.byteLength) {
+                throw new Error(`Rigidbody buffer overflow at shapePosition.z: off=${off}, bufferSize=${buffer.byteLength}, calculatedSize=${size}, name="${rb.name}"`);
+            }
+            view.setFloat32(off, rb.shapePosition.z, true);
+            off += 4;
+            view.setFloat32(off, rb.shapeRotation.x, true);
+            off += 4;
+            view.setFloat32(off, rb.shapeRotation.y, true);
+            off += 4;
+            view.setFloat32(off, rb.shapeRotation.z, true);
+            off += 4;
+            view.setFloat32(off, rb.mass, true);
+            off += 4;
+            view.setFloat32(off, rb.linearDamping, true);
+            off += 4;
+            view.setFloat32(off, rb.angularDamping, true);
+            off += 4;
+            view.setFloat32(off, rb.restitution, true);
+            off += 4;
+            view.setFloat32(off, rb.friction, true);
+            off += 4;
+            view.setUint8(off, rb.type);
+            off += 1;
+            // Verify buffer size matches written data
+            if (off !== size) {
+                throw new Error(`Rigidbody buffer size mismatch: expected ${size} bytes, wrote ${off} bytes for "${rb.name}" (nameLen=${nameBytes.length}, englishNameLen=${englishNameBytes.length})`);
+            }
+            rigidbodyData.push(buffer);
+            totalSize += buffer.length;
+        }
+        const jointData = [];
+        totalSize += 4; // jointCount
+        for (const joint of joints) {
+            const nameBytes = new TextEncoder().encode(joint.name);
+            const englishNameBytes = new TextEncoder().encode(joint.englishName);
+            // Calculate size: nameLen(4) + name + englishNameLen(4) + englishName + type(1) +
+            // rigidbodyIndexA(4) + rigidbodyIndexB(4) + position(12) + rotation(12) +
+            // positionMin(12) + positionMax(12) + rotationMin(12) + rotationMax(12) +
+            // springPosition(12) + springRotation(12)
+            const fixedSize = 4 + 4 + 1 + 4 + 4 + 12 + 12 + 12 + 12 + 12 + 12 + 12 + 12; // 113 bytes
+            const size = fixedSize + nameBytes.length + englishNameBytes.length;
+            // Create ArrayBuffer directly to ensure correct size
+            const arrayBuffer = new ArrayBuffer(size);
+            const buffer = new Uint8Array(arrayBuffer);
+            const view = new DataView(arrayBuffer);
+            let off = 0;
+            view.setUint32(off, nameBytes.length, true);
+            off += 4;
+            buffer.set(nameBytes, off);
+            off += nameBytes.length;
+            view.setUint32(off, englishNameBytes.length, true);
+            off += 4;
+            buffer.set(englishNameBytes, off);
+            off += englishNameBytes.length;
+            view.setUint8(off, joint.type);
+            off += 1;
+            view.setInt32(off, joint.rigidbodyIndexA, true);
+            off += 4;
+            view.setInt32(off, joint.rigidbodyIndexB, true);
+            off += 4;
+            view.setFloat32(off, joint.position.x, true);
+            off += 4;
+            view.setFloat32(off, joint.position.y, true);
+            off += 4;
+            view.setFloat32(off, joint.position.z, true);
+            off += 4;
+            view.setFloat32(off, joint.rotation.x, true);
+            off += 4;
+            view.setFloat32(off, joint.rotation.y, true);
+            off += 4;
+            view.setFloat32(off, joint.rotation.z, true);
+            off += 4;
+            view.setFloat32(off, joint.positionMin.x, true);
+            off += 4;
+            view.setFloat32(off, joint.positionMin.y, true);
+            off += 4;
+            view.setFloat32(off, joint.positionMin.z, true);
+            off += 4;
+            view.setFloat32(off, joint.positionMax.x, true);
+            off += 4;
+            view.setFloat32(off, joint.positionMax.y, true);
+            off += 4;
+            view.setFloat32(off, joint.positionMax.z, true);
+            off += 4;
+            view.setFloat32(off, joint.rotationMin.x, true);
+            off += 4;
+            view.setFloat32(off, joint.rotationMin.y, true);
+            off += 4;
+            view.setFloat32(off, joint.rotationMin.z, true);
+            off += 4;
+            view.setFloat32(off, joint.rotationMax.x, true);
+            off += 4;
+            view.setFloat32(off, joint.rotationMax.y, true);
+            off += 4;
+            view.setFloat32(off, joint.rotationMax.z, true);
+            off += 4;
+            view.setFloat32(off, joint.springPosition.x, true);
+            off += 4;
+            view.setFloat32(off, joint.springPosition.y, true);
+            off += 4;
+            view.setFloat32(off, joint.springPosition.z, true);
+            off += 4;
+            view.setFloat32(off, joint.springRotation.x, true);
+            off += 4;
+            view.setFloat32(off, joint.springRotation.y, true);
+            off += 4;
+            view.setFloat32(off, joint.springRotation.z, true);
+            off += 4;
+            // Verify buffer size matches written data
+            if (off !== size) {
+                throw new Error(`Joint buffer size mismatch: expected ${size} bytes, wrote ${off} bytes for "${joint.name}"`);
+            }
+            jointData.push(buffer);
+            totalSize += buffer.length;
+        }
+        const data = new Uint8Array(totalSize);
+        const view = new DataView(data.buffer);
+        let offset = 0;
+        view.setUint32(offset, rigidbodies.length, true);
+        offset += 4;
+        for (const buffer of rigidbodyData) {
+            data.set(buffer, offset);
+            offset += buffer.length;
+        }
+        view.setUint32(offset, joints.length, true);
+        offset += 4;
+        for (const buffer of jointData) {
+            data.set(buffer, offset);
+            offset += buffer.length;
+        }
+        this.addSection(SectionType.PHYSICS, data);
+    }
+    addSection(type, data) {
+        this.sections.push({
+            type,
+            offset: this.currentOffset,
+            size: data.length,
+            data,
+        });
+        this.currentOffset += data.length;
+    }
+    finalize() {
+        const sectionCount = this.sections.length;
+        const sectionTableSize = sectionCount * RzmWriter.SECTION_TABLE_ENTRY_SIZE;
+        const fileSize = RzmWriter.HEADER_SIZE + sectionTableSize + this.currentOffset;
+        const buffer = new ArrayBuffer(fileSize);
+        const view = new DataView(buffer);
+        const uint8View = new Uint8Array(buffer);
+        // Write header
+        let offset = 0;
+        // Magic
+        uint8View[0] = "R".charCodeAt(0);
+        uint8View[1] = "Z".charCodeAt(0);
+        uint8View[2] = "M".charCodeAt(0);
+        uint8View[3] = 0;
+        offset += 4;
+        view.setUint32(offset, RzmWriter.VERSION, true);
+        offset += 4;
+        view.setBigUint64(offset, BigInt(fileSize), true);
+        offset += 8;
+        view.setUint32(offset, sectionCount, true);
+        offset += 4;
+        // Reserved (16 bytes)
+        offset += 16;
+        // Write section table
+        for (const section of this.sections) {
+            view.setUint32(offset, section.type, true);
+            offset += 4;
+            view.setBigUint64(offset, BigInt(section.offset), true);
+            offset += 8;
+            view.setBigUint64(offset, BigInt(section.size), true);
+            offset += 8;
+        }
+        // Write section data
+        for (const section of this.sections) {
+            uint8View.set(section.data, section.offset);
+        }
+        return buffer;
+    }
+}
+// Header size: 4 (magic) + 4 (version) + 8 (file size) + 4 (section count) + 16 (reserved) = 36 bytes
+RzmWriter.HEADER_SIZE = 36;
+RzmWriter.SECTION_TABLE_ENTRY_SIZE = 20; // 4 (type) + 8 (offset) + 8 (size)
+RzmWriter.MAGIC = "RZM\0";
+RzmWriter.VERSION = 1;