rw-parser-ng 2.1.0 → 2.3.0

package/src/dff/readers/2d-effect.ts

@@ -0,0 +1,265 @@
+import type { RwFile } from "../../core/rw-file";
+import {
+  Rw2dEffectType,
+  type Rw2dEffect,
+  type Rw2dEffectAttractor,
+  type Rw2dEffectCoverPoint,
+  type Rw2dEffectEnEx,
+  type Rw2dEffectEscalator,
+  type Rw2dEffectGeneric,
+  type Rw2dEffectLight,
+  type Rw2dEffectParticle,
+  type Rw2dEffectRoadsign,
+} from "../types";
+
+export function read2dEffects(file: RwFile, sectionSize: number): Rw2dEffect[] {
+  const effects: Rw2dEffect[] = [];
+  const endPosition = file.getPosition() + sectionSize;
+  const effectCount = file.readUint32();
+
+  for (let i = 0; i < effectCount && file.getPosition() < endPosition; i++) {
+    const effect = read2dEffect(file);
+    if (effect) effects.push(effect);
+  }
+
+  file.setPosition(endPosition);
+  return effects;
+}
+
+function read2dEffect(file: RwFile): Rw2dEffect | null {
+  const position = {
+    x: file.readFloat(),
+    y: file.readFloat(),
+    z: file.readFloat(),
+  };
+  const type = file.readUint32() as Rw2dEffectType;
+  const dataSize = file.readUint32();
+  const dataStart = file.getPosition();
+
+  let effect: Rw2dEffect | null = null;
+
+  switch (type) {
+    case Rw2dEffectType.LIGHT:
+      effect = readLight(file, position);
+      break;
+    case Rw2dEffectType.PARTICLE:
+      effect = readParticle(file, position);
+      break;
+    case Rw2dEffectType.ATTRACTOR:
+      effect = readAttractor(file, position);
+      break;
+    case Rw2dEffectType.ENEX:
+      effect = readEnEx(file, position);
+      break;
+    case Rw2dEffectType.ROADSIGN:
+      effect = readRoadsign(file, position);
+      break;
+    case Rw2dEffectType.COVER_POINT:
+      effect = readCoverPoint(file, position);
+      break;
+    case Rw2dEffectType.ESCALATOR:
+      effect = readEscalator(file, position);
+      break;
+    default:
+      effect = readGeneric(file, position, type, dataSize);
+      break;
+  }
+
+  file.setPosition(dataStart + dataSize);
+  return effect;
+}
+
+function readLight(
+  file: RwFile,
+  position: { x: number; y: number; z: number },
+): Rw2dEffectLight {
+  const color = {
+    r: file.readUint8(),
+    g: file.readUint8(),
+    b: file.readUint8(),
+    a: file.readUint8(),
+  };
+  const coronaFarClip = file.readFloat();
+  const pointlightRange = file.readFloat();
+  const coronaSize = file.readFloat();
+  const shadowSize = file.readFloat();
+  const coronaShowMode = file.readUint8();
+  const coronaEnableReflection = file.readUint8() !== 0;
+  const coronaFlareType = file.readUint8();
+  const shadowColorMultiplier = file.readUint8();
+  const flags1 = file.readUint8();
+  const coronaTexName = file.readString(24);
+  const shadowTexName = file.readString(24);
+  const shadowZDistance = file.readUint8();
+  const flags2 = file.readUint8();
+
+  return {
+    type: Rw2dEffectType.LIGHT,
+    position,
+    color,
+    coronaFarClip,
+    pointlightRange,
+    coronaSize,
+    shadowSize,
+    coronaShowMode,
+    coronaEnableReflection,
+    coronaFlareType,
+    shadowColorMultiplier,
+    flags1,
+    coronaTexName,
+    shadowTexName,
+    shadowZDistance,
+    flags2,
+  };
+}
+
+function readParticle(
+  file: RwFile,
+  position: { x: number; y: number; z: number },
+): Rw2dEffectParticle {
+  const effectName = file.readString(24).replace(/\0+$/, "");
+  return { type: Rw2dEffectType.PARTICLE, position, effectName };
+}
+
+function readAttractor(
+  file: RwFile,
+  position: { x: number; y: number; z: number },
+): Rw2dEffectAttractor {
+  const queueDir = {
+    x: file.readFloat(),
+    y: file.readFloat(),
+    z: file.readFloat(),
+  };
+  const useDir = {
+    x: file.readFloat(),
+    y: file.readFloat(),
+    z: file.readFloat(),
+  };
+  const forwardDir = {
+    x: file.readFloat(),
+    y: file.readFloat(),
+    z: file.readFloat(),
+  };
+  const attractorType = file.readInt8();
+  const pedExistingProbability = file.readUint8();
+  file.skip(1);
+  const flags = file.readUint8();
+  const scriptName = file.readString(8).replace(/\0+$/, "");
+
+  return {
+    type: Rw2dEffectType.ATTRACTOR,
+    position,
+    queueDir,
+    useDir,
+    forwardDir,
+    attractorType,
+    pedExistingProbability,
+    flags,
+    scriptName,
+  };
+}
+
+function readEnEx(
+  file: RwFile,
+  position: { x: number; y: number; z: number },
+): Rw2dEffectEnEx {
+  const enterAngle = file.readFloat();
+  const radiusX = file.readFloat();
+  const radiusY = file.readFloat();
+  const exitPos = {
+    x: file.readFloat(),
+    y: file.readFloat(),
+    z: file.readFloat(),
+  };
+  const exitAngle = file.readFloat();
+  const interiorId = file.readInt16();
+  const flags1 = file.readUint8();
+  const skyColor = file.readUint8();
+  const interiorName = file.readString(8).replace(/\0+$/, "");
+  const timeOn = file.readUint8();
+  const timeOff = file.readUint8();
+  const flags2 = file.readUint8();
+
+  return {
+    type: Rw2dEffectType.ENEX,
+    position,
+    enterAngle,
+    radiusX,
+    radiusY,
+    exitPos,
+    exitAngle,
+    interiorId,
+    flags1,
+    skyColor,
+    interiorName,
+    timeOn,
+    timeOff,
+    flags2,
+  };
+}
+
+function readRoadsign(
+  file: RwFile,
+  position: { x: number; y: number; z: number },
+): Rw2dEffectRoadsign {
+  const size = { x: file.readFloat(), y: file.readFloat() };
+  const rotation = {
+    x: file.readFloat(),
+    y: file.readFloat(),
+    z: file.readFloat(),
+  };
+  const flags = file.readUint16();
+  file.skip(2);
+  file.skip(8);
+
+  return {
+    type: Rw2dEffectType.ROADSIGN,
+    position,
+    size,
+    rotation,
+    flags,
+    text: "",
+  };
+}
+
+function readCoverPoint(
+  file: RwFile,
+  position: { x: number; y: number; z: number },
+): Rw2dEffectCoverPoint {
+  const coverDir = { x: file.readFloat(), y: file.readFloat() };
+  const usage = file.readUint32();
+  return { type: Rw2dEffectType.COVER_POINT, position, coverDir, usage };
+}
+
+function readEscalator(
+  file: RwFile,
+  position: { x: number; y: number; z: number },
+): Rw2dEffectEscalator {
+  const bottom = {
+    x: file.readFloat(),
+    y: file.readFloat(),
+    z: file.readFloat(),
+  };
+  const top = { x: file.readFloat(), y: file.readFloat(), z: file.readFloat() };
+  const end = { x: file.readFloat(), y: file.readFloat(), z: file.readFloat() };
+  const direction = file.readUint8();
+
+  return {
+    type: Rw2dEffectType.ESCALATOR,
+    position,
+    bottom,
+    top,
+    end,
+    direction,
+  };
+}
+
+function readGeneric(
+  file: RwFile,
+  position: { x: number; y: number; z: number },
+  type: Rw2dEffectType,
+  dataSize: number,
+): Rw2dEffectGeneric {
+  const data = file.readBytes(dataSize);
+  return { type: type as Rw2dEffectGeneric["type"], position, data };
+}

package/src/dff/readers/geometry.ts

@@ -0,0 +1,264 @@
+import type { RwTextureCoordinate } from "../../common/types";
+import type { RwFile, RwSectionHeader } from "../../core/rw-file";
+import { RwSections } from "../../core/rw-sections";
+import { unpackVersion } from "../../core/rw-version";
+import type {
+  Rw2dEffect,
+  RwBreakable,
+  RwGeometry,
+  RwGeometryList,
+} from "../types";
+import { read2dEffects } from "./2d-effect";
+import { readMaterialList } from "./material";
+import { readBinMesh, readSkin } from "./mesh";
+
+export function readGeometryList(
+  file: RwFile,
+  header: RwSectionHeader,
+): RwGeometryList {
+  file.readSectionHeader();
+  const geometricObjectCount = file.readUint32();
+  const geometries: RwGeometry[] = [];
+  const versionNumber = unpackVersion(header.versionNumber);
+
+  for (let i = 0; i < geometricObjectCount; i++) {
+    file.readSectionHeader();
+    file.readSectionHeader();
+    geometries.push(readGeometry(file, versionNumber));
+  }
+
+  return { geometricObjectCount, geometries };
+}
+
+export function readGeometry(file: RwFile, versionNumber: number): RwGeometry {
+  const flags = file.readUint16();
+  const textureCoordinatesCount = file.readUint8();
+  file.readUint8();
+  const triangleCount = file.readUint32();
+  const vertexCount = file.readUint32();
+  file.readUint32();
+
+  if (versionNumber < 0x34000) {
+    file.skip(12);
+  }
+
+  const isTriangleStrip = (flags & (1 << 0)) !== 0;
+  const isTexturedUV1 = (flags & (1 << 2)) !== 0;
+  const isGeometryPrelit = (flags & (1 << 3)) !== 0;
+  const isTexturedUV2 = (flags & (1 << 7)) !== 0;
+
+  const vertexColorInformation = [];
+  if (isGeometryPrelit) {
+    for (let i = 0; i < vertexCount; i++) {
+      vertexColorInformation.push({
+        r: file.readUint8(),
+        g: file.readUint8(),
+        b: file.readUint8(),
+        a: file.readUint8(),
+      });
+    }
+  }
+
+  const textureMappingInformation: RwTextureCoordinate[][] = [];
+  if (isTexturedUV1 || isTexturedUV2) {
+    for (let t = 0; t < textureCoordinatesCount; t++) {
+      textureMappingInformation[t] = [];
+      for (let v = 0; v < vertexCount; v++) {
+        textureMappingInformation[t][v] = {
+          u: file.readFloat(),
+          v: file.readFloat(),
+        };
+      }
+    }
+  }
+
+  const triangleInformation = [];
+  for (let i = 0; i < triangleCount; i++) {
+    const vertex2 = file.readUint16();
+    const vertex1 = file.readUint16();
+    const materialId = file.readUint16();
+    const vertex3 = file.readUint16();
+    triangleInformation.push({
+      vector: { x: vertex1, y: vertex2, z: vertex3 },
+      materialId,
+    });
+  }
+
+  const boundingSphere = {
+    vector: { x: file.readFloat(), y: file.readFloat(), z: file.readFloat() },
+    radius: file.readFloat(),
+  };
+
+  const hasVertices = !!file.readUint32();
+  const hasNormals = !!file.readUint32();
+
+  const vertexInformation = [];
+  if (hasVertices) {
+    for (let i = 0; i < vertexCount; i++) {
+      vertexInformation.push({
+        x: file.readFloat(),
+        y: file.readFloat(),
+        z: file.readFloat(),
+      });
+    }
+  }
+
+  const normalInformation = [];
+  if (hasNormals) {
+    for (let i = 0; i < vertexCount; i++) {
+      normalInformation.push({
+        x: file.readFloat(),
+        y: file.readFloat(),
+        z: file.readFloat(),
+      });
+    }
+  }
+
+  const materialList = readMaterialList(file);
+  const extensionSize = file.readSectionHeader().sectionSize;
+  let binMesh;
+  let skin;
+  let effects2d: Rw2dEffect[] | undefined;
+  let extraVertColour;
+  let breakable: RwBreakable | undefined;
+  let relativePosition = 0;
+
+  while (relativePosition < extensionSize) {
+    const extHeader = file.readSectionHeader();
+    relativePosition += extHeader.sectionSize + 12;
+    const sectionStart = file.getPosition();
+
+    switch (extHeader.sectionType) {
+      case RwSections.RwBinMesh:
+        binMesh = readBinMesh(file);
+        break;
+      case RwSections.RwSkin:
+        skin = readSkin(file, vertexCount);
+        break;
+      case RwSections.Rw2dEffect:
+        effects2d = read2dEffects(file, extHeader.sectionSize);
+        break;
+      case RwSections.RwExtraVertColour:
+        extraVertColour = [];
+        for (let i = 0; i < vertexCount; i++) {
+          extraVertColour.push({
+            r: file.readUint8(),
+            g: file.readUint8(),
+            b: file.readUint8(),
+            a: file.readUint8(),
+          });
+        }
+        break;
+      case RwSections.RwBreakable:
+        breakable = readBreakable(file);
+        break;
+      default:
+        file.skip(extHeader.sectionSize);
+        break;
+    }
+
+    file.setPosition(sectionStart + extHeader.sectionSize);
+  }
+
+  return {
+    textureCoordinatesCount,
+    textureMappingInformation,
+    boundingSphere,
+    hasVertices,
+    hasNormals,
+    isTriangleStrip,
+    vertexColorInformation,
+    vertexInformation,
+    normalInformation,
+    triangleInformation,
+    materialList,
+    binMesh,
+    skin,
+    effects2d,
+    extraVertColour,
+    breakable,
+  };
+}
+
+function readBreakable(file: RwFile): RwBreakable | undefined {
+  const sectionHeader = file.readUint32();
+  if (!sectionHeader) return undefined;
+
+  const positionRule = file.readUint32();
+  const numVertices = file.readUint16();
+  file.skip(2);
+  file.skip(4 * 3);
+  const numTriangles = file.readUint16();
+  file.skip(2);
+  file.skip(4 * 2);
+  const numMaterials = file.readUint16();
+  file.skip(2);
+  file.skip(4 * 4);
+
+  const vertices = [];
+  for (let i = 0; i < numVertices; i++) {
+    vertices.push({
+      x: file.readFloat(),
+      y: file.readFloat(),
+      z: file.readFloat(),
+    });
+  }
+
+  const texCoords = [];
+  for (let i = 0; i < numVertices; i++) {
+    texCoords.push({ u: file.readFloat(), v: file.readFloat() });
+  }
+
+  const colors = [];
+  for (let i = 0; i < numVertices; i++) {
+    colors.push({
+      r: file.readUint8(),
+      g: file.readUint8(),
+      b: file.readUint8(),
+      a: file.readUint8(),
+    });
+  }
+
+  const triangles = [];
+  for (let i = 0; i < numTriangles; i++) {
+    triangles.push({
+      a: file.readUint16(),
+      b: file.readUint16(),
+      c: file.readUint16(),
+    });
+  }
+
+  const triangleMaterialIndices = [];
+  for (let i = 0; i < numTriangles; i++) {
+    triangleMaterialIndices.push(file.readUint16());
+  }
+
+  const textureNames: string[] = [];
+  for (let i = 0; i < numMaterials; i++) {
+    textureNames.push(file.readString(32).replace(/\0+$/, ""));
+  }
+
+  const maskNames: string[] = [];
+  for (let i = 0; i < numMaterials; i++) {
+    maskNames.push(file.readString(32).replace(/\0+$/, ""));
+  }
+
+  const materials = [];
+  for (let i = 0; i < numMaterials; i++) {
+    materials.push({
+      textureName: textureNames[i],
+      maskName: maskNames[i],
+      color: { r: file.readFloat(), g: file.readFloat(), b: file.readFloat() },
+    });
+  }
+
+  return {
+    positionRule,
+    vertices,
+    texCoords,
+    colors,
+    triangles,
+    triangleMaterialIndices,
+    materials,
+  };
+}

package/src/dff/readers/index.ts

@@ -0,0 +1,5 @@
+export * from "./2d-effect";
+export * from "./geometry";
+export * from "./material";
+export * from "./mesh";
+export * from "./structure";

package/src/dff/readers/material.ts

@@ -0,0 +1,89 @@
+import type { RwFile } from "../../core/rw-file";
+import type { RwMaterial, RwMaterialList, RwTexture } from "../types";
+
+export function readTexture(file: RwFile): RwTexture {
+  file.readSectionHeader();
+  file.readSectionHeader();
+
+  const textureData = file.readUint32();
+  const textureFiltering = textureData & 0xff;
+  const uAddressing = (textureData & 0xf00) >> 8;
+  const vAddressing = (textureData & 0xf000) >> 12;
+  const usesMipLevels = (textureData & (1 << 16)) !== 0;
+
+  const textureNameSize = file.readSectionHeader().sectionSize;
+  const textureName = file.readString(textureNameSize);
+
+  file.skip(file.readSectionHeader().sectionSize);
+  file.skip(file.readSectionHeader().sectionSize);
+
+  return {
+    textureFiltering,
+    uAddressing,
+    vAddressing,
+    usesMipLevels,
+    textureName,
+  };
+}
+
+export function readMaterial(file: RwFile): RwMaterial {
+  file.readSectionHeader();
+  const header = file.readSectionHeader();
+
+  file.skip(4);
+
+  const color = {
+    r: file.readUint8(),
+    g: file.readUint8(),
+    b: file.readUint8(),
+    a: file.readUint8(),
+  };
+
+  file.skip(4);
+
+  const isTextured = file.readUint32() > 0;
+
+  let ambient: number | undefined;
+  let specular: number | undefined;
+  let diffuse: number | undefined;
+
+  if (header.versionNumber > 0x30400) {
+    ambient = file.readFloat();
+    specular = file.readFloat();
+    diffuse = file.readFloat();
+  }
+
+  let texture: RwTexture | undefined;
+  if (isTextured) {
+    texture = readTexture(file);
+  }
+
+  file.skip(file.readSectionHeader().sectionSize);
+
+  return { color, isTextured, ambient, specular, diffuse, texture };
+}
+
+export function readMaterialList(file: RwFile): RwMaterialList {
+  file.readSectionHeader();
+  file.readSectionHeader();
+
+  const materialInstanceCount = file.readUint32();
+  const materialIndices: number[] = [];
+
+  for (let i = 0; i < materialInstanceCount; i++) {
+    materialIndices.push(file.readInt32());
+  }
+
+  const materialData: RwMaterial[] = [];
+
+  for (let i = 0; i < materialInstanceCount; i++) {
+    const materialIndex = materialIndices[i];
+    if (materialIndex === -1) {
+      materialData.push(readMaterial(file));
+    } else {
+      materialData.push(materialData[materialIndex]);
+    }
+  }
+
+  return { materialInstanceCount, materialData };
+}

package/src/dff/readers/mesh.ts

@@ -0,0 +1,93 @@
+import type { RwFile } from "../../core/rw-file";
+import type { RwBinMesh, RwMesh, RwSkin } from "../types";
+
+export function readMesh(file: RwFile): RwMesh {
+  const indexCount = file.readUint32();
+  const materialIndex = file.readUint32();
+  const indices: number[] = [];
+
+  for (let i = 0; i < indexCount; i++) {
+    indices.push(file.readUint32());
+  }
+
+  return { indexCount, materialIndex, indices };
+}
+
+export function readBinMesh(file: RwFile): RwBinMesh {
+  file.skip(4);
+  const meshCount = file.readUint32();
+  file.skip(4);
+
+  const meshes: RwMesh[] = [];
+  for (let i = 0; i < meshCount; i++) {
+    meshes.push(readMesh(file));
+  }
+
+  return { meshCount, meshes };
+}
+
+export function readSkin(file: RwFile, vertexCount: number): RwSkin {
+  const boneCount = file.readUint8();
+  const usedBoneCount = file.readUint8();
+  const maxWeightsPerVertex = file.readUint8();
+
+  file.skip(1);
+  file.skip(usedBoneCount);
+
+  const boneVertexIndices: number[][] = [];
+  for (let i = 0; i < vertexCount; i++) {
+    const indices: number[] = [];
+    for (let j = 0; j < 4; j++) {
+      indices.push(file.readUint8());
+    }
+    boneVertexIndices.push(indices);
+  }
+
+  const vertexWeights: number[][] = [];
+  for (let i = 0; i < vertexCount; i++) {
+    const weights: number[] = [];
+    for (let j = 0; j < 4; j++) {
+      weights.push(file.readFloat());
+    }
+    vertexWeights.push(weights);
+  }
+
+  const inverseBoneMatrices = [];
+  for (let i = 0; i < boneCount; i++) {
+    inverseBoneMatrices.push({
+      right: {
+        x: file.readFloat(),
+        y: file.readFloat(),
+        z: file.readFloat(),
+        t: file.readFloat(),
+      },
+      up: {
+        x: file.readFloat(),
+        y: file.readFloat(),
+        z: file.readFloat(),
+        t: file.readFloat(),
+      },
+      at: {
+        x: file.readFloat(),
+        y: file.readFloat(),
+        z: file.readFloat(),
+        t: file.readFloat(),
+      },
+      transform: {
+        x: file.readFloat(),
+        y: file.readFloat(),
+        z: file.readFloat(),
+        t: file.readFloat(),
+      },
+    });
+  }
+
+  return {
+    boneCount,
+    usedBoneCount,
+    maxWeightsPerVertex,
+    boneVertexIndices,
+    vertexWeights,
+    inverseBoneMatrices,
+  };
+}