rw-parser-ng 2.1.0 → 2.3.0

package/src/fxp/parser.ts

@@ -0,0 +1,323 @@
+import { parseInfo } from "./info-parser";
+import type {
+  FxBoundingSphere,
+  FxEmitterBP,
+  FxInfo,
+  FxInterpData,
+  FxKeyframe,
+  FxMatrix,
+  FxProject,
+  FxSystemBP,
+} from "./types";
+
+const INFO_TYPE_MAP: Record<string, string> = {
+  "FX_INFO_EMRATE_DATA:": "emrate",
+  "FX_INFO_EMSIZE_DATA:": "emsize",
+  "FX_INFO_EMSPEED_DATA:": "emspeed",
+  "FX_INFO_EMDIR_DATA:": "emdir",
+  "FX_INFO_EMANGLE_DATA:": "emangle",
+  "FX_INFO_EMLIFE_DATA:": "emlife",
+  "FX_INFO_EMPOS_DATA:": "empos",
+  "FX_INFO_EMWEATHER_DATA:": "emweather",
+  "FX_INFO_EMROTATION_DATA:": "emrotation",
+  "FX_INFO_NOISE_DATA:": "noise",
+  "FX_INFO_FORCE_DATA:": "force",
+  "FX_INFO_FRICTION_DATA:": "friction",
+  "FX_INFO_ATTRACTPT_DATA:": "attractpt",
+  "FX_INFO_ATTRACTLINE_DATA:": "attractline",
+  "FX_INFO_GROUNDCOLLIDE_DATA:": "groundcollide",
+  "FX_INFO_WIND_DATA:": "wind",
+  "FX_INFO_JITTER_DATA:": "jitter",
+  "FX_INFO_ROTSPEED_DATA:": "rotspeed",
+  "FX_INFO_FLOAT_DATA:": "float",
+  "FX_INFO_UNDERWATER_DATA:": "underwater",
+  "FX_INFO_COLOUR_DATA:": "colour",
+  "FX_INFO_SIZE_DATA:": "size",
+  "FX_INFO_SPRITERECT_DATA:": "spriterect",
+  "FX_INFO_HEATHAZE_DATA:": "heathaze",
+  "FX_INFO_TRAIL_DATA:": "trail",
+  "FX_INFO_FLAT_DATA:": "flat",
+  "FX_INFO_DIR_DATA:": "dir",
+  "FX_INFO_ANIMTEX_DATA:": "animtex",
+  "FX_INFO_COLOURRANGE_DATA:": "colourrange",
+  "FX_INFO_SELFLIT_DATA:": "selflit",
+  "FX_INFO_COLOURBRIGHT_DATA:": "colourbright",
+  "FX_INFO_SMOKE_DATA:": "smoke",
+};
+
+class FxpParserImpl {
+  private _lines: string[] = [];
+  private _pos = 0;
+
+  parse(content: string): FxProject {
+    this._lines = content.split("\n").map((l) => l.trim());
+    this._pos = 0;
+
+    const systems = new Map<string, FxSystemBP>();
+    this._expectLine("FX_PROJECT_DATA:");
+
+    while (this._pos < this._lines.length) {
+      const line = this._currentLine();
+      if (!line) {
+        this._pos++;
+        continue;
+      }
+
+      if (line === "FX_SYSTEM_DATA:") {
+        this._pos++;
+        this._skipEmpty();
+        const version = parseInt(this._currentLine(), 10);
+        this._pos++;
+        const system = this._parseSystem(version);
+        systems.set(system.name, system);
+      } else {
+        this._pos++;
+      }
+    }
+
+    return { systems };
+  }
+
+  private _parseSystem(version: number): FxSystemBP {
+    this._skipEmpty();
+
+    const filename = version > 100 ? this._readField("FILENAME:") : "";
+    const name = this._readField("NAME:");
+    const length = parseFloat(this._readField("LENGTH:"));
+
+    let loopIntervalMin = 0,
+      loopLength = 0;
+    if (version >= 106) {
+      loopIntervalMin = parseFloat(this._currentLine());
+      this._pos++;
+      loopLength = parseFloat(this._currentLine());
+      this._pos++;
+    }
+
+    const playMode = parseInt(this._readField("PLAYMODE:"), 10);
+    const cullDist = parseFloat(this._readField("CULLDIST:"));
+
+    let boundingSphere: FxBoundingSphere | null = null;
+    if (version > 103) {
+      const parts = this._readField("BOUNDINGSPHERE:").split(/\s+/).map(parseFloat);
+      boundingSphere = {
+        x: parts[0],
+        y: parts[1],
+        z: parts[2],
+        radius: parts[3],
+      };
+    }
+
+    const numPrims = parseInt(this._readField("NUM_PRIMS:"), 10);
+    const prims: FxEmitterBP[] = [];
+
+    for (let i = 0; i < numPrims; i++) {
+      this._skipEmpty();
+      if (this._currentLine() === "FX_PRIM_EMITTER_DATA:") {
+        this._pos++;
+        prims.push(this._parsePrimEmitter(version));
+      } else {
+        this._pos++;
+        i--;
+      }
+    }
+
+    if (version >= 108) {
+      this._skipEmpty();
+      if (this._currentLine()?.startsWith("OMITTEXTURES:")) this._pos++;
+    }
+    if (version >= 109) {
+      this._skipEmpty();
+      if (this._currentLine()?.startsWith("TXDNAME:")) this._pos++;
+    }
+
+    return {
+      filename,
+      name,
+      length,
+      loopIntervalMin,
+      loopLength,
+      playMode,
+      cullDist,
+      boundingSphere,
+      prims,
+    };
+  }
+
+  private _parsePrimEmitter(version: number): FxEmitterBP {
+    this._skipEmpty();
+    this._expectLine("FX_PRIM_BASE_DATA:");
+
+    const name = this._readField("NAME:");
+    const matrix = this._parseMatrix();
+
+    const textures: (string | null)[] = [this._readNullableTexture("TEXTURE:")];
+    if (version > 101) {
+      textures.push(this._readNullableTexture("TEXTURE2:"));
+      textures.push(this._readNullableTexture("TEXTURE3:"));
+      textures.push(this._readNullableTexture("TEXTURE4:"));
+    }
+
+    const alphaOn = this._readField("ALPHAON:") === "1";
+    const srcBlendId = parseInt(this._readField("SRCBLENDID:"), 10);
+    const dstBlendId = parseInt(this._readField("DSTBLENDID:"), 10);
+
+    const numInfos = parseInt(this._readField("NUM_INFOS:"), 10);
+    const infos: FxInfo[] = [];
+
+    for (let i = 0; i < numInfos; i++) {
+      this._skipEmpty();
+      const infoType = this._currentLine();
+      this._pos++;
+
+      const typeKey = INFO_TYPE_MAP[infoType];
+      if (!typeKey) {
+        this._skipUnknownInfo();
+        continue;
+      }
+
+      this._skipEmpty();
+      if (this._currentLine()?.startsWith("TIMEMODEPRT:")) this._pos++;
+
+      const interps =
+        typeKey === "underwater" || typeKey === "selflit" ? {} : this._parseAllInterps();
+      const info = parseInfo(typeKey, interps);
+      if (info) infos.push(info);
+    }
+
+    let lodStart = 0,
+      lodEnd = 0;
+    this._skipEmpty();
+    if (this._currentLine()?.startsWith("LODSTART:"))
+      lodStart = parseFloat(this._readField("LODSTART:"));
+    this._skipEmpty();
+    if (this._currentLine()?.startsWith("LODEND:")) lodEnd = parseFloat(this._readField("LODEND:"));
+
+    return {
+      name,
+      matrix,
+      textures,
+      alphaOn,
+      srcBlendId,
+      dstBlendId,
+      lodStart,
+      lodEnd,
+      infos,
+    };
+  }
+
+  private _parseAllInterps(): Record<string, FxInterpData> {
+    const result: Record<string, FxInterpData> = {};
+
+    while (this._pos < this._lines.length) {
+      this._skipEmpty();
+      const line = this._currentLine();
+      if (this._isBlockEnd(line)) break;
+
+      if (line.endsWith(":") && !line.startsWith("FX_")) {
+        const fieldName = line.slice(0, -1).toUpperCase();
+        this._pos++;
+        this._skipEmpty();
+        if (this._currentLine() === "FX_INTERP_DATA:") {
+          result[fieldName] = this._parseInterpolation();
+        }
+      } else {
+        this._pos++;
+      }
+    }
+
+    return result;
+  }
+
+  private _isBlockEnd(line: string): boolean {
+    return (
+      !line ||
+      line.startsWith("FX_INFO_") ||
+      line.startsWith("LODSTART:") ||
+      line.startsWith("LODEND:") ||
+      line.startsWith("FX_PRIM_") ||
+      line.startsWith("FX_SYSTEM_DATA:") ||
+      line.startsWith("OMITTEXTURES:") ||
+      line.startsWith("TXDNAME:")
+    );
+  }
+
+  private _parseInterpolation(): FxInterpData {
+    this._expectLine("FX_INTERP_DATA:");
+    const looped = this._readField("LOOPED:") === "1";
+    const numKeys = parseInt(this._readField("NUM_KEYS:"), 10);
+
+    const keys: FxKeyframe[] = [];
+    for (let i = 0; i < numKeys; i++) {
+      this._expectLine("FX_KEYFLOAT_DATA:");
+      keys.push({
+        time: parseFloat(this._readField("TIME:")),
+        value: parseFloat(this._readField("VAL:")),
+      });
+    }
+
+    return { looped, keys };
+  }
+
+  private _parseMatrix(): FxMatrix {
+    this._skipEmpty();
+    const line = this._currentLine();
+    if (!line?.startsWith("MATRIX:")) {
+      return {
+        right: { x: 1, y: 0, z: 0 },
+        up: { x: 0, y: 1, z: 0 },
+        at: { x: 0, y: 0, z: 1 },
+        pos: { x: 0, y: 0, z: 0 },
+      };
+    }
+
+    const p = line.slice(7).trim().split(/\s+/).map(parseFloat);
+    this._pos++;
+
+    return {
+      right: { x: p[0], y: p[1], z: p[2] },
+      up: { x: p[3], y: p[4], z: p[5] },
+      at: { x: p[6], y: p[7], z: p[8] },
+      pos: { x: p[9], y: p[10], z: p[11] },
+    };
+  }
+
+  private _skipUnknownInfo(): void {
+    while (this._pos < this._lines.length && !this._isBlockEnd(this._currentLine())) this._pos++;
+  }
+
+  private _readField(prefix: string): string {
+    this._skipEmpty();
+    const line = this._currentLine();
+    if (!line?.startsWith(prefix)) return "";
+    this._pos++;
+    return line.slice(prefix.length).trim();
+  }
+
+  private _readNullableTexture(prefix: string): string | null {
+    const val = this._readField(prefix);
+    return val === "NULL" || val === "" ? null : val;
+  }
+
+  private _expectLine(expected: string): void {
+    this._skipEmpty();
+    if (this._currentLine() === expected) this._pos++;
+  }
+
+  private _skipEmpty(): void {
+    while (this._pos < this._lines.length && this._lines[this._pos].trim() === "") this._pos++;
+  }
+
+  private _currentLine(): string {
+    return this._lines[this._pos] ?? "";
+  }
+}
+
+export function parseFxpContent(content: string): FxProject {
+  return new FxpParserImpl().parse(content);
+}
+
+export function parseFxpFile(filePath: string): FxProject {
+  const fs = require("node:fs");
+  return parseFxpContent(fs.readFileSync(filePath, "utf-8"));
+}

package/src/fxp/types/common.ts

@@ -0,0 +1,23 @@
+export interface FxKeyframe {
+  time: number;
+  value: number;
+}
+
+export interface FxInterpData {
+  looped: boolean;
+  keys: FxKeyframe[];
+}
+
+export interface FxMatrix {
+  right: { x: number; y: number; z: number };
+  up: { x: number; y: number; z: number };
+  at: { x: number; y: number; z: number };
+  pos: { x: number; y: number; z: number };
+}
+
+export interface FxBoundingSphere {
+  x: number;
+  y: number;
+  z: number;
+  radius: number;
+}

package/src/fxp/types/index.ts

@@ -0,0 +1,3 @@
+export * from "./common";
+export * from "./info";
+export * from "./system";

package/src/fxp/types/info.ts

@@ -0,0 +1,251 @@
+import type { FxInterpData } from "./common";
+
+export interface FxInfoEmRate {
+  type: "emrate";
+  rate: FxInterpData;
+}
+
+export interface FxInfoEmSize {
+  type: "emsize";
+  radius: FxInterpData;
+  sizeMinX: FxInterpData;
+  sizeMaxX: FxInterpData;
+  sizeMinY: FxInterpData;
+  sizeMaxY: FxInterpData;
+  sizeMinZ: FxInterpData;
+  sizeMaxZ: FxInterpData;
+}
+
+export interface FxInfoEmSpeed {
+  type: "emspeed";
+  speed: FxInterpData;
+  bias: FxInterpData;
+}
+
+export interface FxInfoEmDir {
+  type: "emdir";
+  dirX: FxInterpData;
+  dirY: FxInterpData;
+  dirZ: FxInterpData;
+}
+
+export interface FxInfoEmAngle {
+  type: "emangle";
+  min: FxInterpData;
+  max: FxInterpData;
+}
+
+export interface FxInfoEmLife {
+  type: "emlife";
+  life: FxInterpData;
+  bias: FxInterpData;
+}
+
+export interface FxInfoEmPos {
+  type: "empos";
+  x: FxInterpData;
+  y: FxInterpData;
+  z: FxInterpData;
+}
+
+export interface FxInfoEmWeather {
+  type: "emweather";
+  interp: FxInterpData;
+}
+
+export interface FxInfoEmRotation {
+  type: "emrotation";
+  min: FxInterpData;
+  max: FxInterpData;
+}
+
+export interface FxInfoNoise {
+  type: "noise";
+  x: FxInterpData;
+  y: FxInterpData;
+  z: FxInterpData;
+}
+
+export interface FxInfoForce {
+  type: "force";
+  forceX: FxInterpData;
+  forceY: FxInterpData;
+  forceZ: FxInterpData;
+}
+
+export interface FxInfoFriction {
+  type: "friction";
+  friction: FxInterpData;
+}
+
+export interface FxInfoAttractPt {
+  type: "attractpt";
+  x: FxInterpData;
+  y: FxInterpData;
+  z: FxInterpData;
+  power: FxInterpData;
+}
+
+export interface FxInfoAttractLine {
+  type: "attractline";
+  x1: FxInterpData;
+  y1: FxInterpData;
+  z1: FxInterpData;
+  x2: FxInterpData;
+  y2: FxInterpData;
+  z2: FxInterpData;
+  power: FxInterpData;
+}
+
+export interface FxInfoGroundCollide {
+  type: "groundcollide";
+  damping: FxInterpData;
+  bounce: FxInterpData;
+}
+
+export interface FxInfoWind {
+  type: "wind";
+  interp: FxInterpData;
+}
+
+export interface FxInfoJitter {
+  type: "jitter";
+  x: FxInterpData;
+  y: FxInterpData;
+  z: FxInterpData;
+}
+
+export interface FxInfoRotSpeed {
+  type: "rotspeed";
+  speed: FxInterpData;
+  speedBias: FxInterpData;
+  accel: FxInterpData;
+  accelBias: FxInterpData;
+}
+
+export interface FxInfoFloat {
+  type: "float";
+  interp: FxInterpData;
+}
+
+export interface FxInfoUnderwater {
+  type: "underwater";
+}
+
+export interface FxInfoColour {
+  type: "colour";
+  red: FxInterpData;
+  green: FxInterpData;
+  blue: FxInterpData;
+  alpha: FxInterpData;
+}
+
+export interface FxInfoSize {
+  type: "size";
+  sizeX: FxInterpData;
+  sizeY: FxInterpData;
+  sizeXBias: FxInterpData;
+  sizeYBias: FxInterpData;
+}
+
+export interface FxInfoSpriteRect {
+  type: "spriterect";
+  interps: FxInterpData[];
+}
+
+export interface FxInfoHeatHaze {
+  type: "heathaze";
+  interps: FxInterpData[];
+}
+
+export interface FxInfoTrail {
+  type: "trail";
+  interps: FxInterpData[];
+}
+
+export interface FxInfoFlat {
+  type: "flat";
+  rightX: FxInterpData;
+  rightY: FxInterpData;
+  rightZ: FxInterpData;
+  upX: FxInterpData;
+  upY: FxInterpData;
+  upZ: FxInterpData;
+  atX: FxInterpData;
+  atY: FxInterpData;
+  atZ: FxInterpData;
+}
+
+export interface FxInfoDir {
+  type: "dir";
+  interps: FxInterpData[];
+}
+
+export interface FxInfoAnimTexture {
+  type: "animtex";
+  interps: FxInterpData[];
+}
+
+export interface FxInfoColourRange {
+  type: "colourrange";
+  redMin: FxInterpData;
+  redMax: FxInterpData;
+  greenMin: FxInterpData;
+  greenMax: FxInterpData;
+  blueMin: FxInterpData;
+  blueMax: FxInterpData;
+  alphaMin: FxInterpData;
+  alphaMax: FxInterpData;
+}
+
+export interface FxInfoSelfLit {
+  type: "selflit";
+}
+
+export interface FxInfoColourBright {
+  type: "colourbright";
+  red: FxInterpData;
+  green: FxInterpData;
+  blue: FxInterpData;
+  alpha: FxInterpData;
+  brightness: FxInterpData;
+}
+
+export interface FxInfoSmoke {
+  type: "smoke";
+  interps: FxInterpData[];
+}
+
+export type FxInfo =
+  | FxInfoEmRate
+  | FxInfoEmSize
+  | FxInfoEmSpeed
+  | FxInfoEmDir
+  | FxInfoEmAngle
+  | FxInfoEmLife
+  | FxInfoEmPos
+  | FxInfoEmWeather
+  | FxInfoEmRotation
+  | FxInfoNoise
+  | FxInfoForce
+  | FxInfoFriction
+  | FxInfoAttractPt
+  | FxInfoAttractLine
+  | FxInfoGroundCollide
+  | FxInfoWind
+  | FxInfoJitter
+  | FxInfoRotSpeed
+  | FxInfoFloat
+  | FxInfoUnderwater
+  | FxInfoColour
+  | FxInfoSize
+  | FxInfoSpriteRect
+  | FxInfoHeatHaze
+  | FxInfoTrail
+  | FxInfoFlat
+  | FxInfoDir
+  | FxInfoAnimTexture
+  | FxInfoColourRange
+  | FxInfoSelfLit
+  | FxInfoColourBright
+  | FxInfoSmoke;

package/src/fxp/types/system.ts

@@ -0,0 +1,30 @@
+import type { FxBoundingSphere, FxMatrix } from "./common";
+import type { FxInfo } from "./info";
+
+export interface FxEmitterBP {
+  name: string;
+  matrix: FxMatrix;
+  textures: (string | null)[];
+  alphaOn: boolean;
+  srcBlendId: number;
+  dstBlendId: number;
+  lodStart: number;
+  lodEnd: number;
+  infos: FxInfo[];
+}
+
+export interface FxSystemBP {
+  filename: string;
+  name: string;
+  length: number;
+  loopIntervalMin: number;
+  loopLength: number;
+  playMode: number;
+  cullDist: number;
+  boundingSphere: FxBoundingSphere | null;
+  prims: FxEmitterBP[];
+}
+
+export interface FxProject {
+  systems: Map<string, FxSystemBP>;
+}

package/src/ifp/index.ts

@@ -0,0 +1,4 @@
+export * from "./parser";
+export * from "./readers/anp3";
+export * from "./readers/anpk";
+export * from "./types";

package/src/ifp/parser.ts

@@ -0,0 +1,16 @@
+import { RwFile } from "../core/rw-file";
+import { readAnp3 } from "./readers/anp3";
+import { readAnpk } from "./readers/anpk";
+import type { RwIfp } from "./types";
+
+export class IfpParser extends RwFile {
+  public parse(): RwIfp {
+    const signature = this.readString(4);
+    this.setPosition(0);
+
+    if (signature === "ANP3") return readAnp3(this);
+    if (signature === "ANPK") return readAnpk(this);
+
+    throw new Error("Unsupported IFP version");
+  }
+}