rw-parser-ng 2.1.0 → 2.3.0

package/src/codecs/palette.ts

@@ -0,0 +1,106 @@
+export function lum8(data: Uint8Array, width: number, height: number): Uint8Array {
+  const rgba = new Uint8Array(4 * width * height);
+  for (let i = 0; i < data.length; i++) {
+    const offset = i * 4;
+    const lum = data[i];
+    rgba[offset] = lum;
+    rgba[offset + 1] = lum;
+    rgba[offset + 2] = lum;
+    rgba[offset + 3] = 0xff;
+  }
+  return rgba;
+}
+
+export function lum8a8(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 lum = data[i],
+      alpha = data[i + 1];
+    rgba[offset++] = lum;
+    rgba[offset++] = lum;
+    rgba[offset++] = lum;
+    rgba[offset++] = alpha;
+  }
+  return rgba;
+}
+
+export function pal4(
+  data: Uint8Array,
+  palette: Uint8Array,
+  width: number,
+  height: number,
+): Uint8Array {
+  const rgba = new Uint8Array(4 * width * height);
+  let offset = 0;
+  for (let i = 0; i < data.length; i++) {
+    const idx1 = (data[i] >> 4) & 0xf,
+      idx2 = data[i] & 0xf;
+    rgba[offset++] = palette[idx1 * 4];
+    rgba[offset++] = palette[idx1 * 4 + 1];
+    rgba[offset++] = palette[idx1 * 4 + 2];
+    rgba[offset++] = palette[idx1 * 4 + 3];
+    rgba[offset++] = palette[idx2 * 4];
+    rgba[offset++] = palette[idx2 * 4 + 1];
+    rgba[offset++] = palette[idx2 * 4 + 2];
+    rgba[offset++] = palette[idx2 * 4 + 3];
+  }
+  return rgba;
+}
+
+export function pal4NoAlpha(
+  data: Uint8Array,
+  palette: Uint8Array,
+  width: number,
+  height: number,
+): Uint8Array {
+  const rgba = new Uint8Array(4 * width * height);
+  let offset = 0;
+  for (let i = 0; i < data.length; i++) {
+    const idx1 = (data[i] >> 4) & 0xf,
+      idx2 = data[i] & 0xf;
+    rgba[offset++] = palette[idx1 * 4];
+    rgba[offset++] = palette[idx1 * 4 + 1];
+    rgba[offset++] = palette[idx1 * 4 + 2];
+    rgba[offset++] = 0xff;
+    rgba[offset++] = palette[idx2 * 4];
+    rgba[offset++] = palette[idx2 * 4 + 1];
+    rgba[offset++] = palette[idx2 * 4 + 2];
+    rgba[offset++] = 0xff;
+  }
+  return rgba;
+}
+
+export function pal8(
+  data: Uint8Array,
+  palette: Uint8Array,
+  width: number,
+  height: number,
+): Uint8Array {
+  const rgba = new Uint8Array(4 * width * height);
+  for (let i = 0; i < data.length; i++) {
+    const idx = data[i];
+    rgba[i * 4] = palette[idx * 4];
+    rgba[i * 4 + 1] = palette[idx * 4 + 1];
+    rgba[i * 4 + 2] = palette[idx * 4 + 2];
+    rgba[i * 4 + 3] = palette[idx * 4 + 3];
+  }
+  return rgba;
+}
+
+export function pal8NoAlpha(
+  data: Uint8Array,
+  palette: Uint8Array,
+  width: number,
+  height: number,
+): Uint8Array {
+  const rgba = new Uint8Array(4 * width * height);
+  for (let i = 0; i < data.length; i++) {
+    const idx = data[i];
+    rgba[i * 4] = palette[idx * 4];
+    rgba[i * 4 + 1] = palette[idx * 4 + 1];
+    rgba[i * 4 + 2] = palette[idx * 4 + 2];
+    rgba[i * 4 + 3] = 0xff;
+  }
+  return rgba;
+}

package/src/common/types.ts

@@ -0,0 +1,59 @@
+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/src/core/byte-stream.ts

@@ -0,0 +1,87 @@
+export class ByteStream {
+  private _cursor = 0;
+  private _stream: Buffer;
+
+  constructor(stream: Buffer) {
+    this._stream = stream;
+  }
+
+  public readUint8(): number {
+    return this._stream.readUInt8(this._cursor++);
+  }
+
+  public readUint16(): number {
+    const val = this._stream.readUInt16LE(this._cursor);
+    this._cursor += 2;
+    return val;
+  }
+
+  public readUint32(): number {
+    const val = this._stream.readUInt32LE(this._cursor);
+    this._cursor += 4;
+    return val;
+  }
+
+  public readInt16(): number {
+    const val = this._stream.readInt16LE(this._cursor);
+    this._cursor += 2;
+    return val;
+  }
+
+  public readInt8(): number {
+    return this._stream.readInt8(this._cursor++);
+  }
+
+  public readInt32(): number {
+    const val = this._stream.readInt32LE(this._cursor);
+    this._cursor += 4;
+    return val;
+  }
+
+  public readFloat(): number {
+    const val = this._stream.readFloatLE(this._cursor);
+    this._cursor += 4;
+    return val;
+  }
+
+  public readString(size: number): string {
+    const str = this._stream.toString(
+      "ascii",
+      this._cursor,
+      this._cursor + size,
+    );
+    this._cursor += size;
+    return str.split(/\0/g).shift() || "";
+  }
+
+  public readBytes(size: number): Uint8Array {
+    const data = this._stream.subarray(this._cursor, this._cursor + size);
+    this._cursor += size;
+    return new Uint8Array(data);
+  }
+
+  public read(size: number): Uint8Array {
+    return this.readBytes(size);
+  }
+
+  public getSize(): number {
+    return this._stream.byteLength;
+  }
+
+  public getPosition(): number {
+    return this._cursor;
+  }
+
+  public setPosition(position: number): void {
+    this._cursor = position;
+  }
+
+  public skip(size: number): void {
+    this._cursor += size;
+  }
+
+  public dispose(): void {
+    this._stream = Buffer.alloc(0);
+    this._cursor = 0;
+  }
+}

package/src/core/errors.ts

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

package/src/core/index.ts

@@ -0,0 +1,5 @@
+export * from "./byte-stream";
+export * from "./errors";
+export * from "./rw-file";
+export * from "./rw-sections";
+export * from "./rw-version";

package/src/core/rw-file.ts

@@ -0,0 +1,23 @@
+import { ByteStream } from "./byte-stream";
+
+export interface RwSectionHeader {
+  sectionType: number;
+  sectionSize: number;
+  versionNumber: number;
+}
+
+export class RwFile extends ByteStream {
+  public readSectionHeader(): RwSectionHeader {
+    if (this.getPosition() + 12 > this.getSize()) {
+      throw new Error(
+        `Cannot read section header at offset ${this.getPosition().toString(16)}: need 12 bytes but only ${this.getSize() - this.getPosition()} bytes remaining`,
+      );
+    }
+
+    const sectionType = this.readUint32();
+    const sectionSize = this.readUint32();
+    const versionNumber = this.readUint32();
+
+    return { sectionType, sectionSize, versionNumber };
+  }
+}

package/src/core/rw-sections.ts

@@ -0,0 +1,24 @@
+export enum RwSections {
+  RwStruct = 0x0001,
+  RwString = 0x0002,
+  RwExtension = 0x0003,
+  RwTexture = 0x0006,
+  RwMaterial = 0x0007,
+  RwMaterialList = 0x0008,
+  RwFrameList = 0x000e,
+  RwGeometry = 0x000f,
+  RwClump = 0x0010,
+  RwAtomic = 0x0014,
+  RwTextureNative = 0x0015,
+  RwTextureDictionary = 0x0016,
+  RwGeometryList = 0x001a,
+  RwBinMesh = 0x50e,
+  RwSkin = 0x116,
+  RwAnim = 0x11e,
+  RwMaterialEffectsPLG = 0x0120,
+  RwExtraVertColour = 0x0253f2f9,
+  RwBreakable = 0x0253f2fd,
+  RwReflectionMaterial = 0x0253f2fc,
+  Rw2dEffect = 0x0253f2f8,
+  RwNodeName = 0x0253f2fe,
+}

package/src/core/rw-version.ts

@@ -0,0 +1,24 @@
+const VERSIONS: Record<number, string> = {
+  200704: "RenderWare 3.1.0.0 (III on PS2)",
+  204800: "RenderWare 3.2.0.0 (III on PC)",
+  208898: "RenderWare 3.3.0.2 (III on PC, VC on PS2)",
+  212995: "RenderWare 3.4.0.3 (VC on PC)",
+  212997: "RenderWare 3.4.0.5 (III on PS2, VC on Android/PC)",
+  217088: "RenderWare 3.5.0.0 (III/VC on Xbox)",
+  221187: "RenderWare 3.6.0.3 (SA)",
+};
+
+export function getVersionString(version: number): string {
+  return VERSIONS[version] ?? "";
+}
+
+export function unpackVersion(version: number): number {
+  if (version & 0xffff0000) {
+    return (((version >> 14) & 0x3ff00) + 0x30000) | ((version >> 16) & 0x3f);
+  }
+  return version;
+}
+
+export function unpackBuild(version: number): number {
+  return version & 0xffff0000 ? version & 0xffff : 0;
+}

package/src/dff/dff-model-type.ts

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

package/src/dff/index.ts

@@ -0,0 +1,4 @@
+export * from "./dff-model-type";
+export * from "./parser";
+export * from "./readers";
+export * from "./types";

package/src/dff/parser.ts

@@ -0,0 +1,142 @@
+import { RwParseStructureNotFoundError } from "../core/errors";
+import { RwFile } from "../core/rw-file";
+import { RwSections } from "../core/rw-sections";
+import { getVersionString, unpackVersion } from "../core/rw-version";
+import { DffModelType } from "./dff-model-type";
+import { readAnimNode, readAtomic, readFrameList, readGeometryList } from "./readers";
+import type { RwAnimNode, RwDff, RwFrameList, RwGeometryList } from "./types";
+
+export class DffParser extends RwFile {
+  parse(): RwDff {
+    let version: string | undefined;
+    let versionNumber: number | undefined;
+    const atomics: number[] = [];
+    const dummies: string[] = [];
+    const 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:
+          versionNumber = unpackVersion(header.versionNumber);
+          version = getVersionString(versionNumber);
+          break;
+        case RwSections.RwFrameList:
+          frameList = readFrameList(this);
+          break;
+        case RwSections.RwExtension: {
+          const extHeader = this.readSectionHeader();
+          switch (extHeader.sectionType) {
+            case RwSections.RwNodeName:
+              dummies.push(this.readString(extHeader.sectionSize));
+              break;
+            case RwSections.RwAnim:
+              animNodes.push(readAnimNode(this));
+              break;
+            default:
+              this.skip(extHeader.sectionSize);
+              break;
+          }
+          break;
+        }
+        case RwSections.RwGeometryList:
+          geometryList = readGeometryList(this, header);
+          break;
+        case RwSections.RwAtomic: {
+          const atomic = readAtomic(this);
+          atomics[atomic.geometryIndex] = atomic.frameIndex;
+          break;
+        }
+        case RwSections.RwNodeName:
+          dummies.push(this.readString(header.sectionSize));
+          break;
+        case RwSections.RwAnim:
+          animNodes.push(readAnimNode(this));
+          break;
+        default:
+          this.skip(header.sectionSize);
+          break;
+      }
+    }
+
+    if (!version || !versionNumber) {
+      throw new RwParseStructureNotFoundError("version");
+    }
+
+    if (!geometryList?.geometries?.length) {
+      throw new RwParseStructureNotFoundError("geometry list");
+    }
+
+    // Heuristic model type detection (not authoritative - GTA uses IDE/DAT files)
+    // Based on gta-reversed: eCarNodes.h, AtomicModelInfo.cpp, VehicleModelInfo.cpp
+    const vehiclePrefixes = [
+      "chassis",
+      "wheel_rf",
+      "wheel_lf",
+      "wheel_rb",
+      "wheel_lb",
+      "wheel_rm",
+      "wheel_lm",
+      "door_lf",
+      "door_rf",
+      "door_lr",
+      "door_rr",
+      "bonnet",
+      "boot",
+      "bump_front",
+      "bump_rear",
+      "wing_lf",
+      "wing_rf",
+      "windscreen",
+      "exhaust",
+      "boat_hi",
+      "toprotor",
+      "rearrotor",
+      "moving_rotor",
+    ];
+
+    let modelType = DffModelType.GENERIC;
+    if (geometryList.geometries.some((g) => g.skin)) {
+      modelType = DffModelType.SKIN;
+    } else if (
+      dummies.some((d) => {
+        const lower = d.toLowerCase();
+        return vehiclePrefixes.some((p) => lower.startsWith(p) || lower.includes(`_${p}`));
+      })
+    ) {
+      modelType = DffModelType.VEHICLE;
+    }
+
+    return {
+      modelType,
+      version,
+      versionNumber,
+      geometryList,
+      frameList,
+      atomics,
+      dummies,
+      animNodes,
+    };
+  }
+}