rw-parser-ng 2.0.0

package/src/renderware/dff/DffParser.ts

@@ -0,0 +1,596 @@
+import { RwFile } from '../RwFile';
+import { RwSections } from '../RwSections';
+import { RwParseStructureNotFoundError } from '../errors/RwParseError';
+import RwVersion from '../utils/RwVersion';
+import { DffModelType } from './DffModelType';
+import { RwColor, RwMatrix3, RwMatrix4, RwSphere, RwTextureCoordinate, RwTriangle, RwVector3 } from '../common/types';
+
+export interface RwDff {
+    modelType: DffModelType,
+    version: string,
+    versionNumber: number,
+    geometryList: RwGeometryList | null,
+    frameList: RwFrameList | null,
+    atomics: number[],
+    dummies: string[],
+    animNodes: RwAnimNode[],
+}
+
+export interface RwClump {
+    atomicCount: number,
+    lightCount?: number,
+    cameraCount?: number,
+}
+
+export interface RwAnimNode {
+    boneId: number,
+    bonesCount: number,
+    bones: RwBone[],
+}
+
+export interface RwBone {
+    boneId: number,
+    boneIndex: number,
+    flags: number,
+}
+
+
+export interface RwFrame {
+    rotationMatrix: RwMatrix3,
+    coordinatesOffset: RwVector3,
+    parentFrame: number,
+}
+
+export interface RwFrameList {
+    frameCount: number,
+    frames: RwFrame[],
+}
+
+export interface RwTexture {
+    textureFiltering: number,
+    uAddressing: number,
+    vAddressing: number,
+    usesMipLevels: boolean,
+    textureName: string,
+}
+
+export interface RwMaterial {
+    color: RwColor,
+    isTextured: boolean,
+    ambient?: number,
+    specular?: number,
+    diffuse?: number,
+    texture?: RwTexture,
+}
+
+export interface RwMaterialList {
+    materialInstanceCount: number,
+    materialData: RwMaterial[],
+}
+
+export interface RwGeometry {
+    vertexColorInformation: RwColor[],
+    textureCoordinatesCount: number,
+    textureMappingInformation: RwTextureCoordinate[][],
+    hasVertices: boolean,
+    hasNormals: boolean,
+    triangleInformation: RwTriangle[],
+    vertexInformation: RwVector3[],
+    normalInformation: RwVector3[],
+    boundingSphere?: RwSphere,
+    materialList: RwMaterialList,
+    binMesh: RwBinMesh,
+    skin?: RwSkin,
+}
+
+export interface RwGeometryList {
+    geometricObjectCount: number,
+    geometries: RwGeometry[],
+}
+
+export interface RwAtomic {
+    frameIndex: number,
+    geometryIndex: number,
+    flags: number,
+}
+
+export interface RwBinMesh {
+    meshCount: number,
+    meshes: RwMesh[],
+}
+
+export interface RwSkin {
+    boneCount: number,
+    usedBoneCount: number,
+    maxWeightsPerVertex: number,
+    boneVertexIndices: number[][],
+    vertexWeights: number[][],
+    inverseBoneMatrices: RwMatrix4[],
+}
+
+export interface RwMesh {
+    materialIndex: number,
+    indexCount: number,
+    indices: number[],
+}
+
+export class DffParser extends RwFile {
+
+    constructor(buffer: Buffer) {
+        super(buffer);
+    }
+
+    parse(): RwDff {
+        let version: string | undefined;
+        let versionNumber: number | undefined;
+        let atomics: number[] = [];
+        let dummies: string[] = [];
+        let animNodes: RwAnimNode[] = [];
+        let geometryList: RwGeometryList | null = null;
+        let frameList: RwFrameList | null = null;
+
+        while (this.getPosition() < this.getSize()) {
+            const header = this.readSectionHeader();
+
+            if (header.sectionType === 0) {
+                break;
+            }
+
+            if (header.sectionSize == 0) {
+                continue;
+            }
+
+            switch (header.sectionType) {
+                case RwSections.RwClump:
+                    // Multiple clumps are used in SA player models, so we should eventually support it
+                    versionNumber = RwVersion.unpackVersion(header.versionNumber);
+                    version = RwVersion.versions[versionNumber];
+                    break;
+                case RwSections.RwFrameList:
+                    frameList = this.readFrameList();
+                    break;
+                case RwSections.RwExtension:
+                    const extensionHeader = this.readSectionHeader();
+                    switch (extensionHeader.sectionType) {
+                        case RwSections.RwNodeName:
+                            dummies.push(this.readString(extensionHeader.sectionSize));
+                            break;
+                        case RwSections.RwAnim:
+                            animNodes.push(this.readAnimNode());
+                            break;
+                        default:
+                            console.debug(`Extension type ${extensionHeader.sectionType} (${extensionHeader.sectionType.toString(16)}) not found at offset (${this.getPosition().toString(16)}). Skipping ${extensionHeader.sectionSize} bytes.`);
+                            this.skip(extensionHeader.sectionSize);
+                            break;
+                    }
+                    break;
+                case RwSections.RwGeometryList:
+                    geometryList = this.readGeometryList();
+                    break;
+                case RwSections.RwAtomic:
+                    const atomic = this.readAtomic();
+                    atomics[atomic.geometryIndex] = atomic.frameIndex;
+                    break;
+                case RwSections.RwNodeName:
+                    // For some reason, this frame is outside RwExtension.
+                    dummies.push(this.readString(header.sectionSize));
+                    break;
+                case RwSections.RwAnim:
+                    // For III / VC models
+                    animNodes.push(this.readAnimNode());
+                    break;
+                default:
+                    console.debug(`Section type ${header.sectionType} (${header.sectionType.toString(16)}) not found at offset (${this.getPosition().toString(16)}). Skipping ${header.sectionSize} bytes.`);
+                    this.skip(header.sectionSize);
+                    break;
+            }
+        }
+
+        if (!version || !versionNumber) {
+            throw new RwParseStructureNotFoundError('version');
+        }
+
+        let modelType = DffModelType.GENERIC;
+        if (geometryList?.geometries.some(g => g.skin)) {
+            modelType = DffModelType.SKIN;
+        } else if (dummies.some(d => d.toLowerCase().includes('wheel') || d.toLowerCase().includes('chassis'))) {
+            modelType = DffModelType.VEHICLE;
+        }
+
+        return {
+            modelType,
+            version: version,
+            versionNumber: versionNumber,
+            geometryList: geometryList,
+            frameList: frameList,
+            atomics: atomics,
+            dummies: dummies,
+            animNodes: animNodes,
+        };
+    }
+
+    public readClump(): RwClump {
+        const { versionNumber } = this.readSectionHeader();
+
+        const atomicCount = this.readUint32();
+
+        let lightCount;
+        let cameraCount;
+        if (versionNumber > 0x33000) {
+            lightCount = this.readUint32();
+            cameraCount = this.readUint32();
+        }
+
+        return { atomicCount, lightCount, cameraCount };
+    }
+
+    public readFrameList(): RwFrameList {
+        this.readSectionHeader();
+
+        const frameCount = this.readUint32();
+
+        let frames: RwFrame[] = [];
+
+        for (let i = 0; i < frameCount; i++) {
+            // All these could probably be moved to readFrameData()
+
+            const rotationMatrix: RwMatrix3 = {
+                right: { x: this.readFloat(), y: this.readFloat(), z: this.readFloat() },
+                up: { x: this.readFloat(), y: this.readFloat(), z: this.readFloat() },
+                at: { x: this.readFloat(), y: this.readFloat(), z: this.readFloat() },
+            }
+
+            const coordinatesOffset: RwVector3 = { x: this.readFloat(), y: this.readFloat(), z: this.readFloat() };
+
+            const parentFrame = this.readInt32();
+
+            // Skip matrix creation internal flags
+            // They are read by the game but are not used
+            this.skip(4);
+
+            frames.push({ rotationMatrix, coordinatesOffset, parentFrame });
+        }
+
+        return { frameCount, frames };
+    }
+
+    public readGeometryList(): RwGeometryList {
+        const header = this.readSectionHeader();
+
+        const geometricObjectCount = this.readUint32();
+
+        let geometries: RwGeometry[] = [];
+
+        for (let i = 0; i < geometricObjectCount; i++) {
+            this.readSectionHeader();
+            this.readSectionHeader();
+            const versionNumber = RwVersion.unpackVersion(header.versionNumber);
+            const geometryData = this.readGeometry(versionNumber);
+            geometries.push(geometryData);
+        }
+
+        return { geometricObjectCount, geometries };
+    }
+
+    public readGeometry(versionNumber: number): RwGeometry {
+        const flags = this.readUint16();
+        const textureCoordinatesCount = this.readUint8();
+        const _nativeGeometryFlags = this.readUint8();
+        const triangleCount = this.readUint32();
+        const vertexCount = this.readUint32();
+        const _morphTargetCount = this.readUint32();
+
+        // Surface properties
+        let _ambient;
+        let _specular;
+        let _diffuse;
+
+        if (versionNumber < 0x34000) {
+            _ambient = this.readFloat();
+            _specular = this.readFloat();
+            _diffuse = this.readFloat();
+        }
+
+        const _isTriangleStrip = (flags & (1 << 0)) !== 0;
+        const _vertexTranslation = (flags & (1 << 1)) !== 0;
+        const isTexturedUV1 = (flags & (1 << 2)) !== 0;
+        const isGeometryPrelit = (flags & (1 << 3)) !== 0;
+        const _hasNormals = (flags & (1 << 4)) !== 0;
+        const _isGeometryLit = (flags & (1 << 5)) !== 0;
+        const _shouldModulateMaterialColor = (flags & (1 << 6)) !== 0;
+        const isTexturedUV2 = (flags & (1 << 7)) !== 0;
+
+        const vertexColorInformation: RwColor[] = [];
+        const textureMappingInformation: RwTextureCoordinate[][] = [];
+        const triangleInformation: RwTriangle[] = [];
+
+        // Geometry is marked as prelit
+        if (isGeometryPrelit) {
+            for (let i = 0; i < vertexCount; i++) {
+                vertexColorInformation[i] = { r: this.readUint8(), g: this.readUint8(), b: this.readUint8(), a: this.readUint8() };
+            }
+        }
+
+        // Geometry either has first or second texture
+        if (isTexturedUV1 || isTexturedUV2) {
+            for (let textureCoordinateIndex = 0; textureCoordinateIndex < textureCoordinatesCount; textureCoordinateIndex++) {
+                textureMappingInformation[textureCoordinateIndex] = [];
+                for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+                    textureMappingInformation[textureCoordinateIndex][vertexIndex] = { u: this.readFloat(), v: this.readFloat() };
+                }
+            }
+        }
+
+        for (let i = 0; i < triangleCount; i++) {
+            // Information is written in this order
+            const vertex2 = this.readUint16();
+            const vertex1 = this.readUint16();
+            const materialId = this.readUint16();
+            const vertex3 = this.readUint16();
+            triangleInformation[i] = { vector: { x: vertex1, y: vertex2, z: vertex3 }, materialId: materialId }
+        }
+
+        // We are sure that there's only one morph target, but if
+        // we are wrong, we have to loop these through morphTargetCount
+
+        const boundingSphere: RwSphere = {
+            vector: { x: this.readFloat(), y: this.readFloat(), z: this.readFloat() },
+            radius: this.readFloat(),
+        };
+
+        const hasVertices = !!this.readUint32();
+        const hasNormals = !!this.readUint32();
+
+        const vertexInformation = [];
+        if (hasVertices) {
+            for (let i = 0; i < vertexCount; i++) {
+                vertexInformation[i] = { x: this.readFloat(), y: this.readFloat(), z: this.readFloat() };
+            }
+        }
+
+        const normalInformation = [];
+        if (hasNormals) {
+            for (let i = 0; i < vertexCount; i++) {
+                normalInformation[i] = { x: this.readFloat(), y: this.readFloat(), z: this.readFloat() };
+            }
+        }
+
+        let materialList = this.readMaterialList();
+        let sectionSize = this.readSectionHeader().sectionSize;
+        let position = this.getPosition();
+        let binMesh = this.readBinMesh();
+        let skin = undefined;
+
+        if (this.readSectionHeader().sectionType == RwSections.RwSkin) {
+            skin = this.readSkin(vertexCount);
+        }
+
+        this.setPosition(position + sectionSize);
+
+        return {
+            textureCoordinatesCount,
+            textureMappingInformation,
+            boundingSphere,
+            hasVertices,
+            hasNormals,
+            vertexColorInformation,
+            vertexInformation,
+            normalInformation,
+            triangleInformation,
+            materialList,
+            binMesh,
+            skin, 
+        };
+    }
+
+    public readBinMesh(): RwBinMesh {
+        this.readSectionHeader();
+
+        // Flags (0: triangle list, 1: triangle strip)
+        this.skip(4);
+
+        const meshCount = this.readUint32();
+
+        // Total number of indices
+        this.skip(4);
+
+        const meshes: RwMesh[] = [];
+
+        for (let i = 0; i < meshCount; i++) {
+            meshes.push(this.readMesh());
+        }
+
+        return {
+            meshCount, meshes
+        };
+    }
+
+    public readSkin(vertexCount : number): RwSkin {                                                                                
+        const boneCount = this.readUint8();
+        const usedBoneCount = this.readUint8();
+        const maxWeightsPerVertex = this.readUint8();
+
+        this.skip(1);               // Padding
+        this.skip(usedBoneCount);   // Skipping special indices
+
+        const boneVertexIndices: number[][] = [];                  
+        const vertexWeights: number[][] = [];     
+        const inverseBoneMatrices: RwMatrix4[] = [];     
+
+        for (let i = 0; i < vertexCount; i++) {
+            const indices: number[] = [];
+            for (let j = 0; j < 4; j++) {
+                indices.push(this.readUint8());
+            }
+            boneVertexIndices.push(indices);
+         }
+
+        for (let i = 0; i < vertexCount; i++) {
+            const weights: number[] = [];
+            for (let j = 0; j < 4; j++) {
+                weights.push(this.readFloat());
+            }
+            vertexWeights.push(weights);
+         }
+
+        for (let i = 0; i < boneCount; i++) {
+            const matrix4x4: RwMatrix4 = {
+                right: { x: this.readFloat(), y: this.readFloat(), z: this.readFloat(), t: this.readFloat() },
+                up: { x: this.readFloat(), y: this.readFloat(), z: this.readFloat(), t: this.readFloat() },
+                at: { x: this.readFloat(), y: this.readFloat(), z: this.readFloat(), t: this.readFloat() },
+                transform: { x: this.readFloat(), y: this.readFloat(), z: this.readFloat(), t: this.readFloat() },
+            };
+            
+            inverseBoneMatrices.push(matrix4x4);
+         }
+
+        return {
+            boneCount,
+            usedBoneCount,
+            maxWeightsPerVertex,
+            boneVertexIndices,
+            vertexWeights,
+            inverseBoneMatrices,
+        }                                                           
+    }
+
+    public readAnimNode() :RwAnimNode {
+        this.skip(4);          // Skipping AnimVersion property (0x100)
+        const boneId = this.readInt32();
+        const boneCount = this.readInt32();
+        const bones :RwBone[] = [];
+
+        if (boneId == 0) {
+            this.skip(8);           // Skipping flags and keyFrameSize properties
+        }
+
+        if (boneCount > 0) {
+            for (let i = 0; i < boneCount; i++){
+                bones.push({
+                    boneId: this.readInt32(),
+                    boneIndex: this.readInt32(),
+                    flags: this.readInt32()
+                });
+            }
+        }
+
+        return {
+            boneId: boneId,
+            bonesCount: boneCount,
+            bones: bones
+        }
+    } 
+
+    public readMesh(): RwMesh {
+        const indexCount = this.readUint32();
+        const materialIndex = this.readUint32();
+
+        const indices: number[] = [];
+
+        for (let i = 0; i < indexCount; i++) {
+            indices.push(this.readUint32());
+        }
+
+        return {
+            indexCount, materialIndex, indices
+        };
+    }
+
+    public readMaterialList(): RwMaterialList {
+        this.readSectionHeader();
+        this.readSectionHeader();
+
+        const materialInstanceCount = this.readUint32();
+        const materialIndices: number[] = [];
+
+        for (let i = 0; i < materialInstanceCount; i++) {
+            const materialIndex = this.readInt32();
+            materialIndices.push(materialIndex);
+        }
+
+        const materialData: RwMaterial[] = [];
+
+        for (let i = 0; i < materialInstanceCount; i++) {
+            let materialIndex = materialIndices[i];
+
+            if (materialIndex == -1) {
+                materialData.push(this.readMaterial());
+            } else {
+                materialData.push(materialData[materialIndex]);
+            }
+        }
+
+        return { materialInstanceCount, materialData };
+    }
+
+    public readMaterial(): RwMaterial {
+        this.readSectionHeader();
+        const header = this.readSectionHeader();
+
+        // Flags - not used
+        this.skip(4);
+
+        const color: RwColor = { r: this.readUint8(), g: this.readUint8(), b: this.readUint8(), a: this.readUint8() };
+
+        // Unknown - not used
+        this.skip(4);
+
+        const isTextured = this.readUint32() > 0;
+
+        // Surface properties
+        let ambient;
+        let specular;
+        let diffuse;
+
+        if (header.versionNumber > 0x30400) {
+            ambient = this.readFloat();
+            specular = this.readFloat();
+            diffuse = this.readFloat();
+        }
+
+        let texture;
+
+        if (isTextured) {
+            texture = this.readTexture();
+        }
+
+        // Skip various unused extensions
+        this.skip(this.readSectionHeader().sectionSize);
+
+        return { color, isTextured, ambient, specular, diffuse, texture };
+    }
+
+    public readTexture(): RwTexture {
+        this.readSectionHeader();
+        this.readSectionHeader();
+
+        const textureData = this.readUint32();
+
+        const textureFiltering = (textureData & 0xFF);
+        const uAddressing = (textureData & 0xF00) >> 8;
+        const vAddressing = (textureData & 0xF000) >> 12;
+        const usesMipLevels = (textureData & (1 << 16)) !== 0;
+
+        let textureNameSize = this.readSectionHeader().sectionSize;
+        const textureName = this.readString(textureNameSize);
+
+        // Skip various unused extensions
+        this.skip(this.readSectionHeader().sectionSize);
+        this.skip(this.readSectionHeader().sectionSize);
+
+        return { textureFiltering, uAddressing, vAddressing, usesMipLevels, textureName };
+    }
+
+    public readAtomic(): RwAtomic {
+        this.readSectionHeader();
+
+        const frameIndex = this.readUint32();
+        const geometryIndex = this.readUint32();
+        const flags = this.readUint32();
+
+        // Skip unused bytes
+        this.skip(4);
+
+        return { frameIndex, geometryIndex, flags };
+    }
+}

package/src/renderware/errors/RwParseError.ts

@@ -0,0 +1,11 @@
+export class RwParseError extends Error {
+    constructor(message?: string) {
+        super(message);
+    }
+}
+
+export class RwParseStructureNotFoundError extends RwParseError {
+    constructor(structureName: string) {
+        super(`Structure ${structureName} not found.`);
+    }
+}

package/src/renderware/ifp/IfpData.ts

@@ -0,0 +1,33 @@
+import { RwQuaternion, RwVector3 } from "../common/types";
+
+export enum IfpVersion {
+    ANP3,
+    ANPK,
+    UNSUPPORTED,
+}
+
+export interface RwIfp {
+    version: IfpVersion,
+    name: string,
+    animations: RwIfpAnimation[],
+}
+
+export interface RwIfpAnimation {
+    name: string,
+    bones: RwIfpBone[],
+}
+
+export interface RwIfpBone {
+    name: string,
+    keyframeType: string,
+    useBoneId: boolean,
+    boneId: number,
+    keyframes: RwIfpKeyframe[],
+}
+
+export interface RwIfpKeyframe {
+    time: number,
+    position: RwVector3,
+    rotation: RwQuaternion,
+    scale: RwVector3,
+}