rw-parser-ng 2.1.0 → 2.3.0

package/src/dff/readers/structure.ts

@@ -0,0 +1,79 @@
+import type { RwFile } from "../../core/rw-file";
+import type { RwAnimNode, RwAtomic, RwBone, RwClump, RwFrame, RwFrameList } from "../types";
+
+export function readClump(file: RwFile): RwClump {
+  const { versionNumber } = file.readSectionHeader();
+  const atomicCount = file.readUint32();
+
+  let lightCount: number | undefined;
+  let cameraCount: number | undefined;
+
+  if (versionNumber > 0x33000) {
+    lightCount = file.readUint32();
+    cameraCount = file.readUint32();
+  }
+
+  return { atomicCount, lightCount, cameraCount };
+}
+
+export function readFrameList(file: RwFile): RwFrameList {
+  file.readSectionHeader();
+  const frameCount = file.readUint32();
+  const frames: RwFrame[] = [];
+
+  for (let i = 0; i < frameCount; i++) {
+    const rotationMatrix = {
+      right: {
+        x: file.readFloat(),
+        y: file.readFloat(),
+        z: file.readFloat(),
+      },
+      up: { x: file.readFloat(), y: file.readFloat(), z: file.readFloat() },
+      at: { x: file.readFloat(), y: file.readFloat(), z: file.readFloat() },
+    };
+
+    const coordinatesOffset = {
+      x: file.readFloat(),
+      y: file.readFloat(),
+      z: file.readFloat(),
+    };
+
+    const parentFrame = file.readInt32();
+    file.skip(4);
+
+    frames.push({ rotationMatrix, coordinatesOffset, parentFrame });
+  }
+
+  return { frameCount, frames };
+}
+
+export function readAnimNode(file: RwFile): RwAnimNode {
+  file.skip(4);
+  const boneId = file.readInt32();
+  const boneCount = file.readInt32();
+  const bones: RwBone[] = [];
+
+  if (boneCount > 0) {
+    file.skip(8);
+  }
+
+  for (let i = 0; i < boneCount; i++) {
+    bones.push({
+      boneId: file.readInt32(),
+      boneIndex: file.readInt32(),
+      flags: file.readInt32(),
+    });
+  }
+
+  return { boneId, bonesCount: boneCount, bones };
+}
+
+export function readAtomic(file: RwFile): RwAtomic {
+  file.readSectionHeader();
+  const frameIndex = file.readUint32();
+  const geometryIndex = file.readUint32();
+  const flags = file.readUint32();
+  file.skip(4);
+
+  return { frameIndex, geometryIndex, flags };
+}

package/src/dff/types.ts

@@ -0,0 +1,278 @@
+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 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 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 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/src/fxp/index.ts

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

package/src/fxp/info-parser.ts

@@ -0,0 +1,166 @@
+import type { FxInfo, FxInterpData } from "./types";
+
+const DEFAULT_INTERP: FxInterpData = { looped: false, keys: [] };
+
+export function parseInfo(typeKey: string, interps: Record<string, FxInterpData>): FxInfo | null {
+  const get = (key: string, ...alt: string[]) =>
+    interps[key] ??
+    alt.reduce((r, k) => r ?? interps[k], undefined as FxInterpData | undefined) ??
+    DEFAULT_INTERP;
+
+  switch (typeKey) {
+    case "underwater":
+    case "selflit":
+      return { type: typeKey } as FxInfo;
+    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;
+  }
+}