@threepipe/plugin-blend-importer 0.1.0 → 0.3.1

package/dist/index.js

@@ -1,14 +1,7 @@
 (function(global, factory) {
   typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("threepipe")) : typeof define === "function" && define.amd ? define(["exports", "threepipe"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["@threepipe/plugin-blend-importer"] = {}, global.threepipe));
-})(this, function(exports2, threepipe) {
-  "use strict";/**
- * @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.
- */
-
+})(this, (function(exports2, threepipe) {
+  "use strict";
   let worker = null;
   const return_object = {
     loadBlendFromArrayBuffer: function(array_buffer) {
@@ -41,6 +34,7 @@
         struct_names = [];
         offset = 0;
         current_SDNA_template = null;
+        ERROR = null;
         _data = msg.data;
         AB = _data.slice();
         data = new DataView(_data);
@@ -75,13 +69,30 @@
         } 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);
       }
     };
     self2.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) ;
@@ -96,7 +107,7 @@
     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) ;
@@ -111,7 +122,7 @@
     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) ;
@@ -123,10 +134,25 @@
         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) ;
@@ -141,7 +167,7 @@
     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) ;
@@ -189,18 +215,28 @@
     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;
@@ -236,6 +272,33 @@
         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) {
@@ -246,18 +309,34 @@
             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);
@@ -333,7 +412,7 @@
                 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++) {
@@ -341,7 +420,7 @@
                     }
                     return array;
                   };
-                }(array_names),
+                })(array_names),
                 enumerable: true,
                 configurable: true
               });
@@ -375,6 +454,7 @@
         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;
@@ -437,25 +517,53 @@
       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";
+      }
+      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[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 = "";
@@ -553,27 +661,24 @@
           }
           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) {
@@ -582,7 +687,7 @@
               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,
@@ -591,10 +696,10 @@
             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;
@@ -619,18 +724,9 @@
     }
   }
   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) => {
@@ -719,14 +815,147 @@
     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);
@@ -745,7 +974,12 @@
         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;
@@ -755,9 +989,44 @@
     }
     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] || {};
@@ -776,44 +1045,50 @@
       }
       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;
@@ -824,6 +1099,9 @@
     } 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;
@@ -839,9 +1117,12 @@
     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;
@@ -873,34 +1154,297 @@
         }
         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 threepipe.Texture(el);
+    if (srgb) texture.colorSpace = threepipe.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 ? threepipe.ClampToEdgeWrapping : ext === 3 ? threepipe.MirroredRepeatWrapping : threepipe.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 ? threepipe.FrontSide : threepipe.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;
+        material.metalness = 1;
+      } 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);
+    if (emTex) material.emissiveMap = emTex;
+    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 = threepipe.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;
@@ -1000,25 +1544,743 @@
     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(threepipe.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 threepipe.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 threepipe.Texture(canvas);
+    }
+    texture.needsUpdate = true;
+    if (srgb) texture.colorSpace = threepipe.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 threepipe.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 ? threepipe.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 threepipe.BaseImporterPlugin {
     constructor() {
       super();
       this._importer = new threepipe.Importer(class extends threepipe.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: threepipe.Object3D2,
             Mesh: threepipe.Mesh2,
             MeshPhysicalMaterial: threepipe.PhysicalMaterial,
+            MeshBasicMaterial: threepipe.UnlitMaterial,
             PerspectiveCamera: threepipe.PerspectiveCamera0,
             OrthographicCamera: threepipe.OrthographicCamera0,
             PointLight: threepipe.PointLight2,
+            DirectionalLight: threepipe.DirectionalLight2,
+            SpotLight: threepipe.SpotLight2,
+            AmbientLight: threepipe.AmbientLight2,
             BufferGeometry: threepipe.BufferGeometry2,
-            BufferAttribute: threepipe.BufferAttribute
+            BufferAttribute: threepipe.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 threepipe.Object3D();
           root.add(...objects);
           blend.scene = root;
@@ -1030,12 +2292,15 @@
           }
           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";
   let BlendLoadPlugin = _BlendLoadPlugin;
   exports2.BlendLoadPlugin = BlendLoadPlugin;
   Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
-});
+}));
 //# sourceMappingURL=index.js.map