@threepipe/plugin-blend-importer 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -1,11 +1,4 @@
-/**
- * @license
- * @threepipe/plugin-blend-importer v0.1.0
- * Copyright 2022-2025 repalash <palash@shaders.app>
- * Apache-2.0 License
- * See ./dependencies.txt for any bundled third-party dependencies and licenses.
- */
-import { Quaternion, Euler, Vector3, BaseImporterPlugin, Importer, FileLoader, Object3D, Object3D2, PerspectiveCamera0, OrthographicCamera0, PointLight2, PhysicalMaterial, Mesh2, BufferGeometry2, BufferAttribute } from "threepipe";
+import { FrontSide, DoubleSide, Texture, SRGBColorSpace, ClampToEdgeWrapping, MirroredRepeatWrapping, RepeatWrapping, Quaternion, Euler, Vector3, gunzipSync, BaseImporterPlugin, Importer, FileLoader, Object3D, Object3D2, Source, BufferAttribute, BufferGeometry2, AmbientLight2, SpotLight2, DirectionalLight2, PointLight2, OrthographicCamera0, PerspectiveCamera0, UnlitMaterial, PhysicalMaterial, Mesh2, DataTexture } from "threepipe";
 let worker = null;
 const return_object = {
   loadBlendFromArrayBuffer: function(array_buffer) {
@@ -38,6 +31,7 @@ function worker_code() {
       struct_names = [];
       offset = 0;
       current_SDNA_template = null;
+      ERROR = null;
       _data = msg.data;
       AB = _data.slice();
       data = new DataView(_data);
@@ -72,13 +66,30 @@ function worker_code() {
       } else {
         return pointerLow;
       }
+    },
+    // Alignment-safe TypedArray read over the file buffer. Consumers (e.g. loader/geometry.ts)
+    // that reach into `__blender_file__.AB` at a datablock's `__data_address__` MUST use this
+    // instead of `new Ctor(AB, byteOffset, n)` — Blender packs blocks with no padding, so on
+    // v1 (17-byte header) and some v0 files the payload lands at an offset that isn't a multiple
+    // of the element size, where a direct view throws RangeError. All supported files are
+    // little-endian (big-endian is rejected at header parse), so a raw byte copy is correct.
+    readTypedArray: function(Ctor, byteOffset, length) {
+      return alignedTypedArray(Ctor, this.AB, byteOffset, length);
     }
   };
   self.onmessage = parseFile;
+  function alignedTypedArray(Ctor, buffer, byteOffset, length) {
+    if (byteOffset % Ctor.BYTES_PER_ELEMENT === 0) {
+      return new Ctor(buffer, byteOffset, length);
+    }
+    const out = new Ctor(length);
+    new Uint8Array(out.buffer).set(new Uint8Array(buffer, byteOffset, length * Ctor.BYTES_PER_ELEMENT));
+    return out;
+  }
   function float64Prop(offset2, Blender_Array_Length, length) {
     return {
       get: function() {
-        return Blender_Array_Length > 1 ? new Float64Array(this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getFloat64(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
+        return Blender_Array_Length > 1 ? alignedTypedArray(Float64Array, this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getFloat64(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
       },
       set: function(float) {
         if (Blender_Array_Length > 1) ;
@@ -93,7 +104,7 @@ function worker_code() {
   function floatProp(offset2, Blender_Array_Length, length) {
     return {
       get: function() {
-        return Blender_Array_Length > 1 ? new Float32Array(this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getFloat32(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
+        return Blender_Array_Length > 1 ? alignedTypedArray(Float32Array, this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getFloat32(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
       },
       set: function(float) {
         if (Blender_Array_Length > 1) ;
@@ -108,7 +119,7 @@ function worker_code() {
   function intProp(offset2, Blender_Array_Length, length) {
     return {
       get: function() {
-        return Blender_Array_Length > 1 ? new Int32Array(this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getInt32(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
+        return Blender_Array_Length > 1 ? alignedTypedArray(Int32Array, this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getInt32(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
       },
       set: function(float) {
         if (Blender_Array_Length > 1) ;
@@ -120,10 +131,25 @@ function worker_code() {
       configurable: true
     };
   }
+  function uIntProp(offset2, Blender_Array_Length, length) {
+    return {
+      get: function() {
+        return Blender_Array_Length > 1 ? alignedTypedArray(Uint32Array, this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getUint32(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
+      },
+      set: function(float) {
+        if (Blender_Array_Length > 1) ;
+        else {
+          this.__blender_file__.dv.setUint32(this.__data_address__ + offset2, float, this.__blender_file__.template.endianess);
+        }
+      },
+      enumerable: true,
+      configurable: true
+    };
+  }
   function shortProp(offset2, Blender_Array_Length, length) {
     return {
       get: function() {
-        return Blender_Array_Length > 1 ? new Int16Array(this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getInt16(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
+        return Blender_Array_Length > 1 ? alignedTypedArray(Int16Array, this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getInt16(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
       },
       set: function(float) {
         if (Blender_Array_Length > 1) ;
@@ -138,7 +164,7 @@ function worker_code() {
   const uShortProp = (offset2, Blender_Array_Length, length) => {
     return {
       get: function() {
-        return Blender_Array_Length > 1 ? new Uint16Array(this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getUint16(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
+        return Blender_Array_Length > 1 ? alignedTypedArray(Uint16Array, this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getUint16(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
       },
       set: function(float) {
         if (Blender_Array_Length > 1) ;
@@ -186,18 +212,28 @@ function worker_code() {
   function pointerProp2(offset2) {
     return {
       get: function() {
-        let pointer = this.__blender_file__.getPointer(this.__data_address__ + offset2, this.__blender_file__);
-        const link = this.__blender_file__.memory_lookup[pointer];
+        const bf = this.__blender_file__;
+        let pointer = bf.getPointer(this.__data_address__ + offset2, bf);
+        const link = bf.memory_lookup[pointer];
         const results = [];
         if (link) {
           const address = link.__data_address__;
-          let j = 0;
-          while (true) {
-            pointer = this.__blender_file__.getPointer(address + j * 8, this.__blender_file__);
-            let obj = this.__blender_file__.memory_lookup[pointer];
-            if (!obj) break;
-            results.push(obj);
-            j++;
+          const ps = bf.template && bf.template.pointer_size || 8;
+          const count = typeof link.__byte_length__ === "number" && link.__byte_length__ > 0 ? Math.floor(link.__byte_length__ / ps) : 0;
+          if (count > 0) {
+            for (let j = 0; j < count; j++) {
+              pointer = bf.getPointer(address + j * ps, bf);
+              results.push(bf.memory_lookup[pointer] || null);
+            }
+          } else {
+            let j = 0;
+            while (true) {
+              pointer = bf.getPointer(address + j * ps, bf);
+              const obj = bf.memory_lookup[pointer];
+              if (!obj) break;
+              results.push(obj);
+              j++;
+            }
           }
         }
         return results;
@@ -233,6 +269,33 @@ function worker_code() {
       configurable: true
     };
   }
+  function int8Prop(offset2, Blender_Array_Length, length) {
+    return {
+      get: function() {
+        return Blender_Array_Length > 1 ? alignedTypedArray(Int8Array, this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getInt8(this.__data_address__ + offset2);
+      },
+      set: function(v) {
+        if (Blender_Array_Length <= 1) this.__blender_file__.dv.setInt8(this.__data_address__ + offset2, v);
+      },
+      enumerable: true,
+      configurable: true
+    };
+  }
+  function int64Prop(offset2, Blender_Array_Length, length, unsigned) {
+    return {
+      get: function() {
+        if (Blender_Array_Length > 1) {
+          return alignedTypedArray(unsigned ? BigUint64Array : BigInt64Array, this.__blender_file__.AB, this.__data_address__ + offset2, length);
+        }
+        const dv = this.__blender_file__.dv, le = this.__blender_file__.template.endianess;
+        return Number(unsigned ? dv.getBigUint64(this.__data_address__ + offset2, le) : dv.getBigInt64(this.__data_address__ + offset2, le));
+      },
+      set: function() {
+      },
+      enumerable: true,
+      configurable: true
+    };
+  }
   function compileProp(obj, name, type, offset2, array_size, IS_POINTER, pointer_size2, length) {
     if (!IS_POINTER) {
       switch (type) {
@@ -243,18 +306,34 @@ function worker_code() {
           Object.defineProperty(obj, name, floatProp(offset2, array_size, length >> 2));
           break;
         case "int":
+        case "int32_t":
           Object.defineProperty(obj, name, intProp(offset2, array_size, length >> 2));
           break;
+        case "uint32_t":
+          Object.defineProperty(obj, name, uIntProp(offset2, array_size, length >> 2));
+          break;
         case "short":
+        case "int16_t":
           Object.defineProperty(obj, name, shortProp(offset2, array_size, length >> 1));
           break;
         case "ushort":
+        case "uint16_t":
           Object.defineProperty(obj, name, uShortProp(offset2, array_size, length >> 1));
           break;
+        case "int8_t":
+          Object.defineProperty(obj, name, int8Prop(offset2, array_size, length));
+          break;
         case "char":
         case "uchar":
+        case "uint8_t":
           Object.defineProperty(obj, name, charProp(offset2, array_size, length));
           break;
+        case "int64_t":
+          Object.defineProperty(obj, name, int64Prop(offset2, array_size, length >> 3, false));
+          break;
+        case "uint64_t":
+          Object.defineProperty(obj, name, int64Prop(offset2, array_size, length >> 3, true));
+          break;
         default:
           obj[name] = {};
           obj.__list__.push(name, type, length, offset2, array_size, IS_POINTER);
@@ -330,7 +409,7 @@ function worker_code() {
               offset2 = compileProp(blen_struct.prototype, array_name_, type, offset2, Blender_Array_Length, Pointer_Match, pointer_size, array_length);
             }
             Object.defineProperty(blen_struct.prototype, _name, {
-              get: /* @__PURE__ */ function(array_names2) {
+              get: /* @__PURE__ */ (function(array_names2) {
                 return function() {
                   const array = [];
                   for (let i2 = 0; i2 < array_names2.length; i2++) {
@@ -338,7 +417,7 @@ function worker_code() {
                   }
                   return array;
                 };
-              }(array_names),
+              })(array_names),
               enumerable: true,
               configurable: true
             });
@@ -372,6 +451,7 @@ function worker_code() {
       if (this.__list__ === null) return this;
       BLENDER_FILE2.addObject(this);
       this.__blender_file__ = BLENDER_FILE2;
+      this.__byte_length__ = data_block_length - _data_offset;
       const struct = this.__list__;
       let j = 0, i = 0, name = "", type, length, Blender_Array_Length, offset2, constructor;
       this.__data_address__ = _data_offset;
@@ -434,25 +514,53 @@ function worker_code() {
     offset = 0;
     const magic = toString(_data, offset, 7);
     if (magic !== "BLENDER") return ERROR = "File supplied is not a .blend compatible Blender file.";
-    offset += 7;
-    pointer_size = toString(_data, offset++, offset) == "_" ? 4 : 8;
-    BIG_ENDIAN = toString(_data, offset++, offset) !== "V";
-    const version = toString(_data, offset, offset + 3);
-    if (!templates[version]) {
-      templates[version] = new MASTER_SDNA_SCHEMA(version);
+    let version, large_bhead = false;
+    const fmtByte = toString(_data, 7, 8);
+    if (fmtByte === "_" || fmtByte === "-") {
+      pointer_size = fmtByte === "_" ? 4 : 8;
+      BIG_ENDIAN = toString(_data, 8, 9) !== "V";
+      version = toString(_data, 9, 12);
+      offset = 12;
+    } else {
+      const headerSize = parseInt(toString(_data, 7, 9), 10);
+      if (headerSize !== 17) return ERROR = "Unsupported new-style blend header size: " + headerSize;
+      pointer_size = 8;
+      BIG_ENDIAN = true;
+      large_bhead = true;
+      version = toString(_data, 13, 17);
+      offset = headerSize;
+    }
+    if (!BIG_ENDIAN) {
+      return ERROR = "Big-endian .blend files are not supported";
     }
-    current_SDNA_template = templates[version];
+    const BLOCK_HDR = large_bhead ? 32 : 16 + pointer_size;
+    const SDNA_OFF = large_bhead ? 4 : 8 + pointer_size;
+    const LEN_OFF = large_bhead ? 16 : 4;
+    const NR_OFF = large_bhead ? 24 : 12 + pointer_size;
+    const LEN_I64 = large_bhead;
+    const NR_I64 = large_bhead;
+    const readLen = (o) => LEN_I64 ? Number(data.getBigInt64(o + LEN_OFF, true)) : data.getInt32(o + LEN_OFF, true);
+    const readSdna = (o) => data.getInt32(o + SDNA_OFF, BIG_ENDIAN);
+    const readNr = (o) => NR_I64 ? Number(data.getBigInt64(o + NR_OFF, true)) : data.getInt32(o + NR_OFF, BIG_ENDIAN);
+    const templateKey = (large_bhead ? "v1:" : "v0:") + version;
+    if (!templates[templateKey]) {
+      templates[templateKey] = new MASTER_SDNA_SCHEMA(version);
+    }
+    current_SDNA_template = templates[templateKey];
     FILE.template = current_SDNA_template;
-    offset += 3;
     if (!current_SDNA_template.SDNA_SET) {
       current_SDNA_template.endianess = BIG_ENDIAN;
       current_SDNA_template.pointer_size = pointer_size;
       offset2 = offset;
       while (true) {
-        sdna_index = data.getInt32(offset2 + pointer_size + 8, BIG_ENDIAN);
+        if (offset2 + BLOCK_HDR > data.byteLength) {
+          ERROR = "Unexpected end of file while searching for DNA1";
+          break;
+        }
+        sdna_index = readSdna(offset2);
         code = toString(_data, offset2, offset2 + 4).replace(/\u0000/g, "");
-        block_length = data.getInt32(offset2 + 4, true);
-        offset2 += 16 + pointer_size;
+        block_length = readLen(offset2);
+        offset2 += BLOCK_HDR;
         if (code === "DNA1") {
           count = 0;
           let types = [], names = [], lengths = [], curr_name = "";
@@ -550,27 +658,24 @@ function worker_code() {
         }
         break;
       }
-      if (data.getInt8(offset) === 0) {
-        debugger;
-      }
       data_offset = offset;
-      if (offset + pointer_size + 12 >= data.byteLength) {
+      if (offset + BLOCK_HDR > data.byteLength) {
         ERROR = "Unexpected end of file while parsing";
         break;
       }
-      sdna_index = data.getInt32(offset + pointer_size + 8, BIG_ENDIAN);
+      sdna_index = readSdna(offset);
       const code_str = toString(_data, offset, offset + 4);
-      offset2 = offset + 16 + pointer_size;
-      const blockLength = data.getInt32(offset + 4, true);
-      if (blockLength < 0 || offset + blockLength + 16 + pointer_size > data.byteLength) {
+      offset2 = offset + BLOCK_HDR;
+      const blockLength = readLen(offset);
+      if (blockLength < 0 || offset + blockLength + BLOCK_HDR > data.byteLength) {
         ERROR = "Invalid block length detected";
         break;
       }
-      offset += blockLength + 16 + pointer_size;
+      offset += blockLength + BLOCK_HDR;
       if (code_str === "DNA1") ;
       else if (code_str === "ENDB") break;
       else if (code_str === "TEST") {
-        const data_start = data_offset + pointer_size + 16;
+        const data_start = data_offset + BLOCK_HDR;
         const width = data.getInt32(data_start, BIG_ENDIAN);
         const height = data.getInt32(data_start + 4, BIG_ENDIAN);
         if (width * height > 0) {
@@ -579,7 +684,7 @@ function worker_code() {
             ERROR = "Invalid TEST block length detected";
             break;
           }
-          const image_data = new Uint32Array(_data, data_start + 8, data_len >> 2);
+          const image_data = alignedTypedArray(Uint32Array, _data, data_start + 8, data_len >> 2);
           const image = {
             width,
             height,
@@ -588,10 +693,10 @@ function worker_code() {
           FILE.thumbnail = image;
         }
       } else {
-        const data_start = data_offset + pointer_size + 16;
+        const data_start = data_offset + BLOCK_HDR;
         const constructor = current_SDNA_template.getSDNAStructureConstructor(current_SDNA_template.SDNA_NAMES[sdna_index]);
-        const size = data.getInt32(data_offset + 4, BIG_ENDIAN);
-        count = data.getInt32(data_offset + 12 + pointer_size, BIG_ENDIAN);
+        const size = readLen(data_offset);
+        count = readNr(data_offset);
         if (count > 0 && constructor) {
           let obj = new constructor();
           const length = constructor.prototype._length;
@@ -616,18 +721,9 @@ function worker_code() {
   }
 }
 worker = new worker_code();
-worker.postMessage = function(message, err) {
-  return_object.onParseReady(message, err);
+worker.postMessage = function(message, err2) {
+  return_object.onParseReady(message, err2);
 };
-/**
- * JS.Blend
- * Original Repo: https://github.com/acweathersby/js.blend
- * Slightly modified for three.js and js updates, minor refactor.
- * Object-creation part re-written for latest three.js and typescript
- * MIT License
- * Copyright (c) 2020 Anthony C, Weathersby
- * @license
- */
 async function parseBlend(buffer, name = "") {
   return new Promise((res, rej) => {
     return_object.onParseReady = (file, error) => {
@@ -716,14 +812,147 @@ function getLayer(layers, i) {
   if (!Array.isArray(layers)) return layers;
   return layers[i];
 }
+function readCString(block) {
+  if (!block || block.__data_address__ === void 0 || !block.__blender_file__) return null;
+  const u82 = block.__blender_file__.byte;
+  let s = "", o = block.__data_address__;
+  while (o < u82.length && u82[o] !== 0 && s.length < 256) s += String.fromCharCode(u82[o++]);
+  return s;
+}
+const ATTR_TYPE_INT32 = 3, ATTR_TYPE_FLOAT2 = 6, ATTR_TYPE_FLOAT3 = 7;
+const ATTR_DOMAIN_CORNER = 3;
+function getAttributes(meshData) {
+  const as = meshData.attribute_storage;
+  if (!as) return [];
+  let attrs = as.dna_attributes;
+  if (!attrs) return [];
+  attrs = Array.isArray(attrs) || attrs.length !== void 0 ? Array.from(attrs) : [attrs];
+  return attrs;
+}
+function findAttribute(attrs, name, type) {
+  for (const a of attrs) {
+    if (readCString(a.name) === name && (type === void 0 || a.data_type === type)) return a;
+  }
+  return null;
+}
+function attrSize(attr) {
+  const arr = attr && attr.data;
+  const n = arr && arr.size !== void 0 ? Number(arr.size) : 0;
+  return Number.isFinite(n) && n >= 0 ? n : 0;
+}
+function readAttrArray(attr, Ctor, count) {
+  const arr = attr && attr.data;
+  const block = arr && arr.data;
+  if (!block || block.__data_address__ === void 0 || !block.__blender_file__) return null;
+  return block.__blender_file__.readTypedArray(Ctor, block.__data_address__, count);
+}
+function mergeGroupRun(runs, start, count, mat) {
+  if (count <= 0) return;
+  const last = runs[runs.length - 1];
+  if (last && last.mat === mat && last.start + last.count === start) last.count += count;
+  else runs.push({ start, count, mat });
+}
+function readFaceMaterialIndex(meshData, faceCount) {
+  const pd = meshData.pdata;
+  if (!pd || !pd.layers || !pd.totlayer) return null;
+  for (let i = 0; i < pd.totlayer; i++) {
+    const l = getLayer(pd.layers, i);
+    if (l && l.name === "material_index" && l.data) {
+      const data = Array.isArray(l.data) ? l.data : l.data.length !== void 0 ? Array.from(l.data) : null;
+      if (!data) return null;
+      const out = new Array(faceCount);
+      for (let f = 0; f < faceCount; f++) {
+        const e = data[f];
+        out[f] = e && typeof e === "object" ? e.i ?? e.value ?? 0 : e || 0;
+      }
+      return out;
+    }
+  }
+  return null;
+}
+function createBufferGeometryFromAttributes(meshData, ctx) {
+  const attrs = getAttributes(meshData);
+  if (!attrs.length) return null;
+  const posAttr = findAttribute(attrs, "position", ATTR_TYPE_FLOAT3);
+  const vertCount = attrSize(posAttr);
+  const posRaw = vertCount > 0 && readAttrArray(posAttr, Float32Array, vertCount * 3);
+  if (!posRaw) return null;
+  const geometry = new ctx.BufferGeometry();
+  geometry.name = meshData.aname || "";
+  const positions = new Float32Array(vertCount * 3);
+  for (let j = 0; j < vertCount; j++) {
+    const x = posRaw[j * 3], y = posRaw[j * 3 + 1], z = posRaw[j * 3 + 2];
+    positions[j * 3] = Number.isFinite(x) ? x : 0;
+    positions[j * 3 + 1] = Number.isFinite(z) ? z : 0;
+    positions[j * 3 + 2] = Number.isFinite(y) ? -y : 0;
+  }
+  geometry.setAttribute("position", new ctx.BufferAttribute(positions, 3));
+  const cvAttr = findAttribute(attrs, ".corner_vert", ATTR_TYPE_INT32);
+  const loopCount = attrSize(cvAttr);
+  const cornerVerts = loopCount > 0 && readAttrArray(cvAttr, Int32Array, loopCount);
+  const poi = meshData.poly_offset_indices;
+  const faceOffsetCount = poi && poi.__byte_length__ ? poi.__byte_length__ >> 2 : 0;
+  if (cornerVerts && faceOffsetCount > 1 && poi) {
+    const faceIndices = poi.__blender_file__.readTypedArray(Int32Array, poi.__data_address__, faceOffsetCount);
+    const faceCount = faceIndices.length - 1;
+    let totalTriangles = 0;
+    for (let i = 0; i < faceCount; i++) totalTriangles += Math.max(0, faceIndices[i + 1] - faceIndices[i] - 2);
+    const indexes = new Uint32Array(totalTriangles * 3);
+    const inRange = (v) => v >= 0 && v < vertCount;
+    const matAttr = (meshData.totcol || 0) > 1 ? findAttribute(attrs, "material_index", ATTR_TYPE_INT32) : null;
+    const faceMat = matAttr && attrSize(matAttr) >= faceCount ? readAttrArray(matAttr, Int32Array, faceCount) : null;
+    const groupRuns = [];
+    let t = 0;
+    for (let i = 0; i < faceCount; i++) {
+      const faceStart = faceIndices[i], faceVertCount = faceIndices[i + 1] - faceStart;
+      const triStart = t;
+      if (faceVertCount >= 3 && faceStart >= 0 && faceStart + faceVertCount <= loopCount) {
+        const firstVert = cornerVerts[faceStart];
+        for (let k = 1; k < faceVertCount - 1; k++) {
+          const b = cornerVerts[faceStart + k], c = cornerVerts[faceStart + k + 1];
+          if (inRange(firstVert) && inRange(b) && inRange(c)) {
+            indexes[t++] = firstVert;
+            indexes[t++] = b;
+            indexes[t++] = c;
+          }
+        }
+      }
+      if (faceMat) mergeGroupRun(groupRuns, triStart, t - triStart, faceMat[i] || 0);
+    }
+    geometry.setIndex(new ctx.BufferAttribute(t === indexes.length ? indexes : indexes.slice(0, t), 1));
+    if (faceMat) for (const g of groupRuns) geometry.addGroup(g.start, g.count, g.mat);
+    const uvAttr = attrs.find((a) => a.data_type === ATTR_TYPE_FLOAT2 && a.domain === ATTR_DOMAIN_CORNER && !(readCString(a.name) || ".").startsWith("."));
+    const uvRaw = uvAttr && attrSize(uvAttr) >= loopCount && readAttrArray(uvAttr, Float32Array, loopCount * 2);
+    if (uvRaw) {
+      const uvs = new Float32Array(vertCount * 2);
+      for (let i = 0; i < loopCount; i++) {
+        const v = cornerVerts[i];
+        if (v >= 0 && v < vertCount) {
+          const u = uvRaw[i * 2], vv = uvRaw[i * 2 + 1];
+          uvs[v * 2] = Number.isFinite(u) ? u : 0;
+          uvs[v * 2 + 1] = Number.isFinite(vv) ? vv : 0;
+        }
+      }
+      geometry.setAttribute("uv", new ctx.BufferAttribute(uvs, 2));
+    }
+  }
+  if (geometry.attributes.position && !geometry.attributes.normal)
+    geometry.computeVertexNormals();
+  return geometry;
+}
 function createBufferGeometry(meshData, ctx) {
   if (meshData.mpoly) return createBufferGeometryOld(meshData, ctx);
+  if (meshData.attribute_storage) {
+    const g = createBufferGeometryFromAttributes(meshData, ctx);
+    if (g) return g;
+  }
   const geometry = new ctx.BufferGeometry();
   geometry.name = meshData.aname || "";
   let vertices;
   let verticesData;
   let indices;
   let indicesData;
+  let uvLayerData = null;
   if (meshData.vdata && meshData.vdata.layers && meshData.vdata.totlayer > 0) {
     for (let i = 0; i < meshData.vdata.totlayer; i++) {
       const layer = getLayer(meshData.vdata.layers, i);
@@ -742,7 +971,12 @@ function createBufferGeometry(meshData, ctx) {
       const layer = getLayer(meshData.ldata.layers, i);
       const data = layer.data || [];
       if (data.length === meshData.totloop) {
-        if (indices && (layer.name !== ".corner_vert" || indices.name === ".corner_vert")) {
+        const lname = layer.name || "";
+        if (!uvLayerData && (layer.type === 49 || lname[0] !== "." && /uv/i.test(lname))) {
+          uvLayerData = data;
+          continue;
+        }
+        if (indices && (lname !== ".corner_vert" || indices.name === ".corner_vert")) {
           continue;
         }
         indices = layer;
@@ -752,9 +986,44 @@ function createBufferGeometry(meshData, ctx) {
   }
   let faceIndices = [];
   if (meshData.poly_offset_indices && meshData.totpoly > 0) {
-    faceIndices = [...new Int32Array(meshData.poly_offset_indices.__blender_file__.AB, meshData.poly_offset_indices.__data_address__, meshData.totpoly + 1)];
+    faceIndices = [...meshData.poly_offset_indices.__blender_file__.readTypedArray(Int32Array, meshData.poly_offset_indices.__data_address__, meshData.totpoly + 1)];
+  }
+  const vco = (vd) => vd?.x !== void 0 ? [vd.x, vd.y, vd.z] : vd?.co ? [vd.co[0], vd.co[1], vd.co[2]] : [0, 0, 0];
+  let cornerToVert = null;
+  let expandedPos = null;
+  let expandedUv = null;
+  if (uvLayerData && indicesData && verticesData && verticesData.length) {
+    cornerToVert = new Int32Array(indicesData.length);
+    const seen = /* @__PURE__ */ new Map();
+    const ps = [], us = [];
+    const uvN = uvLayerData.length;
+    for (let i = 0; i < indicesData.length; i++) {
+      const bv = indicesData[i]?.i;
+      if (!(bv >= 0 && bv < verticesData.length)) {
+        cornerToVert[i] = 0;
+        continue;
+      }
+      const e = i < uvN ? uvLayerData[i] : null;
+      const u = e && Number.isFinite(e.x) ? e.x : 0;
+      const w = e && Number.isFinite(e.y) ? e.y : 0;
+      const key = bv + "|" + Math.round(u * 4096) + "|" + Math.round(w * 4096);
+      let ev = seen.get(key);
+      if (ev === void 0) {
+        ev = us.length / 2;
+        seen.set(key, ev);
+        const [x, y, z] = vco(verticesData[bv]);
+        ps.push(x, z, -y);
+        us.push(u, w);
+      }
+      cornerToVert[i] = ev;
+    }
+    expandedPos = new Float32Array(ps);
+    expandedUv = new Float32Array(us);
   }
-  if (verticesData && verticesData.length > 0) {
+  const vAt = (corner) => cornerToVert ? cornerToVert[corner] : indicesData[corner].i;
+  if (expandedPos) {
+    geometry.setAttribute("position", new ctx.BufferAttribute(expandedPos, 3));
+  } else if (verticesData && verticesData.length > 0) {
     const positions = new Float32Array(verticesData.length * 3);
     for (let j = 0; j < verticesData.length; j++) {
       const { x, y, z, co } = verticesData[j] || {};
@@ -773,44 +1042,50 @@ function createBufferGeometry(meshData, ctx) {
     }
     geometry.setAttribute("position", new ctx.BufferAttribute(positions, 3));
   }
-  if (indicesData && indicesData.length > 0 && (verticesData == null ? void 0 : verticesData.length)) {
+  if (indicesData && indicesData.length > 0 && verticesData?.length) {
     const faceSize = meshData.totloop / meshData.totpoly;
     if (faceIndices.length > 0) {
+      const faceCount = faceIndices.length - 1;
       let totalTriangles = 0;
-      for (let i = 0; i < faceIndices.length - 1; i++) {
+      for (let i = 0; i < faceCount; i++) {
         const faceVertCount = faceIndices[i + 1] - faceIndices[i];
         totalTriangles += Math.max(0, faceVertCount - 2);
       }
       const indexes = new Uint32Array(totalTriangles * 3);
       let t = 0;
-      for (let i = 0; i < faceIndices.length - 1; i++) {
+      const faceMat = (meshData.totcol || 0) > 1 ? readFaceMaterialIndex(meshData, faceCount) : null;
+      const groupRuns = [];
+      for (let i = 0; i < faceCount; i++) {
         const faceStart = faceIndices[i];
         const faceEnd = faceIndices[i + 1];
         const faceVertCount = faceEnd - faceStart;
+        const triStart = t;
         if (faceVertCount >= 3) {
-          const firstVert = indicesData[faceStart].i;
+          const firstVert = vAt(faceStart);
           for (let k = 1; k < faceVertCount - 1; k++) {
             indexes[t++] = firstVert;
-            indexes[t++] = indicesData[faceStart + k].i;
-            indexes[t++] = indicesData[faceStart + k + 1].i;
+            indexes[t++] = vAt(faceStart + k);
+            indexes[t++] = vAt(faceStart + k + 1);
           }
         }
+        if (faceMat) mergeGroupRun(groupRuns, triStart, t - triStart, faceMat[i] || 0);
       }
       geometry.setIndex(new ctx.BufferAttribute(indexes, 1));
+      if (faceMat) for (const g of groupRuns) geometry.addGroup(g.start, g.count, g.mat);
     } else if (faceSize === 3 || faceSize === 4) {
       const isQuad = faceSize === 4;
       const faceCount = indices.length / faceSize;
       const indexes = new Uint32Array(faceCount * 3 * (isQuad ? 2 : 1));
       if (faceSize !== 3 && faceSize !== 4) return geometry;
       for (let j = 0, t = 0; j < indices.length; j += faceSize) {
-        const a = indices[j].i;
-        const b = indices[j + 1].i;
-        const c = indices[j + 2].i;
+        const a = vAt(j);
+        const b = vAt(j + 1);
+        const c = vAt(j + 2);
         indexes[t++] = a;
         indexes[t++] = b;
         indexes[t++] = c;
         if (isQuad) {
-          const d = indices[j + 3].i;
+          const d = vAt(j + 3);
           indexes[t++] = a;
           indexes[t++] = c;
           indexes[t++] = d;
@@ -821,6 +1096,9 @@ function createBufferGeometry(meshData, ctx) {
   } else if (faceIndices) {
     console.error("BlendLoader - no indices data found, but face indices are present", faceIndices);
   }
+  if (expandedUv && !geometry.attributes.uv) {
+    geometry.setAttribute("uv", new ctx.BufferAttribute(expandedUv, 2));
+  }
   if (geometry.attributes.position && !geometry.attributes.normal)
     geometry.computeVertexNormals();
   return geometry;
@@ -836,9 +1114,12 @@ function createBufferGeometryOld(mesh, ctx) {
   const positions = new Float32Array(size * 3);
   let currentIndex = 0;
   let computeNormals = false;
+  const useGroups = (mesh.totcol || 0) > 1;
+  const groupRuns = [];
   for (const face of faces) {
     const len = face.totloop;
     const start = face.loopstart;
+    const faceStartIndex = currentIndex;
     let indexi = 1;
     while (indexi < len) {
       let index = 0;
@@ -870,34 +1151,294 @@ function createBufferGeometryOld(mesh, ctx) {
       }
       indexi += 2;
     }
+    if (useGroups) mergeGroupRun(groupRuns, faceStartIndex, currentIndex - faceStartIndex, face.mat_nr || 0);
   }
   geometry.setAttribute("position", new ctx.BufferAttribute(positions, 3));
   geometry.setIndex(new ctx.BufferAttribute(indices, 1));
   geometry.setAttribute("normal", new ctx.BufferAttribute(normals, 3));
   geometry.setAttribute("uv", new ctx.BufferAttribute(uvs, 2));
+  if (useGroups && groupRuns.length)
+    for (const g of groupRuns) geometry.addGroup(g.start, g.count, g.mat);
   if (computeNormals) {
     geometry.computeVertexNormals();
   }
   return geometry;
 }
+const MA_BL_CULL_BACKFACE = 1 << 2;
+const MA_BM_CLIP = 3;
+function listBaseToArray(lb) {
+  const out = [];
+  if (!lb) return out;
+  let n = lb.first, guard = 0;
+  while (n && guard++ < 8192) {
+    out.push(n);
+    n = n.next;
+  }
+  return out;
+}
+const idnameOf = (n) => n && typeof n.idname === "string" ? n.idname : "";
+const nameOf = (s) => s && typeof s.name === "string" ? s.name : "";
+function socketByName(sockets, ...names) {
+  for (const name of names) {
+    const s = sockets.find((x) => nameOf(x) === name);
+    if (s) return s;
+  }
+  return null;
+}
+function inputsOf(node) {
+  return node ? listBaseToArray(node.inputs) : [];
+}
+function socketConst(sock) {
+  const dv = sock && sock.default_value;
+  return dv ? dv.value : void 0;
+}
+const num = (v) => typeof v === "number" ? v : void 0;
+const clamp01 = (c) => Math.max(0, Math.min(1, c));
+function nodeFeeding(links, socket) {
+  if (!socket) return null;
+  let link = links.find((l) => l.tosock === socket);
+  let guard = 0;
+  while (link && idnameOf(link.fromnode).includes("Reroute") && guard++ < 32) {
+    const re = inputsOf(link.fromnode)[0];
+    link = links.find((l) => l.tosock === re);
+  }
+  return link ? link.fromnode : null;
+}
+function imageMime(b) {
+  if (b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71) return "image/png";
+  if (b[0] === 255 && b[1] === 216 && b[2] === 255) return "image/jpeg";
+  if (b[0] === 66 && b[1] === 77) return "image/bmp";
+  if (b[0] === 82 && b[1] === 73 && b[2] === 70 && b[3] === 70 && b[8] === 87 && b[9] === 69) return "image/webp";
+  return null;
+}
+function packedTexture(imageNode, srgb) {
+  const img = imageNode && imageNode.id;
+  if (!img) return null;
+  const pf = img.packedfile || img.packedfiles && img.packedfiles.first && img.packedfiles.first.packedfile;
+  const block = pf && pf.data;
+  const size = pf && typeof pf.size === "number" ? pf.size : 0;
+  if (!block || block.__data_address__ === void 0 || size <= 0) return null;
+  const buf = block.__blender_file__.byte.buffer;
+  if (block.__data_address__ + size > buf.byteLength) return null;
+  const bytes = new Uint8Array(buf, block.__data_address__, size).slice();
+  const mime = imageMime(bytes);
+  if (!mime || typeof Blob === "undefined" || typeof URL === "undefined" || typeof Image === "undefined") return null;
+  const url = URL.createObjectURL(new Blob([bytes], { type: mime }));
+  const el = new Image();
+  const texture = new Texture(el);
+  if (srgb) texture.colorSpace = SRGBColorSpace;
+  texture.name = (typeof img.aname === "string" ? img.aname : "") || "blendTexture";
+  el.onload = () => {
+    texture.needsUpdate = true;
+    URL.revokeObjectURL(url);
+  };
+  el.onerror = () => {
+    URL.revokeObjectURL(url);
+  };
+  el.src = url;
+  return texture;
+}
+const IMA_SRC_GENERATED = 4, IMA_SRC_VIEWER = 5;
+function applyWrap(tex, imageNode) {
+  if (!tex) return tex;
+  const ext = imageNode?.storage?.extension;
+  tex.wrapS = tex.wrapT = ext === 1 || ext === 2 ? ClampToEdgeWrapping : ext === 3 ? MirroredRepeatWrapping : RepeatWrapping;
+  tex.needsUpdate = true;
+  return tex;
+}
+function imageNodeTexture(imageNode, srgb, ctx) {
+  const packed = packedTexture(imageNode, srgb);
+  if (packed) return applyWrap(packed, imageNode);
+  const img = imageNode && imageNode.id;
+  if (img && img.source !== IMA_SRC_GENERATED && img.source !== IMA_SRC_VIEWER && typeof img.name === "string" && img.name && ctx.loadExternalTexture) {
+    return applyWrap(ctx.loadExternalTexture(img.name, srgb), imageNode);
+  }
+  return null;
+}
+function imageNodeFeeding(links, socket) {
+  let src = nodeFeeding(links, socket);
+  if (src && idnameOf(src).includes("NormalMap")) src = nodeFeeding(links, socketByName(inputsOf(src), "Color"));
+  return src && idnameOf(src).includes("TexImage") ? src : null;
+}
+function textureFromSocket(links, socket, srgb, ctx) {
+  const src = imageNodeFeeding(links, socket);
+  return src ? imageNodeTexture(src, srgb, ctx) : null;
+}
+function resolveShaders(nodes, links) {
+  const outputs = nodes.filter((n) => idnameOf(n).includes("OutputMaterial"));
+  const activeOut = outputs.find((n) => n.is_active_output) || outputs[0];
+  let principled = null, emission = null;
+  if (activeOut) {
+    let surf = nodeFeeding(links, socketByName(inputsOf(activeOut), "Surface"));
+    let guard = 0;
+    while (surf && !idnameOf(surf).includes("BsdfPrincipled") && guard++ < 4) {
+      if (idnameOf(surf).includes("Emission") && !emission) emission = surf;
+      const next = inputsOf(surf).map((s) => nodeFeeding(links, s)).find((n) => n && idnameOf(n).includes("BsdfPrincipled"));
+      if (!next) break;
+      surf = next;
+    }
+    if (surf && idnameOf(surf).includes("BsdfPrincipled")) principled = surf;
+  }
+  if (!principled) principled = nodes.find((n) => idnameOf(n).includes("BsdfPrincipled"));
+  if (!emission) emission = nodes.find((n) => idnameOf(n) === "ShaderNodeEmission");
+  return { principled, emission };
+}
 function createMaterial(mat, ctx) {
   const material = new ctx.MeshPhysicalMaterial();
-  material.color.setRGB(mat.r, mat.g, mat.b);
-  material.roughness = mat.roughness !== void 0 ? mat.roughness : 0.4;
-  material.metalness = mat.metallic !== void 0 ? mat.metallic : 0;
-  material.opacity = 1;
-  material.transparent = material.opacity < 1;
+  material.side = typeof mat.blend_flag === "number" && mat.blend_flag & MA_BL_CULL_BACKFACE ? FrontSide : DoubleSide;
+  const nodes = mat.nodetree ? listBaseToArray(mat.nodetree.nodes) : [];
+  const links = mat.nodetree ? listBaseToArray(mat.nodetree.links) : [];
+  const { principled, emission } = resolveShaders(nodes, links);
+  let applied = false;
+  if (principled) {
+    const inp = inputsOf(principled);
+    applied = true;
+    const baseSock = socketByName(inp, "Base Color", "BaseColor");
+    const baseImgNode = imageNodeFeeding(links, baseSock);
+    const baseTex = baseImgNode ? imageNodeTexture(baseImgNode, true, ctx) : null;
+    if (baseTex) {
+      material.map = baseTex;
+      material.color.setRGB(1, 1, 1);
+    } else {
+      const base = socketConst(baseSock);
+      if (base && base.length >= 3) material.color.setRGB(clamp01(base[0]), clamp01(base[1]), clamp01(base[2]));
+    }
+    const roughSock = socketByName(inp, "Roughness");
+    const roughTex = textureFromSocket(links, roughSock, false, ctx);
+    if (roughTex) material.roughnessMap = roughTex;
+    else {
+      const r = num(socketConst(roughSock));
+      if (r !== void 0) material.roughness = r;
+    }
+    const metalSock = socketByName(inp, "Metallic");
+    const metalTex = textureFromSocket(links, metalSock, false, ctx);
+    if (metalTex) material.metalnessMap = metalTex;
+    else {
+      const m = num(socketConst(metalSock));
+      if (m !== void 0) material.metalness = m;
+    }
+    const normSrc = nodeFeeding(links, socketByName(inp, "Normal"));
+    if (normSrc) {
+      const normTex = textureFromSocket(links, socketByName(inp, "Normal"), false, ctx);
+      if (normTex) {
+        material.normalMap = normTex;
+        const strength = num(socketConst(socketByName(inputsOf(normSrc), "Strength")));
+        if (strength !== void 0 && material.normalScale) material.normalScale.set(strength, strength);
+      }
+    }
+    const alphaSock = socketByName(inp, "Alpha");
+    const alphaImgNode = imageNodeFeeding(links, alphaSock);
+    const alphaFromBase = !!(alphaImgNode && baseImgNode && alphaImgNode === baseImgNode);
+    const alphaTex = alphaImgNode && !alphaFromBase ? imageNodeTexture(alphaImgNode, false, ctx) : null;
+    const alphaC = num(socketConst(alphaSock));
+    const hasAlpha = !!alphaTex || alphaFromBase || alphaC !== void 0 && alphaC < 1;
+    if (alphaTex) material.alphaMap = alphaTex;
+    else if (!alphaFromBase && alphaC !== void 0 && alphaC < 1) material.opacity = alphaC;
+    if (hasAlpha) {
+      if (mat.blend_method === MA_BM_CLIP) {
+        const thr = num(mat.alpha_threshold);
+        material.alphaTest = thr !== void 0 && thr > 0 ? thr : 0.5;
+      } else material.transparent = true;
+    }
+    const ior = num(socketConst(socketByName(inp, "IOR")));
+    if (ior !== void 0 && material.ior !== void 0) material.ior = ior;
+    const trans = num(socketConst(socketByName(inp, "Transmission Weight", "Transmission")));
+    if (trans !== void 0 && trans > 0 && material.transmission !== void 0) {
+      material.transmission = trans;
+    }
+    const coat = num(socketConst(socketByName(inp, "Coat Weight", "Clearcoat")));
+    if (coat !== void 0 && coat > 0 && material.clearcoat !== void 0) {
+      material.clearcoat = coat;
+      const cr = num(socketConst(socketByName(inp, "Coat Roughness", "Clearcoat Roughness")));
+      if (cr !== void 0) material.clearcoatRoughness = cr;
+    }
+    const sheen = num(socketConst(socketByName(inp, "Sheen Weight", "Sheen")));
+    if (sheen !== void 0 && sheen > 0 && material.sheen !== void 0) {
+      material.sheen = sheen;
+      const stint = socketConst(socketByName(inp, "Sheen Tint"));
+      if (stint && stint.length >= 3 && material.sheenColor) material.sheenColor.setRGB(stint[0], stint[1], stint[2]);
+      const sr = num(socketConst(socketByName(inp, "Sheen Roughness")));
+      if (sr !== void 0) material.sheenRoughness = sr;
+    }
+    const spec = num(socketConst(socketByName(inp, "Specular IOR Level", "Specular")));
+    if (spec !== void 0 && material.specularIntensity !== void 0) {
+      material.specularIntensity = Math.min(1, spec * 2);
+    }
+  }
+  const matOutput = nodes.find((n) => idnameOf(n).includes("OutputMaterial") && n.is_active_output) || nodes.find((n) => idnameOf(n).includes("OutputMaterial"));
+  const dispNode = matOutput ? nodeFeeding(links, socketByName(inputsOf(matOutput), "Displacement")) : null;
+  if (dispNode && idnameOf(dispNode).includes("Displacement")) {
+    const heightTex = textureFromSocket(links, socketByName(inputsOf(dispNode), "Height"), false, ctx);
+    if (heightTex) {
+      const scale = num(socketConst(socketByName(inputsOf(dispNode), "Scale")));
+      const s = scale !== void 0 && scale > 0 ? scale : 1;
+      const mid = num(socketConst(socketByName(inputsOf(dispNode), "Midlevel")));
+      if (material.displacementMap !== void 0) {
+        material.displacementMap = heightTex;
+        material.displacementScale = s;
+        material.displacementBias = -(mid ?? 0.5) * s;
+      }
+      if (!material.normalMap && material.bumpMap !== void 0) {
+        material.bumpMap = heightTex;
+        material.bumpScale = s;
+      }
+    }
+  }
+  const emSock = emission ? socketByName(inputsOf(emission), "Color") : principled ? socketByName(inputsOf(principled), "Emission Color", "Emission") : null;
+  const emStrSock = emission ? socketByName(inputsOf(emission), "Strength") : principled ? socketByName(inputsOf(principled), "Emission Strength") : null;
+  const emTex = textureFromSocket(links, emSock, true, ctx);
+  let emCol = socketConst(emSock);
+  if (emTex && (!emCol || emCol.length < 3 || !emCol[0] && !emCol[1] && !emCol[2])) emCol = [1, 1, 1];
+  if (emCol && emCol.length >= 3 && (emCol[0] || emCol[1] || emCol[2] || emTex)) {
+    const f = [emCol[0], emCol[1], emCol[2]];
+    const strength = num(socketConst(emStrSock));
+    if (typeof strength === "number") for (let i = 0; i < 3; i++) f[i] *= strength;
+    const peak = Math.max(f[0], f[1], f[2]);
+    if (peak > 1) {
+      material.emissiveIntensity = peak;
+      material.emissive.setRGB(f[0] / peak, f[1] / peak, f[2] / peak);
+    } else material.emissive.setRGB(f[0], f[1], f[2]);
+  }
+  if (!applied) {
+    if (mat.r !== void 0) material.color.setRGB(mat.r, mat.g, mat.b);
+    material.roughness = mat.roughness !== void 0 ? mat.roughness : 0.4;
+    material.metalness = mat.metallic !== void 0 ? mat.metallic : 0;
+  }
   return material;
 }
 function createMesh(object, loaded, ctx) {
   if (!object.data) {
     return void 0;
   }
-  const geometry = loaded.get(object.data) ?? createBufferGeometry(object.data, ctx);
-  loaded.set(object.data, geometry);
-  const mat = object.data.mat[0];
-  const material = mat ? loaded.get(mat) ?? createMaterial(mat, ctx) : new ctx.MeshPhysicalMaterial();
-  if (mat) loaded.set(mat, material);
+  let geometry = loaded.get(object.data);
+  if (!geometry) {
+    geometry = createBufferGeometry(object.data, ctx);
+    loaded.set(object.data, geometry);
+  }
+  const matData = object.data.mat;
+  const slots = Array.isArray(matData) ? matData : matData ? [matData] : [];
+  const buildMaterial = (m) => {
+    if (!m) {
+      const d = new ctx.MeshPhysicalMaterial();
+      d.side = DoubleSide;
+      return d;
+    }
+    const cached = loaded.get(m);
+    if (cached) return cached;
+    const created = createMaterial(m, ctx);
+    loaded.set(m, created);
+    return created;
+  };
+  const hasGroups = !!(geometry.groups && geometry.groups.length);
+  let material;
+  if (hasGroups) {
+    material = slots.map(buildMaterial);
+    let maxIdx = 0;
+    for (const g of geometry.groups) if (g.materialIndex > maxIdx) maxIdx = g.materialIndex;
+    while (material.length <= maxIdx) material.push(buildMaterial(null));
+  } else {
+    material = buildMaterial(slots[0]);
+  }
   const mesh = new ctx.Mesh(geometry, material);
   mesh.castShadow = true;
   mesh.receiveShadow = true;
@@ -997,25 +1538,743 @@ function setTransform(object, obj) {
   obj.updateMatrix();
   if (obj.setDirty) obj.setDirty();
 }
+var ab = ArrayBuffer, u8 = Uint8Array, u16 = Uint16Array, i16 = Int16Array, i32 = Int32Array;
+var slc = function(v, s, e) {
+  if (u8.prototype.slice)
+    return u8.prototype.slice.call(v, s, e);
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  var n = new u8(e - s);
+  n.set(v.subarray(s, e));
+  return n;
+};
+var fill = function(v, n, s, e) {
+  if (u8.prototype.fill)
+    return u8.prototype.fill.call(v, n, s, e);
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  for (; s < e; ++s)
+    v[s] = n;
+  return v;
+};
+var cpw = function(v, t, s, e) {
+  if (u8.prototype.copyWithin)
+    return u8.prototype.copyWithin.call(v, t, s, e);
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  while (s < e) {
+    v[t++] = v[s++];
+  }
+};
+var ec = [
+  "invalid zstd data",
+  "window size too large (>2046MB)",
+  "invalid block type",
+  "FSE accuracy too high",
+  "match distance too far back",
+  "unexpected EOF"
+];
+var err = function(ind, msg, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var rb = function(d, b, n) {
+  var i = 0, o = 0;
+  for (; i < n; ++i)
+    o |= d[b++] << (i << 3);
+  return o;
+};
+var b4 = function(d, b) {
+  return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+};
+var rzfh = function(dat, w) {
+  var n3 = dat[0] | dat[1] << 8 | dat[2] << 16;
+  if (n3 == 3126568 && dat[3] == 253) {
+    var flg = dat[4];
+    var ss = flg >> 5 & 1, cc = flg >> 2 & 1, df = flg & 3, fcf = flg >> 6;
+    if (flg & 8)
+      err(0);
+    var bt = 6 - ss;
+    var db = df == 3 ? 4 : df;
+    var di = rb(dat, bt, db);
+    bt += db;
+    var fsb = fcf ? 1 << fcf : ss;
+    var fss = rb(dat, bt, fsb) + (fcf == 1 && 256);
+    var ws = fss;
+    if (!ss) {
+      var wb = 1 << 10 + (dat[5] >> 3);
+      ws = wb + (wb >> 3) * (dat[5] & 7);
+    }
+    if (ws > 2145386496)
+      err(1);
+    var buf = new u8((w == 1 ? fss || ws : w ? 0 : ws) + 12);
+    buf[0] = 1, buf[4] = 4, buf[8] = 8;
+    return {
+      b: bt + fsb,
+      y: 0,
+      l: 0,
+      d: di,
+      w: w && w != 1 ? w : buf.subarray(12),
+      e: ws,
+      o: new i32(buf.buffer, 0, 3),
+      u: fss,
+      c: cc,
+      m: Math.min(131072, ws)
+    };
+  } else if ((n3 >> 4 | dat[3] << 20) == 25481893) {
+    return b4(dat, 4) + 8;
+  }
+  err(0);
+};
+var msb = function(val) {
+  var bits = 0;
+  for (; 1 << bits <= val; ++bits)
+    ;
+  return bits - 1;
+};
+var rfse = function(dat, bt, mal) {
+  var tpos = (bt << 3) + 4;
+  var al = (dat[bt] & 15) + 5;
+  if (al > mal)
+    err(3);
+  var sz = 1 << al;
+  var probs = sz, sym = -1, re = -1, i = -1, ht = sz;
+  var buf = new ab(512 + (sz << 2));
+  var freq = new i16(buf, 0, 256);
+  var dstate = new u16(buf, 0, 256);
+  var nstate = new u16(buf, 512, sz);
+  var bb1 = 512 + (sz << 1);
+  var syms = new u8(buf, bb1, sz);
+  var nbits = new u8(buf, bb1 + sz);
+  while (sym < 255 && probs > 0) {
+    var bits = msb(probs + 1);
+    var cbt = tpos >> 3;
+    var msk = (1 << bits + 1) - 1;
+    var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (tpos & 7) & msk;
+    var msk1fb = (1 << bits) - 1;
+    var msv = msk - probs - 1;
+    var sval = val & msk1fb;
+    if (sval < msv)
+      tpos += bits, val = sval;
+    else {
+      tpos += bits + 1;
+      if (val > msk1fb)
+        val -= msv;
+    }
+    freq[++sym] = --val;
+    if (val == -1) {
+      probs += val;
+      syms[--ht] = sym;
+    } else
+      probs -= val;
+    if (!val) {
+      do {
+        var rbt = tpos >> 3;
+        re = (dat[rbt] | dat[rbt + 1] << 8) >> (tpos & 7) & 3;
+        tpos += 2;
+        sym += re;
+      } while (re == 3);
+    }
+  }
+  if (sym > 255 || probs)
+    err(0);
+  var sympos = 0;
+  var sstep = (sz >> 1) + (sz >> 3) + 3;
+  var smask = sz - 1;
+  for (var s = 0; s <= sym; ++s) {
+    var sf = freq[s];
+    if (sf < 1) {
+      dstate[s] = -sf;
+      continue;
+    }
+    for (i = 0; i < sf; ++i) {
+      syms[sympos] = s;
+      do {
+        sympos = sympos + sstep & smask;
+      } while (sympos >= ht);
+    }
+  }
+  if (sympos)
+    err(0);
+  for (i = 0; i < sz; ++i) {
+    var ns = dstate[syms[i]]++;
+    var nb = nbits[i] = al - msb(ns);
+    nstate[i] = (ns << nb) - sz;
+  }
+  return [tpos + 7 >> 3, {
+    b: al,
+    s: syms,
+    n: nbits,
+    t: nstate
+  }];
+};
+var rhu = function(dat, bt) {
+  var i = 0, wc = -1;
+  var buf = new u8(292), hb = dat[bt];
+  var hw = buf.subarray(0, 256);
+  var rc = buf.subarray(256, 268);
+  var ri = new u16(buf.buffer, 268);
+  if (hb < 128) {
+    var _a = rfse(dat, bt + 1, 6), ebt = _a[0], fdt = _a[1];
+    bt += hb;
+    var epos = ebt << 3;
+    var lb = dat[bt];
+    if (!lb)
+      err(0);
+    var st1 = 0, st2 = 0, btr1 = fdt.b, btr2 = btr1;
+    var fpos = (++bt << 3) - 8 + msb(lb);
+    for (; ; ) {
+      fpos -= btr1;
+      if (fpos < epos)
+        break;
+      var cbt = fpos >> 3;
+      st1 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr1) - 1;
+      hw[++wc] = fdt.s[st1];
+      fpos -= btr2;
+      if (fpos < epos)
+        break;
+      cbt = fpos >> 3;
+      st2 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr2) - 1;
+      hw[++wc] = fdt.s[st2];
+      btr1 = fdt.n[st1];
+      st1 = fdt.t[st1];
+      btr2 = fdt.n[st2];
+      st2 = fdt.t[st2];
+    }
+    if (++wc > 255)
+      err(0);
+  } else {
+    wc = hb - 127;
+    for (; i < wc; i += 2) {
+      var byte = dat[++bt];
+      hw[i] = byte >> 4;
+      hw[i + 1] = byte & 15;
+    }
+    ++bt;
+  }
+  var wes = 0;
+  for (i = 0; i < wc; ++i) {
+    var wt = hw[i];
+    if (wt > 11)
+      err(0);
+    wes += wt && 1 << wt - 1;
+  }
+  var mb = msb(wes) + 1;
+  var ts = 1 << mb;
+  var rem = ts - wes;
+  if (rem & rem - 1)
+    err(0);
+  hw[wc++] = msb(rem) + 1;
+  for (i = 0; i < wc; ++i) {
+    var wt = hw[i];
+    ++rc[hw[i] = wt && mb + 1 - wt];
+  }
+  var hbuf = new u8(ts << 1);
+  var syms = hbuf.subarray(0, ts), nb = hbuf.subarray(ts);
+  ri[mb] = 0;
+  for (i = mb; i > 0; --i) {
+    var pv = ri[i];
+    fill(nb, i, pv, ri[i - 1] = pv + rc[i] * (1 << mb - i));
+  }
+  if (ri[0] != ts)
+    err(0);
+  for (i = 0; i < wc; ++i) {
+    var bits = hw[i];
+    if (bits) {
+      var code = ri[bits];
+      fill(syms, i, code, ri[bits] = code + (1 << mb - bits));
+    }
+  }
+  return [bt, {
+    n: nb,
+    b: mb,
+    s: syms
+  }];
+};
+var dllt = rfse(/* @__PURE__ */ new u8([
+  81,
+  16,
+  99,
+  140,
+  49,
+  198,
+  24,
+  99,
+  12,
+  33,
+  196,
+  24,
+  99,
+  102,
+  102,
+  134,
+  70,
+  146,
+  4
+]), 0, 6)[1];
+var dmlt = rfse(/* @__PURE__ */ new u8([
+  33,
+  20,
+  196,
+  24,
+  99,
+  140,
+  33,
+  132,
+  16,
+  66,
+  8,
+  33,
+  132,
+  16,
+  66,
+  8,
+  33,
+  68,
+  68,
+  68,
+  68,
+  68,
+  68,
+  68,
+  68,
+  36,
+  9
+]), 0, 6)[1];
+var doct = rfse(/* @__PURE__ */ new u8([
+  32,
+  132,
+  16,
+  66,
+  102,
+  70,
+  68,
+  68,
+  68,
+  68,
+  36,
+  73,
+  2
+]), 0, 5)[1];
+var b2bl = function(b, s) {
+  var len = b.length, bl = new i32(len);
+  for (var i = 0; i < len; ++i) {
+    bl[i] = s;
+    s += 1 << b[i];
+  }
+  return bl;
+};
+var llb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
+  0,
+  0,
+  0,
+  0,
+  16843009,
+  50528770,
+  134678020,
+  202050057,
+  269422093
+])).buffer, 0, 36);
+var llbl = /* @__PURE__ */ b2bl(llb, 0);
+var mlb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  16843009,
+  50528770,
+  117769220,
+  185207048,
+  252579084,
+  16
+])).buffer, 0, 53);
+var mlbl = /* @__PURE__ */ b2bl(mlb, 3);
+var dhu = function(dat, out, hu) {
+  var len = dat.length, ss = out.length, lb = dat[len - 1], msk = (1 << hu.b) - 1, eb = -hu.b;
+  if (!lb)
+    err(0);
+  var st = 0, btr = hu.b, pos = (len << 3) - 8 + msb(lb) - btr, i = -1;
+  for (; pos > eb && i < ss; ) {
+    var cbt = pos >> 3;
+    var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (pos & 7);
+    st = (st << btr | val) & msk;
+    out[++i] = hu.s[st];
+    pos -= btr = hu.n[st];
+  }
+  if (pos != eb || i + 1 != ss)
+    err(0);
+};
+var dhu4 = function(dat, out, hu) {
+  var bt = 6;
+  var ss = out.length, sz1 = ss + 3 >> 2, sz2 = sz1 << 1, sz3 = sz1 + sz2;
+  dhu(dat.subarray(bt, bt += dat[0] | dat[1] << 8), out.subarray(0, sz1), hu);
+  dhu(dat.subarray(bt, bt += dat[2] | dat[3] << 8), out.subarray(sz1, sz2), hu);
+  dhu(dat.subarray(bt, bt += dat[4] | dat[5] << 8), out.subarray(sz2, sz3), hu);
+  dhu(dat.subarray(bt), out.subarray(sz3), hu);
+};
+var rzb = function(dat, st, out) {
+  var _a;
+  var bt = st.b;
+  var b0 = dat[bt], btype = b0 >> 1 & 3;
+  st.l = b0 & 1;
+  var sz = b0 >> 3 | dat[bt + 1] << 5 | dat[bt + 2] << 13;
+  var ebt = (bt += 3) + sz;
+  if (btype == 1) {
+    if (bt >= dat.length)
+      return;
+    st.b = bt + 1;
+    if (out) {
+      fill(out, dat[bt], st.y, st.y += sz);
+      return out;
+    }
+    return fill(new u8(sz), dat[bt]);
+  }
+  if (ebt > dat.length)
+    return;
+  if (btype == 0) {
+    st.b = ebt;
+    if (out) {
+      out.set(dat.subarray(bt, ebt), st.y);
+      st.y += sz;
+      return out;
+    }
+    return slc(dat, bt, ebt);
+  }
+  if (btype == 2) {
+    var b3 = dat[bt], lbt = b3 & 3, sf = b3 >> 2 & 3;
+    var lss = b3 >> 4, lcs = 0, s4 = 0;
+    if (lbt < 2) {
+      if (sf & 1)
+        lss |= dat[++bt] << 4 | (sf & 2 && dat[++bt] << 12);
+      else
+        lss = b3 >> 3;
+    } else {
+      s4 = sf;
+      if (sf < 2)
+        lss |= (dat[++bt] & 63) << 4, lcs = dat[bt] >> 6 | dat[++bt] << 2;
+      else if (sf == 2)
+        lss |= dat[++bt] << 4 | (dat[++bt] & 3) << 12, lcs = dat[bt] >> 2 | dat[++bt] << 6;
+      else
+        lss |= dat[++bt] << 4 | (dat[++bt] & 63) << 12, lcs = dat[bt] >> 6 | dat[++bt] << 2 | dat[++bt] << 10;
+    }
+    ++bt;
+    var buf = out ? out.subarray(st.y, st.y + st.m) : new u8(st.m);
+    var spl = buf.length - lss;
+    if (lbt == 0)
+      buf.set(dat.subarray(bt, bt += lss), spl);
+    else if (lbt == 1)
+      fill(buf, dat[bt++], spl);
+    else {
+      var hu = st.h;
+      if (lbt == 2) {
+        var hud = rhu(dat, bt);
+        lcs += bt - (bt = hud[0]);
+        st.h = hu = hud[1];
+      } else if (!hu)
+        err(0);
+      (s4 ? dhu4 : dhu)(dat.subarray(bt, bt += lcs), buf.subarray(spl), hu);
+    }
+    var ns = dat[bt++];
+    if (ns) {
+      if (ns == 255)
+        ns = (dat[bt++] | dat[bt++] << 8) + 32512;
+      else if (ns > 127)
+        ns = ns - 128 << 8 | dat[bt++];
+      var scm = dat[bt++];
+      if (scm & 3)
+        err(0);
+      var dts = [dmlt, doct, dllt];
+      for (var i = 2; i > -1; --i) {
+        var md = scm >> (i << 1) + 2 & 3;
+        if (md == 1) {
+          var rbuf = new u8([0, 0, dat[bt++]]);
+          dts[i] = {
+            s: rbuf.subarray(2, 3),
+            n: rbuf.subarray(0, 1),
+            t: new u16(rbuf.buffer, 0, 1),
+            b: 0
+          };
+        } else if (md == 2) {
+          _a = rfse(dat, bt, 9 - (i & 1)), bt = _a[0], dts[i] = _a[1];
+        } else if (md == 3) {
+          if (!st.t)
+            err(0);
+          dts[i] = st.t[i];
+        }
+      }
+      var _b = st.t = dts, mlt = _b[0], oct = _b[1], llt = _b[2];
+      var lb = dat[ebt - 1];
+      if (!lb)
+        err(0);
+      var spos = (ebt << 3) - 8 + msb(lb) - llt.b, cbt = spos >> 3, oubt = 0;
+      var lst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << llt.b) - 1;
+      cbt = (spos -= oct.b) >> 3;
+      var ost = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << oct.b) - 1;
+      cbt = (spos -= mlt.b) >> 3;
+      var mst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mlt.b) - 1;
+      for (++ns; --ns; ) {
+        var llc = llt.s[lst];
+        var lbtr = llt.n[lst];
+        var mlc = mlt.s[mst];
+        var mbtr = mlt.n[mst];
+        var ofc = oct.s[ost];
+        var obtr = oct.n[ost];
+        cbt = (spos -= ofc) >> 3;
+        var ofp = 1 << ofc;
+        var off = ofp + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16 | dat[cbt + 3] << 24) >>> (spos & 7) & ofp - 1);
+        cbt = (spos -= mlb[mlc]) >> 3;
+        var ml = mlbl[mlc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << mlb[mlc]) - 1);
+        cbt = (spos -= llb[llc]) >> 3;
+        var ll = llbl[llc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << llb[llc]) - 1);
+        cbt = (spos -= lbtr) >> 3;
+        lst = llt.t[lst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << lbtr) - 1);
+        cbt = (spos -= mbtr) >> 3;
+        mst = mlt.t[mst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mbtr) - 1);
+        cbt = (spos -= obtr) >> 3;
+        ost = oct.t[ost] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << obtr) - 1);
+        if (off > 3) {
+          st.o[2] = st.o[1];
+          st.o[1] = st.o[0];
+          st.o[0] = off -= 3;
+        } else {
+          var idx = off - (ll != 0);
+          if (idx) {
+            off = idx == 3 ? st.o[0] - 1 : st.o[idx];
+            if (idx > 1)
+              st.o[2] = st.o[1];
+            st.o[1] = st.o[0];
+            st.o[0] = off;
+          } else
+            off = st.o[0];
+        }
+        for (var i = 0; i < ll; ++i) {
+          buf[oubt + i] = buf[spl + i];
+        }
+        oubt += ll, spl += ll;
+        var stin = oubt - off;
+        if (stin < 0) {
+          var len = -stin;
+          var bs = st.e + stin;
+          if (len > ml)
+            len = ml;
+          for (var i = 0; i < len; ++i) {
+            buf[oubt + i] = st.w[bs + i];
+          }
+          oubt += len, ml -= len, stin = 0;
+        }
+        for (var i = 0; i < ml; ++i) {
+          buf[oubt + i] = buf[stin + i];
+        }
+        oubt += ml;
+      }
+      if (oubt != spl) {
+        while (spl < buf.length) {
+          buf[oubt++] = buf[spl++];
+        }
+      } else
+        oubt = buf.length;
+      if (out)
+        st.y += oubt;
+      else
+        buf = slc(buf, 0, oubt);
+    } else if (out) {
+      st.y += lss;
+      if (spl) {
+        for (var i = 0; i < lss; ++i) {
+          buf[i] = buf[spl + i];
+        }
+      }
+    } else if (spl)
+      buf = slc(buf, spl);
+    st.b = ebt;
+    return buf;
+  }
+  err(2);
+};
+var cct = function(bufs, ol) {
+  if (bufs.length == 1)
+    return bufs[0];
+  var buf = new u8(ol);
+  for (var i = 0, b = 0; i < bufs.length; ++i) {
+    var chk = bufs[i];
+    buf.set(chk, b);
+    b += chk.length;
+  }
+  return buf;
+};
+function decompress(dat, buf) {
+  var bufs = [], nb = +!buf;
+  var bt = 0, ol = 0;
+  for (; dat.length; ) {
+    var st = rzfh(dat, nb || buf);
+    if (typeof st == "object") {
+      if (nb) {
+        buf = null;
+        if (st.w.length == st.u) {
+          bufs.push(buf = st.w);
+          ol += st.u;
+        }
+      } else {
+        bufs.push(buf);
+        st.e = 0;
+      }
+      for (; !st.l; ) {
+        var blk = rzb(dat, st, buf);
+        if (!blk)
+          err(5);
+        if (buf)
+          st.e = st.y;
+        else {
+          bufs.push(blk);
+          ol += blk.length;
+          cpw(st.w, 0, blk.length);
+          st.w.set(blk, st.w.length - blk.length);
+        }
+      }
+      bt = st.b + st.c * 4;
+    } else
+      bt = st;
+    dat = dat.subarray(bt);
+  }
+  return cct(bufs, ol);
+}
+function detectBlendCompression(u82) {
+  if (u82.length >= 3 && u82[0] === 31 && u82[1] === 139 && u82[2] === 8) return "gzip";
+  if (u82.length >= 4) {
+    if (u82[0] === 40 && u82[1] === 181 && u82[2] === 47 && u82[3] === 253) return "zstd";
+    if ((u82[0] & 240) === 80 && u82[1] === 42 && u82[2] === 77 && u82[3] === 24) return "zstd";
+  }
+  if (u82.length >= 7 && u82[0] === 66 && u82[1] === 76 && u82[2] === 69 && u82[3] === 78 && u82[4] === 68 && u82[5] === 69 && u82[6] === 82) return "none";
+  return "unknown";
+}
+function toArrayBuffer(u82) {
+  if (u82.byteOffset === 0 && u82.byteLength === u82.buffer.byteLength) return u82.buffer;
+  return u82.buffer.slice(u82.byteOffset, u82.byteOffset + u82.byteLength);
+}
+function decompressBlend(buf) {
+  const u82 = new Uint8Array(buf);
+  const kind = detectBlendCompression(u82);
+  if (kind === "none") return buf;
+  let out;
+  if (kind === "gzip") out = toArrayBuffer(gunzipSync(u82));
+  else if (kind === "zstd") out = toArrayBuffer(decompress(u82));
+  else {
+    const hex = [u82[0], u82[1], u82[2], u82[3]].map((b) => (b ?? 0).toString(16).padStart(2, "0")).join(" ");
+    throw new Error(`BlendLoadPlugin: unrecognised file magic (first 4 bytes: ${hex}). Expected 'BLENDER' literal, gzip, or zstd.`);
+  }
+  if (out.byteLength < 12) {
+    throw new Error(`BlendLoadPlugin: ${kind} decompression produced ${out.byteLength} bytes, too short to be a valid .blend file.`);
+  }
+  return out;
+}
+function resolveExternalTexture(blenderPath, srgb, importer, blendUrl) {
+  if (typeof document === "undefined") return null;
+  const path = blenderPath.replace(/^\/\//, "").replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!path) return null;
+  let url = importer.resolveURL(path);
+  if (url === path && !/^([a-z][a-z0-9+.-]*:|\/|blob:|data:)/i.test(url)) {
+    url = blendUrl.replace(/[?#].*$/, "").replace(/[^/]*$/, "") + path;
+  }
+  const isData = /\.(exr|hdr|rgbe)$/i.test(path.split(/[?#]/)[0]);
+  let texture;
+  if (isData) {
+    texture = new DataTexture(new Uint8Array([255, 255, 255, 255]), 1, 1);
+  } else {
+    const canvas = document.createElement("canvas");
+    canvas.width = canvas.height = 1;
+    const c2d = canvas.getContext("2d");
+    if (c2d) {
+      c2d.fillStyle = "#ffffff";
+      c2d.fillRect(0, 0, 1, 1);
+    }
+    texture = new Texture(canvas);
+  }
+  texture.needsUpdate = true;
+  if (srgb) texture.colorSpace = SRGBColorSpace;
+  return { texture, url, srgb, path };
+}
+function flipDataTextureRowsY(tex) {
+  const img = tex.image;
+  const data = img?.data;
+  if (!data?.length || !img.width || !img.height) return;
+  const { width, height } = img;
+  const elemsPerRow = data.length / height;
+  if (!Number.isInteger(elemsPerRow)) return;
+  const flipped = new data.constructor(data.length);
+  for (let y = 0; y < height; y++) {
+    flipped.set(data.subarray(y * elemsPerRow, (y + 1) * elemsPerRow), (height - 1 - y) * elemsPerRow);
+  }
+  const newImage = { data: flipped, width, height };
+  tex.image = newImage;
+  tex.source = new Source(newImage);
+  tex.needsUpdate = true;
+}
+async function importExternalTexture(req, importer) {
+  try {
+    const imported = await importer.importSingle(req.url);
+    if (imported && imported.isTexture && imported.image) {
+      const wrapS = req.texture.wrapS, wrapT = req.texture.wrapT;
+      req.texture.copy(imported);
+      req.texture.wrapS = wrapS;
+      req.texture.wrapT = wrapT;
+      req.texture.colorSpace = req.srgb ? SRGBColorSpace : imported.colorSpace;
+      if (imported.isDataTexture && imported.flipY === false) flipDataTextureRowsY(req.texture);
+      req.texture.needsUpdate = true;
+    } else {
+      console.warn("BlendLoadPlugin - external texture not found/unsupported:", req.path);
+    }
+  } catch (e) {
+    console.warn("BlendLoadPlugin - external texture failed:", req.path, e);
+  }
+}
 const _BlendLoadPlugin = class _BlendLoadPlugin extends BaseImporterPlugin {
   constructor() {
     super();
     this._importer = new Importer(class extends FileLoader {
       async loadAsync(url, onProgress) {
         this.setResponseType("arraybuffer");
-        const res = await super.loadAsync(url, onProgress);
-        const blend = await parseBlend(res);
+        let res = await super.loadAsync(url, onProgress);
+        const decompressed = decompressBlend(res);
+        res = null;
+        const blend = await parseBlend(decompressed);
+        const importer = this.assetImporter;
+        const texReqs = [];
         const ctx = {
           Object3D: Object3D2,
           Mesh: Mesh2,
           MeshPhysicalMaterial: PhysicalMaterial,
+          MeshBasicMaterial: UnlitMaterial,
           PerspectiveCamera: PerspectiveCamera0,
           OrthographicCamera: OrthographicCamera0,
           PointLight: PointLight2,
+          DirectionalLight: DirectionalLight2,
+          SpotLight: SpotLight2,
+          AmbientLight: AmbientLight2,
           BufferGeometry: BufferGeometry2,
-          BufferAttribute
+          BufferAttribute,
+          loadExternalTexture: importer ? (p, srgb) => {
+            const req = resolveExternalTexture(p, srgb, importer, url);
+            if (req) texReqs.push(req);
+            return req ? req.texture : null;
+          } : void 0
         };
         const objects = await createObjects(blend, ctx);
+        if (importer && texReqs.length) await Promise.all(texReqs.map((r) => importExternalTexture(r, importer)));
         const root = new Object3D();
         root.add(...objects);
         blend.scene = root;
@@ -1027,7 +2286,10 @@ const _BlendLoadPlugin = class _BlendLoadPlugin extends BaseImporterPlugin {
         }
         return res.scene;
       }
-    }, ["blend"], ["application/x-blender"], true);
+    }, ["blend"], ["application/x-blender"], true, (loader, assetImporter) => {
+      if (loader) loader.assetImporter = assetImporter;
+      return loader;
+    });
   }
 };
 _BlendLoadPlugin.PluginType = "BlendLoadPlugin";