rw-parser-ng 2.1.0 → 2.3.0

package/lib/txd/parser.js

@@ -0,0 +1,122 @@
+"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.TxdParser = void 0;
+var formats_1 = require("../codecs/formats");
+var rw_file_1 = require("../core/rw-file");
+var bitmap_decoder_1 = require("./bitmap-decoder");
+var TxdParser = /** @class */ (function (_super) {
+    __extends(TxdParser, _super);
+    function TxdParser() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TxdParser.prototype.parse = function () {
+        return { textureDictionary: this.readTextureDictionary() };
+    };
+    TxdParser.prototype.readTextureDictionary = function () {
+        this.readSectionHeader();
+        this.readSectionHeader();
+        var textureCount = this.readUint16();
+        this.skip(2);
+        var textureNatives = [];
+        for (var i = 0; i < textureCount; i++) {
+            textureNatives.push(this.readTextureNative());
+        }
+        this.skip(this.readSectionHeader().sectionSize);
+        return { textureCount: textureCount, textureNatives: textureNatives };
+    };
+    TxdParser.prototype.readTextureNative = function () {
+        this.readSectionHeader();
+        this.readSectionHeader();
+        var platformId = this.readUint32();
+        var flags = this.readUint32();
+        var filterMode = flags & 0xff;
+        var uAddressing = (flags & 0xf00) >> 8;
+        var vAddressing = (flags & 0xf000) >> 12;
+        var textureName = this.readString(32);
+        var maskName = this.readString(32);
+        var rasterFormat = this.readUint32();
+        var d3dFormat = this.readString(4);
+        var width = this.readUint16();
+        var height = this.readUint16();
+        var depth = this.readUint8();
+        var mipmapCount = this.readUint8();
+        var rasterType = this.readUint8();
+        var compressionFlags = this.readUint8();
+        var alpha = (compressionFlags & (1 << 0)) !== 0;
+        var cubeTexture = (compressionFlags & (1 << 1)) !== 0;
+        var autoMipMaps = (compressionFlags & (1 << 2)) !== 0;
+        var compressed = (compressionFlags & (1 << 3)) !== 0;
+        var paletteType = (rasterFormat >> 13) & 3;
+        var pixelFormat = rasterFormat & 0x0f00;
+        var palette = paletteType !== formats_1.PaletteType.PALETTE_NONE
+            ? this.read(paletteType === formats_1.PaletteType.PALETTE_8 ? 1024 : depth === 4 ? 64 : 128)
+            : new Uint8Array(0);
+        var mipmaps = [];
+        for (var i = 0; i < mipmapCount; i++) {
+            var rasterSize = this.readUint32();
+            var raster = this.read(rasterSize);
+            if (i === 0) {
+                var bitmap = this.decodeBitmap(platformId, compressionFlags, compressed, alpha, paletteType, depth, pixelFormat, d3dFormat, raster, palette, width, height);
+                mipmaps.push(Array.from(bitmap));
+            }
+        }
+        this.skip(this.readSectionHeader().sectionSize);
+        return {
+            platformId: platformId,
+            filterMode: filterMode,
+            uAddressing: uAddressing,
+            vAddressing: vAddressing,
+            textureName: textureName,
+            maskName: maskName,
+            rasterFormat: rasterFormat,
+            d3dFormat: d3dFormat,
+            width: width,
+            height: height,
+            depth: depth,
+            mipmapCount: mipmapCount,
+            rasterType: rasterType,
+            alpha: alpha,
+            cubeTexture: cubeTexture,
+            autoMipMaps: autoMipMaps,
+            compressed: compressed,
+            mipmaps: mipmaps,
+        };
+    };
+    TxdParser.prototype.decodeBitmap = function (platformId, compressionFlags, compressed, alpha, paletteType, depth, pixelFormat, d3dFormat, raster, palette, width, height) {
+        if (palette.length !== 0) {
+            var noAlphaFormats = [
+                formats_1.RasterFormat.RASTER_565,
+                formats_1.RasterFormat.RASTER_LUM,
+                formats_1.RasterFormat.RASTER_888,
+                formats_1.RasterFormat.RASTER_555,
+            ];
+            var hasAlpha = (platformId === formats_1.PlatformType.D3D9 && alpha) ||
+                (platformId === formats_1.PlatformType.D3D8 && !noAlphaFormats.includes(pixelFormat));
+            return (0, bitmap_decoder_1.decodePaletteBitmap)(paletteType, depth, hasAlpha, raster, palette, width, height);
+        }
+        if (platformId === formats_1.PlatformType.D3D8 && compressionFlags !== 0) {
+            return (0, bitmap_decoder_1.decodeDxtBitmap)("DXT".concat(compressionFlags), raster, width, height);
+        }
+        if (platformId === formats_1.PlatformType.D3D9 && compressed) {
+            return (0, bitmap_decoder_1.decodeDxtBitmap)(d3dFormat, raster, width, height);
+        }
+        return (0, bitmap_decoder_1.decodeRasterBitmap)(pixelFormat, raster, width, height);
+    };
+    return TxdParser;
+}(rw_file_1.RwFile));
+exports.TxdParser = TxdParser;

package/lib/txd/types.d.ts

@@ -0,0 +1,27 @@
+export interface RwTxd {
+    textureDictionary: RwTextureDictionary;
+}
+export interface RwTextureDictionary {
+    textureCount: number;
+    textureNatives: RwTextureNative[];
+}
+export interface RwTextureNative {
+    platformId: number;
+    filterMode: number;
+    uAddressing: number;
+    vAddressing: number;
+    textureName: string;
+    maskName: string;
+    rasterFormat: number;
+    d3dFormat: string;
+    width: number;
+    height: number;
+    depth: number;
+    mipmapCount: number;
+    rasterType: number;
+    alpha: boolean;
+    cubeTexture: boolean;
+    autoMipMaps: boolean;
+    compressed: boolean;
+    mipmaps: number[][];
+}

package/lib/txd/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rw-parser-ng",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Parses RenderWare DFF, TXD and IFP files into usable format!",
   "author": {
     "name": "DepsCian",
@@ -35,30 +35,37 @@
     "rw-parser",
     "dff",
     "txd",
-    "ifp"
+    "ifp",
+    "fxp"
   ],
   "main": "lib/index.js",
+  "module": "lib/index.js",
   "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "require": "./lib/index.js"
+    }
+  },
   "devDependencies": {
-    "@types/jest": "^30.0.0",
+    "@biomejs/biome": "^2.3.10",
     "@types/node": "^24.0.3",
-    "jest": "^30.0.0",
-    "ts-jest": "^29.4.0",
     "typescript": "^5.8.3"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch",
-    "prepare": "npm run build",
-    "test": "jest",
-    "sort:models": "tsc && node lib/scripts/sort_models.js"
+    "lint": "biome check .",
+    "format": "biome format --write .",
+    "prepare": "bun run build",
+    "test": "bun test"
   },
   "files": [
     "lib",
     "src",
     "LICENSE",
     "README.md",
-    "package.json",
     "tsconfig.json"
   ]
 }

package/src/codecs/bitmap.ts

@@ -0,0 +1,75 @@
+import { decode555, decode565, decode1555, decode4444, readUInt16LE } from "./color";
+
+export function bgra1555(data: Uint8Array, width: number, height: number): Uint8Array {
+  const rgba = new Uint8Array(4 * width * height);
+  let offset = 0;
+  for (let i = 0; i < data.length; i += 2) {
+    const [a, r, g, b] = decode1555(readUInt16LE(data, i));
+    rgba[offset++] = r;
+    rgba[offset++] = g;
+    rgba[offset++] = b;
+    rgba[offset++] = a;
+  }
+  return rgba;
+}
+
+export function bgra4444(data: Uint8Array, width: number, height: number): Uint8Array {
+  const rgba = new Uint8Array(4 * width * height);
+  let offset = 0;
+  for (let i = 0; i < data.length; i += 2) {
+    const [a, r, g, b] = decode4444(readUInt16LE(data, i));
+    rgba[offset++] = r;
+    rgba[offset++] = g;
+    rgba[offset++] = b;
+    rgba[offset++] = a;
+  }
+  return rgba;
+}
+
+export function bgra555(data: Uint8Array, width: number, height: number): Uint8Array {
+  const rgba = new Uint8Array(4 * width * height);
+  let offset = 0;
+  for (let i = 0; i < data.length; i += 2) {
+    const [r, g, b] = decode555(readUInt16LE(data, i));
+    rgba[offset++] = r;
+    rgba[offset++] = g;
+    rgba[offset++] = b;
+    rgba[offset++] = 0xff;
+  }
+  return rgba;
+}
+
+export function bgra565(data: Uint8Array, width: number, height: number): Uint8Array {
+  const rgba = new Uint8Array(4 * width * height);
+  let offset = 0;
+  for (let i = 0; i < data.length; i += 2) {
+    const [r, g, b] = decode565(readUInt16LE(data, i));
+    rgba[offset++] = r;
+    rgba[offset++] = g;
+    rgba[offset++] = b;
+    rgba[offset++] = 0xff;
+  }
+  return rgba;
+}
+
+export function bgra888(data: Uint8Array, width: number, height: number): Uint8Array {
+  const rgba = new Uint8Array(4 * width * height);
+  for (let i = 0; i < data.length; i += 4) {
+    rgba[i] = data[i + 2];
+    rgba[i + 1] = data[i + 1];
+    rgba[i + 2] = data[i];
+    rgba[i + 3] = 0xff;
+  }
+  return rgba;
+}
+
+export function bgra8888(data: Uint8Array, width: number, height: number): Uint8Array {
+  const rgba = new Uint8Array(4 * width * height);
+  for (let i = 0; i < data.length; i += 4) {
+    rgba[i] = data[i + 2];
+    rgba[i + 1] = data[i + 1];
+    rgba[i + 2] = data[i];
+    rgba[i + 3] = data[i + 3];
+  }
+  return rgba;
+}

package/src/codecs/color.ts

@@ -0,0 +1,40 @@
+export function readUInt16LE(buf: Uint8Array, offset: number): number {
+  return buf[offset] | (buf[offset + 1] << 8);
+}
+
+export function readUInt32LE(buf: Uint8Array, offset: number): number {
+  return buf[offset] | (buf[offset + 1] << 8) | (buf[offset + 2] << 16) | (buf[offset + 3] << 24);
+}
+
+export function decode565(bits: number): [number, number, number] {
+  const r = (bits >> 11) & 0b11111;
+  const g = (bits >> 5) & 0b111111;
+  const b = bits & 0b11111;
+  return [(r << 3) | (r >> 2), (g << 2) | (g >> 4), (b << 3) | (b >> 2)];
+}
+
+export function decode555(bits: number): [number, number, number] {
+  return [
+    Math.round((((bits >> 10) & 0b11111) * 255) / 31),
+    Math.round((((bits >> 5) & 0b11111) * 255) / 31),
+    Math.round(((bits & 0b11111) * 255) / 31),
+  ];
+}
+
+export function decode1555(bits: number): [number, number, number, number] {
+  return [
+    Math.round(((bits >> 15) & 0b1) * 255),
+    Math.round((((bits >> 10) & 0b11111) * 255) / 31),
+    Math.round((((bits >> 5) & 0b11111) * 255) / 31),
+    Math.round(((bits & 0b11111) * 255) / 31),
+  ];
+}
+
+export function decode4444(bits: number): [number, number, number, number] {
+  return [
+    Math.round((((bits >> 12) & 0b1111) * 255) / 15),
+    Math.round((((bits >> 8) & 0b1111) * 255) / 15),
+    Math.round((((bits >> 4) & 0b1111) * 255) / 15),
+    Math.round(((bits & 0b1111) * 255) / 15),
+  ];
+}

package/src/codecs/dxt.ts

@@ -0,0 +1,243 @@
+import { decode565, readUInt16LE, readUInt32LE } from "./color";
+
+export function bc1(data: Uint8Array, width: number, height: number): Uint8Array {
+  const rgba = new Uint8Array(4 * width * height);
+  const colorPalette = new Uint8Array(16);
+  let offset = 0;
+
+  for (let y = 0; y < height; y += 4) {
+    for (let x = 0; x < width; x += 4) {
+      const color0 = readUInt16LE(data, offset);
+      const color1 = readUInt16LE(data, offset + 2);
+      let colorBits = readUInt32LE(data, offset + 4);
+      offset += 8;
+
+      const [c0r, c0g, c0b] = decode565(color0);
+      const [c1r, c1g, c1b] = decode565(color1);
+
+      colorPalette[0] = c0r;
+      colorPalette[1] = c0g;
+      colorPalette[2] = c0b;
+      colorPalette[4] = c1r;
+      colorPalette[5] = c1g;
+      colorPalette[6] = c1b;
+
+      if (color0 > color1) {
+        colorPalette[8] = (2 * c0r + c1r) / 3;
+        colorPalette[9] = (2 * c0g + c1g) / 3;
+        colorPalette[10] = (2 * c0b + c1b) / 3;
+        colorPalette[12] = (c0r + 2 * c1r) / 3;
+        colorPalette[13] = (c0g + 2 * c1g) / 3;
+        colorPalette[14] = (c0b + 2 * c1b) / 3;
+      } else {
+        colorPalette[8] = (c0r + c1r) >> 1;
+        colorPalette[9] = (c0g + c1g) >> 1;
+        colorPalette[10] = (c0b + c1b) >> 1;
+        colorPalette[12] = 0;
+        colorPalette[13] = 0;
+        colorPalette[14] = 0;
+      }
+
+      const baseIndex = (y * width + x) * 4;
+      for (let k = 0; k < 16; k++) {
+        const colorIdx = colorBits & 0x3;
+        colorBits >>>= 2;
+        const j = k >> 2,
+          i = k & 3;
+        const idx = baseIndex + ((j * width + i) << 2);
+
+        rgba[idx] = colorPalette[colorIdx * 4];
+        rgba[idx + 1] = colorPalette[colorIdx * 4 + 1];
+        rgba[idx + 2] = colorPalette[colorIdx * 4 + 2];
+        rgba[idx + 3] = color0 <= color1 && colorIdx === 3 ? 0 : 255;
+      }
+    }
+  }
+  return rgba;
+}
+
+export function bc2(
+  data: Uint8Array,
+  width: number,
+  height: number,
+  premultiplied: boolean,
+): Uint8Array {
+  const rgba = new Uint8Array(4 * width * height);
+  const colorPalette = new Uint8Array(16);
+  const alphaTable = new Uint8Array(16);
+  for (let i = 0; i < 16; i++) alphaTable[i] = ((i * 255 + 7.5) / 15) | 0;
+
+  let offset = 0;
+  for (let y = 0; y < height; y += 4) {
+    for (let x = 0; x < width; x += 4) {
+      const alpha0 = readUInt32LE(data, offset);
+      const alpha1 = readUInt32LE(data, offset + 4);
+      offset += 8;
+
+      const color0 = readUInt16LE(data, offset);
+      const color1 = readUInt16LE(data, offset + 2);
+      let colorBits = readUInt32LE(data, offset + 4);
+      offset += 8;
+
+      const [c0r, c0g, c0b] = decode565(color0);
+      const [c1r, c1g, c1b] = decode565(color1);
+
+      colorPalette[0] = c0r;
+      colorPalette[1] = c0g;
+      colorPalette[2] = c0b;
+      colorPalette[4] = c1r;
+      colorPalette[5] = c1g;
+      colorPalette[6] = c1b;
+
+      if (color0 > color1) {
+        colorPalette[8] = (2 * c0r + c1r) / 3;
+        colorPalette[9] = (2 * c0g + c1g) / 3;
+        colorPalette[10] = (2 * c0b + c1b) / 3;
+        colorPalette[12] = (c0r + 2 * c1r) / 3;
+        colorPalette[13] = (c0g + 2 * c1g) / 3;
+        colorPalette[14] = (c0b + 2 * c1b) / 3;
+      } else {
+        colorPalette[8] = (c0r + c1r) >> 1;
+        colorPalette[9] = (c0g + c1g) >> 1;
+        colorPalette[10] = (c0b + c1b) >> 1;
+        colorPalette[12] = 0;
+        colorPalette[13] = 0;
+        colorPalette[14] = 0;
+      }
+
+      const baseIndex = (y * width + x) << 2;
+      for (let k = 0; k < 16; k++) {
+        const j = k >> 2,
+          i = k & 3;
+        const idx = baseIndex + ((j * width + i) << 2);
+        const colorIdx = colorBits & 0x3;
+        colorBits >>>= 2;
+
+        const bitPos = (j << 2) + i;
+        const byteIndex = bitPos >> 3;
+        const shift = (bitPos & 7) << 2;
+        const alpha4 = ((byteIndex === 0 ? alpha0 : alpha1) >>> shift) & 0xf;
+        const alpha = alphaTable[alpha4];
+
+        rgba[idx] = colorPalette[colorIdx * 4];
+        rgba[idx + 1] = colorPalette[colorIdx * 4 + 1];
+        rgba[idx + 2] = colorPalette[colorIdx * 4 + 2];
+        rgba[idx + 3] = alpha;
+
+        if (premultiplied && alpha > 0 && alpha < 255) {
+          const factor = 255 / alpha;
+          rgba[idx] = Math.min(255, Math.round(rgba[idx] * factor));
+          rgba[idx + 1] = Math.min(255, Math.round(rgba[idx + 1] * factor));
+          rgba[idx + 2] = Math.min(255, Math.round(rgba[idx + 2] * factor));
+        }
+      }
+    }
+  }
+  return rgba;
+}
+
+export function bc3(
+  data: Uint8Array,
+  width: number,
+  height: number,
+  premultiplied: boolean,
+): Uint8Array {
+  const rgba = new Uint8Array(4 * width * height);
+  const alphaPalette = new Uint8Array(8);
+  const colorPalette = new Uint8Array(16);
+  const alphaIndices = new Uint8Array(16);
+  let offset = 0;
+
+  for (let y = 0; y < height; y += 4) {
+    for (let x = 0; x < width; x += 4) {
+      const alpha0 = data[offset++];
+      const alpha1 = data[offset++];
+      const alphaBits = data.subarray(offset, offset + 6);
+      offset += 6;
+
+      const color0 = readUInt16LE(data, offset);
+      const color1 = readUInt16LE(data, offset + 2);
+      let colorBits = readUInt32LE(data, offset + 4);
+      offset += 8;
+
+      const [c0r, c0g, c0b] = decode565(color0);
+      const [c1r, c1g, c1b] = decode565(color1);
+
+      colorPalette[0] = c0r;
+      colorPalette[1] = c0g;
+      colorPalette[2] = c0b;
+      colorPalette[4] = c1r;
+      colorPalette[5] = c1g;
+      colorPalette[6] = c1b;
+
+      if (color0 > color1) {
+        colorPalette[8] = (2 * c0r + c1r) / 3;
+        colorPalette[9] = (2 * c0g + c1g) / 3;
+        colorPalette[10] = (2 * c0b + c1b) / 3;
+        colorPalette[12] = (c0r + 2 * c1r) / 3;
+        colorPalette[13] = (c0g + 2 * c1g) / 3;
+        colorPalette[14] = (c0b + 2 * c1b) / 3;
+      } else {
+        colorPalette[8] = (c0r + c1r) >> 1;
+        colorPalette[9] = (c0g + c1g) >> 1;
+        colorPalette[10] = (c0b + c1b) >> 1;
+        colorPalette[12] = 0;
+        colorPalette[13] = 0;
+        colorPalette[14] = 0;
+      }
+
+      if (alpha0 > alpha1) {
+        alphaPalette[0] = alpha0;
+        alphaPalette[1] = alpha1;
+        alphaPalette[2] = (alpha0 * 6 + alpha1 + 3) / 7;
+        alphaPalette[3] = (alpha0 * 5 + alpha1 * 2 + 3) / 7;
+        alphaPalette[4] = (alpha0 * 4 + alpha1 * 3 + 3) / 7;
+        alphaPalette[5] = (alpha0 * 3 + alpha1 * 4 + 3) / 7;
+        alphaPalette[6] = (alpha0 * 2 + alpha1 * 5 + 3) / 7;
+        alphaPalette[7] = (alpha0 + alpha1 * 6 + 3) / 7;
+      } else {
+        alphaPalette[0] = alpha0;
+        alphaPalette[1] = alpha1;
+        alphaPalette[2] = (alpha0 * 4 + alpha1 + 2) / 5;
+        alphaPalette[3] = (alpha0 * 3 + alpha1 * 2 + 2) / 5;
+        alphaPalette[4] = (alpha0 * 2 + alpha1 * 3 + 2) / 5;
+        alphaPalette[5] = (alpha0 + alpha1 * 4 + 2) / 5;
+        alphaPalette[6] = 0;
+        alphaPalette[7] = 255;
+      }
+
+      for (let k = 0; k < 16; k++) {
+        const bitOffset = k * 3;
+        const byteOffset = bitOffset >> 3;
+        const shift = bitOffset & 7;
+        alphaIndices[k] =
+          shift <= 5
+            ? (alphaBits[byteOffset] >> shift) & 0x7
+            : ((alphaBits[byteOffset] >> shift) | (alphaBits[byteOffset + 1] << (8 - shift))) & 0x7;
+      }
+
+      const baseIndex = (y * width + x) << 2;
+      for (let k = 0; k < 16; k++) {
+        const j = k >> 2,
+          i = k & 3;
+        const idx = baseIndex + ((j * width + i) << 2);
+        const colorIdx = colorBits & 0x3;
+        colorBits >>>= 2;
+        const alpha = alphaPalette[alphaIndices[k] & 0x7];
+
+        rgba[idx] = colorPalette[colorIdx * 4];
+        rgba[idx + 1] = colorPalette[colorIdx * 4 + 1];
+        rgba[idx + 2] = colorPalette[colorIdx * 4 + 2];
+        rgba[idx + 3] = alpha;
+
+        if (premultiplied && alpha > 0 && alpha < 255) {
+          const factor = 255 / alpha;
+          rgba[idx] = Math.min(255, Math.round(rgba[idx] * factor));
+          rgba[idx + 1] = Math.min(255, Math.round(rgba[idx + 1] * factor));
+          rgba[idx + 2] = Math.min(255, Math.round(rgba[idx + 2] * factor));
+        }
+      }
+    }
+  }
+  return rgba;
+}

package/src/codecs/formats.ts

@@ -0,0 +1,28 @@
+export enum RasterFormat {
+  RASTER_1555 = 0x0100,
+  RASTER_565 = 0x0200,
+  RASTER_4444 = 0x0300,
+  RASTER_LUM = 0x0400,
+  RASTER_8888 = 0x0500,
+  RASTER_888 = 0x0600,
+  RASTER_555 = 0x0a00,
+}
+
+export enum D3DFormat {
+  D3DFMT_A8L8 = "3",
+  D3D_DXT1 = "DXT1",
+  D3D_DXT2 = "DXT2",
+  D3D_DXT3 = "DXT3",
+  D3D_DXT4 = "DXT4",
+  D3D_DXT5 = "DXT5",
+}
+
+export enum PaletteType {
+  PALETTE_NONE = 0,
+  PALETTE_8 = 1,
+}
+
+export enum PlatformType {
+  D3D8 = 0x8,
+  D3D9 = 0x9,
+}

package/src/codecs/index.ts

@@ -0,0 +1,5 @@
+export * from "./bitmap";
+export * from "./color";
+export * from "./dxt";
+export * from "./formats";
+export * from "./palette";