rw-parser-ng 2.1.0 → 2.3.0

package/lib/fxp/parser.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFxpContent = parseFxpContent;
+exports.parseFxpFile = parseFxpFile;
+var info_parser_1 = require("./info-parser");
+var INFO_TYPE_MAP = {
+    "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",
+};
+var FxpParserImpl = /** @class */ (function () {
+    function FxpParserImpl() {
+        this._lines = [];
+        this._pos = 0;
+    }
+    FxpParserImpl.prototype.parse = function (content) {
+        this._lines = content.split("\n").map(function (l) { return l.trim(); });
+        this._pos = 0;
+        var systems = new Map();
+        this._expectLine("FX_PROJECT_DATA:");
+        while (this._pos < this._lines.length) {
+            var line = this._currentLine();
+            if (!line) {
+                this._pos++;
+                continue;
+            }
+            if (line === "FX_SYSTEM_DATA:") {
+                this._pos++;
+                this._skipEmpty();
+                var version = parseInt(this._currentLine(), 10);
+                this._pos++;
+                var system = this._parseSystem(version);
+                systems.set(system.name, system);
+            }
+            else {
+                this._pos++;
+            }
+        }
+        return { systems: systems };
+    };
+    FxpParserImpl.prototype._parseSystem = function (version) {
+        var _a, _b;
+        this._skipEmpty();
+        var filename = version > 100 ? this._readField("FILENAME:") : "";
+        var name = this._readField("NAME:");
+        var length = parseFloat(this._readField("LENGTH:"));
+        var loopIntervalMin = 0, loopLength = 0;
+        if (version >= 106) {
+            loopIntervalMin = parseFloat(this._currentLine());
+            this._pos++;
+            loopLength = parseFloat(this._currentLine());
+            this._pos++;
+        }
+        var playMode = parseInt(this._readField("PLAYMODE:"), 10);
+        var cullDist = parseFloat(this._readField("CULLDIST:"));
+        var boundingSphere = null;
+        if (version > 103) {
+            var parts = this._readField("BOUNDINGSPHERE:").split(/\s+/).map(parseFloat);
+            boundingSphere = {
+                x: parts[0],
+                y: parts[1],
+                z: parts[2],
+                radius: parts[3],
+            };
+        }
+        var numPrims = parseInt(this._readField("NUM_PRIMS:"), 10);
+        var prims = [];
+        for (var 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 ((_a = this._currentLine()) === null || _a === void 0 ? void 0 : _a.startsWith("OMITTEXTURES:"))
+                this._pos++;
+        }
+        if (version >= 109) {
+            this._skipEmpty();
+            if ((_b = this._currentLine()) === null || _b === void 0 ? void 0 : _b.startsWith("TXDNAME:"))
+                this._pos++;
+        }
+        return {
+            filename: filename,
+            name: name,
+            length: length,
+            loopIntervalMin: loopIntervalMin,
+            loopLength: loopLength,
+            playMode: playMode,
+            cullDist: cullDist,
+            boundingSphere: boundingSphere,
+            prims: prims,
+        };
+    };
+    FxpParserImpl.prototype._parsePrimEmitter = function (version) {
+        var _a, _b, _c;
+        this._skipEmpty();
+        this._expectLine("FX_PRIM_BASE_DATA:");
+        var name = this._readField("NAME:");
+        var matrix = this._parseMatrix();
+        var textures = [this._readNullableTexture("TEXTURE:")];
+        if (version > 101) {
+            textures.push(this._readNullableTexture("TEXTURE2:"));
+            textures.push(this._readNullableTexture("TEXTURE3:"));
+            textures.push(this._readNullableTexture("TEXTURE4:"));
+        }
+        var alphaOn = this._readField("ALPHAON:") === "1";
+        var srcBlendId = parseInt(this._readField("SRCBLENDID:"), 10);
+        var dstBlendId = parseInt(this._readField("DSTBLENDID:"), 10);
+        var numInfos = parseInt(this._readField("NUM_INFOS:"), 10);
+        var infos = [];
+        for (var i = 0; i < numInfos; i++) {
+            this._skipEmpty();
+            var infoType = this._currentLine();
+            this._pos++;
+            var typeKey = INFO_TYPE_MAP[infoType];
+            if (!typeKey) {
+                this._skipUnknownInfo();
+                continue;
+            }
+            this._skipEmpty();
+            if ((_a = this._currentLine()) === null || _a === void 0 ? void 0 : _a.startsWith("TIMEMODEPRT:"))
+                this._pos++;
+            var interps = typeKey === "underwater" || typeKey === "selflit" ? {} : this._parseAllInterps();
+            var info = (0, info_parser_1.parseInfo)(typeKey, interps);
+            if (info)
+                infos.push(info);
+        }
+        var lodStart = 0, lodEnd = 0;
+        this._skipEmpty();
+        if ((_b = this._currentLine()) === null || _b === void 0 ? void 0 : _b.startsWith("LODSTART:"))
+            lodStart = parseFloat(this._readField("LODSTART:"));
+        this._skipEmpty();
+        if ((_c = this._currentLine()) === null || _c === void 0 ? void 0 : _c.startsWith("LODEND:"))
+            lodEnd = parseFloat(this._readField("LODEND:"));
+        return {
+            name: name,
+            matrix: matrix,
+            textures: textures,
+            alphaOn: alphaOn,
+            srcBlendId: srcBlendId,
+            dstBlendId: dstBlendId,
+            lodStart: lodStart,
+            lodEnd: lodEnd,
+            infos: infos,
+        };
+    };
+    FxpParserImpl.prototype._parseAllInterps = function () {
+        var result = {};
+        while (this._pos < this._lines.length) {
+            this._skipEmpty();
+            var line = this._currentLine();
+            if (this._isBlockEnd(line))
+                break;
+            if (line.endsWith(":") && !line.startsWith("FX_")) {
+                var 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;
+    };
+    FxpParserImpl.prototype._isBlockEnd = function (line) {
+        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:"));
+    };
+    FxpParserImpl.prototype._parseInterpolation = function () {
+        this._expectLine("FX_INTERP_DATA:");
+        var looped = this._readField("LOOPED:") === "1";
+        var numKeys = parseInt(this._readField("NUM_KEYS:"), 10);
+        var keys = [];
+        for (var i = 0; i < numKeys; i++) {
+            this._expectLine("FX_KEYFLOAT_DATA:");
+            keys.push({
+                time: parseFloat(this._readField("TIME:")),
+                value: parseFloat(this._readField("VAL:")),
+            });
+        }
+        return { looped: looped, keys: keys };
+    };
+    FxpParserImpl.prototype._parseMatrix = function () {
+        this._skipEmpty();
+        var line = this._currentLine();
+        if (!(line === null || line === void 0 ? void 0 : 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 },
+            };
+        }
+        var 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] },
+        };
+    };
+    FxpParserImpl.prototype._skipUnknownInfo = function () {
+        while (this._pos < this._lines.length && !this._isBlockEnd(this._currentLine()))
+            this._pos++;
+    };
+    FxpParserImpl.prototype._readField = function (prefix) {
+        this._skipEmpty();
+        var line = this._currentLine();
+        if (!(line === null || line === void 0 ? void 0 : line.startsWith(prefix)))
+            return "";
+        this._pos++;
+        return line.slice(prefix.length).trim();
+    };
+    FxpParserImpl.prototype._readNullableTexture = function (prefix) {
+        var val = this._readField(prefix);
+        return val === "NULL" || val === "" ? null : val;
+    };
+    FxpParserImpl.prototype._expectLine = function (expected) {
+        this._skipEmpty();
+        if (this._currentLine() === expected)
+            this._pos++;
+    };
+    FxpParserImpl.prototype._skipEmpty = function () {
+        while (this._pos < this._lines.length && this._lines[this._pos].trim() === "")
+            this._pos++;
+    };
+    FxpParserImpl.prototype._currentLine = function () {
+        var _a;
+        return (_a = this._lines[this._pos]) !== null && _a !== void 0 ? _a : "";
+    };
+    return FxpParserImpl;
+}());
+function parseFxpContent(content) {
+    return new FxpParserImpl().parse(content);
+}
+function parseFxpFile(filePath) {
+    var fs = require("node:fs");
+    return parseFxpContent(fs.readFileSync(filePath, "utf-8"));
+}

package/lib/fxp/types/common.d.ts

@@ -0,0 +1,36 @@
+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/lib/fxp/types/common.js

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

package/lib/fxp/types/index.d.ts

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

package/lib/fxp/types/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./common"), exports);
+__exportStar(require("./info"), exports);
+__exportStar(require("./system"), exports);

package/lib/fxp/types/info.d.ts

@@ -0,0 +1,186 @@
+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/lib/fxp/types/info.js

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

package/lib/fxp/types/system.d.ts

@@ -0,0 +1,27 @@
+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/lib/fxp/types/system.js

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

package/lib/ifp/index.d.ts

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

package/lib/ifp/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./parser"), exports);
+__exportStar(require("./readers/anp3"), exports);
+__exportStar(require("./readers/anpk"), exports);
+__exportStar(require("./types"), exports);

package/lib/ifp/parser.d.ts

@@ -0,0 +1,5 @@
+import { RwFile } from "../core/rw-file";
+import type { RwIfp } from "./types";
+export declare class IfpParser extends RwFile {
+    parse(): RwIfp;
+}

package/lib/ifp/parser.js

@@ -0,0 +1,38 @@
+"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.IfpParser = void 0;
+var rw_file_1 = require("../core/rw-file");
+var anp3_1 = require("./readers/anp3");
+var anpk_1 = require("./readers/anpk");
+var IfpParser = /** @class */ (function (_super) {
+    __extends(IfpParser, _super);
+    function IfpParser() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    IfpParser.prototype.parse = function () {
+        var signature = this.readString(4);
+        this.setPosition(0);
+        if (signature === "ANP3")
+            return (0, anp3_1.readAnp3)(this);
+        if (signature === "ANPK")
+            return (0, anpk_1.readAnpk)(this);
+        throw new Error("Unsupported IFP version");
+    };
+    return IfpParser;
+}(rw_file_1.RwFile));
+exports.IfpParser = IfpParser;

package/lib/ifp/readers/anp3.d.ts

@@ -0,0 +1,3 @@
+import type { RwFile } from "../../core/rw-file";
+import { type RwIfp } from "../types";
+export declare function readAnp3(file: RwFile): RwIfp;