rw-parser-ng 2.0.5 → 2.1.1

package/src/renderware/dff/DffParser.ts

@@ -1,596 +1,611 @@
-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 };
-    }
-}
+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()) {
+            let header;
+            try {
+                header = this.readSectionHeader();
+            } catch (error) {
+                console.warn(`Failed to read section header at offset ${this.getPosition().toString(16)}: ${error instanceof Error ? error.message : error}. Truncating file.`);
+                break;
+            }
+
+            if (header.sectionType === 0) {
+                break;
+            }
+
+            if (header.sectionSize == 0) {
+                continue;
+            }
+
+            if (this.getPosition() + header.sectionSize > this.getSize()) {
+                console.warn(`Section at offset ${this.getPosition().toString(16)} claims size ${header.sectionSize} but only ${this.getSize() - this.getPosition()} bytes remaining. Truncating file.`);
+                break;
+            }
+
+            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');
+        }
+
+        if (!geometryList || !geometryList.geometries || geometryList.geometries.length === 0) {
+            throw new RwParseStructureNotFoundError('geometry list');
+        }
+
+        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 };
+    }
+}