@threenative/ueformat 0.1.1

package/dist/index.js

@@ -0,0 +1,861 @@
+import { gunzipSync } from 'fflate';
+import { BufferGeometry, Float32BufferAttribute, LOD, Group, Loader, FileLoader, MeshStandardMaterial, Uint16BufferAttribute, Mesh } from 'three';
+
+// src/errors.ts
+var UEFormatError = class extends Error {
+  code;
+  offset;
+  constructor(code, message, offset = -1, cause) {
+    super(message, cause === void 0 ? void 0 : { cause });
+    this.name = "UEFormatError";
+    this.code = code;
+    this.offset = offset;
+  }
+};
+
+// src/binary.ts
+var BinaryReader = class _BinaryReader {
+  bytes;
+  limits;
+  baseOffset;
+  view;
+  offset = 0;
+  constructor(bytes, limits, baseOffset = 0) {
+    this.bytes = bytes;
+    this.limits = limits;
+    this.baseOffset = baseOffset;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+  get remaining() {
+    return this.bytes.length - this.offset;
+  }
+  get absoluteOffset() {
+    return this.baseOffset + this.offset;
+  }
+  ensure(size) {
+    if (!Number.isSafeInteger(size) || size < 0 || size > this.remaining) {
+      throw new UEFormatError(
+        "TRUNCATED_FILE",
+        `Need ${size} byte(s), but only ${this.remaining} remain`,
+        this.absoluteOffset
+      );
+    }
+  }
+  uint8() {
+    this.ensure(1);
+    return this.view.getUint8(this.offset++);
+  }
+  bool() {
+    const value = this.uint8();
+    if (value > 1) {
+      throw new UEFormatError(
+        "INVALID_LENGTH",
+        `Invalid boolean value ${value}`,
+        this.absoluteOffset - 1
+      );
+    }
+    return value === 1;
+  }
+  uint16() {
+    this.ensure(2);
+    const value = this.view.getUint16(this.offset, true);
+    this.offset += 2;
+    return value;
+  }
+  int32() {
+    this.ensure(4);
+    const value = this.view.getInt32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  uint32() {
+    this.ensure(4);
+    const value = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  float32() {
+    this.ensure(4);
+    const value = this.view.getFloat32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  raw(size) {
+    this.ensure(size);
+    const result = this.bytes.subarray(this.offset, this.offset + size);
+    this.offset += size;
+    return result;
+  }
+  fixedString(size) {
+    return new TextDecoder("utf-8", { fatal: true }).decode(this.raw(size)).replace(/\0+$/, "");
+  }
+  string() {
+    const start = this.absoluteOffset;
+    const size = this.int32();
+    if (size < 0 || size > this.limits.maxStringBytes) {
+      throw new UEFormatError("INVALID_LENGTH", `Invalid string byte length ${size}`, start);
+    }
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(this.raw(size)).replace(/\0+$/, "");
+    } catch (error) {
+      if (error instanceof UEFormatError) throw error;
+      throw new UEFormatError("INVALID_LENGTH", "String is not valid UTF-8", start, error);
+    }
+  }
+  count(label) {
+    const start = this.absoluteOffset;
+    const count = this.int32();
+    if (count < 0 || count > this.limits.maxArrayElements) {
+      throw new UEFormatError("INVALID_COUNT", `Invalid ${label} count ${count}`, start);
+    }
+    return count;
+  }
+  vector2() {
+    return { u: this.float32(), v: this.float32() };
+  }
+  vector3() {
+    return { x: this.float32(), y: this.float32(), z: this.float32() };
+  }
+  quaternion() {
+    return { ...this.vector3(), w: this.float32() };
+  }
+  array(label, read) {
+    const count = this.count(label);
+    const values = new Array(count);
+    for (let index = 0; index < count; index++) values[index] = read(this, index);
+    return values;
+  }
+  chunk(size) {
+    const start = this.absoluteOffset;
+    return new _BinaryReader(this.raw(size), this.limits, start);
+  }
+};
+function toUint8Array(input) {
+  return input instanceof ArrayBuffer ? new Uint8Array(input) : new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+}
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (const byte of bytes) {
+    crc ^= byte;
+    for (let bit = 0; bit < 8; bit++) {
+      crc = crc >>> 1 ^ 3988292384 & -(crc & 1);
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function validateGzipTrailer(compressed, decoded) {
+  if (compressed.length < 18)
+    throw new TypeError("GZIP payload is shorter than its minimum header and trailer");
+  const trailer = new DataView(
+    compressed.buffer,
+    compressed.byteOffset + compressed.byteLength - 8,
+    8
+  );
+  const expectedCrc = trailer.getUint32(0, true);
+  const expectedSize = trailer.getUint32(4, true);
+  if (crc32(decoded) !== expectedCrc || decoded.length >>> 0 !== expectedSize) {
+    throw new TypeError("GZIP CRC32 or ISIZE trailer check failed");
+  }
+}
+function decompressBody(format, compressed, uncompressedSize, zstdDecoder) {
+  let result;
+  try {
+    if (format === "GZIP") {
+      result = gunzipSync(compressed);
+      validateGzipTrailer(compressed, result);
+    } else if (format === "ZSTD") {
+      if (!zstdDecoder) {
+        throw new UEFormatError(
+          "INVALID_COMPRESSION",
+          "ZSTD body requires ParseUEModelOptions.zstdDecoder"
+        );
+      }
+      result = zstdDecoder(compressed, uncompressedSize);
+      if (!(result instanceof Uint8Array)) {
+        throw new TypeError("ZSTD decoder must return Uint8Array");
+      }
+    } else {
+      throw new UEFormatError(
+        "INVALID_COMPRESSION",
+        `Unsupported compression format ${JSON.stringify(format)}`
+      );
+    }
+  } catch (error) {
+    if (error instanceof UEFormatError) throw error;
+    throw new UEFormatError(
+      "DECOMPRESSION_FAILED",
+      `Failed to decompress ${format} body`,
+      -1,
+      error
+    );
+  }
+  if (result.length !== uncompressedSize) {
+    throw new UEFormatError(
+      "SIZE_MISMATCH",
+      `Decoded body has ${result.length} byte(s); header declares ${uncompressedSize}`
+    );
+  }
+  return result;
+}
+
+// src/parser.ts
+var DEFAULT_LIMITS = {
+  maxStringBytes: 16 * 1024 * 1024,
+  maxArrayElements: 5e7,
+  maxAttributes: 1e5
+};
+function readAttributes(reader, handlers, unknown) {
+  const count = reader.int32();
+  if (count < 0 || count > reader.limits.maxAttributes) {
+    throw new UEFormatError(
+      "INVALID_COUNT",
+      `Invalid attribute count ${count}`,
+      reader.absoluteOffset - 4
+    );
+  }
+  for (let index = 0; index < count; index++) {
+    const name = reader.string();
+    const byteSizeOffset = reader.absoluteOffset;
+    const byteSize = reader.int32();
+    if (byteSize < 0) {
+      throw new UEFormatError(
+        "INVALID_LENGTH",
+        `Invalid byte size ${byteSize} for attribute ${name}`,
+        byteSizeOffset
+      );
+    }
+    const payload = reader.chunk(byteSize);
+    const handler = handlers[name];
+    if (!handler) {
+      unknown.push(name);
+      continue;
+    }
+    handler(payload);
+    if (payload.remaining !== 0) {
+      throw new UEFormatError(
+        "ATTRIBUTE_SIZE_MISMATCH",
+        `Attribute ${name} has ${payload.remaining} unread byte(s)`,
+        payload.absoluteOffset
+      );
+    }
+  }
+}
+function readVectorArray(reader, label) {
+  return reader.array(label, (item) => item.vector3());
+}
+function readLod(reader) {
+  const lod = {
+    name: reader.string(),
+    vertices: [],
+    normals: [],
+    tangents: [],
+    texCoords: [],
+    indices: [],
+    vertexColors: [],
+    materials: [],
+    weights: [],
+    morphTargets: [],
+    unknownAttributes: []
+  };
+  readAttributes(
+    reader,
+    {
+      VERTICES(payload) {
+        lod.vertices = readVectorArray(payload, "vertex");
+      },
+      INDICES(payload) {
+        lod.indices = payload.array("index", (item) => item.uint32());
+      },
+      NORMALS(payload) {
+        lod.normals = payload.array("normal", (item) => ({
+          binormalSign: item.float32(),
+          ...item.vector3()
+        }));
+      },
+      TANGENTS(payload) {
+        lod.tangents = readVectorArray(payload, "tangent");
+      },
+      TEXCOORDS(payload) {
+        lod.texCoords = payload.array("texture-coordinate channel", (item) => ({
+          name: item.string(),
+          uvs: item.array("texture coordinate", (uvReader) => uvReader.vector2())
+        }));
+      },
+      VERTEXCOLORS(payload) {
+        lod.vertexColors = payload.array("vertex-color channel", (item) => ({
+          name: item.string(),
+          colors: item.array("vertex color", (colorReader) => ({
+            r: colorReader.uint8(),
+            g: colorReader.uint8(),
+            b: colorReader.uint8(),
+            a: colorReader.uint8()
+          }))
+        }));
+      },
+      MATERIALS(payload) {
+        lod.materials = payload.array("material", (item) => ({
+          materialName: item.string(),
+          materialPath: item.string(),
+          firstIndex: item.int32(),
+          numFaces: item.int32()
+        }));
+      },
+      WEIGHTS(payload) {
+        lod.weights = payload.array("weight", (item) => ({
+          boneIndex: item.uint16(),
+          vertexIndex: item.int32(),
+          weight: item.float32()
+        }));
+      },
+      MORPHTARGETS(payload) {
+        lod.morphTargets = payload.array("morph target", (item) => ({
+          name: item.string(),
+          deltas: item.array("morph delta", (deltaReader) => ({
+            positionDelta: deltaReader.vector3(),
+            tangentZDelta: deltaReader.vector3(),
+            vertexIndex: deltaReader.uint32()
+          }))
+        }));
+      }
+    },
+    lod.unknownAttributes
+  );
+  return lod;
+}
+function readBone(reader) {
+  return {
+    name: reader.string(),
+    parentIndex: reader.int32(),
+    position: reader.vector3(),
+    orientation: reader.quaternion(),
+    scale: reader.vector3()
+  };
+}
+function readSkeleton(reader) {
+  const skeleton = {
+    metadata: "",
+    bones: [],
+    sockets: [],
+    virtualBones: [],
+    unknownAttributes: []
+  };
+  readAttributes(
+    reader,
+    {
+      METADATA(payload) {
+        skeleton.metadata = payload.string();
+      },
+      BONES(payload) {
+        skeleton.bones = payload.array("bone", (item) => readBone(item));
+      },
+      SOCKETS(payload) {
+        skeleton.sockets = payload.array("socket", (item) => ({
+          name: item.string(),
+          boneName: item.string(),
+          relativeLocation: item.vector3(),
+          relativeRotation: item.quaternion(),
+          relativeScale: item.vector3()
+        }));
+      },
+      VIRTUALBONES(payload) {
+        skeleton.virtualBones = payload.array("virtual bone", (item) => ({
+          sourceBoneName: item.string(),
+          targetBoneName: item.string(),
+          virtualBoneName: item.string()
+        }));
+      }
+    },
+    skeleton.unknownAttributes
+  );
+  return skeleton;
+}
+function readCollision(reader) {
+  return {
+    name: reader.string(),
+    vertices: readVectorArray(reader, "collision vertex"),
+    indices: reader.array("collision index", (item) => item.uint32())
+  };
+}
+function parseUEModel(input, options = {}) {
+  const limits = {
+    maxStringBytes: options.maxStringBytes ?? DEFAULT_LIMITS.maxStringBytes,
+    maxArrayElements: options.maxArrayElements ?? DEFAULT_LIMITS.maxArrayElements,
+    maxAttributes: options.maxAttributes ?? DEFAULT_LIMITS.maxAttributes
+  };
+  const reader = new BinaryReader(toUint8Array(input), limits);
+  const magic = reader.fixedString(8);
+  if (magic !== "UEFORMAT") {
+    throw new UEFormatError(
+      "INVALID_MAGIC",
+      `Expected UEFORMAT, received ${JSON.stringify(magic)}`,
+      0
+    );
+  }
+  const identifier = reader.string();
+  if (identifier !== "UEMODEL") {
+    throw new UEFormatError(
+      "INVALID_IDENTIFIER",
+      `Expected UEMODEL, received ${JSON.stringify(identifier)}`,
+      8
+    );
+  }
+  const fileVersion = reader.uint8();
+  if (fileVersion !== 10) {
+    throw new UEFormatError(
+      "UNSUPPORTED_VERSION",
+      `Only UEFormat v10 is supported; received v${fileVersion}`,
+      reader.absoluteOffset - 1
+    );
+  }
+  const objectName = reader.string();
+  const objectPath = reader.string();
+  const compressed = reader.bool();
+  let bodyReader = reader;
+  let compression = null;
+  if (compressed) {
+    const format = reader.string();
+    const uncompressedSize = reader.int32();
+    const compressedSize = reader.int32();
+    if (uncompressedSize < 0 || compressedSize < 0) {
+      throw new UEFormatError(
+        "INVALID_LENGTH",
+        "Compression sizes must be non-negative",
+        reader.absoluteOffset - 8
+      );
+    }
+    if (compressedSize !== reader.remaining) {
+      throw new UEFormatError(
+        "SIZE_MISMATCH",
+        `Compressed body has ${reader.remaining} byte(s); header declares ${compressedSize}`,
+        reader.absoluteOffset
+      );
+    }
+    if (format !== "GZIP" && format !== "ZSTD") {
+      throw new UEFormatError(
+        "INVALID_COMPRESSION",
+        `Unsupported compression format ${JSON.stringify(format)}`,
+        reader.absoluteOffset
+      );
+    }
+    const decoded = decompressBody(
+      format,
+      reader.raw(compressedSize),
+      uncompressedSize,
+      options.zstdDecoder
+    );
+    bodyReader = new BinaryReader(decoded, limits);
+    compression = { format, uncompressedSize, compressedSize };
+  }
+  const header = {
+    magic: "UEFORMAT",
+    identifier: "UEMODEL",
+    fileVersion: 10,
+    objectName,
+    objectPath,
+    compression
+  };
+  const model = {
+    header,
+    lods: [],
+    skeleton: null,
+    collision: [],
+    unknownAttributes: []
+  };
+  readAttributes(
+    bodyReader,
+    {
+      LODS(payload) {
+        model.lods = payload.array("LOD", (item) => readLod(item));
+      },
+      SKELETON(payload) {
+        model.skeleton = readSkeleton(payload);
+      },
+      COLLISION(payload) {
+        model.collision = payload.array("collision mesh", (item) => readCollision(item));
+      }
+    },
+    model.unknownAttributes
+  );
+  if (bodyReader.remaining !== 0) {
+    throw new UEFormatError(
+      "ATTRIBUTE_SIZE_MISMATCH",
+      `Model has ${bodyReader.remaining} trailing byte(s)`,
+      bodyReader.absoluteOffset
+    );
+  }
+  return model;
+}
+function resolveOptions(options) {
+  const coordinateSystem = options.coordinateSystem ?? "three-y-up";
+  const unitScale = options.unitScale ?? 0.01;
+  if (!Number.isFinite(unitScale) || unitScale <= 0) {
+    throw new UEFormatError(
+      "INVALID_GEOMETRY",
+      `unitScale must be positive; received ${unitScale}`
+    );
+  }
+  const repairWinding = options.repairWinding ?? "auto";
+  const flipWinding = repairWinding === "always" || repairWinding === "auto" && coordinateSystem === "three-y-up";
+  return {
+    coordinateSystem,
+    unitScale,
+    flipV: options.flipV ?? coordinateSystem === "three-y-up",
+    flipWinding,
+    ...options.lodDistances === void 0 ? {} : { lodDistances: options.lodDistances },
+    // The default matches three.js's own GLTFLoader: a plain MeshStandardMaterial named after
+    // the slot. No colour, roughness or metalness is decided here — every look parameter comes
+    // from the game, through materialFactory.
+    materialFactory: options.materialFactory ?? ((slot) => new MeshStandardMaterial({ name: slot.materialName }))
+  };
+}
+function convertVector(value, options, scale) {
+  const amount = scale;
+  const clean = (component) => Object.is(component, -0) ? 0 : component;
+  if (options.coordinateSystem === "unreal-z-up") {
+    return [clean(value.x * amount), clean(value.y * amount), clean(value.z * amount)];
+  }
+  return [clean(value.y * amount), clean(value.z * amount), clean(-value.x * amount)];
+}
+function flattenVectors(values, options, scale) {
+  const result = new Array(values.length * 3);
+  let offset = 0;
+  for (const value of values) {
+    const converted = convertVector(value, options, scale);
+    result[offset++] = converted[0];
+    result[offset++] = converted[1];
+    result[offset++] = converted[2];
+  }
+  return result;
+}
+function transformedIndices(indices, flipWinding) {
+  const result = Array.from(indices);
+  if (flipWinding) {
+    for (let index = 0; index + 2 < result.length; index += 3) {
+      const second = result[index + 1] ?? 0;
+      result[index + 1] = result[index + 2] ?? 0;
+      result[index + 2] = second;
+    }
+  }
+  return result;
+}
+function validateLod(lod) {
+  const vertexCount = lod.vertices.length;
+  if (vertexCount === 0) {
+    throw new UEFormatError("INVALID_GEOMETRY", `${lod.name} contains no vertices`);
+  }
+  if (lod.indices.length === 0 || lod.indices.length % 3 !== 0) {
+    throw new UEFormatError(
+      "INVALID_GEOMETRY",
+      `${lod.name} index count must be a non-zero multiple of 3`
+    );
+  }
+  for (const index of lod.indices) {
+    if (!Number.isInteger(index) || index < 0 || index >= vertexCount) {
+      throw new UEFormatError(
+        "INVALID_GEOMETRY",
+        `${lod.name} contains out-of-range index ${index}`
+      );
+    }
+  }
+  for (const [label, count] of [
+    ["normal", lod.normals.length],
+    ["tangent", lod.tangents.length]
+  ]) {
+    if (count !== 0 && count !== vertexCount) {
+      throw new UEFormatError(
+        "INVALID_GEOMETRY",
+        `${lod.name} ${label} count ${count} does not match ${vertexCount} vertices`
+      );
+    }
+  }
+  for (const channel of lod.texCoords) {
+    if (channel.uvs.length !== vertexCount) {
+      throw new UEFormatError(
+        "INVALID_GEOMETRY",
+        `${lod.name} UV channel ${channel.name} has the wrong length`
+      );
+    }
+  }
+  for (const channel of lod.vertexColors) {
+    if (channel.colors.length !== vertexCount) {
+      throw new UEFormatError(
+        "INVALID_GEOMETRY",
+        `${lod.name} color channel ${channel.name} has the wrong length`
+      );
+    }
+  }
+  for (const section of lod.materials) {
+    const count = section.numFaces * 3;
+    if (!Number.isInteger(section.firstIndex) || !Number.isInteger(section.numFaces) || section.firstIndex < 0 || section.numFaces < 0 || section.firstIndex + count > lod.indices.length) {
+      throw new UEFormatError(
+        "INVALID_GEOMETRY",
+        `${lod.name} has an invalid material section ${section.materialName}`
+      );
+    }
+  }
+  for (const target of lod.morphTargets) {
+    for (const delta of target.deltas) {
+      if (delta.vertexIndex < 0 || delta.vertexIndex >= vertexCount) {
+        throw new UEFormatError(
+          "INVALID_GEOMETRY",
+          `${lod.name} morph ${target.name} references vertex ${delta.vertexIndex}`
+        );
+      }
+    }
+  }
+  for (const weight of lod.weights) {
+    if (weight.vertexIndex < 0 || weight.vertexIndex >= vertexCount || weight.boneIndex < 0) {
+      throw new UEFormatError("INVALID_GEOMETRY", `${lod.name} contains an invalid skin weight`);
+    }
+  }
+}
+function addUvAttributes(geometry, lod, options) {
+  lod.texCoords.forEach((channel, channelIndex) => {
+    const values = new Array(channel.uvs.length * 2);
+    let offset = 0;
+    for (const uv of channel.uvs) {
+      values[offset++] = uv.u;
+      values[offset++] = options.flipV ? 1 - uv.v : uv.v;
+    }
+    geometry.setAttribute(
+      channelIndex === 0 ? "uv" : `uv${channelIndex}`,
+      new Float32BufferAttribute(values, 2)
+    );
+  });
+}
+function addColorAttributes(geometry, lod) {
+  lod.vertexColors.forEach((channel, channelIndex) => {
+    const values = new Array(channel.colors.length * 3);
+    let offset = 0;
+    for (const color of channel.colors) {
+      values[offset++] = color.r / 255;
+      values[offset++] = color.g / 255;
+      values[offset++] = color.b / 255;
+    }
+    geometry.setAttribute(
+      channelIndex === 0 ? "color" : `color${channelIndex}`,
+      new Float32BufferAttribute(values, 3)
+    );
+  });
+}
+function addMorphAttributes(geometry, lod, options) {
+  if (lod.morphTargets.length === 0) return;
+  geometry.morphAttributes.position = lod.morphTargets.map((target) => {
+    const values = new Float32Array(lod.vertices.length * 3);
+    for (const delta of target.deltas) {
+      const converted = convertVector(delta.positionDelta, options, options.unitScale);
+      const offset = delta.vertexIndex * 3;
+      values[offset] = converted[0];
+      values[offset + 1] = converted[1];
+      values[offset + 2] = converted[2];
+    }
+    const attribute = new Float32BufferAttribute(values, 3);
+    attribute.name = target.name;
+    return attribute;
+  });
+  geometry.morphTargetsRelative = true;
+}
+function addSkinAttributes(geometry, lod) {
+  if (lod.weights.length === 0) return;
+  const perVertex = /* @__PURE__ */ new Map();
+  for (const weight of lod.weights) {
+    const influences = perVertex.get(weight.vertexIndex) ?? [];
+    influences.push({ bone: weight.boneIndex, weight: weight.weight });
+    perVertex.set(weight.vertexIndex, influences);
+  }
+  const indices = new Uint16Array(lod.vertices.length * 4);
+  const weights = new Float32Array(lod.vertices.length * 4);
+  perVertex.forEach((influences, vertexIndex) => {
+    const selected = influences.filter((influence) => Number.isFinite(influence.weight) && influence.weight > 0).sort((left, right) => right.weight - left.weight).slice(0, 4);
+    const total = selected.reduce((sum, influence) => sum + influence.weight, 0);
+    selected.forEach((influence, influenceIndex) => {
+      const offset = vertexIndex * 4 + influenceIndex;
+      indices[offset] = influence.bone;
+      weights[offset] = total === 0 ? 0 : influence.weight / total;
+    });
+  });
+  geometry.setAttribute("skinIndex", new Uint16BufferAttribute(indices, 4));
+  geometry.setAttribute("skinWeight", new Float32BufferAttribute(weights, 4));
+}
+function createThreeGeometry(lod, adapterOptions = {}) {
+  validateLod(lod);
+  const options = resolveOptions(adapterOptions);
+  const geometry = new BufferGeometry();
+  geometry.name = lod.name;
+  geometry.setAttribute(
+    "position",
+    new Float32BufferAttribute(flattenVectors(lod.vertices, options, options.unitScale), 3)
+  );
+  geometry.setIndex(transformedIndices(lod.indices, options.flipWinding));
+  if (lod.normals.length > 0) {
+    geometry.setAttribute(
+      "normal",
+      new Float32BufferAttribute(flattenVectors(lod.normals, options, 1), 3)
+    );
+  } else {
+    geometry.computeVertexNormals();
+  }
+  if (lod.tangents.length > 0) {
+    const tangents = new Array(lod.tangents.length * 4);
+    let offset = 0;
+    lod.tangents.forEach((tangent, index) => {
+      const converted = convertVector(tangent, options, 1);
+      tangents[offset++] = converted[0];
+      tangents[offset++] = converted[1];
+      tangents[offset++] = converted[2];
+      tangents[offset++] = (lod.normals[index]?.binormalSign ?? 1) * (options.flipWinding ? -1 : 1);
+    });
+    geometry.setAttribute("tangent", new Float32BufferAttribute(tangents, 4));
+  }
+  addUvAttributes(geometry, lod, options);
+  addColorAttributes(geometry, lod);
+  addMorphAttributes(geometry, lod, options);
+  addSkinAttributes(geometry, lod);
+  lod.materials.forEach((section, materialIndex) => {
+    geometry.addGroup(section.firstIndex, section.numFaces * 3, materialIndex);
+  });
+  geometry.userData.ue = {
+    lodName: lod.name,
+    materialSlots: lod.materials,
+    vertexColorChannels: lod.vertexColors.map((channel) => channel.name),
+    uvChannels: lod.texCoords.map((channel) => channel.name)
+  };
+  geometry.computeBoundingBox();
+  geometry.computeBoundingSphere();
+  return geometry;
+}
+function materialSlots(lod) {
+  if (lod.materials.length > 0) return lod.materials;
+  return [
+    {
+      materialName: "DefaultMaterial",
+      materialPath: "",
+      firstIndex: 0,
+      numFaces: lod.indices.length / 3
+    }
+  ];
+}
+function createMesh(lod, options) {
+  const geometry = createThreeGeometry(lod, options);
+  const materials = materialSlots(lod).map(
+    (slot, index) => options.materialFactory(slot, index, lod)
+  );
+  const mesh = new Mesh(geometry, materials.length === 1 ? materials[0] : materials);
+  mesh.name = lod.name;
+  mesh.userData.ue = { lod };
+  return mesh;
+}
+function createCollisionGeometry(collision, options) {
+  const pseudoLod = {
+    name: collision.name,
+    vertices: collision.vertices,
+    normals: [],
+    tangents: [],
+    texCoords: [],
+    indices: collision.indices,
+    vertexColors: [],
+    materials: [],
+    weights: [],
+    morphTargets: []};
+  return createThreeGeometry(pseudoLod, options);
+}
+function createThreeObject(model, adapterOptions = {}) {
+  const options = resolveOptions(adapterOptions);
+  let object;
+  if (model.lods.length > 1) {
+    const lodObject = new LOD();
+    model.lods.forEach((lod, index) => {
+      const defaultDistance = index === 0 ? 0 : 10 * 2 ** (index - 1);
+      const distance = options.lodDistances?.[index] ?? defaultDistance;
+      if (!Number.isFinite(distance) || distance < 0) {
+        throw new UEFormatError("INVALID_GEOMETRY", `LOD distance ${distance} is invalid`);
+      }
+      lodObject.addLevel(createMesh(lod, options), distance);
+    });
+    object = lodObject;
+  } else {
+    const group = new Group();
+    if (model.lods[0]) group.add(createMesh(model.lods[0], options));
+    object = group;
+  }
+  object.name = model.header.objectName;
+  const collisionGeometries = model.collision.map(
+    (collision) => createCollisionGeometry(collision, options)
+  );
+  object.userData.ue = {
+    header: model.header,
+    skeleton: model.skeleton,
+    collisionGeometries,
+    source: model
+  };
+  return object;
+}
+var UEFormatLoader = class extends Loader {
+  options;
+  constructor(manager, options = {}) {
+    super(manager);
+    this.options = options;
+  }
+  parse(data) {
+    return createThreeObject(parseUEModel(data, this.options.parse), this.options.three);
+  }
+  load(url, onLoad, onProgress, onError) {
+    const fileLoader = new FileLoader(this.manager);
+    fileLoader.setPath(this.path);
+    fileLoader.setRequestHeader(this.requestHeader);
+    fileLoader.setWithCredentials(this.withCredentials);
+    fileLoader.setResponseType("arraybuffer");
+    fileLoader.load(
+      url,
+      (data) => {
+        try {
+          if (!(data instanceof ArrayBuffer))
+            throw new TypeError("Expected FileLoader to return an ArrayBuffer");
+          onLoad(this.parse(data));
+        } catch (error) {
+          onError?.(error);
+        }
+      },
+      onProgress,
+      onError
+    );
+    return this;
+  }
+};
+
+// src/summary.ts
+function summarizeUEModel(model) {
+  return {
+    objectName: model.header.objectName,
+    objectPath: model.header.objectPath,
+    formatVersion: model.header.fileVersion,
+    compression: model.header.compression?.format ?? null,
+    lods: model.lods.map((lod) => ({
+      name: lod.name,
+      vertices: lod.vertices.length,
+      triangles: lod.indices.length / 3,
+      materials: lod.materials.map((material) => material.materialName),
+      uvChannels: lod.texCoords.map((channel) => channel.name),
+      vertexColorChannels: lod.vertexColors.map((channel) => channel.name),
+      weights: lod.weights.length,
+      morphTargets: lod.morphTargets.map((target) => target.name)
+    })),
+    skeleton: model.skeleton === null ? null : {
+      bones: model.skeleton.bones.length,
+      sockets: model.skeleton.sockets.length,
+      virtualBones: model.skeleton.virtualBones.length
+    },
+    collisionMeshes: model.collision.map((collision) => ({
+      name: collision.name,
+      vertices: collision.vertices.length,
+      triangles: collision.indices.length / 3
+    })),
+    unknownAttributes: [
+      ...model.unknownAttributes,
+      ...model.lods.flatMap((lod) => lod.unknownAttributes.map((name) => `${lod.name}:${name}`)),
+      ...model.skeleton?.unknownAttributes.map((name) => `SKELETON:${name}`) ?? []
+    ]
+  };
+}
+
+export { UEFormatError, UEFormatLoader, createThreeGeometry, createThreeObject, parseUEModel, summarizeUEModel };