rw-parser-ng 2.0.0

package/lib/scripts/sort_models.js

@@ -0,0 +1,185 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+var worker_threads_1 = require("worker_threads");
+var index_1 = require("../src/index");
+var fs_1 = require("fs");
+var path = __importStar(require("path"));
+var os = __importStar(require("os"));
+var sourceDir = 'C:\\Users\\Administrator\\Documents\\Code\\playground-render\\assets\\source_skins';
+var outputDir = 'C:\\Users\\Administrator\\Documents\\Code\\playground-render\\assets\\sorted_skins';
+var modelTypeToDir = (_a = {},
+    _a[index_1.DffModelType.GENERIC] = 'objects',
+    _a[index_1.DffModelType.SKIN] = 'skins',
+    _a[index_1.DffModelType.VEHICLE] = 'vehicles',
+    _a);
+function createDirectory(dir) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fs_1.promises.mkdir(dir, { recursive: true })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function sortAndIndexAssets() {
+    return __awaiter(this, void 0, void 0, function () {
+        var texturesDir, modelDirs, allFiles, filesQueue, numWorkers, modelIndex, textureIndex, processedFiles, runWorker, workerPromises, i;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    console.time('Total execution time');
+                    texturesDir = path.join(outputDir, 'textures');
+                    modelDirs = Object.values(modelTypeToDir).map(function (dir) { return path.join(outputDir, dir); });
+                    return [4 /*yield*/, Promise.all(__spreadArray([createDirectory(texturesDir)], modelDirs.map(createDirectory), true))];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, fs_1.promises.readdir(sourceDir)];
+                case 2:
+                    allFiles = (_a.sent()).filter(function (f) { return ['.dff', '.txd'].includes(path.extname(f).toLowerCase()); });
+                    filesQueue = __spreadArray([], allFiles, true);
+                    numWorkers = os.cpus().length;
+                    console.log("Starting processing with ".concat(numWorkers, " workers for ").concat(allFiles.length, " files."));
+                    modelIndex = { skins: [], objects: [], vehicles: [] };
+                    textureIndex = {};
+                    processedFiles = 0;
+                    runWorker = function (workerId) { return new Promise(function (resolve, reject) {
+                        var worker = new worker_threads_1.Worker(path.join(__dirname, 'sort_worker.js'));
+                        worker.on('message', function (result) {
+                            processedFiles++;
+                            process.stdout.write("\rProcessing: ".concat(processedFiles, "/").concat(allFiles.length));
+                            if (result.type === 'dff') {
+                                modelIndex[result.category].push(result.file);
+                            }
+                            else if (result.type === 'txd') {
+                                textureIndex[result.file] = result.textures;
+                            }
+                            else if (result.type === 'error') {
+                                console.error("\n[Worker ".concat(workerId, "] Error processing ").concat(result.file, ": ").concat(result.message));
+                            }
+                            if (filesQueue.length > 0) {
+                                worker.postMessage({ file: filesQueue.pop(), sourceDir: sourceDir, outputDir: outputDir, texturesDir: texturesDir, modelTypeToDir: modelTypeToDir });
+                            }
+                            else {
+                                worker.postMessage(null);
+                            }
+                        });
+                        worker.on('error', reject);
+                        worker.on('exit', function (code) {
+                            if (code === 0) {
+                                resolve();
+                            }
+                            else {
+                                reject(new Error("Worker ".concat(workerId, " stopped with exit code ").concat(code)));
+                            }
+                        });
+                        if (filesQueue.length > 0) {
+                            worker.postMessage({ file: filesQueue.pop(), sourceDir: sourceDir, outputDir: outputDir, texturesDir: texturesDir, modelTypeToDir: modelTypeToDir });
+                        }
+                        else {
+                            worker.postMessage(null);
+                        }
+                    }); };
+                    workerPromises = [];
+                    for (i = 0; i < numWorkers; i++) {
+                        workerPromises.push(runWorker(i + 1));
+                    }
+                    return [4 /*yield*/, Promise.all(workerPromises)];
+                case 3:
+                    _a.sent();
+                    console.log('\nWriting index files...');
+                    return [4 /*yield*/, Promise.all([
+                            fs_1.promises.writeFile(path.join(outputDir, 'index.json'), JSON.stringify(modelIndex, null, 2)),
+                            fs_1.promises.writeFile(path.join(texturesDir, 'index.json'), JSON.stringify(textureIndex, null, 2))
+                        ])];
+                case 4:
+                    _a.sent();
+                    console.log('Sorting and indexing complete!');
+                    console.timeEnd('Total execution time');
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+sortAndIndexAssets().catch(console.error);

package/lib/scripts/sort_worker.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/scripts/sort_worker.js

@@ -0,0 +1,140 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var worker_threads_1 = require("worker_threads");
+var index_1 = require("../src/index");
+var fs_1 = require("fs");
+var path = __importStar(require("path"));
+if (!worker_threads_1.parentPort) {
+    throw new Error('This script must be run as a worker thread.');
+}
+function processFile(task) {
+    return __awaiter(this, void 0, void 0, function () {
+        var file, sourceDir, outputDir, texturesDir, modelTypeToDir, sourcePath, ext, dffBuffer, modelType, targetDirName, destPath, destPath, txdBuffer, textureDictionary, textureNames, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    file = task.file, sourceDir = task.sourceDir, outputDir = task.outputDir, texturesDir = task.texturesDir, modelTypeToDir = task.modelTypeToDir;
+                    sourcePath = path.join(sourceDir, file);
+                    ext = path.extname(file).toLowerCase();
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 8, , 9]);
+                    if (!(ext === '.dff')) return [3 /*break*/, 4];
+                    return [4 /*yield*/, fs_1.promises.readFile(sourcePath)];
+                case 2:
+                    dffBuffer = _a.sent();
+                    modelType = new index_1.DffParser(dffBuffer).parse().modelType;
+                    targetDirName = modelTypeToDir[modelType];
+                    destPath = path.join(outputDir, targetDirName, file);
+                    return [4 /*yield*/, fs_1.promises.copyFile(sourcePath, destPath)];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/, { type: 'dff', file: file, category: targetDirName }];
+                case 4:
+                    if (!(ext === '.txd')) return [3 /*break*/, 7];
+                    destPath = path.join(texturesDir, file);
+                    return [4 /*yield*/, fs_1.promises.copyFile(sourcePath, destPath)];
+                case 5:
+                    _a.sent();
+                    return [4 /*yield*/, fs_1.promises.readFile(sourcePath)];
+                case 6:
+                    txdBuffer = _a.sent();
+                    textureDictionary = new index_1.TxdParser(txdBuffer).parse().textureDictionary;
+                    textureNames = textureDictionary.textureNatives.map(function (t) { return t.textureName; });
+                    return [2 /*return*/, { type: 'txd', file: file, textures: textureNames }];
+                case 7: return [3 /*break*/, 9];
+                case 8:
+                    error_1 = _a.sent();
+                    return [2 /*return*/, { type: 'error', file: file, message: error_1.message }];
+                case 9: return [2 /*return*/];
+            }
+        });
+    });
+}
+worker_threads_1.parentPort.on('message', function (task) { return __awaiter(void 0, void 0, void 0, function () {
+    var result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (task === null) {
+                    process.exit(0);
+                }
+                return [4 /*yield*/, processFile(task)];
+            case 1:
+                result = _a.sent();
+                if (result) {
+                    worker_threads_1.parentPort === null || worker_threads_1.parentPort === void 0 ? void 0 : worker_threads_1.parentPort.postMessage(result);
+                }
+                return [2 /*return*/];
+        }
+    });
+}); });

package/lib/src/index.d.ts

@@ -0,0 +1,8 @@
+export { ByteStream } from './utils/ByteStream';
+export { RwFile } from './renderware/RwFile';
+export { RwSections } from './renderware/RwSections';
+export * from './renderware/dff/DffParser';
+export * from './renderware/txd/TxdParser';
+export * from './renderware/ifp/IfpParser';
+export * from './renderware/dff/DffModelType';
+export * from './renderware/ifp/IfpData';

package/lib/src/index.js

@@ -0,0 +1,28 @@
+"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 });
+exports.RwSections = exports.RwFile = exports.ByteStream = void 0;
+var ByteStream_1 = require("./utils/ByteStream");
+Object.defineProperty(exports, "ByteStream", { enumerable: true, get: function () { return ByteStream_1.ByteStream; } });
+var RwFile_1 = require("./renderware/RwFile");
+Object.defineProperty(exports, "RwFile", { enumerable: true, get: function () { return RwFile_1.RwFile; } });
+var RwSections_1 = require("./renderware/RwSections");
+Object.defineProperty(exports, "RwSections", { enumerable: true, get: function () { return RwSections_1.RwSections; } });
+__exportStar(require("./renderware/dff/DffParser"), exports);
+__exportStar(require("./renderware/txd/TxdParser"), exports);
+__exportStar(require("./renderware/ifp/IfpParser"), exports);
+__exportStar(require("./renderware/dff/DffModelType"), exports);
+__exportStar(require("./renderware/ifp/IfpData"), exports);

package/lib/src/renderware/RwFile.d.ts

@@ -0,0 +1,10 @@
+import { ByteStream } from "../utils/ByteStream";
+export interface RwSectionHeader {
+    sectionType: number;
+    sectionSize: number;
+    versionNumber: number;
+}
+export declare class RwFile extends ByteStream {
+    constructor(stream: Buffer);
+    readSectionHeader(): RwSectionHeader;
+}

package/lib/src/renderware/RwFile.js

@@ -0,0 +1,33 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RwFile = void 0;
+var ByteStream_1 = require("../utils/ByteStream");
+var RwFile = /** @class */ (function (_super) {
+    __extends(RwFile, _super);
+    function RwFile(stream) {
+        return _super.call(this, stream) || this;
+    }
+    RwFile.prototype.readSectionHeader = function () {
+        var sectionType = this.readUint32();
+        var sectionSize = this.readUint32();
+        var versionNumber = this.readUint32();
+        return { sectionType: sectionType, sectionSize: sectionSize, versionNumber: versionNumber };
+    };
+    return RwFile;
+}(ByteStream_1.ByteStream));
+exports.RwFile = RwFile;

package/lib/src/renderware/RwSections.d.ts

@@ -0,0 +1,20 @@
+export declare enum RwSections {
+    RwStruct = 1,
+    RwString = 2,
+    RwExtension = 3,
+    RwTexture = 6,
+    RwMaterial = 7,
+    RwMaterialList = 8,
+    RwFrameList = 14,
+    RwGeometry = 15,
+    RwClump = 16,
+    RwAtomic = 20,
+    RwTextureNative = 21,
+    RwTextureDictionary = 22,
+    RwGeometryList = 26,
+    RwSkin = 278,
+    RwAnim = 286,
+    RwMaterialEffectsPLG = 288,
+    RwReflectionMaterial = 39056124,
+    RwNodeName = 39056126
+}

package/lib/src/renderware/RwSections.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RwSections = void 0;
+var RwSections;
+(function (RwSections) {
+    // Core
+    RwSections[RwSections["RwStruct"] = 1] = "RwStruct";
+    RwSections[RwSections["RwString"] = 2] = "RwString";
+    RwSections[RwSections["RwExtension"] = 3] = "RwExtension";
+    RwSections[RwSections["RwTexture"] = 6] = "RwTexture";
+    RwSections[RwSections["RwMaterial"] = 7] = "RwMaterial";
+    RwSections[RwSections["RwMaterialList"] = 8] = "RwMaterialList";
+    RwSections[RwSections["RwFrameList"] = 14] = "RwFrameList";
+    RwSections[RwSections["RwGeometry"] = 15] = "RwGeometry";
+    RwSections[RwSections["RwClump"] = 16] = "RwClump";
+    RwSections[RwSections["RwAtomic"] = 20] = "RwAtomic";
+    RwSections[RwSections["RwTextureNative"] = 21] = "RwTextureNative";
+    RwSections[RwSections["RwTextureDictionary"] = 22] = "RwTextureDictionary";
+    RwSections[RwSections["RwGeometryList"] = 26] = "RwGeometryList";
+    RwSections[RwSections["RwSkin"] = 278] = "RwSkin";
+    RwSections[RwSections["RwAnim"] = 286] = "RwAnim";
+    // Toolkit
+    RwSections[RwSections["RwMaterialEffectsPLG"] = 288] = "RwMaterialEffectsPLG";
+    // R* specific RW plugins
+    RwSections[RwSections["RwReflectionMaterial"] = 39056124] = "RwReflectionMaterial";
+    // This was renamed to RwNodeName from RwFrame to prevent confusion.
+    // https://gtamods.com/wiki/Node_Name_(RW_Section)
+    RwSections[RwSections["RwNodeName"] = 39056126] = "RwNodeName";
+})(RwSections || (exports.RwSections = RwSections = {}));

package/lib/src/renderware/common/types.d.ts

@@ -0,0 +1,50 @@
+export interface RwVector2 {
+    x: number;
+    y: number;
+}
+export interface RwVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface RwVector4 {
+    x: number;
+    y: number;
+    z: number;
+    t: number;
+}
+export interface RwQuaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface RwMatrix3 {
+    right: RwVector3;
+    up: RwVector3;
+    at: RwVector3;
+}
+export interface RwMatrix4 {
+    right: RwVector4;
+    up: RwVector4;
+    at: RwVector4;
+    transform: RwVector4;
+}
+export interface RwColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface RwTextureCoordinate {
+    u: number;
+    v: number;
+}
+export interface RwTriangle {
+    vector: RwVector3;
+    materialId: number;
+}
+export interface RwSphere {
+    vector: RwVector3;
+    radius: number;
+}

package/lib/src/renderware/common/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/renderware/dff/DffModelType.d.ts

@@ -0,0 +1,5 @@
+export declare enum DffModelType {
+    GENERIC = 0,
+    SKIN = 1,
+    VEHICLE = 2
+}

package/lib/src/renderware/dff/DffModelType.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DffModelType = void 0;
+var DffModelType;
+(function (DffModelType) {
+    DffModelType[DffModelType["GENERIC"] = 0] = "GENERIC";
+    DffModelType[DffModelType["SKIN"] = 1] = "SKIN";
+    DffModelType[DffModelType["VEHICLE"] = 2] = "VEHICLE";
+})(DffModelType || (exports.DffModelType = DffModelType = {}));

package/lib/src/renderware/dff/DffParser.d.ts

@@ -0,0 +1,112 @@
+import { RwFile } from '../RwFile';
+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 declare class DffParser extends RwFile {
+    constructor(buffer: Buffer);
+    parse(): RwDff;
+    readClump(): RwClump;
+    readFrameList(): RwFrameList;
+    readGeometryList(): RwGeometryList;
+    readGeometry(versionNumber: number): RwGeometry;
+    readBinMesh(): RwBinMesh;
+    readSkin(vertexCount: number): RwSkin;
+    readAnimNode(): RwAnimNode;
+    readMesh(): RwMesh;
+    readMaterialList(): RwMaterialList;
+    readMaterial(): RwMaterial;
+    readTexture(): RwTexture;
+    readAtomic(): RwAtomic;
+}