@bis-toolkit/p3d 1.0.0

package/dist/index.js

@@ -0,0 +1,2265 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/mlod/index.ts
+var mlod_exports = {};
+__export(mlod_exports, {
+  BinaryReader: () => BinaryReader,
+  Face: () => Face,
+  FaceFlags: () => FaceFlags,
+  Mlod: () => Mlod,
+  MlodLod: () => MlodLod,
+  Point: () => Point,
+  PointFlags: () => PointFlags,
+  TaggReader: () => TaggReader,
+  Vector3: () => Vector3,
+  Vertex: () => Vertex,
+  getLodName: () => getLodName
+});
+
+// ../utils/dist/index.js
+var BinaryReader = class {
+  constructor(buffer) {
+    this.position = 0;
+    this.buffer = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  get length() {
+    return this.buffer.length;
+  }
+  get pos() {
+    return this.position;
+  }
+  seek(offset, origin = "begin") {
+    switch (origin) {
+      case "begin":
+        this.position = offset;
+        break;
+      case "current":
+        this.position += offset;
+        break;
+      case "end":
+        this.position = this.buffer.length + offset;
+        break;
+    }
+  }
+  readByte() {
+    const value = this.view.getUint8(this.position);
+    this.position += 1;
+    return value;
+  }
+  readUInt16() {
+    const value = this.view.getUint16(this.position, true);
+    this.position += 2;
+    return value;
+  }
+  readUInt32() {
+    const value = this.view.getUint32(this.position, true);
+    this.position += 4;
+    return value;
+  }
+  readInt32() {
+    const value = this.view.getInt32(this.position, true);
+    this.position += 4;
+    return value;
+  }
+  readInt24() {
+    const b1 = this.view.getUint8(this.position);
+    const b2 = this.view.getUint8(this.position + 1);
+    const b3 = this.view.getUint8(this.position + 2);
+    this.position += 3;
+    return b1 | b2 << 8 | b3 << 16;
+  }
+  readBytes(count) {
+    const bytes = this.buffer.subarray(this.position, this.position + count);
+    this.position += count;
+    return bytes;
+  }
+  readRawString(length) {
+    const bytes = this.buffer.subarray(this.position, this.position + length);
+    this.position += length;
+    return String.fromCharCode(...bytes);
+  }
+  readFloat() {
+    const value = this.view.getFloat32(this.position, true);
+    this.position += 4;
+    return value;
+  }
+  readBoolean() {
+    return this.readByte() !== 0;
+  }
+  /**
+   * Read a null-terminated C-style string
+   */
+  readCString() {
+    const start = this.position;
+    let end = start;
+    while (end < this.buffer.length && this.buffer[end] !== 0) {
+      end++;
+    }
+    const bytes = this.buffer.subarray(start, end);
+    this.position = end + 1;
+    const decoder = new TextDecoder("utf-8");
+    return decoder.decode(bytes);
+  }
+  /**
+   * Alias for readRawString for compatibility
+   */
+  readString(length) {
+    return this.readRawString(length);
+  }
+};
+var LZO = class _LZO {
+  constructor() {
+    this._blockSize = 128 * 1024;
+    this._minNewSize = this.blockSize;
+    this._out = new Uint8Array(256 * 1024);
+    this._cbl = 0;
+    this._t = 0;
+    this._inputPointer = 0;
+    this._outputPointer = 0;
+    this._matchPosition = 0;
+    this._skipToFirstLiteralFunc = false;
+  }
+  get blockSize() {
+    return this._blockSize;
+  }
+  set blockSize(value) {
+    if (value <= 0) throw new Error("Block size must be a positive integer");
+    this._blockSize = value;
+  }
+  _extendBuffer() {
+    const newBuffer = new Uint8Array(
+      this._minNewSize + (this.blockSize - this._minNewSize % this.blockSize)
+    );
+    newBuffer.set(this._out);
+    this._out = newBuffer;
+    this._cbl = this._out.length;
+  }
+  _matchNext() {
+    this._minNewSize = this._outputPointer + 3;
+    if (this._minNewSize > this._cbl) this._extendBuffer();
+    this._out[this._outputPointer++] = this._buffer[this._inputPointer++];
+    if (this._t > 1) {
+      this._out[this._outputPointer++] = this._buffer[this._inputPointer++];
+      if (this._t > 2) {
+        this._out[this._outputPointer++] = this._buffer[this._inputPointer++];
+      }
+    }
+    this._t = this._buffer[this._inputPointer++];
+  }
+  _matchDone() {
+    this._t = this._buffer[this._inputPointer - 2] & 3;
+    return this._t;
+  }
+  _copyMatch() {
+    this._t += 2;
+    this._minNewSize = this._outputPointer + this._t;
+    if (this._minNewSize > this._cbl) {
+      this._extendBuffer();
+    }
+    do {
+      this._out[this._outputPointer++] = this._out[this._matchPosition++];
+    } while (--this._t > 0);
+  }
+  _copyFromBuffer() {
+    this._minNewSize = this._outputPointer + this._t;
+    if (this._minNewSize > this._cbl) {
+      this._extendBuffer();
+    }
+    do {
+      this._out[this._outputPointer++] = this._buffer[this._inputPointer++];
+    } while (--this._t > 0);
+  }
+  _match() {
+    while (true) {
+      if (this._t >= 64) {
+        this._matchPosition = this._outputPointer - 1 - (this._t >> 2 & 7) - (this._buffer[this._inputPointer++] << 3);
+        this._t = (this._t >> 5) - 1;
+        this._copyMatch();
+      } else if (this._t >= 32) {
+        this._t &= 31;
+        if (this._t === 0) {
+          while (this._buffer[this._inputPointer] === 0) {
+            this._t += 255;
+            this._inputPointer++;
+          }
+          this._t += 31 + this._buffer[this._inputPointer++];
+        }
+        this._matchPosition = this._outputPointer - 1 - (this._buffer[this._inputPointer] >> 2) - (this._buffer[this._inputPointer + 1] << 6);
+        this._inputPointer += 2;
+        this._copyMatch();
+      } else if (this._t >= 16) {
+        this._matchPosition = this._outputPointer - ((this._t & 8) << 11);
+        this._t &= 7;
+        if (this._t === 0) {
+          while (this._buffer[this._inputPointer] === 0) {
+            this._t += 255;
+            this._inputPointer++;
+          }
+          this._t += 7 + this._buffer[this._inputPointer++];
+        }
+        this._matchPosition -= (this._buffer[this._inputPointer] >> 2) + (this._buffer[this._inputPointer + 1] << 6);
+        this._inputPointer += 2;
+        if (this._matchPosition === this._outputPointer) {
+          return this._out.subarray(0, this._outputPointer);
+        } else {
+          this._matchPosition -= 16384;
+          this._copyMatch();
+        }
+      } else {
+        this._matchPosition = this._outputPointer - 1 - (this._t >> 2) - (this._buffer[this._inputPointer++] << 2);
+        this._minNewSize = this._outputPointer + 2;
+        if (this._minNewSize > this._cbl) {
+          this._extendBuffer();
+        }
+        this._out[this._outputPointer++] = this._out[this._matchPosition++];
+        this._out[this._outputPointer++] = this._out[this._matchPosition];
+      }
+      if (this._matchDone() === 0) {
+        return true;
+      }
+      this._matchNext();
+    }
+  }
+  _decompressBuffer(buffer) {
+    this._buffer = buffer;
+    this._cbl = this._out.length;
+    this._t = 0;
+    this._inputPointer = 0;
+    this._outputPointer = 0;
+    this._matchPosition = 0;
+    this._skipToFirstLiteralFunc = false;
+    if (this._buffer[this._inputPointer] > 17) {
+      this._t = this._buffer[this._inputPointer++] - 17;
+      if (this._t < 4) {
+        this._matchNext();
+        const matched = this._match();
+        if (matched !== true) return matched;
+      } else {
+        this._copyFromBuffer();
+        this._skipToFirstLiteralFunc = true;
+      }
+    }
+    while (true) {
+      if (!this._skipToFirstLiteralFunc) {
+        this._t = this._buffer[this._inputPointer++];
+        if (this._t >= 16) {
+          const matched2 = this._match();
+          if (matched2 !== true) return matched2;
+          continue;
+        } else if (this._t === 0) {
+          while (this._buffer[this._inputPointer] === 0) {
+            this._t += 255;
+            this._inputPointer++;
+          }
+          this._t += 15 + this._buffer[this._inputPointer++];
+        }
+        this._t += 3;
+        this._copyFromBuffer();
+      } else this._skipToFirstLiteralFunc = false;
+      this._t = this._buffer[this._inputPointer++];
+      if (this._t < 16) {
+        this._matchPosition = this._outputPointer - (1 + 2048);
+        this._matchPosition -= this._t >> 2;
+        this._matchPosition -= this._buffer[this._inputPointer++] << 2;
+        this._minNewSize = this._outputPointer + 3;
+        if (this._minNewSize > this._cbl) {
+          this._extendBuffer();
+        }
+        this._out[this._outputPointer++] = this._out[this._matchPosition++];
+        this._out[this._outputPointer++] = this._out[this._matchPosition++];
+        this._out[this._outputPointer++] = this._out[this._matchPosition];
+        if (this._matchDone() === 0) continue;
+        else this._matchNext();
+      }
+      const matched = this._match();
+      if (matched !== true) return matched;
+    }
+  }
+  /**
+   * Decompresses the given buffer using the LZO1X-1 algorithm.
+   * @param buffer The buffer to decompress.
+   * @returns The decompressed buffer.
+   */
+  static decompress(buffer) {
+    return new _LZO()._decompressBuffer(buffer);
+  }
+  /**
+   * Decompresses the given buffer and returns both the decompressed data and bytes read.
+   * @param buffer The buffer to decompress.
+   * @returns Object containing decompressed data and number of bytes consumed from input.
+   */
+  static decompressWithSize(buffer) {
+    const lzo = new _LZO();
+    const decompressed = lzo._decompressBuffer(buffer);
+    return {
+      data: decompressed,
+      bytesRead: lzo._inputPointer
+    };
+  }
+};
+function lzoDecompressWithSize(src, expectedSize) {
+  const input = src instanceof Uint8Array ? src : new Uint8Array(src);
+  const result = LZO.decompressWithSize(input);
+  if (result.data.length !== expectedSize) {
+    throw new Error(`LZO decompression size mismatch: expected ${expectedSize}, got ${result.data.length}`);
+  }
+  return result;
+}
+
+// src/mlod/Vector3.ts
+var Vector3 = class _Vector3 {
+  constructor(x = 0, y = 0, z = 0) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  get length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  }
+  static fromReader(reader) {
+    return new _Vector3(
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat()
+    );
+  }
+  /**
+   * Returns a new Vector3 with the X coordinate flipped.
+   * Useful for converting between coordinate systems (e.g., MLOD to Three.js)
+   */
+  flipX() {
+    return new _Vector3(-this.x, this.y, this.z);
+  }
+  /**
+   * Returns a new Vector3 with the Y coordinate flipped.
+   * Useful for converting between coordinate systems
+   */
+  flipY() {
+    return new _Vector3(this.x, -this.y, this.z);
+  }
+  /**
+   * Returns a new Vector3 with the Z coordinate flipped.
+   * Useful for converting between coordinate systems
+   */
+  flipZ() {
+    return new _Vector3(this.x, this.y, -this.z);
+  }
+  toArray() {
+    return [this.x, this.y, this.z];
+  }
+};
+
+// src/mlod/PointFlags.ts
+var PointFlags = /* @__PURE__ */ ((PointFlags2) => {
+  PointFlags2[PointFlags2["None"] = 0] = "None";
+  PointFlags2[PointFlags2["Selected"] = 1] = "Selected";
+  PointFlags2[PointFlags2["Hidden"] = 2] = "Hidden";
+  PointFlags2[PointFlags2["Locked"] = 4] = "Locked";
+  return PointFlags2;
+})(PointFlags || {});
+
+// src/mlod/Point.ts
+var Point = class _Point extends Vector3 {
+  constructor(x = 0, y = 0, z = 0, flags = 0 /* None */) {
+    super(x, y, z);
+    this.flags = flags;
+  }
+  static fromReader(reader) {
+    const x = reader.readFloat();
+    const y = reader.readFloat();
+    const z = reader.readFloat();
+    const flags = reader.readUInt32();
+    return new _Point(x, y, z, flags);
+  }
+  /**
+   * Returns a new Point with the X coordinate flipped.
+   * Useful for converting between coordinate systems (e.g., MLOD to Three.js)
+   */
+  flipX() {
+    return new _Point(-this.x, this.y, this.z, this.flags);
+  }
+  /**
+   * Returns a new Point with the Y coordinate flipped.
+   * Useful for converting between coordinate systems
+   */
+  flipY() {
+    return new _Point(this.x, -this.y, this.z, this.flags);
+  }
+  /**
+   * Returns a new Point with the Z coordinate flipped.
+   * Useful for converting between coordinate systems
+   */
+  flipZ() {
+    return new _Point(this.x, this.y, -this.z, this.flags);
+  }
+};
+
+// src/mlod/Vertex.ts
+var Vertex = class _Vertex {
+  constructor(pointIndex, normalIndex, u, v) {
+    this.pointIndex = pointIndex;
+    this.normalIndex = normalIndex;
+    this.u = u;
+    this.v = v;
+  }
+  static fromReader(reader) {
+    const pointIndex = reader.readInt32();
+    const normalIndex = reader.readInt32();
+    const u = reader.readFloat();
+    const v = reader.readFloat();
+    return new _Vertex(pointIndex, normalIndex, u, v);
+  }
+};
+
+// src/mlod/Face.ts
+var Face = class _Face {
+  constructor(sidesCnt, vertices, flags, texture, material) {
+    this.sidesCnt = sidesCnt;
+    this.vertices = vertices;
+    this.flags = flags;
+    this.texture = texture;
+    this.material = material;
+  }
+  static fromReader(reader) {
+    const sidesCnt = reader.readInt32();
+    const vertices = [];
+    for (let i = 0; i < 4; i++) {
+      vertices.push(Vertex.fromReader(reader));
+    }
+    const flags = reader.readInt32();
+    const texture = reader.readCString();
+    const material = reader.readCString();
+    return new _Face(sidesCnt, vertices, flags, texture, material);
+  }
+  /**
+   * Get only the used vertices (based on sidesCnt)
+   */
+  getUsedVertices() {
+    return this.vertices.slice(0, this.sidesCnt);
+  }
+};
+
+// src/mlod/TaggReader.ts
+var TaggReader = class {
+  static readTaggs(reader, verticesLength, faces) {
+    const taggSignature = reader.readString(4);
+    if (taggSignature !== "TAGG") {
+      throw new Error("TAGG section expected");
+    }
+    const taggs = [];
+    while (reader.pos < reader.length) {
+      const isActive = reader.readBoolean();
+      if (!isActive) {
+        throw new Error("Deactivated TAGG encountered");
+      }
+      const taggName = reader.readCString();
+      const tagg = this.readTaggByName(reader, taggName, verticesLength, faces);
+      taggs.push(tagg);
+      if (tagg.name === "#EndOfFile#") {
+        break;
+      }
+    }
+    return taggs;
+  }
+  static readTaggByName(reader, taggName, verticesLength, faces) {
+    switch (taggName) {
+      case "#Animation#":
+        return this.readAnimationTagg(reader);
+      case "#Lock#":
+        return this.readLockTagg(reader, verticesLength, faces.length);
+      case "#Mass#":
+        return this.readMassTagg(reader);
+      case "#Property#":
+        return this.readPropertyTagg(reader);
+      case "#Selected#":
+        return this.readSelectedTagg(reader, verticesLength, faces.length);
+      case "#SharpEdges#":
+        return this.readSharpEdgesTagg(reader);
+      case "#UVSet#":
+        return this.readUvSetTagg(reader, faces);
+      case "#EndOfFile#":
+        return this.readEndOfFileTagg(reader);
+      default:
+        return this.readNamedSelectionTagg(reader, taggName, verticesLength, faces.length);
+    }
+  }
+  static readAnimationTagg(reader) {
+    const dataSize = reader.readUInt32();
+    const endPos = reader.pos + dataSize;
+    const frameTime = reader.readFloat();
+    const remainingBytes = endPos - reader.pos;
+    const frameCount = Math.max(0, Math.floor(remainingBytes / 12));
+    const framePoints = new Array(frameCount);
+    for (let i = 0; i < frameCount; i++) {
+      framePoints[i] = Vector3.fromReader(reader);
+    }
+    this.ensureSectionEnd(reader, endPos, "#Animation#");
+    return { kind: "Animation", name: "#Animation#", frameTime, framePoints };
+  }
+  static readLockTagg(reader, verticesLength, facesLength) {
+    const dataSize = reader.readUInt32();
+    const endPos = reader.pos + dataSize;
+    const lockedPoints = new Array(verticesLength);
+    for (let i = 0; i < verticesLength; i++) {
+      lockedPoints[i] = reader.readBoolean();
+    }
+    const lockedFaces = new Array(facesLength);
+    for (let i = 0; i < facesLength; i++) {
+      lockedFaces[i] = reader.readBoolean();
+    }
+    this.ensureSectionEnd(reader, endPos, "#Lock#");
+    return { kind: "Lock", name: "#Lock#", lockedPoints, lockedFaces };
+  }
+  static readMassTagg(reader) {
+    const dataSize = reader.readUInt32();
+    const endPos = reader.pos + dataSize;
+    const entryCount = Math.max(0, Math.floor(dataSize / 4));
+    const mass = new Array(entryCount);
+    for (let i = 0; i < entryCount; i++) {
+      mass[i] = reader.readFloat();
+    }
+    this.ensureSectionEnd(reader, endPos, "#Mass#");
+    return { kind: "Mass", name: "#Mass#", mass };
+  }
+  static readPropertyTagg(reader) {
+    const dataSize = reader.readUInt32();
+    if (dataSize !== 128) {
+      throw new Error(`Unexpected #Property# data size: ${dataSize}`);
+    }
+    const endPos = reader.pos + dataSize;
+    const propName = this.readFixedString(reader, 64);
+    const propValue = this.readFixedString(reader, 64);
+    this.ensureSectionEnd(reader, endPos, "#Property#");
+    return { kind: "Property", name: "#Property#", propName, propValue };
+  }
+  static readSelectedTagg(reader, verticesLength, facesLength) {
+    const dataSize = reader.readUInt32();
+    const endPos = reader.pos + dataSize;
+    const weightedPoints = reader.readBytes(verticesLength);
+    const faces = new Array(facesLength);
+    for (let i = 0; i < facesLength; i++) {
+      faces[i] = reader.readBoolean();
+    }
+    this.ensureSectionEnd(reader, endPos, "#Selected#");
+    return { kind: "Selected", name: "#Selected#", weightedPoints, faces };
+  }
+  static readSharpEdgesTagg(reader) {
+    const dataSize = reader.readUInt32();
+    const endPos = reader.pos + dataSize;
+    const pairCount = Math.max(0, Math.floor(dataSize / 8));
+    const pointIndices = new Array(pairCount);
+    for (let i = 0; i < pairCount; i++) {
+      pointIndices[i] = [reader.readUInt32(), reader.readUInt32()];
+    }
+    this.ensureSectionEnd(reader, endPos, "#SharpEdges#");
+    return { kind: "SharpEdges", name: "#SharpEdges#", pointIndices };
+  }
+  static readUvSetTagg(reader, faces) {
+    const dataSize = reader.readUInt32();
+    const endPos = reader.pos + dataSize;
+    const uvSetNr = reader.readUInt32();
+    const faceUVs = new Array(faces.length);
+    for (let faceIdx = 0; faceIdx < faces.length; faceIdx++) {
+      const vertexCount = faces[faceIdx].sidesCnt;
+      const uvs = new Array(vertexCount);
+      for (let uvIdx = 0; uvIdx < vertexCount; uvIdx++) {
+        uvs[uvIdx] = [reader.readFloat(), reader.readFloat()];
+      }
+      faceUVs[faceIdx] = uvs;
+    }
+    this.ensureSectionEnd(reader, endPos, "#UVSet#");
+    return { kind: "UVSet", name: "#UVSet#", uvSetNr, faceUVs };
+  }
+  static readNamedSelectionTagg(reader, taggName, verticesLength, facesLength) {
+    const dataSize = reader.readUInt32();
+    const endPos = reader.pos + dataSize;
+    const points = new Array(verticesLength);
+    for (let i = 0; i < verticesLength; i++) {
+      points[i] = reader.readBoolean();
+    }
+    const faces = new Array(facesLength);
+    for (let i = 0; i < facesLength; i++) {
+      faces[i] = reader.readBoolean();
+    }
+    this.ensureSectionEnd(reader, endPos, taggName);
+    return { kind: "NamedSelection", name: taggName, points, faces };
+  }
+  static readEndOfFileTagg(reader) {
+    const dataSize = reader.readUInt32();
+    const endPos = reader.pos + dataSize;
+    this.ensureSectionEnd(reader, endPos, "#EndOfFile#");
+    return { kind: "EndOfFile", name: "#EndOfFile#" };
+  }
+  static readFixedString(reader, length) {
+    const raw = reader.readRawString(length);
+    const nullIndex = raw.indexOf("\0");
+    return nullIndex >= 0 ? raw.slice(0, nullIndex) : raw;
+  }
+  static ensureSectionEnd(reader, expectedEnd, taggName) {
+    if (reader.pos !== expectedEnd) {
+      throw new Error(`TAGG ${taggName} length mismatch (expected end ${expectedEnd}, actual ${reader.pos})`);
+    }
+  }
+};
+
+// src/shared/Resolution.ts
+function getLodName(resolution) {
+  if (approxEqual(resolution, 1e3)) return "View-Gunner";
+  if (approxEqual(resolution, 1100)) return "View-Pilot";
+  if ((resolution > 1200 || approxEqual(resolution, 1200)) && resolution < 1300) {
+    return `View-Cargo ${toFixedNumber(resolution, 1200)}`;
+  }
+  if (approxEqual(resolution, 1300)) return "View-Cargo Fire Geom. [obsolete]";
+  if ((resolution > 1e4 || approxEqual(resolution, 1e4)) && resolution < 2e4) {
+    return `ShadowVolume ${toFixedNumber(resolution, 1e4)}`;
+  }
+  if ((resolution > 2e4 || approxEqual(resolution, 2e4)) && resolution < 3e4) {
+    return `Edit ${toFixedNumber(resolution, 2e4)}`;
+  }
+  if (approxEqual(resolution, 1e13)) return "Geometry";
+  if (approxEqual(resolution, 2e13)) return "Geometry Buoyancy";
+  if (approxEqual(resolution, 3e13)) return "Geometry Phys Old";
+  if (approxEqual(resolution, 4e13)) return "Geometry Phys";
+  if (approxEqual(resolution, 1e15)) return "Memory";
+  if (approxEqual(resolution, 2e15)) return "LandContact";
+  if (approxEqual(resolution, 3e15)) return "RoadWay";
+  if (approxEqual(resolution, 4e15)) return "Paths";
+  if (approxEqual(resolution, 5e15)) return "Hit-Points";
+  if (approxEqual(resolution, 6e15)) return "View Geometry";
+  if (approxEqual(resolution, 7e15)) return "Fire Geometry";
+  if ((resolution > 8e15 || approxEqual(resolution, 8e15)) && resolution < 9e15) {
+    return `View-Cargo Geom. ${toFixedNumber(resolution, 8e15)}`;
+  }
+  if (approxEqual(resolution, 9e15)) return "View-Cargo Fire Geom. [obsolete]";
+  if (approxEqual(resolution, 1e16)) return "View-Commander [obsolete]";
+  if (approxEqual(resolution, 11e15)) return "View-Commander Geom. [obsolete]";
+  if (approxEqual(resolution, 12e15)) return "View-Commander Fire Geom. [obsolete]";
+  if (approxEqual(resolution, 13e15)) return "View-Pilot Geom.";
+  if (approxEqual(resolution, 14e15)) return "View-Pilot Fire Geom. [obsolete]";
+  if (approxEqual(resolution, 15e15)) return "View-Gunner Geom.";
+  if (approxEqual(resolution, 16e15)) return "View-Gunner Fire Geom. [obsolete]";
+  if (approxEqual(resolution, 17e15)) return "Sub Parts [obsolete]";
+  if ((resolution > 18e15 || approxEqual(resolution, 18e15)) && resolution < 19e15) {
+    return `ShadowVolume - View Cargo ${toFixedNumber(resolution, 18e15)}`;
+  }
+  if (approxEqual(resolution, 19e15)) return "ShadowVolume - View Pilot";
+  if (approxEqual(resolution, 2e16)) return "ShadowVolume - View Gunner";
+  if (approxEqual(resolution, 21e15)) return "Wreck";
+  return resolution.toFixed(3);
+  function toFixedNumber(value, subtract) {
+    return Math.max(0, value - subtract).toFixed(3);
+  }
+  function approxEqual(a, b, tolerance = 1e-5) {
+    if (Math.abs(a) > 1e10 || Math.abs(b) > 1e10) {
+      const maxVal = Math.max(Math.abs(a), Math.abs(b));
+      return Math.abs(a - b) <= maxVal * tolerance;
+    }
+    return Math.abs(a - b) <= tolerance;
+  }
+}
+
+// src/mlod/MlodLod.ts
+var MlodLod = class _MlodLod {
+  constructor() {
+    this.resolution = 0;
+    this.flags = 0;
+    this.vertices = [];
+    this.normals = [];
+    this.faces = [];
+    this.taggs = [];
+  }
+  get resolutionName() {
+    return getLodName(this.resolution);
+  }
+  get verticesCount() {
+    return this.vertices.length;
+  }
+  get facesCount() {
+    return this.faces.length;
+  }
+  /**
+   * Get unique textures used in this LOD
+   */
+  get textures() {
+    const uniqueTextures = /* @__PURE__ */ new Set();
+    for (const face of this.faces) {
+      if (face.texture) {
+        uniqueTextures.add(face.texture);
+      }
+    }
+    return Array.from(uniqueTextures);
+  }
+  /**
+   * Get unique materials used in this LOD
+   */
+  get materials() {
+    const uniqueMaterials = /* @__PURE__ */ new Set();
+    for (const face of this.faces) {
+      if (face.material) {
+        uniqueMaterials.add(face.material);
+      }
+    }
+    return Array.from(uniqueMaterials);
+  }
+  get namedSelections() {
+    const selections = this.taggs.filter((tagg) => tagg.kind === "NamedSelection").map((tagg) => tagg.name);
+    return selections;
+  }
+  static fromReader(reader) {
+    const lod = new _MlodLod();
+    const signature = reader.readString(4);
+    if (signature !== "P3DM") {
+      const bytes = signature.split("").map((c) => c.charCodeAt(0).toString(16).padStart(2, "0")).join(" ");
+      throw new Error(`Unsupported LOD type: "${signature}" (0x${bytes}) at position ${reader.pos - 4}`);
+    }
+    const majorVersion = reader.readUInt32();
+    const minorVersion = reader.readUInt32();
+    if (majorVersion !== 28 || minorVersion !== 256) {
+      throw new Error(`Unknown P3DM version: ${majorVersion}.${minorVersion}`);
+    }
+    const pointsCnt = reader.readInt32();
+    const normalsCnt = reader.readInt32();
+    const facesCnt = reader.readInt32();
+    lod.flags = reader.readUInt32();
+    lod.vertices = new Array(pointsCnt);
+    for (let i = 0; i < pointsCnt; i++) {
+      lod.vertices[i] = Point.fromReader(reader);
+    }
+    lod.normals = new Array(normalsCnt);
+    for (let i = 0; i < normalsCnt; i++) {
+      lod.normals[i] = Vector3.fromReader(reader);
+    }
+    lod.faces = new Array(facesCnt);
+    for (let i = 0; i < facesCnt; i++) {
+      lod.faces[i] = Face.fromReader(reader);
+    }
+    lod.taggs = TaggReader.readTaggs(reader, lod.vertices.length, lod.faces);
+    lod.resolution = reader.readFloat();
+    return lod;
+  }
+};
+
+// src/mlod/Mlod.ts
+var _Mlod = class _Mlod {
+  constructor() {
+    this.version = 0;
+    this.lods = [];
+  }
+  /**
+   * Read MLOD from a buffer
+   */
+  static fromBuffer(buffer) {
+    const reader = new BinaryReader(buffer);
+    return _Mlod.fromReader(reader);
+  }
+  /**
+   * Read MLOD from a BinaryReader
+   */
+  static fromReader(reader) {
+    const mlod = new _Mlod();
+    const signature = reader.readString(4);
+    if (signature !== "MLOD") {
+      throw new Error(`Expected MLOD signature, got: ${signature}`);
+    }
+    mlod.version = reader.readInt32();
+    if (mlod.version !== _Mlod.SUPPORTED_VERSION) {
+      throw new Error(`Unsupported MLOD version: ${mlod.version} (expected ${_Mlod.SUPPORTED_VERSION})`);
+    }
+    const lodCount = reader.readInt32();
+    mlod.lods = new Array(lodCount);
+    for (let i = 0; i < lodCount; i++) {
+      mlod.lods[i] = MlodLod.fromReader(reader);
+    }
+    return mlod;
+  }
+  /**
+   * Get all unique textures across all LODs
+   */
+  get allTextures() {
+    const textures = /* @__PURE__ */ new Set();
+    for (const lod of this.lods) {
+      for (const texture of lod.textures) {
+        textures.add(texture);
+      }
+    }
+    return Array.from(textures);
+  }
+  /**
+   * Get all unique materials across all LODs
+   */
+  get allMaterials() {
+    const materials = /* @__PURE__ */ new Set();
+    for (const lod of this.lods) {
+      for (const material of lod.materials) {
+        materials.add(material);
+      }
+    }
+    return Array.from(materials);
+  }
+  /**
+   * Get statistics about the model
+   */
+  getStats() {
+    return {
+      version: this.version,
+      lodCount: this.lods.length,
+      totalVertices: this.lods.reduce((sum, lod) => sum + lod.vertices.length, 0),
+      totalFaces: this.lods.reduce((sum, lod) => sum + lod.faces.length, 0),
+      textures: this.allTextures,
+      materials: this.allMaterials
+    };
+  }
+};
+_Mlod.SUPPORTED_VERSION = 257;
+var Mlod = _Mlod;
+
+// src/mlod/FaceFlags.ts
+var FaceFlags = /* @__PURE__ */ ((FaceFlags2) => {
+  FaceFlags2[FaceFlags2["None"] = 0] = "None";
+  FaceFlags2[FaceFlags2["FlatShaded"] = 1] = "FlatShaded";
+  FaceFlags2[FaceFlags2["UserValue"] = 128] = "UserValue";
+  return FaceFlags2;
+})(FaceFlags || {});
+
+// src/odol/index.ts
+var odol_exports = {};
+__export(odol_exports, {
+  Animation: () => Animation,
+  AnimationRTPair: () => AnimationRTPair,
+  AnimationRTWeight: () => AnimationRTWeight,
+  AnimationType: () => AnimationType,
+  Animations: () => Animations,
+  ClipFlags: () => ClipFlags,
+  Color: () => Color,
+  EmbeddedMaterial: () => EmbeddedMaterial,
+  Face: () => Face2,
+  Keyframe: () => Keyframe,
+  LodMetadata: () => LodMetadata,
+  MapType: () => MapType,
+  Matrix3: () => Matrix3,
+  Matrix4: () => Matrix4,
+  ModelInfo: () => ModelInfo,
+  NamedSelection: () => NamedSelection,
+  Odol: () => Odol,
+  OdolLod: () => OdolLod,
+  OdolReader: () => OdolReader,
+  PackedColor: () => PackedColor,
+  Polygons: () => Polygons,
+  ProxyObject: () => ProxyObject,
+  STPair: () => STPair,
+  Section: () => Section,
+  ShadowBufferSource: () => ShadowBufferSource,
+  Skeleton: () => Skeleton,
+  SpecialFlags: () => SpecialFlags,
+  StageTexture: () => StageTexture,
+  StageTransform: () => StageTransform,
+  SubSkeletonIndexSet: () => SubSkeletonIndexSet,
+  UVSet: () => UVSet,
+  Vector3: () => Vector32,
+  VertexData: () => VertexData,
+  VertexNeighborInfo: () => VertexNeighborInfo,
+  getLodName: () => getLodName
+});
+
+// src/odol/math.ts
+var Vector32 = class _Vector3 {
+  constructor(x = 0, y = 0, z = 0) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  get length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  }
+  static fromReader(reader) {
+    return new _Vector3(
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat()
+    );
+  }
+  static readCompressed(reader) {
+    const compressed = reader.readInt32();
+    return _Vector3.fromInt32(compressed);
+  }
+  static fromInt32(compressed) {
+    const scaleFactor = -1 / 511;
+    let x = compressed & 1023;
+    let y = compressed >> 10 & 1023;
+    let z = compressed >> 20 & 1023;
+    if (x > 511) x -= 1024;
+    if (y > 511) y -= 1024;
+    if (z > 511) z -= 1024;
+    return new _Vector3(
+      x * scaleFactor,
+      y * scaleFactor,
+      z * scaleFactor
+    );
+  }
+  distance(v) {
+    const dx = this.x - v.x;
+    const dy = this.y - v.y;
+    const dz = this.z - v.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+  normalize() {
+    const len = this.length;
+    if (len === 0) return new _Vector3(0, 0, 0);
+    return new _Vector3(this.x / len, this.y / len, this.z / len);
+  }
+  toArray() {
+    return [this.x, this.y, this.z];
+  }
+};
+var Matrix3 = class _Matrix3 {
+  constructor(m00 = 0, m01 = 0, m02 = 0, m10 = 0, m11 = 0, m12 = 0, m20 = 0, m21 = 0, m22 = 0) {
+    this.m00 = m00;
+    this.m01 = m01;
+    this.m02 = m02;
+    this.m10 = m10;
+    this.m11 = m11;
+    this.m12 = m12;
+    this.m20 = m20;
+    this.m21 = m21;
+    this.m22 = m22;
+  }
+  static fromReader(reader) {
+    return new _Matrix3(
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat()
+    );
+  }
+};
+var Matrix4 = class _Matrix4 {
+  // 3x3 orientation matrix
+  constructor(m00 = 0, m01 = 0, m02 = 0, m10 = 0, m11 = 0, m12 = 0, m20 = 0, m21 = 0, m22 = 0, px = 0, py = 0, pz = 0) {
+    this.m00 = m00;
+    this.m01 = m01;
+    this.m02 = m02;
+    this.m10 = m10;
+    this.m11 = m11;
+    this.m12 = m12;
+    this.m20 = m20;
+    this.m21 = m21;
+    this.m22 = m22;
+    this.px = px;
+    this.py = py;
+    this.pz = pz;
+  }
+  static fromReader(reader) {
+    return new _Matrix4(
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat(),
+      reader.readFloat()
+    );
+  }
+};
+
+// src/odol/Animation.ts
+var Animation = class {
+  constructor() {
+    this.kind = 0;
+    this.animName = "";
+    this.source = "";
+    this.minValue = 0;
+    this.maxValue = 0;
+    this.minPhase = 0;
+    this.maxPhase = 0;
+    this.sourceAddress = 0;
+  }
+  read(reader, kind) {
+    this.kind = kind;
+    this.animName = reader.readCString();
+    this.source = reader.readCString();
+    this.minPhase = reader.readFloat();
+    this.maxPhase = reader.readFloat();
+    this.minValue = reader.readFloat();
+    this.maxValue = reader.readFloat();
+    this.sourceAddress = reader.readUInt32();
+  }
+};
+var AnimationRotation = class _AnimationRotation extends Animation {
+  constructor() {
+    super(...arguments);
+    this.angle0 = 0;
+    this.angle1 = 0;
+  }
+  static fromReader(reader, kind) {
+    const anim = new _AnimationRotation();
+    anim.read(reader, kind);
+    anim.angle0 = reader.readFloat();
+    anim.angle1 = reader.readFloat();
+    return anim;
+  }
+};
+var AnimationTranslation = class _AnimationTranslation extends Animation {
+  constructor() {
+    super(...arguments);
+    this.offset0 = 0;
+    this.offset1 = 0;
+  }
+  static fromReader(reader, kind) {
+    const anim = new _AnimationTranslation();
+    anim.read(reader, kind);
+    anim.offset0 = reader.readFloat();
+    anim.offset1 = reader.readFloat();
+    return anim;
+  }
+};
+var AnimationDirect = class _AnimationDirect extends Animation {
+  constructor() {
+    super(...arguments);
+    this.axisPos = new Vector32();
+    this.axisDir = new Vector32();
+    this.angle = 0;
+    this.axisOffset = 0;
+  }
+  static fromReader(reader, kind) {
+    const anim = new _AnimationDirect();
+    anim.read(reader, kind);
+    anim.axisPos = Vector32.fromReader(reader);
+    anim.axisDir = Vector32.fromReader(reader);
+    anim.angle = reader.readFloat();
+    anim.axisOffset = reader.readFloat();
+    return anim;
+  }
+};
+var AnimationHide = class _AnimationHide extends Animation {
+  constructor() {
+    super(...arguments);
+    this.hideValue = 0;
+  }
+  static fromReader(reader, kind) {
+    const anim = new _AnimationHide();
+    anim.read(reader, kind);
+    anim.hideValue = reader.readFloat();
+    return anim;
+  }
+};
+function isAnimationDirect(anim) {
+  return anim.kind === 8 /* Direct */;
+}
+function isAnimationHide(anim) {
+  return anim.kind === 9 /* Hide */;
+}
+
+// src/odol/Animations.ts
+var Animations = class _Animations {
+  constructor() {
+    this.animations = [];
+    this.bonesToAnims = [];
+    this.animsToBones = [];
+  }
+  static fromReader(reader) {
+    const animations = new _Animations();
+    const animationCount = reader.readInt32();
+    if (animationCount < 0 || animationCount > 1e4) {
+      throw new Error(`Invalid animations count: ${animationCount}`);
+    }
+    animations.animations = new Array(animationCount);
+    for (let i = 0; i < animationCount; i++) {
+      const kind = reader.readUInt32();
+      switch (kind) {
+        case 0 /* Rotation */:
+        case 1 /* RotationX */:
+        case 2 /* RotationY */:
+        case 3 /* RotationZ */:
+          animations.animations[i] = AnimationRotation.fromReader(reader, kind);
+          break;
+        case 4 /* Translation */:
+        case 5 /* TranslationX */:
+        case 6 /* TranslationY */:
+        case 7 /* TranslationZ */:
+          animations.animations[i] = AnimationTranslation.fromReader(reader, kind);
+          break;
+        case 8 /* Direct */:
+          animations.animations[i] = AnimationDirect.fromReader(reader, kind);
+          break;
+        case 9 /* Hide */:
+          animations.animations[i] = AnimationHide.fromReader(reader, kind);
+          break;
+        default:
+          throw new Error(`Unknown AnimType encountered: ${kind}`);
+      }
+    }
+    const animLodsCount = reader.readInt32();
+    animations.bonesToAnims = new Array(animLodsCount);
+    for (let animLodIdx = 0; animLodIdx < animLodsCount; animLodIdx++) {
+      const length = reader.readUInt32();
+      animations.bonesToAnims[animLodIdx] = new Array(length);
+      for (let i = 0; i < length; i++) {
+        const length2 = reader.readUInt32();
+        animations.bonesToAnims[animLodIdx][i] = new Array(length2);
+        for (let j = 0; j < length2; j++) {
+          animations.bonesToAnims[animLodIdx][i][j] = reader.readUInt32();
+        }
+      }
+    }
+    animations.animsToBones = new Array(animLodsCount);
+    for (let lodIdx = 0; lodIdx < animLodsCount; lodIdx++) {
+      animations.animsToBones[lodIdx] = new Array(animationCount);
+      for (let animIdx = 0; animIdx < animationCount; animIdx++) {
+        const boneIdx = reader.readInt32();
+        if (boneIdx !== -1 && !isAnimationHide(animations.animations[animIdx]) && !isAnimationDirect(animations.animations[animIdx])) {
+          const axisData = [
+            Vector32.fromReader(reader),
+            Vector32.fromReader(reader)
+          ];
+          animations.animsToBones[lodIdx][animIdx] = { boneIdx, axisData };
+        } else {
+          animations.animsToBones[lodIdx][animIdx] = { boneIdx };
+        }
+      }
+    }
+    return animations;
+  }
+};
+
+// src/odol/OdolReader.ts
+var OdolReader = class _OdolReader extends BinaryReader {
+  constructor() {
+    super(...arguments);
+    this.version = 0;
+  }
+  /**
+   * Read an array of elements
+   */
+  readArray(readElement, size) {
+    const count = size ?? this.readInt32();
+    const array = new Array(count);
+    for (let i = 0; i < count; i++) {
+      array[i] = readElement(this);
+    }
+    return array;
+  }
+  /**
+   * Read a compressed array of elements
+   */
+  readCompressedArray(readElement, elemSize) {
+    const size = this.readInt32();
+    const compressed = this.readCompressed(size * elemSize);
+    const tempReader = new _OdolReader(compressed);
+    tempReader.version = this.version;
+    const array = new Array(size);
+    for (let i = 0; i < size; i++) {
+      array[i] = readElement(tempReader);
+    }
+    return array;
+  }
+  /**
+   * Read a compressed fill array (optimized for arrays with many repeated values)
+   */
+  readCompressedFillArray(readElement, sizeOfT) {
+    const size = this.readInt32();
+    const isFilled = this.readBoolean();
+    if (isFilled) {
+      const value = readElement(this);
+      return new Array(size).fill(value);
+    }
+    const compressed = this.readCompressed(size * sizeOfT);
+    const tempReader = new _OdolReader(compressed);
+    tempReader.version = this.version;
+    const array = new Array(size);
+    for (let i = 0; i < size; i++) {
+      array[i] = readElement(tempReader);
+    }
+    return array;
+  }
+  /**
+   * Read compressed data
+   */
+  readCompressed(expectedSize) {
+    if (expectedSize === 0) {
+      return new Uint8Array(0);
+    }
+    const useCompression = expectedSize >= 1024;
+    if (!useCompression) {
+      return this.readBytes(expectedSize);
+    }
+    const worstCompressedSize = expectedSize + Math.floor(expectedSize / 64) + 16 + 3 + 4;
+    const remainingBytes = this.length - this.pos;
+    const bytesToRead = Math.min(worstCompressedSize, remainingBytes);
+    const compressedData = this.readBytes(bytesToRead);
+    const result = lzoDecompressWithSize(compressedData, expectedSize);
+    const bytesNotConsumed = compressedData.length - result.bytesRead;
+    if (bytesNotConsumed > 0) {
+      this.seek(-bytesNotConsumed, "current");
+    }
+    return result.data;
+  }
+  /**
+   * Read compressed vertex index array
+   */
+  readCompressedVertexIndexArray() {
+    return this.readCompressedArray((reader) => reader.readUInt16(), 2);
+  }
+  readCompressedVector3() {
+    const compressed = this.readInt32();
+    return Vector32.fromInt32(compressed);
+  }
+};
+
+// src/odol/enums.ts
+var ClipFlags = /* @__PURE__ */ ((ClipFlags2) => {
+  ClipFlags2[ClipFlags2["DecalNone"] = 0] = "DecalNone";
+  ClipFlags2[ClipFlags2["FogNormal"] = 0] = "FogNormal";
+  ClipFlags2[ClipFlags2["LandNone"] = 0] = "LandNone";
+  ClipFlags2[ClipFlags2["LightNormal"] = 0] = "LightNormal";
+  ClipFlags2[ClipFlags2["None"] = 0] = "None";
+  ClipFlags2[ClipFlags2["Front"] = 1] = "Front";
+  ClipFlags2[ClipFlags2["Back"] = 2] = "Back";
+  ClipFlags2[ClipFlags2["Left"] = 4] = "Left";
+  ClipFlags2[ClipFlags2["Right"] = 8] = "Right";
+  ClipFlags2[ClipFlags2["Bottom"] = 16] = "Bottom";
+  ClipFlags2[ClipFlags2["Top"] = 32] = "Top";
+  ClipFlags2[ClipFlags2["All"] = 63] = "All";
+  ClipFlags2[ClipFlags2["User0"] = 64] = "User0";
+  ClipFlags2[ClipFlags2["MaxUserValue"] = 255] = "MaxUserValue";
+  ClipFlags2[ClipFlags2["LandOn"] = 256] = "LandOn";
+  ClipFlags2[ClipFlags2["LandAbove"] = 512] = "LandAbove";
+  ClipFlags2[ClipFlags2["LandUnder"] = 1024] = "LandUnder";
+  ClipFlags2[ClipFlags2["LandKeep"] = 2048] = "LandKeep";
+  ClipFlags2[ClipFlags2["LandMask"] = 3328] = "LandMask";
+  ClipFlags2[ClipFlags2["DecalNormal"] = 4096] = "DecalNormal";
+  ClipFlags2[ClipFlags2["DecalVertical"] = 8192] = "DecalVertical";
+  ClipFlags2[ClipFlags2["DecalMask"] = 12288] = "DecalMask";
+  ClipFlags2[ClipFlags2["FogDisable"] = 16384] = "FogDisable";
+  ClipFlags2[ClipFlags2["FogSky"] = 32768] = "FogSky";
+  ClipFlags2[ClipFlags2["FogMask"] = 49152] = "FogMask";
+  ClipFlags2[ClipFlags2["UserStep"] = 1048576] = "UserStep";
+  ClipFlags2[ClipFlags2["UserMask"] = 267386880] = "UserMask";
+  ClipFlags2[ClipFlags2["Hints"] = 268435456] = "Hints";
+  ClipFlags2[ClipFlags2["Shining"] = 209715200] = "Shining";
+  ClipFlags2[ClipFlags2["AlwaysInShadow"] = 210763776] = "AlwaysInShadow";
+  ClipFlags2[ClipFlags2["HalfLight"] = 211812352] = "HalfLight";
+  ClipFlags2[ClipFlags2["FullLight"] = 212860928] = "FullLight";
+  return ClipFlags2;
+})(ClipFlags || {});
+var SpecialFlags = /* @__PURE__ */ ((SpecialFlags2) => {
+  SpecialFlags2[SpecialFlags2["None"] = 0] = "None";
+  SpecialFlags2[SpecialFlags2["Unk_2"] = 2] = "Unk_2";
+  SpecialFlags2[SpecialFlags2["Unk_16"] = 16] = "Unk_16";
+  SpecialFlags2[SpecialFlags2["NoShadows"] = 32] = "NoShadows";
+  SpecialFlags2[SpecialFlags2["Unk_256"] = 256] = "Unk_256";
+  SpecialFlags2[SpecialFlags2["Unk_512"] = 512] = "Unk_512";
+  SpecialFlags2[SpecialFlags2["Unk_4096"] = 4096] = "Unk_4096";
+  SpecialFlags2[SpecialFlags2["SectionSpecial"] = 8192] = "SectionSpecial";
+  SpecialFlags2[SpecialFlags2["Unk_16384"] = 16384] = "Unk_16384";
+  SpecialFlags2[SpecialFlags2["Unk_32768"] = 32768] = "Unk_32768";
+  SpecialFlags2[SpecialFlags2["Unk_131072"] = 131072] = "Unk_131072";
+  SpecialFlags2[SpecialFlags2["HiddenVertex"] = 4202496] = "HiddenVertex";
+  SpecialFlags2[SpecialFlags2["ZBiasLow"] = 67108864] = "ZBiasLow";
+  SpecialFlags2[SpecialFlags2["ZBiasMiddle"] = 134217728] = "ZBiasMiddle";
+  SpecialFlags2[SpecialFlags2["ZBiasHigh"] = 201326592] = "ZBiasHigh";
+  return SpecialFlags2;
+})(SpecialFlags || {});
+var ShadowBufferSource = /* @__PURE__ */ ((ShadowBufferSource2) => {
+  ShadowBufferSource2[ShadowBufferSource2["Visual"] = 0] = "Visual";
+  ShadowBufferSource2[ShadowBufferSource2["ShadowVolume"] = 1] = "ShadowVolume";
+  ShadowBufferSource2[ShadowBufferSource2["Explicit"] = 2] = "Explicit";
+  ShadowBufferSource2[ShadowBufferSource2["None"] = 3] = "None";
+  ShadowBufferSource2[ShadowBufferSource2["VisualEx"] = 4] = "VisualEx";
+  return ShadowBufferSource2;
+})(ShadowBufferSource || {});
+var MapType = /* @__PURE__ */ ((MapType2) => {
+  MapType2[MapType2["Tree"] = 0] = "Tree";
+  MapType2[MapType2["SmallTree"] = 1] = "SmallTree";
+  MapType2[MapType2["Bush"] = 2] = "Bush";
+  MapType2[MapType2["Building"] = 3] = "Building";
+  MapType2[MapType2["House"] = 4] = "House";
+  MapType2[MapType2["ForestBorder"] = 5] = "ForestBorder";
+  MapType2[MapType2["ForestTriangle"] = 6] = "ForestTriangle";
+  MapType2[MapType2["ForestSquare"] = 7] = "ForestSquare";
+  MapType2[MapType2["Church"] = 8] = "Church";
+  MapType2[MapType2["Chapel"] = 9] = "Chapel";
+  MapType2[MapType2["Cross"] = 10] = "Cross";
+  MapType2[MapType2["Rock"] = 11] = "Rock";
+  MapType2[MapType2["Bunker"] = 12] = "Bunker";
+  MapType2[MapType2["Fortress"] = 13] = "Fortress";
+  MapType2[MapType2["Fountain"] = 14] = "Fountain";
+  MapType2[MapType2["ViewTower"] = 15] = "ViewTower";
+  MapType2[MapType2["Lighthouse"] = 16] = "Lighthouse";
+  MapType2[MapType2["Quay"] = 17] = "Quay";
+  MapType2[MapType2["Fuelstation"] = 18] = "Fuelstation";
+  MapType2[MapType2["Hospital"] = 19] = "Hospital";
+  MapType2[MapType2["Fence"] = 20] = "Fence";
+  MapType2[MapType2["Wall"] = 21] = "Wall";
+  MapType2[MapType2["Hide"] = 22] = "Hide";
+  MapType2[MapType2["BusStop"] = 23] = "BusStop";
+  MapType2[MapType2["Road"] = 24] = "Road";
+  MapType2[MapType2["Forest"] = 25] = "Forest";
+  MapType2[MapType2["Transmitter"] = 26] = "Transmitter";
+  MapType2[MapType2["Stack"] = 27] = "Stack";
+  MapType2[MapType2["Ruin"] = 28] = "Ruin";
+  MapType2[MapType2["Tourism"] = 29] = "Tourism";
+  MapType2[MapType2["Watertower"] = 30] = "Watertower";
+  MapType2[MapType2["Track"] = 31] = "Track";
+  MapType2[MapType2["MainRoad"] = 32] = "MainRoad";
+  MapType2[MapType2["Rocks"] = 33] = "Rocks";
+  MapType2[MapType2["PowerLines"] = 34] = "PowerLines";
+  MapType2[MapType2["RailWay"] = 35] = "RailWay";
+  return MapType2;
+})(MapType || {});
+var AnimationType = /* @__PURE__ */ ((AnimationType2) => {
+  AnimationType2[AnimationType2["None"] = 0] = "None";
+  AnimationType2[AnimationType2["Software"] = 1] = "Software";
+  AnimationType2[AnimationType2["Hardware"] = 2] = "Hardware";
+  return AnimationType2;
+})(AnimationType || {});
+
+// src/odol/PackedColor.ts
+var PackedColor = class _PackedColor {
+  constructor(value = 0) {
+    this.value = value;
+  }
+  static fromReader(reader) {
+    return new _PackedColor(reader.readUInt32());
+  }
+  get r() {
+    return this.value >> 0 & 255;
+  }
+  get g() {
+    return this.value >> 8 & 255;
+  }
+  get b() {
+    return this.value >> 16 & 255;
+  }
+  get a() {
+    return this.value >> 24 & 255;
+  }
+  toArray() {
+    return [this.r, this.g, this.b, this.a];
+  }
+};
+
+// src/odol/auxiliaryStructures.ts
+var Skeleton = class _Skeleton {
+  constructor() {
+    this.name = "";
+    this.isDiscrete = false;
+    this.bones = [];
+    this.pivotsName = "";
+  }
+  static fromReader(reader) {
+    const skeleton = new _Skeleton();
+    skeleton.name = reader.readCString();
+    if (skeleton.name === "") {
+      return skeleton;
+    }
+    skeleton.isDiscrete = reader.readBoolean();
+    const bonesCnt = reader.readInt32();
+    skeleton.bones = new Array(bonesCnt * 2);
+    for (let i = 0; i < bonesCnt; i++) {
+      skeleton.bones[i * 2] = reader.readCString();
+      skeleton.bones[i * 2 + 1] = reader.readCString();
+    }
+    skeleton.pivotsName = reader.readCString();
+    return skeleton;
+  }
+  getBonePairs() {
+    const pairs = [];
+    for (let i = 0; i < this.bones.length; i += 2) {
+      pairs.push([this.bones[i], this.bones[i + 1]]);
+    }
+    return pairs;
+  }
+};
+var ProxyObject = class _ProxyObject {
+  constructor() {
+    this.proxyModel = "";
+    this.transformation = new Matrix4();
+    this.sequenceId = 0;
+    this.namedSelectionIndex = 0;
+    this.boneIndex = 0;
+    this.sectionIndex = 0;
+  }
+  static fromReader(reader) {
+    const proxy = new _ProxyObject();
+    proxy.proxyModel = reader.readCString();
+    proxy.transformation = Matrix4.fromReader(reader);
+    proxy.sequenceId = reader.readInt32();
+    proxy.namedSelectionIndex = reader.readInt32();
+    proxy.boneIndex = reader.readInt32();
+    proxy.sectionIndex = reader.readInt32();
+    return proxy;
+  }
+};
+var Keyframe = class _Keyframe {
+  constructor() {
+    this.time = 0;
+    this.points = [];
+  }
+  static fromReader(reader) {
+    const keyframe = new _Keyframe();
+    keyframe.time = reader.readFloat();
+    keyframe.points = reader.readArray((r) => Vector32.fromReader(r));
+    return keyframe;
+  }
+};
+var SubSkeletonIndexSet = class _SubSkeletonIndexSet {
+  constructor() {
+    this.subSkeletons = [];
+  }
+  static fromReader(reader) {
+    const set = new _SubSkeletonIndexSet();
+    set.subSkeletons = reader.readArray((r) => r.readInt32());
+    return set;
+  }
+};
+var LodMetadata = class _LodMetadata {
+  constructor() {
+    this.facesCount = 0;
+    this.color = new PackedColor();
+    this.special = 0 /* None */;
+    this.orHints = 0 /* None */;
+    this.hasSkeleton = false;
+    this.verticesCount = 0;
+    this.faceArea = 0;
+  }
+  static fromReader(reader) {
+    const info = new _LodMetadata();
+    info.facesCount = reader.readInt32();
+    info.color = PackedColor.fromReader(reader);
+    info.special = reader.readInt32();
+    info.orHints = reader.readUInt32();
+    info.hasSkeleton = reader.readBoolean();
+    info.verticesCount = reader.readInt32();
+    info.faceArea = reader.readFloat();
+    return info;
+  }
+};
+
+// src/odol/Materials.ts
+var Color = class _Color {
+  constructor() {
+    this.r = 0;
+    this.g = 0;
+    this.b = 0;
+    this.a = 0;
+  }
+  static fromReader(reader) {
+    const color = new _Color();
+    color.r = reader.readFloat();
+    color.g = reader.readFloat();
+    color.b = reader.readFloat();
+    color.a = reader.readFloat();
+    return color;
+  }
+};
+var StageTexture = class _StageTexture {
+  constructor() {
+    this.textureFilter = 0;
+    // TextureFilterType enum
+    this.texture = "";
+    this.stageId = 0;
+    this.useWorldEnvMap = false;
+  }
+  static fromReader(reader) {
+    const stage = new _StageTexture();
+    stage.textureFilter = reader.readUInt32();
+    stage.texture = reader.readCString();
+    stage.stageId = reader.readUInt32();
+    stage.useWorldEnvMap = reader.readBoolean();
+    return stage;
+  }
+};
+var StageTransform = class _StageTransform {
+  constructor() {
+    this.uvSource = 0;
+    // UVSource enum
+    this.transformation = new Matrix4();
+  }
+  static fromReader(reader) {
+    const transform = new _StageTransform();
+    transform.uvSource = reader.readUInt32();
+    transform.transformation = Matrix4.fromReader(reader);
+    return transform;
+  }
+};
+var EmbeddedMaterial = class _EmbeddedMaterial {
+  constructor() {
+    this.materialName = "";
+    this.version = 0;
+    // Color properties (RGBA floats)
+    this.emissive = new Color();
+    this.ambient = new Color();
+    this.diffuse = new Color();
+    this.forcedDiffuse = new Color();
+    this.specular = new Color();
+    this.emissive2 = new Color();
+    this.specular2 = new Color();
+    this.unkCol1 = new Color();
+    this.unkCol2 = new Color();
+    // Material properties
+    this.specularPower = 0;
+    this.pixelShaderId = 0;
+    this.vertexShaderId = 0;
+    this.mainLight = 0;
+    this.fogMode = 0;
+    this.surfaceFile = "";
+    this.nRenderFlags = 0;
+    this.renderFlags = 0;
+    // Stage data
+    this.stageTextures = [];
+    this.stageTransforms = [];
+    this.stageTI = null;
+    // Unknown fields
+    this.unk2 = 0;
+    this.unk3 = 0;
+  }
+  static fromReader(reader) {
+    const material = new _EmbeddedMaterial();
+    material.materialName = reader.readCString();
+    material.version = reader.readUInt32();
+    material.emissive = Color.fromReader(reader);
+    material.ambient = Color.fromReader(reader);
+    material.diffuse = Color.fromReader(reader);
+    material.forcedDiffuse = Color.fromReader(reader);
+    material.specular = Color.fromReader(reader);
+    material.emissive2 = Color.fromReader(reader);
+    material.unkCol1 = Color.fromReader(reader);
+    material.specular2 = Color.fromReader(reader);
+    material.specularPower = reader.readFloat();
+    material.unk2 = reader.readInt32();
+    material.unk3 = reader.readInt32();
+    material.unkCol2 = Color.fromReader(reader);
+    if (material.version >= 20) {
+      const _unk1 = reader.readInt32();
+      const _unk2 = reader.readInt32();
+      const _unk3 = reader.readInt32();
+      const _unk4 = reader.readFloat();
+      const _unk5 = reader.readFloat();
+      const _unk6 = reader.readInt32();
+      const _unk7 = reader.readInt32();
+      const _unk8 = reader.readInt32();
+      const _unk9 = reader.readFloat();
+      const _unk10 = reader.readInt32();
+      const _unk11 = reader.readInt32();
+      const _unk12 = reader.readInt32();
+    }
+    material.pixelShaderId = reader.readUInt32();
+    material.vertexShaderId = reader.readUInt32();
+    material.mainLight = reader.readUInt32();
+    material.fogMode = reader.readUInt32();
+    material.surfaceFile = reader.readCString();
+    material.nRenderFlags = reader.readUInt32();
+    material.renderFlags = reader.readUInt32();
+    const nStages = reader.readInt32();
+    const nTexGens = reader.readInt32();
+    material.stageTextures = new Array(nStages);
+    for (let i = 0; i < nStages; i++) {
+      material.stageTextures[i] = StageTexture.fromReader(reader);
+    }
+    material.stageTransforms = new Array(nTexGens);
+    for (let i = 0; i < nTexGens; i++) {
+      material.stageTransforms[i] = StageTransform.fromReader(reader);
+    }
+    material.stageTI = StageTexture.fromReader(reader);
+    return material;
+  }
+};
+
+// src/odol/structures.ts
+var Face2 = class _Face {
+  constructor() {
+    this.vertexIndices = [];
+    this.size = 0;
+  }
+  static fromReader(reader) {
+    const face = new _Face();
+    const vertexCount = reader.readByte();
+    face.vertexIndices = new Array(vertexCount);
+    for (let i = 0; i < vertexCount; i++) {
+      face.vertexIndices[i] = reader.readUInt16();
+    }
+    face.size = 1 + vertexCount * 2;
+    return face;
+  }
+};
+var Polygons = class _Polygons {
+  constructor() {
+    this.faces = [];
+    this.unk = 0;
+  }
+  static fromReader(reader) {
+    const polygons = new _Polygons();
+    const facesCount = reader.readInt32();
+    const allocationSize = reader.readInt32();
+    polygons.unk = reader.readUInt16();
+    if (polygons.unk !== 0) {
+      console.warn(`Polygons.unk expected to be 0, got: ${polygons.unk}`);
+    }
+    let size = 0;
+    polygons.faces = new Array(facesCount);
+    for (let i = 0; i < facesCount; i++) {
+      polygons.faces[i] = Face2.fromReader(reader);
+      size += polygons.faces[i].size;
+    }
+    size += polygons.faces.length;
+    if (size !== allocationSize) {
+      console.warn(`Polygon allocation size mismatch: expected ${allocationSize}, got ${size}`);
+    }
+    return polygons;
+  }
+};
+var Section = class _Section {
+  constructor() {
+    this.faceLowerIndex = 0;
+    this.faceUpperIndex = 0;
+    this.minBoneIndex = 0;
+    this.bonesCount = 0;
+    this.textureIndex = 0;
+    this.commonFaceFlags = 0 /* None */;
+    this.materialIndex = 0;
+    this.material = "";
+    this.areaOverTex = [];
+    this.unk1 = 0;
+  }
+  static fromReader(reader) {
+    const section = new _Section();
+    section.faceLowerIndex = reader.readInt32();
+    section.faceUpperIndex = reader.readInt32();
+    section.minBoneIndex = reader.readInt32();
+    section.bonesCount = reader.readInt32();
+    section.unk1 = reader.readInt32();
+    section.textureIndex = reader.readUInt16();
+    section.commonFaceFlags = reader.readUInt32();
+    section.materialIndex = reader.readInt32();
+    if (section.materialIndex === -1) {
+      section.material = reader.readCString();
+    }
+    section.areaOverTex = reader.readArray((r) => r.readFloat());
+    return section;
+  }
+  getFaceIndexes(faces) {
+    let curFaceOffset = 0;
+    const faceStride = 8;
+    const quadExtra = 2;
+    const indexes = [];
+    for (let index = 0; index < faces.length; index++) {
+      if (curFaceOffset >= this.faceLowerIndex && curFaceOffset < this.faceUpperIndex) {
+        indexes.push(index);
+      }
+      curFaceOffset += faceStride;
+      if (faces[index].vertexIndices.length === 4) {
+        curFaceOffset += quadExtra;
+      }
+      if (curFaceOffset >= this.faceUpperIndex) break;
+    }
+    return indexes;
+  }
+};
+var NamedSelection = class _NamedSelection {
+  constructor() {
+    this.name = "";
+    this.isSectional = false;
+    this.selectedFaces = [];
+    this.sections = [];
+    this.selectedVertices = [];
+    this.selectedVerticesWeights = new Uint8Array(0);
+  }
+  static fromReader(reader) {
+    const selection = new _NamedSelection();
+    selection.name = reader.readCString();
+    selection.selectedFaces = reader.readCompressedVertexIndexArray();
+    const unk0 = reader.readInt32();
+    if (unk0 !== 0) {
+      console.warn(`NamedSelection: expected 0, got ${unk0}`);
+    }
+    selection.isSectional = reader.readBoolean();
+    selection.sections = reader.readCompressedArray((r) => r.readInt32(), 4);
+    selection.selectedVertices = reader.readCompressedVertexIndexArray();
+    const weightsSize = reader.readInt32();
+    selection.selectedVerticesWeights = reader.readCompressed(weightsSize);
+    return selection;
+  }
+};
+var UVSet = class _UVSet {
+  constructor() {
+    this.minU = 0;
+    this.minV = 0;
+    this.maxU = 0;
+    this.maxV = 0;
+    this.nVertices = 0;
+    this.isDefault = false;
+    this.defaultValue = new Uint8Array(0);
+    this.uvData = new Uint8Array(0);
+  }
+  static fromReader(reader) {
+    const uvSet = new _UVSet();
+    uvSet.minU = reader.readFloat();
+    uvSet.minV = reader.readFloat();
+    uvSet.maxU = reader.readFloat();
+    uvSet.maxV = reader.readFloat();
+    uvSet.nVertices = reader.readInt32();
+    uvSet.isDefault = reader.readBoolean();
+    if (uvSet.isDefault) {
+      uvSet.defaultValue = reader.readBytes(4);
+    } else {
+      uvSet.uvData = reader.readCompressed(uvSet.nVertices * 4);
+    }
+    return uvSet;
+  }
+  /**
+   * Get UV data as float array
+   */
+  getUVData() {
+    const uvData = new Float32Array(this.nVertices * 2);
+    const rangeU = this.maxU - this.minU;
+    const rangeV = this.maxV - this.minV;
+    const view = this.isDefault ? new DataView(this.defaultValue.buffer, this.defaultValue.byteOffset) : new DataView(this.uvData.buffer, this.uvData.byteOffset);
+    if (this.isDefault) {
+      const u = this.decodeUVComponent(view.getInt16(0, true), rangeU, this.minU);
+      const v = this.decodeUVComponent(view.getInt16(2, true), rangeV, this.minV);
+      for (let i = 0; i < this.nVertices; i++) {
+        const dst = i * 2;
+        uvData[dst] = u;
+        uvData[dst + 1] = v;
+      }
+    } else {
+      for (let i = 0; i < this.nVertices; i++) {
+        const src = i * 4;
+        const dst = i * 2;
+        uvData[dst] = this.decodeUVComponent(view.getInt16(src, true), rangeU, this.minU);
+        uvData[dst + 1] = this.decodeUVComponent(view.getInt16(src + 2, true), rangeV, this.minV);
+      }
+    }
+    return uvData;
+  }
+  decodeUVComponent(value, range, min) {
+    return (value + 32767) / 65536 * range + min;
+  }
+};
+
+// src/odol/VertexData.ts
+var AnimationRTPair = class {
+  constructor(selectionIndex, weight) {
+    this.selectionIndex = selectionIndex;
+    this.weight = weight;
+  }
+};
+var AnimationRTWeight = class _AnimationRTWeight {
+  constructor() {
+    this.nSmall = 0;
+    this.smallSpace = new Uint8Array(8);
+  }
+  static fromReader(reader) {
+    const weight = new _AnimationRTWeight();
+    weight.nSmall = reader.readInt32();
+    weight.smallSpace = reader.readBytes(8);
+    return weight;
+  }
+  getAnimationRTPairs() {
+    const pairs = [];
+    for (let i = 0; i < this.nSmall; i++) {
+      pairs.push(new AnimationRTPair(
+        this.smallSpace[i * 2],
+        this.smallSpace[i * 2 + 1]
+      ));
+    }
+    return pairs;
+  }
+};
+var VertexNeighborInfo = class _VertexNeighborInfo {
+  constructor() {
+    this.posA = 0;
+    this.unk1 = 0;
+    this.weightA = null;
+    this.posB = 0;
+    this.unk2 = 0;
+    this.weightB = null;
+  }
+  static fromReader(reader) {
+    const info = new _VertexNeighborInfo();
+    info.posA = reader.readUInt16();
+    info.unk1 = reader.readUInt16();
+    info.weightA = AnimationRTWeight.fromReader(reader);
+    info.posB = reader.readUInt16();
+    info.unk2 = reader.readUInt16();
+    info.weightB = AnimationRTWeight.fromReader(reader);
+    return info;
+  }
+};
+var STPair = class _STPair {
+  constructor() {
+    this.s = new Vector32();
+    this.t = new Vector32();
+  }
+  static fromReader(reader) {
+    const pair = new _STPair();
+    pair.s = reader.readCompressedVector3();
+    pair.t = reader.readCompressedVector3();
+    return pair;
+  }
+};
+var VertexData = class _VertexData {
+  constructor() {
+    this.vertexBoneRefIsSimple = false;
+    this.clipFlags = [];
+    this.uvSets = [];
+    this.vertices = [];
+    this.normals = [];
+    this.stCoords = [];
+    this.vertexBoneRef = [];
+    this.neighborBoneRef = [];
+  }
+  static fromReader(reader) {
+    const data = new _VertexData();
+    data.vertexBoneRefIsSimple = reader.readBoolean();
+    const calcSizeStart = reader.pos;
+    const sizeOfData = reader.readUInt32();
+    const clipFlagsInt = reader.readCompressedFillArray((r) => r.readInt32(), 4);
+    data.clipFlags = clipFlagsInt.map((f) => f);
+    const uvSet0 = UVSet.fromReader(reader);
+    const uvSetCount = reader.readInt32();
+    data.uvSets = new Array(uvSetCount);
+    data.uvSets[0] = uvSet0;
+    for (let i = 1; i < uvSetCount; i++) {
+      data.uvSets[i] = UVSet.fromReader(reader);
+    }
+    data.vertices = reader.readCompressedArray((r) => Vector32.fromReader(r), 12);
+    data.normals = reader.readCompressedFillArray((r) => r.readCompressedVector3(), 4);
+    data.stCoords = reader.readCompressedArray((r) => STPair.fromReader(r), 8);
+    data.vertexBoneRef = reader.readCompressedArray((r) => AnimationRTWeight.fromReader(r), 12);
+    data.neighborBoneRef = reader.readCompressedArray((r) => VertexNeighborInfo.fromReader(r), 32);
+    const size = reader.pos - calcSizeStart;
+    if (size !== sizeOfData) {
+      console.warn(`Vertex Data size mismatch: expected ${sizeOfData}, got ${size}`);
+    }
+    return data;
+  }
+};
+
+// src/odol/OdolLod.ts
+var OdolLod = class _OdolLod {
+  constructor() {
+    this.resolution = 0;
+    this.proxyObjects = [];
+    this.subSkeletonsToSkeleton = [];
+    this.skeletonToSubSkeleton = [];
+    this.vertexCount = 0;
+    this.faceArea = 0;
+    this.orHints = 0 /* None */;
+    this.andHints = 0 /* None */;
+    this.bMin = new Vector32();
+    this.bMax = new Vector32();
+    this.bCenter = new Vector32();
+    this.bRadius = 0;
+    this.textures = [];
+    this.materials = [];
+    this.pointToVertex = [];
+    this.vertexToPoint = [];
+    this.polygons = new Polygons();
+    this.sections = [];
+    this.namedSelections = [];
+    this.namedProperties = [];
+    this.frames = [];
+    this.iconColor = 0;
+    this.selectedColor = 0;
+    this.special = 0 /* None */;
+    this.vertexData = new VertexData();
+    this.lodMetadata = null;
+  }
+  static fromReader(reader) {
+    const lod = new _OdolLod();
+    lod.proxyObjects = reader.readArray((r) => ProxyObject.fromReader(r));
+    lod.subSkeletonsToSkeleton = reader.readArray((r) => r.readInt32());
+    lod.skeletonToSubSkeleton = reader.readArray((r) => SubSkeletonIndexSet.fromReader(r));
+    lod.vertexCount = reader.readUInt32();
+    lod.faceArea = reader.readFloat();
+    lod.orHints = reader.readInt32();
+    lod.andHints = reader.readInt32();
+    lod.bMin = Vector32.fromReader(reader);
+    lod.bMax = Vector32.fromReader(reader);
+    lod.bCenter = Vector32.fromReader(reader);
+    lod.bRadius = reader.readFloat();
+    lod.textures = reader.readArray((r) => r.readCString());
+    lod.materials = reader.readArray((r) => EmbeddedMaterial.fromReader(r));
+    lod.pointToVertex = reader.readCompressedVertexIndexArray();
+    lod.vertexToPoint = reader.readCompressedVertexIndexArray();
+    lod.polygons = Polygons.fromReader(reader);
+    lod.sections = reader.readArray((r) => Section.fromReader(r));
+    lod.namedSelections = reader.readArray((r) => NamedSelection.fromReader(r));
+    const namedPropertiesCnt = reader.readInt32();
+    lod.namedProperties = new Array(namedPropertiesCnt);
+    for (let i = 0; i < namedPropertiesCnt; i++) {
+      const key = reader.readCString();
+      const value = reader.readCString();
+      lod.namedProperties[i] = [key, value];
+    }
+    lod.frames = reader.readArray((r) => Keyframe.fromReader(r));
+    lod.iconColor = reader.readInt32();
+    lod.selectedColor = reader.readUInt32();
+    lod.special = reader.readInt32();
+    lod.vertexData = VertexData.fromReader(reader);
+    return lod;
+  }
+  /**
+   * Get resolution name
+   */
+  get resolutionName() {
+    return getLodName(this.resolution);
+  }
+  /**
+   * Get all unique texture paths
+   */
+  get allTextures() {
+    return [...new Set(this.textures)];
+  }
+  /**
+   * Get all material names
+   */
+  get materialNames() {
+    return this.materials.map((m) => m.materialName);
+  }
+  /**
+   * Get vertices
+   */
+  get vertices() {
+    return this.vertexData.vertices;
+  }
+  get verticesCount() {
+    return this.vertexData.vertices.length;
+  }
+  get facesCount() {
+    return this.polygons.faces.length;
+  }
+  /**
+   * Get face count
+   */
+  get faces() {
+    return this.polygons.faces;
+  }
+  /**
+   * Get statistics about this LOD
+   */
+  getStats() {
+    return {
+      resolution: this.resolution,
+      vertexCount: this.vertices.length,
+      faceCount: this.faces.length,
+      textureCount: this.textures.length,
+      materialCount: this.materials.length,
+      sectionCount: this.sections.length,
+      namedSelectionCount: this.namedSelections.length,
+      proxyCount: this.proxyObjects.length
+    };
+  }
+};
+
+// src/odol/ModelInfo.ts
+var ModelInfo = class _ModelInfo {
+  constructor() {
+    this.special = 0;
+    this.boundingSphere = 0;
+    this.geometrySphere = 0;
+    this.remarks = 0;
+    this.andHints = 0 /* None */;
+    this.orHints = 0 /* None */;
+    this.aimingCenter = new Vector32();
+    this.color = new PackedColor();
+    this.colorType = new PackedColor();
+    this.viewDensity = 0;
+    this.bboxMin = new Vector32();
+    this.bboxMax = new Vector32();
+    this.bboxMinVisual = new Vector32();
+    this.bboxMaxVisual = new Vector32();
+    this.boundingCenter = new Vector32();
+    this.geometryCenter = new Vector32();
+    this.centerOfMass = new Vector32();
+    this.invInertia = new Matrix3();
+    this.autoCenter = false;
+    this.lockAutoCenter = false;
+    this.canOcclude = false;
+    this.canBeOccluded = false;
+    this.unknownBool = false;
+    this.unknownFloat = 0;
+    this.forceNotAlphaModel = false;
+    this.sbSource = 0 /* Visual */;
+    this.preferShadowVolume = false;
+    this.shadowOffset = 0;
+    this.animated = false;
+    this.skeleton = new Skeleton();
+    this.mapType = 0 /* Tree */;
+    this.massArray = [0, 0, 0, 0];
+    this.mass = 0;
+    this.invMass = 0;
+    this.armor = 0;
+    this.invArmor = 0;
+    this.htMin = 0;
+    this.htMax = 0;
+    this.afMax = 0;
+    this.mfMax = 0;
+    this.mFact = 0;
+    this.tBody = 0;
+    this.minShadow = 0;
+    this.canBlend = false;
+    this.propertyClass = "";
+    this.propertyDamage = "";
+    this.propertyFrequent = false;
+    this.memoryIndex = 0;
+    this.geometryIndex = 0;
+    this.unkLodType1Index = 0;
+    this.geometryFireIndex = 0;
+    this.geometryViewIndex = 0;
+    this.geometryViewPilotIndex = 0;
+    this.geometryViewGunnerIndex = 0;
+    this.unkLodType2Index = 0;
+    this.geometryViewCargoIndex = 0;
+    this.landContactIndex = 0;
+    this.roadwayIndex = 0;
+    this.pathsIndex = 0;
+    this.hitpointsIndex = 0;
+  }
+  static fromReader(reader) {
+    const info = new _ModelInfo();
+    info.special = reader.readInt32();
+    info.boundingSphere = reader.readFloat();
+    info.geometrySphere = reader.readFloat();
+    info.remarks = reader.readInt32();
+    info.andHints = reader.readUInt32();
+    info.orHints = reader.readUInt32();
+    info.aimingCenter = Vector32.fromReader(reader);
+    info.color = PackedColor.fromReader(reader);
+    info.colorType = PackedColor.fromReader(reader);
+    info.viewDensity = reader.readFloat();
+    info.bboxMin = Vector32.fromReader(reader);
+    info.bboxMax = Vector32.fromReader(reader);
+    info.bboxMinVisual = Vector32.fromReader(reader);
+    info.bboxMaxVisual = Vector32.fromReader(reader);
+    info.boundingCenter = Vector32.fromReader(reader);
+    info.geometryCenter = Vector32.fromReader(reader);
+    info.centerOfMass = Vector32.fromReader(reader);
+    info.invInertia = Matrix3.fromReader(reader);
+    info.autoCenter = reader.readBoolean();
+    info.lockAutoCenter = reader.readBoolean();
+    info.canOcclude = reader.readBoolean();
+    info.canBeOccluded = reader.readBoolean();
+    info.unknownBool = reader.readBoolean();
+    info.unknownFloat = reader.readFloat();
+    console.warn("Unknown ModelInfo values:", info.unknownBool, info.unknownFloat);
+    info.htMin = reader.readFloat();
+    info.htMax = reader.readFloat();
+    info.afMax = reader.readFloat();
+    info.mfMax = reader.readFloat();
+    info.mFact = reader.readFloat();
+    info.tBody = reader.readFloat();
+    info.forceNotAlphaModel = reader.readBoolean();
+    info.sbSource = reader.readInt32();
+    info.preferShadowVolume = reader.readBoolean();
+    info.shadowOffset = reader.readFloat();
+    info.animated = reader.readBoolean();
+    info.skeleton = Skeleton.fromReader(reader);
+    info.mapType = reader.readByte();
+    info.massArray = reader.readCompressedArray((r) => r.readFloat(), 4);
+    info.mass = reader.readFloat();
+    info.invMass = reader.readFloat();
+    info.armor = reader.readFloat();
+    info.invArmor = reader.readFloat();
+    info.memoryIndex = reader.readByte();
+    info.geometryIndex = reader.readByte();
+    if (reader.version >= 54) {
+      info.unkLodType1Index = reader.readByte();
+    }
+    info.geometryFireIndex = reader.readByte();
+    info.geometryViewIndex = reader.readByte();
+    info.geometryViewPilotIndex = reader.readByte();
+    info.geometryViewGunnerIndex = reader.readByte();
+    info.unkLodType2Index = reader.readByte();
+    info.geometryViewCargoIndex = reader.readByte();
+    info.landContactIndex = reader.readByte();
+    info.roadwayIndex = reader.readByte();
+    info.pathsIndex = reader.readByte();
+    info.hitpointsIndex = reader.readByte();
+    info.minShadow = reader.readUInt32();
+    info.canBlend = reader.readBoolean();
+    info.propertyClass = reader.readCString();
+    info.propertyDamage = reader.readCString();
+    info.propertyFrequent = reader.readBoolean();
+    return info;
+  }
+};
+
+// src/odol/Odol.ts
+var LodInfo = class {
+  constructor() {
+    this.resolution = 0;
+    this.lodStartPosition = 0;
+    this.lodEndPosition = 0;
+    this.hasLodMeta = false;
+    this.lodMetadata = null;
+  }
+};
+var _Odol = class _Odol {
+  constructor() {
+    this.version = 0;
+    this.modelInfo = null;
+    this.lods = [];
+    this.animations = null;
+  }
+  /**
+   * Read ODOL from a buffer
+   */
+  static fromBuffer(buffer) {
+    const reader = new OdolReader(buffer);
+    return _Odol.fromReader(reader);
+  }
+  /**
+   * Read ODOL from an OdolReader
+   */
+  static fromReader(reader) {
+    const odol = new _Odol();
+    const signature = reader.readString(4);
+    if (signature !== "ODOL") {
+      throw new Error(`Expected ODOL signature, got: ${signature}`);
+    }
+    odol.version = reader.readInt32();
+    reader.version = odol.version;
+    if (odol.version > _Odol.MAX_SUPPORTED_VERSION || odol.version < _Odol.MIN_SUPPORTED_VERSION) {
+      throw new Error(`Unsupported ODOL version: ${odol.version}. Supported versions: ${_Odol.MIN_SUPPORTED_VERSION}-${_Odol.MAX_SUPPORTED_VERSION}`);
+    }
+    const lodCount = reader.readInt32();
+    const lodInfos = new Array(lodCount);
+    for (let i = 0; i < lodCount; i++) {
+      lodInfos[i] = new LodInfo();
+      lodInfos[i].resolution = reader.readFloat();
+    }
+    odol.modelInfo = ModelInfo.fromReader(reader);
+    const _unk = reader.readUInt32();
+    const hasAnimations = reader.readBoolean();
+    if (hasAnimations) {
+      odol.animations = Animations.fromReader(reader);
+    }
+    for (let i = 0; i < lodCount; i++) {
+      lodInfos[i].lodStartPosition = reader.readUInt32();
+    }
+    for (let i = 0; i < lodCount; i++) {
+      lodInfos[i].lodEndPosition = reader.readUInt32();
+    }
+    for (let i = 0; i < lodCount; i++) {
+      lodInfos[i].hasLodMeta = !reader.readBoolean();
+    }
+    for (let i = 0; i < lodCount; i++) {
+      if (lodInfos[i].hasLodMeta) {
+        lodInfos[i].lodMetadata = LodMetadata.fromReader(reader);
+      }
+    }
+    const lowestPos = Math.min(...lodInfos.map((info) => info.lodStartPosition));
+    if (reader.pos !== lowestPos) {
+      throw new Error(`Not all data read correctly, expected LODs to start at ${lowestPos}, but current position is ${reader.pos} (Difference: ${lowestPos - reader.pos})`);
+    }
+    odol.lods = new Array(lodCount);
+    for (let i = 0; i < lodCount; i++) {
+      const lodInfo = lodInfos[i];
+      if (lodInfo.lodStartPosition >= reader.length) {
+        continue;
+      }
+      reader.seek(lodInfo.lodStartPosition, "begin");
+      const lod = OdolLod.fromReader(reader);
+      lod.resolution = lodInfo.resolution;
+      lod.lodMetadata = lodInfos[i].lodMetadata;
+      odol.lods[i] = lod;
+      if (lodInfo.lodEndPosition > 0 && lodInfo.lodEndPosition <= reader.length) {
+        if (reader.pos !== lodInfo.lodEndPosition) {
+          console.warn(`LOD[${i}] position mismatch: expected ${lodInfo.lodEndPosition}, got ${reader.pos}`);
+        }
+      }
+    }
+    return odol;
+  }
+  /**
+   * Get skeleton from model info
+   */
+  get skeleton() {
+    return this.modelInfo?.skeleton ?? null;
+  }
+  /**
+   * Get mass from model info
+   */
+  get mass() {
+    return this.modelInfo?.mass ?? 0;
+  }
+  /**
+   * Check if model has animations
+   */
+  get hasAnims() {
+    return this.animations !== null;
+  }
+  /**
+   * Get all unique textures across all LODs
+   */
+  get allTextures() {
+    const textures = /* @__PURE__ */ new Set();
+    for (const lod of this.lods) {
+      for (const texture of lod.textures) {
+        textures.add(texture);
+      }
+    }
+    return Array.from(textures);
+  }
+  get allMaterials() {
+    const materials = /* @__PURE__ */ new Set();
+    for (const lod of this.lods) {
+      for (const material of lod.materials) {
+        materials.add(material.materialName);
+      }
+    }
+    return Array.from(materials);
+  }
+  /**
+   * Get statistics about the model
+   */
+  getStats() {
+    return {
+      version: this.version,
+      lodCount: this.lods.length,
+      totalVertices: this.lods.reduce((sum, lod) => sum + lod.vertices.length, 0),
+      totalFaces: this.lods.reduce((sum, lod) => sum + lod.faces.length, 0),
+      textures: this.allTextures,
+      materials: this.allMaterials,
+      mass: this.mass,
+      hasAnimations: this.hasAnims,
+      skeleton: this.skeleton?.name ?? "none"
+    };
+  }
+};
+_Odol.MIN_SUPPORTED_VERSION = 53;
+_Odol.MAX_SUPPORTED_VERSION = 54;
+var Odol = _Odol;
+export {
+  mlod_exports as MLOD,
+  Mlod,
+  MlodLod,
+  ModelInfo,
+  odol_exports as ODOL,
+  Odol,
+  OdolLod,
+  OdolReader
+};
+/**
+ * LZO1X compression and decompression
+ * Based on https://github.com/thaumictom/lzo-ts
+ * @license GPL-3.0
+ */
+//# sourceMappingURL=index.js.map