rw-parser-ng 2.1.0 → 2.3.0

package/lib/dff/types.d.ts

@@ -0,0 +1,237 @@
+import type { RwColor, RwMatrix3, RwMatrix4, RwSphere, RwTextureCoordinate, RwTriangle, RwVector2, RwVector3 } from "../common/types";
+import type { DffModelType } from "./dff-model-type";
+export interface RwDff {
+    modelType: DffModelType;
+    version: string;
+    versionNumber: number;
+    geometryList: RwGeometryList | null;
+    frameList: RwFrameList | null;
+    atomics: number[];
+    dummies: string[];
+    animNodes: RwAnimNode[];
+}
+export interface RwClump {
+    atomicCount: number;
+    lightCount?: number;
+    cameraCount?: number;
+}
+export interface RwAnimNode {
+    boneId: number;
+    bonesCount: number;
+    bones: RwBone[];
+}
+export interface RwBone {
+    boneId: number;
+    boneIndex: number;
+    flags: number;
+}
+export interface RwFrame {
+    rotationMatrix: RwMatrix3;
+    coordinatesOffset: RwVector3;
+    parentFrame: number;
+}
+export interface RwFrameList {
+    frameCount: number;
+    frames: RwFrame[];
+}
+export interface RwTexture {
+    textureFiltering: number;
+    uAddressing: number;
+    vAddressing: number;
+    usesMipLevels: boolean;
+    textureName: string;
+}
+export interface RwMaterial {
+    color: RwColor;
+    isTextured: boolean;
+    ambient?: number;
+    specular?: number;
+    diffuse?: number;
+    texture?: RwTexture;
+}
+export interface RwMaterialList {
+    materialInstanceCount: number;
+    materialData: RwMaterial[];
+}
+export interface RwGeometry {
+    vertexColorInformation: RwColor[];
+    textureCoordinatesCount: number;
+    textureMappingInformation: RwTextureCoordinate[][];
+    hasVertices: boolean;
+    hasNormals: boolean;
+    isTriangleStrip: boolean;
+    triangleInformation: RwTriangle[];
+    vertexInformation: RwVector3[];
+    normalInformation: RwVector3[];
+    boundingSphere?: RwSphere;
+    materialList: RwMaterialList;
+    binMesh?: RwBinMesh;
+    skin?: RwSkin;
+    effects2d?: Rw2dEffect[];
+    extraVertColour?: RwColor[];
+    breakable?: RwBreakable;
+}
+export interface RwBreakable {
+    positionRule: number;
+    vertices: RwVector3[];
+    texCoords: RwTextureCoordinate[];
+    colors: RwColor[];
+    triangles: {
+        a: number;
+        b: number;
+        c: number;
+    }[];
+    triangleMaterialIndices: number[];
+    materials: RwBreakableMaterial[];
+}
+export interface RwBreakableMaterial {
+    textureName: string;
+    maskName: string;
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+}
+export interface RwGeometryList {
+    geometricObjectCount: number;
+    geometries: RwGeometry[];
+}
+export interface RwAtomic {
+    frameIndex: number;
+    geometryIndex: number;
+    flags: number;
+}
+export interface RwBinMesh {
+    meshCount: number;
+    meshes: RwMesh[];
+}
+export interface RwSkin {
+    boneCount: number;
+    usedBoneCount: number;
+    maxWeightsPerVertex: number;
+    boneVertexIndices: number[][];
+    vertexWeights: number[][];
+    inverseBoneMatrices: RwMatrix4[];
+}
+export interface RwMesh {
+    materialIndex: number;
+    indexCount: number;
+    indices: number[];
+}
+export declare enum Rw2dEffectType {
+    LIGHT = 0,
+    PARTICLE = 1,
+    ATTRACTOR = 3,
+    SUN_GLARE = 4,
+    INTERIOR = 5,
+    ENEX = 6,
+    ROADSIGN = 7,
+    TRIGGER_POINT = 8,
+    COVER_POINT = 9,
+    ESCALATOR = 10
+}
+export declare enum Rw2dCoronaFlashType {
+    DEFAULT = 0,
+    RANDOM = 1,
+    RANDOM_WHEN_WET = 2,
+    ANIM_SPEED_4X = 3,
+    ANIM_SPEED_2X = 4,
+    ANIM_SPEED_1X = 5,
+    TRAFFICLIGHT = 7,
+    TRAINCROSSING = 8,
+    ONLY_RAIN = 10,
+    FIVE_ON_FIVE_OFF = 11,
+    SIX_ON_FOUR_OFF = 12,
+    FOUR_ON_SIX_OFF = 13
+}
+export declare enum RwPedAttractorType {
+    ATM = 0,
+    SEAT = 1,
+    STOP = 2,
+    PIZZA = 3,
+    SHELTER = 4,
+    TRIGGER_SCRIPT = 5,
+    LOOK_AT = 6,
+    SCRIPTED = 7,
+    PARK = 8,
+    STEP = 9
+}
+export interface Rw2dEffectLight {
+    type: Rw2dEffectType.LIGHT;
+    position: RwVector3;
+    color: RwColor;
+    coronaFarClip: number;
+    pointlightRange: number;
+    coronaSize: number;
+    shadowSize: number;
+    coronaShowMode: number;
+    coronaEnableReflection: boolean;
+    coronaFlareType: number;
+    shadowColorMultiplier: number;
+    flags1: number;
+    coronaTexName: string;
+    shadowTexName: string;
+    shadowZDistance: number;
+    flags2: number;
+}
+export interface Rw2dEffectParticle {
+    type: Rw2dEffectType.PARTICLE;
+    position: RwVector3;
+    effectName: string;
+}
+export interface Rw2dEffectAttractor {
+    type: Rw2dEffectType.ATTRACTOR;
+    position: RwVector3;
+    queueDir: RwVector3;
+    useDir: RwVector3;
+    forwardDir: RwVector3;
+    attractorType: RwPedAttractorType;
+    pedExistingProbability: number;
+    flags: number;
+    scriptName: string;
+}
+export interface Rw2dEffectEnEx {
+    type: Rw2dEffectType.ENEX;
+    position: RwVector3;
+    enterAngle: number;
+    radiusX: number;
+    radiusY: number;
+    exitPos: RwVector3;
+    exitAngle: number;
+    interiorId: number;
+    flags1: number;
+    skyColor: number;
+    interiorName: string;
+    timeOn: number;
+    timeOff: number;
+    flags2: number;
+}
+export interface Rw2dEffectRoadsign {
+    type: Rw2dEffectType.ROADSIGN;
+    position: RwVector3;
+    size: RwVector2;
+    rotation: RwVector3;
+    flags: number;
+    text: string;
+}
+export interface Rw2dEffectCoverPoint {
+    type: Rw2dEffectType.COVER_POINT;
+    position: RwVector3;
+    coverDir: RwVector2;
+    usage: number;
+}
+export interface Rw2dEffectEscalator {
+    type: Rw2dEffectType.ESCALATOR;
+    position: RwVector3;
+    bottom: RwVector3;
+    top: RwVector3;
+    end: RwVector3;
+    direction: number;
+}
+export interface Rw2dEffectGeneric {
+    type: Rw2dEffectType.SUN_GLARE | Rw2dEffectType.INTERIOR | Rw2dEffectType.TRIGGER_POINT;
+    position: RwVector3;
+    data: Uint8Array;
+}
+export type Rw2dEffect = Rw2dEffectLight | Rw2dEffectParticle | Rw2dEffectAttractor | Rw2dEffectEnEx | Rw2dEffectRoadsign | Rw2dEffectCoverPoint | Rw2dEffectEscalator | Rw2dEffectGeneric;

package/lib/dff/types.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RwPedAttractorType = exports.Rw2dCoronaFlashType = exports.Rw2dEffectType = void 0;
+var Rw2dEffectType;
+(function (Rw2dEffectType) {
+    Rw2dEffectType[Rw2dEffectType["LIGHT"] = 0] = "LIGHT";
+    Rw2dEffectType[Rw2dEffectType["PARTICLE"] = 1] = "PARTICLE";
+    Rw2dEffectType[Rw2dEffectType["ATTRACTOR"] = 3] = "ATTRACTOR";
+    Rw2dEffectType[Rw2dEffectType["SUN_GLARE"] = 4] = "SUN_GLARE";
+    Rw2dEffectType[Rw2dEffectType["INTERIOR"] = 5] = "INTERIOR";
+    Rw2dEffectType[Rw2dEffectType["ENEX"] = 6] = "ENEX";
+    Rw2dEffectType[Rw2dEffectType["ROADSIGN"] = 7] = "ROADSIGN";
+    Rw2dEffectType[Rw2dEffectType["TRIGGER_POINT"] = 8] = "TRIGGER_POINT";
+    Rw2dEffectType[Rw2dEffectType["COVER_POINT"] = 9] = "COVER_POINT";
+    Rw2dEffectType[Rw2dEffectType["ESCALATOR"] = 10] = "ESCALATOR";
+})(Rw2dEffectType || (exports.Rw2dEffectType = Rw2dEffectType = {}));
+var Rw2dCoronaFlashType;
+(function (Rw2dCoronaFlashType) {
+    Rw2dCoronaFlashType[Rw2dCoronaFlashType["DEFAULT"] = 0] = "DEFAULT";
+    Rw2dCoronaFlashType[Rw2dCoronaFlashType["RANDOM"] = 1] = "RANDOM";
+    Rw2dCoronaFlashType[Rw2dCoronaFlashType["RANDOM_WHEN_WET"] = 2] = "RANDOM_WHEN_WET";
+    Rw2dCoronaFlashType[Rw2dCoronaFlashType["ANIM_SPEED_4X"] = 3] = "ANIM_SPEED_4X";
+    Rw2dCoronaFlashType[Rw2dCoronaFlashType["ANIM_SPEED_2X"] = 4] = "ANIM_SPEED_2X";
+    Rw2dCoronaFlashType[Rw2dCoronaFlashType["ANIM_SPEED_1X"] = 5] = "ANIM_SPEED_1X";
+    Rw2dCoronaFlashType[Rw2dCoronaFlashType["TRAFFICLIGHT"] = 7] = "TRAFFICLIGHT";
+    Rw2dCoronaFlashType[Rw2dCoronaFlashType["TRAINCROSSING"] = 8] = "TRAINCROSSING";
+    Rw2dCoronaFlashType[Rw2dCoronaFlashType["ONLY_RAIN"] = 10] = "ONLY_RAIN";
+    Rw2dCoronaFlashType[Rw2dCoronaFlashType["FIVE_ON_FIVE_OFF"] = 11] = "FIVE_ON_FIVE_OFF";
+    Rw2dCoronaFlashType[Rw2dCoronaFlashType["SIX_ON_FOUR_OFF"] = 12] = "SIX_ON_FOUR_OFF";
+    Rw2dCoronaFlashType[Rw2dCoronaFlashType["FOUR_ON_SIX_OFF"] = 13] = "FOUR_ON_SIX_OFF";
+})(Rw2dCoronaFlashType || (exports.Rw2dCoronaFlashType = Rw2dCoronaFlashType = {}));
+var RwPedAttractorType;
+(function (RwPedAttractorType) {
+    RwPedAttractorType[RwPedAttractorType["ATM"] = 0] = "ATM";
+    RwPedAttractorType[RwPedAttractorType["SEAT"] = 1] = "SEAT";
+    RwPedAttractorType[RwPedAttractorType["STOP"] = 2] = "STOP";
+    RwPedAttractorType[RwPedAttractorType["PIZZA"] = 3] = "PIZZA";
+    RwPedAttractorType[RwPedAttractorType["SHELTER"] = 4] = "SHELTER";
+    RwPedAttractorType[RwPedAttractorType["TRIGGER_SCRIPT"] = 5] = "TRIGGER_SCRIPT";
+    RwPedAttractorType[RwPedAttractorType["LOOK_AT"] = 6] = "LOOK_AT";
+    RwPedAttractorType[RwPedAttractorType["SCRIPTED"] = 7] = "SCRIPTED";
+    RwPedAttractorType[RwPedAttractorType["PARK"] = 8] = "PARK";
+    RwPedAttractorType[RwPedAttractorType["STEP"] = 9] = "STEP";
+})(RwPedAttractorType || (exports.RwPedAttractorType = RwPedAttractorType = {}));

package/lib/fxp/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./parser";
+export * from "./types";

package/lib/fxp/index.js

@@ -0,0 +1,18 @@
+"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("./types"), exports);

package/lib/fxp/info-parser.d.ts

@@ -0,0 +1,2 @@
+import type { FxInfo, FxInterpData } from "./types";
+export declare function parseInfo(typeKey: string, interps: Record<string, FxInterpData>): FxInfo | null;

package/lib/fxp/info-parser.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInfo = parseInfo;
+var DEFAULT_INTERP = { looped: false, keys: [] };
+function parseInfo(typeKey, interps) {
+    var get = function (key) {
+        var _a, _b;
+        var alt = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            alt[_i - 1] = arguments[_i];
+        }
+        return (_b = (_a = interps[key]) !== null && _a !== void 0 ? _a : alt.reduce(function (r, k) { return r !== null && r !== void 0 ? r : interps[k]; }, undefined)) !== null && _b !== void 0 ? _b : DEFAULT_INTERP;
+    };
+    switch (typeKey) {
+        case "underwater":
+        case "selflit":
+            return { type: typeKey };
+        case "emrate":
+            return { type: "emrate", rate: get("RATE") };
+        case "emsize":
+            return {
+                type: "emsize",
+                radius: get("RADIUS"),
+                sizeMinX: get("SIZEMINX"),
+                sizeMaxX: get("SIZEMAXX"),
+                sizeMinY: get("SIZEMINY"),
+                sizeMaxY: get("SIZEMAXY"),
+                sizeMinZ: get("SIZEMINZ"),
+                sizeMaxZ: get("SIZEMAXZ"),
+            };
+        case "emspeed":
+            return { type: "emspeed", speed: get("SPEED"), bias: get("BIAS") };
+        case "emdir":
+            return {
+                type: "emdir",
+                dirX: get("DIRX"),
+                dirY: get("DIRY"),
+                dirZ: get("DIRZ"),
+            };
+        case "emangle":
+            return {
+                type: "emangle",
+                min: get("MIN", "ANGLEMIN"),
+                max: get("MAX", "ANGLEMAX"),
+            };
+        case "emlife":
+            return { type: "emlife", life: get("LIFE"), bias: get("BIAS") };
+        case "empos":
+            return { type: "empos", x: get("X"), y: get("Y"), z: get("Z") };
+        case "emweather":
+            return { type: "emweather", interp: get("WEATHER") };
+        case "emrotation":
+            return { type: "emrotation", min: get("ANGLEMIN"), max: get("ANGLEMAX") };
+        case "noise":
+            return { type: "noise", x: get("NOISE", "X"), y: get("Y"), z: get("Z") };
+        case "force":
+            return {
+                type: "force",
+                forceX: get("FORCEX"),
+                forceY: get("FORCEY"),
+                forceZ: get("FORCEZ"),
+            };
+        case "friction":
+            return { type: "friction", friction: get("FRICTION") };
+        case "attractpt":
+            return {
+                type: "attractpt",
+                x: get("X"),
+                y: get("Y"),
+                z: get("Z"),
+                power: get("POWER"),
+            };
+        case "attractline":
+            return {
+                type: "attractline",
+                x1: get("X1"),
+                y1: get("Y1"),
+                z1: get("Z1"),
+                x2: get("X2"),
+                y2: get("Y2"),
+                z2: get("Z2"),
+                power: get("POWER"),
+            };
+        case "groundcollide":
+            return {
+                type: "groundcollide",
+                damping: get("DAMPING"),
+                bounce: get("BOUNCE"),
+            };
+        case "wind":
+            return { type: "wind", interp: get("WINDFACTOR") };
+        case "jitter":
+            return { type: "jitter", x: get("X"), y: get("Y"), z: get("Z") };
+        case "rotspeed":
+            return {
+                type: "rotspeed",
+                speed: get("SPEED"),
+                speedBias: get("SPEEDBIAS"),
+                accel: get("ACCEL"),
+                accelBias: get("ACCELBIAS"),
+            };
+        case "float":
+            return { type: "float", interp: get("FLOAT") };
+        case "colour":
+            return {
+                type: "colour",
+                red: get("RED"),
+                green: get("GREEN"),
+                blue: get("BLUE"),
+                alpha: get("ALPHA"),
+            };
+        case "size":
+            return {
+                type: "size",
+                sizeX: get("SIZEX"),
+                sizeY: get("SIZEY"),
+                sizeXBias: get("SIZEXBIAS"),
+                sizeYBias: get("SIZEYBIAS"),
+            };
+        case "spriterect":
+            return { type: "spriterect", interps: Object.values(interps) };
+        case "heathaze":
+            return { type: "heathaze", interps: Object.values(interps) };
+        case "trail":
+            return { type: "trail", interps: Object.values(interps) };
+        case "flat":
+            return {
+                type: "flat",
+                rightX: get("RIGHTX"),
+                rightY: get("RIGHTY"),
+                rightZ: get("RIGHTZ"),
+                upX: get("UPX"),
+                upY: get("UPY"),
+                upZ: get("UPZ"),
+                atX: get("ATX"),
+                atY: get("ATY"),
+                atZ: get("ATZ"),
+            };
+        case "dir":
+            return { type: "dir", interps: Object.values(interps) };
+        case "animtex":
+            return { type: "animtex", interps: Object.values(interps) };
+        case "colourrange":
+            return {
+                type: "colourrange",
+                redMin: get("REDMIN"),
+                redMax: get("REDMAX"),
+                greenMin: get("GREENMIN"),
+                greenMax: get("GREENMAX"),
+                blueMin: get("BLUEMIN"),
+                blueMax: get("BLUEMAX"),
+                alphaMin: get("ALPHAMIN"),
+                alphaMax: get("ALPHAMAX"),
+            };
+        case "colourbright":
+            return {
+                type: "colourbright",
+                red: get("RED"),
+                green: get("GREEN"),
+                blue: get("BLUE"),
+                alpha: get("ALPHA"),
+                brightness: get("BRIGHTNESS", "BIAS"),
+            };
+        case "smoke":
+            return { type: "smoke", interps: Object.values(interps) };
+        default:
+            return null;
+    }
+}

package/lib/fxp/parser.d.ts

@@ -0,0 +1,3 @@
+import type { FxProject } from "./types";
+export declare function parseFxpContent(content: string): FxProject;
+export declare function parseFxpFile(filePath: string): FxProject;