rw-parser-ng 2.1.1 → 2.3.0

package/lib/dff/readers/geometry.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readGeometryList = readGeometryList;
+exports.readGeometry = readGeometry;
+var rw_sections_1 = require("../../core/rw-sections");
+var rw_version_1 = require("../../core/rw-version");
+var _2d_effect_1 = require("./2d-effect");
+var material_1 = require("./material");
+var mesh_1 = require("./mesh");
+function readGeometryList(file, header) {
+    file.readSectionHeader();
+    var geometricObjectCount = file.readUint32();
+    var geometries = [];
+    var versionNumber = (0, rw_version_1.unpackVersion)(header.versionNumber);
+    for (var i = 0; i < geometricObjectCount; i++) {
+        file.readSectionHeader();
+        file.readSectionHeader();
+        geometries.push(readGeometry(file, versionNumber));
+    }
+    return { geometricObjectCount: geometricObjectCount, geometries: geometries };
+}
+function readGeometry(file, versionNumber) {
+    var flags = file.readUint16();
+    var textureCoordinatesCount = file.readUint8();
+    file.readUint8();
+    var triangleCount = file.readUint32();
+    var vertexCount = file.readUint32();
+    file.readUint32();
+    if (versionNumber < 0x34000) {
+        file.skip(12);
+    }
+    var isTriangleStrip = (flags & (1 << 0)) !== 0;
+    var isTexturedUV1 = (flags & (1 << 2)) !== 0;
+    var isGeometryPrelit = (flags & (1 << 3)) !== 0;
+    var isTexturedUV2 = (flags & (1 << 7)) !== 0;
+    var vertexColorInformation = [];
+    if (isGeometryPrelit) {
+        for (var i = 0; i < vertexCount; i++) {
+            vertexColorInformation.push({
+                r: file.readUint8(),
+                g: file.readUint8(),
+                b: file.readUint8(),
+                a: file.readUint8(),
+            });
+        }
+    }
+    var textureMappingInformation = [];
+    if (isTexturedUV1 || isTexturedUV2) {
+        for (var t = 0; t < textureCoordinatesCount; t++) {
+            textureMappingInformation[t] = [];
+            for (var v = 0; v < vertexCount; v++) {
+                textureMappingInformation[t][v] = {
+                    u: file.readFloat(),
+                    v: file.readFloat(),
+                };
+            }
+        }
+    }
+    var triangleInformation = [];
+    for (var i = 0; i < triangleCount; i++) {
+        var vertex2 = file.readUint16();
+        var vertex1 = file.readUint16();
+        var materialId = file.readUint16();
+        var vertex3 = file.readUint16();
+        triangleInformation.push({
+            vector: { x: vertex1, y: vertex2, z: vertex3 },
+            materialId: materialId,
+        });
+    }
+    var boundingSphere = {
+        vector: { x: file.readFloat(), y: file.readFloat(), z: file.readFloat() },
+        radius: file.readFloat(),
+    };
+    var hasVertices = !!file.readUint32();
+    var hasNormals = !!file.readUint32();
+    var vertexInformation = [];
+    if (hasVertices) {
+        for (var i = 0; i < vertexCount; i++) {
+            vertexInformation.push({
+                x: file.readFloat(),
+                y: file.readFloat(),
+                z: file.readFloat(),
+            });
+        }
+    }
+    var normalInformation = [];
+    if (hasNormals) {
+        for (var i = 0; i < vertexCount; i++) {
+            normalInformation.push({
+                x: file.readFloat(),
+                y: file.readFloat(),
+                z: file.readFloat(),
+            });
+        }
+    }
+    var materialList = (0, material_1.readMaterialList)(file);
+    var extensionSize = file.readSectionHeader().sectionSize;
+    var binMesh;
+    var skin;
+    var effects2d;
+    var extraVertColour;
+    var breakable;
+    var relativePosition = 0;
+    while (relativePosition < extensionSize) {
+        var extHeader = file.readSectionHeader();
+        relativePosition += extHeader.sectionSize + 12;
+        var sectionStart = file.getPosition();
+        switch (extHeader.sectionType) {
+            case rw_sections_1.RwSections.RwBinMesh:
+                binMesh = (0, mesh_1.readBinMesh)(file);
+                break;
+            case rw_sections_1.RwSections.RwSkin:
+                skin = (0, mesh_1.readSkin)(file, vertexCount);
+                break;
+            case rw_sections_1.RwSections.Rw2dEffect:
+                effects2d = (0, _2d_effect_1.read2dEffects)(file, extHeader.sectionSize);
+                break;
+            case rw_sections_1.RwSections.RwExtraVertColour:
+                extraVertColour = [];
+                for (var i = 0; i < vertexCount; i++) {
+                    extraVertColour.push({
+                        r: file.readUint8(),
+                        g: file.readUint8(),
+                        b: file.readUint8(),
+                        a: file.readUint8(),
+                    });
+                }
+                break;
+            case rw_sections_1.RwSections.RwBreakable:
+                breakable = readBreakable(file);
+                break;
+            default:
+                file.skip(extHeader.sectionSize);
+                break;
+        }
+        file.setPosition(sectionStart + extHeader.sectionSize);
+    }
+    return {
+        textureCoordinatesCount: textureCoordinatesCount,
+        textureMappingInformation: textureMappingInformation,
+        boundingSphere: boundingSphere,
+        hasVertices: hasVertices,
+        hasNormals: hasNormals,
+        isTriangleStrip: isTriangleStrip,
+        vertexColorInformation: vertexColorInformation,
+        vertexInformation: vertexInformation,
+        normalInformation: normalInformation,
+        triangleInformation: triangleInformation,
+        materialList: materialList,
+        binMesh: binMesh,
+        skin: skin,
+        effects2d: effects2d,
+        extraVertColour: extraVertColour,
+        breakable: breakable,
+    };
+}
+function readBreakable(file) {
+    var sectionHeader = file.readUint32();
+    if (!sectionHeader)
+        return undefined;
+    var positionRule = file.readUint32();
+    var numVertices = file.readUint16();
+    file.skip(2);
+    file.skip(4 * 3);
+    var numTriangles = file.readUint16();
+    file.skip(2);
+    file.skip(4 * 2);
+    var numMaterials = file.readUint16();
+    file.skip(2);
+    file.skip(4 * 4);
+    var vertices = [];
+    for (var i = 0; i < numVertices; i++) {
+        vertices.push({
+            x: file.readFloat(),
+            y: file.readFloat(),
+            z: file.readFloat(),
+        });
+    }
+    var texCoords = [];
+    for (var i = 0; i < numVertices; i++) {
+        texCoords.push({ u: file.readFloat(), v: file.readFloat() });
+    }
+    var colors = [];
+    for (var i = 0; i < numVertices; i++) {
+        colors.push({
+            r: file.readUint8(),
+            g: file.readUint8(),
+            b: file.readUint8(),
+            a: file.readUint8(),
+        });
+    }
+    var triangles = [];
+    for (var i = 0; i < numTriangles; i++) {
+        triangles.push({
+            a: file.readUint16(),
+            b: file.readUint16(),
+            c: file.readUint16(),
+        });
+    }
+    var triangleMaterialIndices = [];
+    for (var i = 0; i < numTriangles; i++) {
+        triangleMaterialIndices.push(file.readUint16());
+    }
+    var textureNames = [];
+    for (var i = 0; i < numMaterials; i++) {
+        textureNames.push(file.readString(32).replace(/\0+$/, ""));
+    }
+    var maskNames = [];
+    for (var i = 0; i < numMaterials; i++) {
+        maskNames.push(file.readString(32).replace(/\0+$/, ""));
+    }
+    var materials = [];
+    for (var i = 0; i < numMaterials; i++) {
+        materials.push({
+            textureName: textureNames[i],
+            maskName: maskNames[i],
+            color: { r: file.readFloat(), g: file.readFloat(), b: file.readFloat() },
+        });
+    }
+    return {
+        positionRule: positionRule,
+        vertices: vertices,
+        texCoords: texCoords,
+        colors: colors,
+        triangles: triangles,
+        triangleMaterialIndices: triangleMaterialIndices,
+        materials: materials,
+    };
+}

package/lib/dff/readers/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./2d-effect";
+export * from "./geometry";
+export * from "./material";
+export * from "./mesh";
+export * from "./structure";

package/lib/dff/readers/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./2d-effect"), exports);
+__exportStar(require("./geometry"), exports);
+__exportStar(require("./material"), exports);
+__exportStar(require("./mesh"), exports);
+__exportStar(require("./structure"), exports);

package/lib/dff/readers/material.d.ts

@@ -0,0 +1,5 @@
+import type { RwFile } from "../../core/rw-file";
+import type { RwMaterial, RwMaterialList, RwTexture } from "../types";
+export declare function readTexture(file: RwFile): RwTexture;
+export declare function readMaterial(file: RwFile): RwMaterial;
+export declare function readMaterialList(file: RwFile): RwMaterialList;

package/lib/dff/readers/material.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTexture = readTexture;
+exports.readMaterial = readMaterial;
+exports.readMaterialList = readMaterialList;
+function readTexture(file) {
+    file.readSectionHeader();
+    file.readSectionHeader();
+    var textureData = file.readUint32();
+    var textureFiltering = textureData & 0xff;
+    var uAddressing = (textureData & 0xf00) >> 8;
+    var vAddressing = (textureData & 0xf000) >> 12;
+    var usesMipLevels = (textureData & (1 << 16)) !== 0;
+    var textureNameSize = file.readSectionHeader().sectionSize;
+    var textureName = file.readString(textureNameSize);
+    file.skip(file.readSectionHeader().sectionSize);
+    file.skip(file.readSectionHeader().sectionSize);
+    return {
+        textureFiltering: textureFiltering,
+        uAddressing: uAddressing,
+        vAddressing: vAddressing,
+        usesMipLevels: usesMipLevels,
+        textureName: textureName,
+    };
+}
+function readMaterial(file) {
+    file.readSectionHeader();
+    var header = file.readSectionHeader();
+    file.skip(4);
+    var color = {
+        r: file.readUint8(),
+        g: file.readUint8(),
+        b: file.readUint8(),
+        a: file.readUint8(),
+    };
+    file.skip(4);
+    var isTextured = file.readUint32() > 0;
+    var ambient;
+    var specular;
+    var diffuse;
+    if (header.versionNumber > 0x30400) {
+        ambient = file.readFloat();
+        specular = file.readFloat();
+        diffuse = file.readFloat();
+    }
+    var texture;
+    if (isTextured) {
+        texture = readTexture(file);
+    }
+    file.skip(file.readSectionHeader().sectionSize);
+    return { color: color, isTextured: isTextured, ambient: ambient, specular: specular, diffuse: diffuse, texture: texture };
+}
+function readMaterialList(file) {
+    file.readSectionHeader();
+    file.readSectionHeader();
+    var materialInstanceCount = file.readUint32();
+    var materialIndices = [];
+    for (var i = 0; i < materialInstanceCount; i++) {
+        materialIndices.push(file.readInt32());
+    }
+    var materialData = [];
+    for (var i = 0; i < materialInstanceCount; i++) {
+        var materialIndex = materialIndices[i];
+        if (materialIndex === -1) {
+            materialData.push(readMaterial(file));
+        }
+        else {
+            materialData.push(materialData[materialIndex]);
+        }
+    }
+    return { materialInstanceCount: materialInstanceCount, materialData: materialData };
+}

package/lib/dff/readers/mesh.d.ts

@@ -0,0 +1,5 @@
+import type { RwFile } from "../../core/rw-file";
+import type { RwBinMesh, RwMesh, RwSkin } from "../types";
+export declare function readMesh(file: RwFile): RwMesh;
+export declare function readBinMesh(file: RwFile): RwBinMesh;
+export declare function readSkin(file: RwFile, vertexCount: number): RwSkin;

package/lib/dff/readers/mesh.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readMesh = readMesh;
+exports.readBinMesh = readBinMesh;
+exports.readSkin = readSkin;
+function readMesh(file) {
+    var indexCount = file.readUint32();
+    var materialIndex = file.readUint32();
+    var indices = [];
+    for (var i = 0; i < indexCount; i++) {
+        indices.push(file.readUint32());
+    }
+    return { indexCount: indexCount, materialIndex: materialIndex, indices: indices };
+}
+function readBinMesh(file) {
+    file.skip(4);
+    var meshCount = file.readUint32();
+    file.skip(4);
+    var meshes = [];
+    for (var i = 0; i < meshCount; i++) {
+        meshes.push(readMesh(file));
+    }
+    return { meshCount: meshCount, meshes: meshes };
+}
+function readSkin(file, vertexCount) {
+    var boneCount = file.readUint8();
+    var usedBoneCount = file.readUint8();
+    var maxWeightsPerVertex = file.readUint8();
+    file.skip(1);
+    file.skip(usedBoneCount);
+    var boneVertexIndices = [];
+    for (var i = 0; i < vertexCount; i++) {
+        var indices = [];
+        for (var j = 0; j < 4; j++) {
+            indices.push(file.readUint8());
+        }
+        boneVertexIndices.push(indices);
+    }
+    var vertexWeights = [];
+    for (var i = 0; i < vertexCount; i++) {
+        var weights = [];
+        for (var j = 0; j < 4; j++) {
+            weights.push(file.readFloat());
+        }
+        vertexWeights.push(weights);
+    }
+    var inverseBoneMatrices = [];
+    for (var i = 0; i < boneCount; i++) {
+        inverseBoneMatrices.push({
+            right: {
+                x: file.readFloat(),
+                y: file.readFloat(),
+                z: file.readFloat(),
+                t: file.readFloat(),
+            },
+            up: {
+                x: file.readFloat(),
+                y: file.readFloat(),
+                z: file.readFloat(),
+                t: file.readFloat(),
+            },
+            at: {
+                x: file.readFloat(),
+                y: file.readFloat(),
+                z: file.readFloat(),
+                t: file.readFloat(),
+            },
+            transform: {
+                x: file.readFloat(),
+                y: file.readFloat(),
+                z: file.readFloat(),
+                t: file.readFloat(),
+            },
+        });
+    }
+    return {
+        boneCount: boneCount,
+        usedBoneCount: usedBoneCount,
+        maxWeightsPerVertex: maxWeightsPerVertex,
+        boneVertexIndices: boneVertexIndices,
+        vertexWeights: vertexWeights,
+        inverseBoneMatrices: inverseBoneMatrices,
+    };
+}

package/lib/dff/readers/structure.d.ts

@@ -0,0 +1,6 @@
+import type { RwFile } from "../../core/rw-file";
+import type { RwAnimNode, RwAtomic, RwClump, RwFrameList } from "../types";
+export declare function readClump(file: RwFile): RwClump;
+export declare function readFrameList(file: RwFile): RwFrameList;
+export declare function readAnimNode(file: RwFile): RwAnimNode;
+export declare function readAtomic(file: RwFile): RwAtomic;

package/lib/dff/readers/structure.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readClump = readClump;
+exports.readFrameList = readFrameList;
+exports.readAnimNode = readAnimNode;
+exports.readAtomic = readAtomic;
+function readClump(file) {
+    var versionNumber = file.readSectionHeader().versionNumber;
+    var atomicCount = file.readUint32();
+    var lightCount;
+    var cameraCount;
+    if (versionNumber > 0x33000) {
+        lightCount = file.readUint32();
+        cameraCount = file.readUint32();
+    }
+    return { atomicCount: atomicCount, lightCount: lightCount, cameraCount: cameraCount };
+}
+function readFrameList(file) {
+    file.readSectionHeader();
+    var frameCount = file.readUint32();
+    var frames = [];
+    for (var i = 0; i < frameCount; i++) {
+        var rotationMatrix = {
+            right: {
+                x: file.readFloat(),
+                y: file.readFloat(),
+                z: file.readFloat(),
+            },
+            up: { x: file.readFloat(), y: file.readFloat(), z: file.readFloat() },
+            at: { x: file.readFloat(), y: file.readFloat(), z: file.readFloat() },
+        };
+        var coordinatesOffset = {
+            x: file.readFloat(),
+            y: file.readFloat(),
+            z: file.readFloat(),
+        };
+        var parentFrame = file.readInt32();
+        file.skip(4);
+        frames.push({ rotationMatrix: rotationMatrix, coordinatesOffset: coordinatesOffset, parentFrame: parentFrame });
+    }
+    return { frameCount: frameCount, frames: frames };
+}
+function readAnimNode(file) {
+    file.skip(4);
+    var boneId = file.readInt32();
+    var boneCount = file.readInt32();
+    var bones = [];
+    if (boneCount > 0) {
+        file.skip(8);
+    }
+    for (var i = 0; i < boneCount; i++) {
+        bones.push({
+            boneId: file.readInt32(),
+            boneIndex: file.readInt32(),
+            flags: file.readInt32(),
+        });
+    }
+    return { boneId: boneId, bonesCount: boneCount, bones: bones };
+}
+function readAtomic(file) {
+    file.readSectionHeader();
+    var frameIndex = file.readUint32();
+    var geometryIndex = file.readUint32();
+    var flags = file.readUint32();
+    file.skip(4);
+    return { frameIndex: frameIndex, geometryIndex: geometryIndex, flags: flags };
+}