rw-parser-ng 2.1.0 → 2.3.0

package/src/ifp/readers/anp3.ts

@@ -0,0 +1,75 @@
+import type { RwFile } from "../../core/rw-file";
+import {
+  IfpVersion,
+  type RwIfp,
+  type RwIfpAnimation,
+  type RwIfpBone,
+  type RwIfpKeyframe,
+} from "../types";
+
+const QUAT_SCALE = 4096.0;
+const POS_SCALE = 1024.0;
+
+export function readAnp3(file: RwFile): RwIfp {
+  file.skip(4); // ANP3 signature
+  file.readUint32(); // size
+  const name = file.readString(24);
+  const animationsCount = file.readUint32();
+
+  const animations: RwIfpAnimation[] = [];
+  for (let i = 0; i < animationsCount; i++) {
+    animations.push(readAnimation(file));
+  }
+
+  return { version: IfpVersion.ANP3, name, animations };
+}
+
+function readAnimation(file: RwFile): RwIfpAnimation {
+  const name = file.readString(24);
+  const bonesCount = file.readUint32();
+  file.skip(8); // keyframes_size + unk
+
+  const bones: RwIfpBone[] = [];
+  for (let i = 0; i < bonesCount; i++) {
+    bones.push(readBone(file));
+  }
+
+  return { name, bones };
+}
+
+function readBone(file: RwFile): RwIfpBone {
+  const name = file.readString(24);
+  const keyframeTypeNum = file.readUint32();
+  const keyframesCount = file.readUint32();
+  const keyframeType = keyframeTypeNum === 4 ? "KRT0" : "KR00";
+  const boneId = file.readInt32();
+
+  const keyframes: RwIfpKeyframe[] = [];
+  const hasTranslation = keyframeType[2] === "T";
+
+  for (let i = 0; i < keyframesCount; i++) {
+    const qx = file.readInt16() / QUAT_SCALE;
+    const qy = file.readInt16() / QUAT_SCALE;
+    const qz = file.readInt16() / QUAT_SCALE;
+    const qw = file.readInt16() / QUAT_SCALE;
+    const time = file.readInt16();
+
+    let px = 0,
+      py = 0,
+      pz = 0;
+    if (hasTranslation) {
+      px = file.readInt16() / POS_SCALE;
+      py = file.readInt16() / POS_SCALE;
+      pz = file.readInt16() / POS_SCALE;
+    }
+
+    keyframes.push({
+      time,
+      position: { x: px, y: py, z: pz },
+      rotation: { w: qw, x: qx, y: qy, z: qz },
+      scale: { x: 1, y: 1, z: 1 },
+    });
+  }
+
+  return { name, keyframeType, useBoneId: true, boneId, keyframes };
+}

package/src/ifp/readers/anpk.ts

@@ -0,0 +1,110 @@
+import type { RwFile } from "../../core/rw-file";
+import {
+  IfpVersion,
+  type RwIfp,
+  type RwIfpAnimation,
+  type RwIfpBone,
+  type RwIfpKeyframe,
+} from "../types";
+
+export function readAnpk(file: RwFile): RwIfp {
+  file.skip(4); // ANPK signature
+  file.readUint32(); // size
+  file.skip(4); // INFO
+  const infoLen = file.readUint32();
+  const animationsCount = file.readUint32();
+  const name = file.readString(infoLen - 4);
+  file.skip((4 - (infoLen % 4)) % 4); // align
+
+  const animations: RwIfpAnimation[] = [];
+  for (let i = 0; i < animationsCount; i++) {
+    animations.push(readAnimation(file));
+  }
+
+  return { version: IfpVersion.ANPK, name, animations };
+}
+
+function readAnimation(file: RwFile): RwIfpAnimation {
+  file.skip(4); // NAME
+  const nameLen = file.readUint32();
+  const name = file.readString(nameLen);
+  file.skip((4 - (nameLen % 4)) % 4); // align
+  file.skip(4); // DGAN
+  file.skip(4); // animation_size
+  file.skip(4); // INFO
+  file.skip(4); // unk_size
+  const bonesCount = file.readUint32();
+  file.skip(4); // unk
+
+  const bones: RwIfpBone[] = [];
+  for (let i = 0; i < bonesCount; i++) {
+    bones.push(readBone(file));
+  }
+
+  return { name, bones };
+}
+
+function readBone(file: RwFile): RwIfpBone {
+  file.skip(4); // CPAN
+  file.skip(4); // bone_len
+  file.skip(4); // ANIM
+  const animLen = file.readUint32();
+  const name = file.readString(28);
+  const keyframesCount = file.readUint32();
+  file.skip(8); // unk
+
+  const useBoneId = animLen === 44;
+  let boneId = 0;
+  if (useBoneId) {
+    boneId = file.readInt32();
+  } else {
+    file.skip(8); // sibling_x, sibling_y
+  }
+
+  let keyframeType = "K000";
+  const keyframes: RwIfpKeyframe[] = [];
+
+  if (keyframesCount > 0) {
+    keyframeType = file.readString(4);
+    file.skip(4); // keyframes_len
+
+    const hasTranslation = keyframeType[2] === "T";
+    const hasScale = keyframeType[3] === "S";
+
+    for (let i = 0; i < keyframesCount; i++) {
+      const qx = file.readFloat();
+      const qy = file.readFloat();
+      const qz = file.readFloat();
+      const qw = file.readFloat();
+
+      let px = 0,
+        py = 0,
+        pz = 0;
+      if (hasTranslation) {
+        px = file.readFloat();
+        py = file.readFloat();
+        pz = file.readFloat();
+      }
+
+      let sx = 1,
+        sy = 1,
+        sz = 1;
+      if (hasScale) {
+        sx = file.readFloat();
+        sy = file.readFloat();
+        sz = file.readFloat();
+      }
+
+      const time = file.readFloat();
+
+      keyframes.push({
+        time,
+        position: { x: px, y: py, z: pz },
+        rotation: { w: qw, x: qx, y: qy, z: qz },
+        scale: { x: sx, y: sy, z: sz },
+      });
+    }
+  }
+
+  return { name, keyframeType, useBoneId, boneId, keyframes };
+}

package/src/ifp/types.ts

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

package/src/index.ts

@@ -1,12 +1,6 @@
-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';
-
-export * from './renderware/common/types';
+export * from "./common/types";
+export * from "./core";
+export * from "./dff";
+export * from "./fxp";
+export * from "./ifp";
+export * from "./txd";

package/src/txd/bitmap-decoder.ts

@@ -0,0 +1,73 @@
+import { bgra555, bgra565, bgra888, bgra1555, bgra4444, bgra8888 } from "../codecs/bitmap";
+import { bc1, bc2, bc3 } from "../codecs/dxt";
+import { D3DFormat, PaletteType, RasterFormat } from "../codecs/formats";
+import { lum8, lum8a8, pal4, pal4NoAlpha, pal8, pal8NoAlpha } from "../codecs/palette";
+
+export function decodePaletteBitmap(
+  paletteType: number,
+  depth: number,
+  hasAlpha: boolean,
+  raster: Uint8Array,
+  palette: Uint8Array,
+  width: number,
+  height: number,
+): Uint8Array {
+  if (paletteType !== PaletteType.PALETTE_8 && depth === 4) {
+    return hasAlpha
+      ? pal4(raster, palette, width, height)
+      : pal4NoAlpha(raster, palette, width, height);
+  }
+  return hasAlpha
+    ? pal8(raster, palette, width, height)
+    : pal8NoAlpha(raster, palette, width, height);
+}
+
+export function decodeDxtBitmap(
+  dxtType: string,
+  raster: Uint8Array,
+  width: number,
+  height: number,
+): Uint8Array {
+  switch (dxtType) {
+    case D3DFormat.D3D_DXT1:
+      return bc1(raster, width, height);
+    case D3DFormat.D3D_DXT2:
+      return bc2(raster, width, height, true);
+    case D3DFormat.D3D_DXT3:
+      return bc2(raster, width, height, false);
+    case D3DFormat.D3D_DXT4:
+      return bc3(raster, width, height, true);
+    case D3DFormat.D3D_DXT5:
+      return bc3(raster, width, height, false);
+    case D3DFormat.D3DFMT_A8L8:
+      return lum8a8(raster, width, height);
+    default:
+      return new Uint8Array(0);
+  }
+}
+
+export function decodeRasterBitmap(
+  rasterFormat: number,
+  raster: Uint8Array,
+  width: number,
+  height: number,
+): Uint8Array {
+  switch (rasterFormat) {
+    case RasterFormat.RASTER_1555:
+      return bgra1555(raster, width, height);
+    case RasterFormat.RASTER_565:
+      return bgra565(raster, width, height);
+    case RasterFormat.RASTER_4444:
+      return bgra4444(raster, width, height);
+    case RasterFormat.RASTER_LUM:
+      return lum8(raster, width, height);
+    case RasterFormat.RASTER_8888:
+      return bgra8888(raster, width, height);
+    case RasterFormat.RASTER_888:
+      return bgra888(raster, width, height);
+    case RasterFormat.RASTER_555:
+      return bgra555(raster, width, height);
+    default:
+      return new Uint8Array(0);
+  }
+}

package/src/txd/index.ts

@@ -0,0 +1,3 @@
+export * from "./bitmap-decoder";
+export * from "./parser";
+export * from "./types";

package/src/txd/parser.ts

@@ -0,0 +1,148 @@
+import { PaletteType, PlatformType, RasterFormat } from "../codecs/formats";
+import { RwFile } from "../core/rw-file";
+import { decodeDxtBitmap, decodePaletteBitmap, decodeRasterBitmap } from "./bitmap-decoder";
+import type { RwTextureDictionary, RwTextureNative, RwTxd } from "./types";
+
+export class TxdParser extends RwFile {
+  parse(): RwTxd {
+    return { textureDictionary: this.readTextureDictionary() };
+  }
+
+  public readTextureDictionary(): RwTextureDictionary {
+    this.readSectionHeader();
+    this.readSectionHeader();
+
+    const textureCount = this.readUint16();
+    this.skip(2);
+
+    const textureNatives: RwTextureNative[] = [];
+    for (let i = 0; i < textureCount; i++) {
+      textureNatives.push(this.readTextureNative());
+    }
+
+    this.skip(this.readSectionHeader().sectionSize);
+
+    return { textureCount, textureNatives };
+  }
+
+  public readTextureNative(): RwTextureNative {
+    this.readSectionHeader();
+    this.readSectionHeader();
+
+    const platformId = this.readUint32();
+    const flags = this.readUint32();
+    const filterMode = flags & 0xff;
+    const uAddressing = (flags & 0xf00) >> 8;
+    const vAddressing = (flags & 0xf000) >> 12;
+
+    const textureName = this.readString(32);
+    const maskName = this.readString(32);
+
+    const rasterFormat = this.readUint32();
+    const d3dFormat = this.readString(4);
+    const width = this.readUint16();
+    const height = this.readUint16();
+    const depth = this.readUint8();
+    const mipmapCount = this.readUint8();
+    const rasterType = this.readUint8();
+    const compressionFlags = this.readUint8();
+
+    const alpha = (compressionFlags & (1 << 0)) !== 0;
+    const cubeTexture = (compressionFlags & (1 << 1)) !== 0;
+    const autoMipMaps = (compressionFlags & (1 << 2)) !== 0;
+    const compressed = (compressionFlags & (1 << 3)) !== 0;
+
+    const paletteType = (rasterFormat >> 13) & 0b11;
+    const pixelFormat = rasterFormat & 0x0f00;
+    const palette =
+      paletteType !== PaletteType.PALETTE_NONE
+        ? this.read(paletteType === PaletteType.PALETTE_8 ? 1024 : depth === 4 ? 64 : 128)
+        : new Uint8Array(0);
+
+    const mipmaps: number[][] = [];
+
+    for (let i = 0; i < mipmapCount; i++) {
+      const rasterSize = this.readUint32();
+      const raster = this.read(rasterSize);
+
+      if (i === 0) {
+        const 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,
+      filterMode,
+      uAddressing,
+      vAddressing,
+      textureName,
+      maskName,
+      rasterFormat,
+      d3dFormat,
+      width,
+      height,
+      depth,
+      mipmapCount,
+      rasterType,
+      alpha,
+      cubeTexture,
+      autoMipMaps,
+      compressed,
+      mipmaps,
+    };
+  }
+
+  private decodeBitmap(
+    platformId: number,
+    compressionFlags: number,
+    compressed: boolean,
+    alpha: boolean,
+    paletteType: number,
+    depth: number,
+    pixelFormat: number,
+    d3dFormat: string,
+    raster: Uint8Array,
+    palette: Uint8Array,
+    width: number,
+    height: number,
+  ): Uint8Array {
+    if (palette.length !== 0) {
+      const noAlphaFormats = [
+        RasterFormat.RASTER_565,
+        RasterFormat.RASTER_LUM,
+        RasterFormat.RASTER_888,
+        RasterFormat.RASTER_555,
+      ];
+      const hasAlpha =
+        (platformId === PlatformType.D3D9 && alpha) ||
+        (platformId === PlatformType.D3D8 && !noAlphaFormats.includes(pixelFormat));
+      return decodePaletteBitmap(paletteType, depth, hasAlpha, raster, palette, width, height);
+    }
+
+    if (platformId === PlatformType.D3D8 && compressionFlags !== 0) {
+      return decodeDxtBitmap(`DXT${compressionFlags}`, raster, width, height);
+    }
+
+    if (platformId === PlatformType.D3D9 && compressed) {
+      return decodeDxtBitmap(d3dFormat, raster, width, height);
+    }
+
+    return decodeRasterBitmap(pixelFormat, raster, width, height);
+  }
+}

package/src/txd/types.ts

@@ -0,0 +1,29 @@
+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/src/renderware/RwFile.ts

@@ -1,26 +0,0 @@
-import { ByteStream } from "../utils/ByteStream";
-
-export interface RwSectionHeader {
-    sectionType: number,
-    sectionSize: number,
-    versionNumber: number
-}
-
-export class RwFile extends ByteStream {
-
-    constructor(stream: Buffer) {
-        super(stream);
-    }
-
-    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/renderware/RwSections.ts

@@ -1,27 +0,0 @@
-export enum RwSections {
-    // Core
-    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,
-    RwSkin = 0x116,  
-    RwAnim = 0x11E,
-
-    // Toolkit
-    RwMaterialEffectsPLG = 0x0120,
-
-    // R* specific RW plugins
-    RwReflectionMaterial = 0x0253F2FC,
-    // This was renamed to RwNodeName from RwFrame to prevent confusion.
-    // https://gtamods.com/wiki/Node_Name_(RW_Section)
-    RwNodeName = 0x0253F2FE,
-}

package/src/renderware/common/types.ts

@@ -1,59 +0,0 @@
-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/renderware/dff/DffModelType.ts

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