@threepipe/plugin-blend-importer 0.0.4 → 0.0.5

package/dist/index.mjs

@@ -1,13 +1,11 @@
 /**
  * @license
- * @threepipe/plugin-blend-importer v0.0.4
+ * @threepipe/plugin-blend-importer v0.0.5
  * Copyright 2022-2025 repalash <palash@shaders.app>
  * Apache-2.0 License
  * See ./dependencies.txt for any bundled third-party dependencies and licenses.
  */
-import { PointLight, BufferGeometry, BufferAttribute, MeshPhysicalMaterial, Mesh, BaseImporterPlugin, Importer, FileLoader, Object3D } from "threepipe";
-const DNA1 = 826363460;
-const ENDB = 1111772741;
+import { BaseImporterPlugin, Importer, FileLoader, Object3D, Object3D2, PerspectiveCamera0, OrthographicCamera0, PointLight2, PhysicalMaterial, Mesh2, BufferGeometry2, BufferAttribute } from "threepipe";
 let worker = null;
 const return_object = {
   loadBlendFromArrayBuffer: function(array_buffer) {
@@ -48,7 +46,7 @@ function worker_code() {
       self.postMessage(FILE, ERROR);
     }
   }
-  var BLENDER_FILE = function(AB2) {
+  const BLENDER_FILE = function(AB2) {
     this.AB = AB2;
     this.byte = new Uint8Array(AB2);
     this.dv = new DataView(AB2);
@@ -87,7 +85,9 @@ function worker_code() {
         else {
           this.__blender_file__.dv.setFloat64(this.__data_address__ + offset2, float, this.__blender_file__.template.endianess);
         }
-      }
+      },
+      enumerable: true,
+      configurable: true
     };
   }
   function floatProp(offset2, Blender_Array_Length, length) {
@@ -100,7 +100,9 @@ function worker_code() {
         else {
           this.__blender_file__.dv.setFloat32(this.__data_address__ + offset2, float, this.__blender_file__.template.endianess);
         }
-      }
+      },
+      enumerable: true,
+      configurable: true
     };
   }
   function intProp(offset2, Blender_Array_Length, length) {
@@ -113,7 +115,9 @@ function worker_code() {
         else {
           this.__blender_file__.dv.setInt32(this.__data_address__ + offset2, float, this.__blender_file__.template.endianess);
         }
-      }
+      },
+      enumerable: true,
+      configurable: true
     };
   }
   function shortProp(offset2, Blender_Array_Length, length) {
@@ -126,9 +130,26 @@ function worker_code() {
         else {
           this.__blender_file__.dv.setInt16(this.__data_address__ + offset2, float, this.__blender_file__.template.endianess);
         }
-      }
+      },
+      enumerable: true,
+      configurable: true
     };
   }
+  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);
+      },
+      set: function(float) {
+        if (Blender_Array_Length > 1) ;
+        else {
+          this.__blender_file__.dv.setUint16(this.__data_address__ + offset2, float, this.__blender_file__.template.endianess);
+        }
+      },
+      enumerable: true,
+      configurable: true
+    };
+  };
   function charProp(offset2, Blender_Array_Length, length) {
     return {
       get: function() {
@@ -157,7 +178,9 @@ function worker_code() {
         } else {
           this.__blender_file__.byte[this.__data_address__ + offset2] = byte | 0;
         }
-      }
+      },
+      enumerable: true,
+      configurable: true
     };
   }
   function pointerProp2(offset2) {
@@ -180,7 +203,9 @@ function worker_code() {
         return results;
       },
       set: function() {
-      }
+      },
+      enumerable: true,
+      configurable: true
     };
   }
   function pointerProp(offset2, Blender_Array_Length, length) {
@@ -203,7 +228,9 @@ function worker_code() {
         }
       },
       set: function() {
-      }
+      },
+      enumerable: true,
+      configurable: true
     };
   }
   function compileProp(obj, name, type, offset2, array_size, IS_POINTER, pointer_size2, length) {
@@ -219,9 +246,11 @@ function worker_code() {
           Object.defineProperty(obj, name, intProp(offset2, array_size, length >> 2));
           break;
         case "short":
-        case "ushort":
           Object.defineProperty(obj, name, shortProp(offset2, array_size, length >> 1));
           break;
+        case "ushort":
+          Object.defineProperty(obj, name, uShortProp(offset2, array_size, length >> 1));
+          break;
         case "char":
         case "uchar":
           Object.defineProperty(obj, name, charProp(offset2, array_size, length));
@@ -234,6 +263,7 @@ function worker_code() {
       offset2 += length;
     } else {
       Object.defineProperty(obj, name, pointerProp(offset2, array_size, pointer_size2));
+      obj._length += pointer_size2 * array_size;
       offset2 += pointer_size2 * array_size;
     }
     return offset2;
@@ -250,19 +280,20 @@ function worker_code() {
   MASTER_SDNA_SCHEMA.prototype = {
     getSDNAStructureConstructor: function(name, struct) {
       if (struct) {
-        const blen_struct = Function("function " + name + "(){}; return " + name)();
+        const jsName = name === "void" ? "void_" : name;
+        const blen_struct = Function("function " + jsName + "(){}; return " + jsName)();
         blen_struct.prototype = new BLENDER_STRUCTURE();
         blen_struct.prototype.blender_name = name;
         blen_struct.prototype.__pointers = [];
         blen_struct.prototype.__list__ = [];
+        const DNA = this.SDNA[name] = {
+          constructor: blen_struct
+        };
         let offset2 = 0;
         for (let i = 0; i < struct.length; i += 3) {
           let _name = struct[i];
           const n = _name, type = struct[i + 1];
           let length = struct[i + 2], array_length = 0, match = null, Blender_Array_Length = 1, Suparray_match = 1, PointerToArray = false, Pointer_Match = 0;
-          const DNA = this.SDNA[name] = {
-            constructor: blen_struct
-          };
           if (match = _name.match(/(\*?)(\*?)(\w+)(\[(\w*)\])?(\[(\w*)\])?/)) {
             _name = match[3];
             if (match[1]) {
@@ -307,7 +338,9 @@ function worker_code() {
                   }
                   return array;
                 };
-              }(array_names)
+              }(array_names),
+              enumerable: true,
+              configurable: true
             });
           } else {
             offset2 = compileProp(blen_struct.prototype, _name, type, offset2, Blender_Array_Length, Pointer_Match, pointer_size, length);
@@ -322,7 +355,7 @@ function worker_code() {
       }
     }
   };
-  var BLENDER_STRUCTURE = function() {
+  const BLENDER_STRUCTURE = function() {
     this.__blender_file__ = null;
     this.__list__ = null;
     this.__super_array_list__ = null;
@@ -390,7 +423,8 @@ function worker_code() {
     FILE.memory_lookup = {};
     struct_names = [];
     offset = 0;
-    if (toString(_data, offset, 7) !== "BLENDER") return ERROR = "File supplied is not a .blend compatible Blender file.";
+    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";
@@ -427,9 +461,17 @@ function worker_code() {
             offset2++;
             curr_count++;
           }
-          if (offset2 % 4 > 0) offset2 = 4 - offset2 % 4 + offset2;
+          if (toString(_data, offset2, offset2 + 4) !== "TYPE") {
+            for (let j = 0; j < 8; j++) {
+              if (toString(_data, offset2, offset2 + 4) === "TYPE") break;
+              offset2++;
+            }
+          }
+          if (toString(_data, offset2, offset2 + 4) !== "TYPE") {
+            debugger;
+          }
           offset2 += 4;
-          count = data.getInt32(offset2, true);
+          count = data.getUint32(offset2, true);
           offset2 += 4;
           curr_count = 0;
           while (curr_count < count) {
@@ -442,7 +484,15 @@ function worker_code() {
             offset2++;
             curr_count++;
           }
-          if (offset2 % 4 > 0) offset2 = 4 - offset2 % 4 + offset2;
+          if (toString(_data, offset2, offset2 + 4) !== "TLEN") {
+            for (let j = 0; j < 8; j++) {
+              if (toString(_data, offset2, offset2 + 4) === "TLEN") break;
+              offset2++;
+            }
+          }
+          if (toString(_data, offset2, offset2 + 4) !== "TLEN") {
+            debugger;
+          }
           offset2 += 4;
           curr_count = 0;
           while (curr_count < count) {
@@ -450,7 +500,15 @@ function worker_code() {
             offset2 += 2;
             curr_count++;
           }
-          if (offset2 % 4 > 0) offset2 = 4 - offset2 % 4 + offset2;
+          if (toString(_data, offset2, offset2 + 4) !== "STRC") {
+            for (let j = 0; j < 8; j++) {
+              if (toString(_data, offset2, offset2 + 4) === "STRC") break;
+              offset2++;
+            }
+          }
+          if (toString(_data, offset2, offset2 + 4) !== "STRC") {
+            debugger;
+          }
           offset2 += 4;
           const structure_count = data.getInt32(offset2, BIG_ENDIAN);
           offset2 += 4;
@@ -479,22 +537,56 @@ function worker_code() {
       }
     }
     while (true) {
-      if (offset % 4 > 0) {
-        offset = 4 - offset % 4 + offset;
+      for (let j = 0; j < 8; j++) {
+        if (data.getInt8(offset) === 0) {
+          offset++;
+          continue;
+        }
+        break;
+      }
+      if (data.getInt8(offset) === 0) {
+        debugger;
       }
       data_offset = offset;
+      if (offset + pointer_size + 12 >= data.byteLength) {
+        ERROR = "Unexpected end of file while parsing";
+        break;
+      }
       sdna_index = data.getInt32(offset + pointer_size + 8, BIG_ENDIAN);
-      let code_uint = data.getUint32(offset, BIG_ENDIAN);
+      const code_str = toString(_data, offset, offset + 4);
       offset2 = offset + 16 + pointer_size;
-      offset += data.getInt32(offset + 4, true) + 16 + pointer_size;
-      if (code_uint === DNA1) ;
-      else if (code_uint === ENDB) break;
-      else {
+      const blockLength = data.getInt32(offset + 4, true);
+      if (blockLength < 0 || offset + blockLength + 16 + pointer_size > data.byteLength) {
+        ERROR = "Invalid block length detected";
+        break;
+      }
+      offset += blockLength + 16 + pointer_size;
+      if (code_str === "DNA1") ;
+      else if (code_str === "ENDB") break;
+      else if (code_str === "TEST") {
+        const data_start = data_offset + pointer_size + 16;
+        const width = data.getInt32(data_start, BIG_ENDIAN);
+        const height = data.getInt32(data_start + 4, BIG_ENDIAN);
+        if (width * height > 0) {
+          const data_len = width * height * 4;
+          if (blockLength < data_len + 8) {
+            ERROR = "Invalid TEST block length detected";
+            break;
+          }
+          const image_data = new Uint32Array(_data, data_start + 8, data_len >> 2);
+          const image = {
+            width,
+            height,
+            data: image_data
+          };
+          FILE.thumbnail = image;
+        }
+      } else {
         const data_start = data_offset + pointer_size + 16;
         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);
-        if (count > 0) {
+        if (count > 0 && constructor) {
           let obj = new constructor();
           const length = constructor.prototype._length;
           const address = FILE.getPointer(data_offset + 8);
@@ -518,8 +610,8 @@ function worker_code() {
   }
 }
 worker = new worker_code();
-worker.postMessage = function(message) {
-  return_object.onParseReady(message);
+worker.postMessage = function(message, err) {
+  return_object.onParseReady(message, err);
 };
 /**
  * JS.Blend
@@ -533,49 +625,201 @@ worker.postMessage = function(message) {
 async function parseBlend(buffer, name = "") {
   return new Promise((res, rej) => {
     return_object.onParseReady = (file, error) => {
-      if (error) rej(error);
-      else res(file);
+      if (error) console.error(error);
+      res(file);
     };
     return_object.loadBlendFromArrayBuffer(buffer, name);
   });
 }
+function createCamera(object, ctx) {
+  const cdata = object.data;
+  if (!cdata) return void 0;
+  const type = cdata.type;
+  let camera;
+  if (type === 0) {
+    camera = new ctx.PerspectiveCamera(
+      cdata.lens || 50,
+      // fov or lens
+      (cdata.sensor_x || 36) / (cdata.sensor_y || 24),
+      // aspect
+      cdata.clipsta || 0.1,
+      // near
+      cdata.clipend || 1e3
+      // far
+    );
+    camera.position.set(0, 0, 0);
+    if ("shiftx" in cdata) camera.userData.shiftX = cdata.shiftx;
+    if ("shifty" in cdata) camera.userData.shiftY = cdata.shifty;
+  } else if (type === 1) {
+    const scale = cdata.ortho_scale || 1;
+    const aspect = (cdata.sensor_x || 36) / (cdata.sensor_y || 24);
+    const left = -scale * aspect / 2;
+    const right = scale * aspect / 2;
+    const top = scale / 2;
+    const bottom = -scale / 2;
+    camera = new ctx.OrthographicCamera(
+      left,
+      right,
+      top,
+      bottom,
+      cdata.clipsta || 0.1,
+      cdata.clipend || 1e3
+    );
+    camera.position.set(0, 0, 0);
+    if ("shiftx" in cdata) camera.userData.shiftX = cdata.shiftx;
+    if ("shifty" in cdata) camera.userData.shiftY = cdata.shifty;
+  } else {
+    camera = new ctx.PerspectiveCamera();
+    console.warn("Unsupported camera type", type);
+  }
+  return camera;
+}
 const blenderLightTypes = {
   point: 0,
-  sun: 1,
-  spot: 0,
-  hemi: 0,
-  area: 0
+  sun: 1
 };
-function createLight(lamp) {
+function createLight(lamp, ctx) {
   const ldata = lamp.data;
   const position = [lamp.loc[0], lamp.loc[2], -lamp.loc[1]];
   const color = ldata.r * 255 << 16 | ldata.g * 255 << 8 | ldata.b * 255 << 0;
   const intensity = ldata.energy;
   const distance = 0;
-  let light = null;
+  let light = void 0;
   switch (ldata.type) {
     case blenderLightTypes.point:
-      light = new PointLight(color, intensity, distance);
+      light = new ctx.PointLight(color, intensity, distance);
       light.position.fromArray(position, 0);
       light.castShadow = true;
       break;
     case blenderLightTypes.sun:
-      light = new PointLight(color, intensity, distance);
+      light = new ctx.PointLight(color, intensity, distance);
       light.position.fromArray(position, 0);
       light.castShadow = true;
-      light.shadow.mapSize.width = 1024;
-      light.shadow.mapSize.height = 1024;
-      light.shadow.camera.near = 0.01;
-      light.shadow.camera.far = 500;
+      if (light.shadow) {
+        light.shadow.mapSize.width = 1024;
+        light.shadow.mapSize.height = 1024;
+        light.shadow.camera.near = 0.01;
+        light.shadow.camera.far = 500;
+      }
       break;
     default:
       console.warn("Unsupported light type", ldata.type);
   }
   return light;
 }
-function createBufferGeometry(mesh, origin) {
+function getLayer(layers, i) {
+  if (!Array.isArray(layers)) return layers;
+  return layers[i];
+}
+function createBufferGeometry(meshData, ctx) {
+  var _a;
+  if (meshData.mpoly) return createBufferGeometryOld(meshData, ctx);
+  const geometry = new ctx.BufferGeometry();
+  geometry.name = meshData.aname || "";
+  let vertices;
+  let indices;
+  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);
+      const data = layer.data || [];
+      if (data.length === meshData.totvert) {
+        if (vertices && (layer.name !== "position" || vertices.name === "position")) {
+          continue;
+        }
+        vertices = layer;
+      }
+    }
+  }
+  if (meshData.ldata && meshData.ldata.layers) {
+    for (let i = 0; i < meshData.ldata.totlayer; i++) {
+      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")) {
+          continue;
+        }
+        indices = layer;
+      }
+    }
+  }
+  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)];
+  }
+  if ((vertices == null ? void 0 : vertices.data) && vertices.data.length > 0) {
+    const positions = new Float32Array(vertices.data.length * 3);
+    for (let j = 0; j < vertices.data.length; j++) {
+      const vertex = vertices.data[j];
+      if (vertex.x !== void 0) {
+        positions[j * 3] = vertex.x;
+        positions[j * 3 + 1] = vertex.z;
+        positions[j * 3 + 2] = -vertex.y;
+      } else if (vertex.co !== void 0) {
+        positions[j * 3] = vertex.co[0];
+        positions[j * 3 + 1] = vertex.co[2];
+        positions[j * 3 + 2] = -vertex.co[1];
+      } else {
+        console.error("BlendLoader - unknown vertex", vertex);
+        break;
+      }
+    }
+    geometry.setAttribute("position", new ctx.BufferAttribute(positions, 3));
+  }
+  if ((indices == null ? void 0 : indices.data) && indices.data.length > 0 && ((_a = vertices == null ? void 0 : vertices.data) == null ? void 0 : _a.length)) {
+    const faceSize = meshData.totloop / meshData.totpoly;
+    if (faceIndices.length > 0) {
+      let totalTriangles = 0;
+      for (let i = 0; i < faceIndices.length - 1; 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 faceStart = faceIndices[i];
+        const faceEnd = faceIndices[i + 1];
+        const faceVertCount = faceEnd - faceStart;
+        if (faceVertCount >= 3) {
+          const firstVert = indices.data[faceStart].i;
+          for (let k = 1; k < faceVertCount - 1; k++) {
+            indexes[t++] = firstVert;
+            indexes[t++] = indices.data[faceStart + k].i;
+            indexes[t++] = indices.data[faceStart + k + 1].i;
+          }
+        }
+      }
+      geometry.setIndex(new ctx.BufferAttribute(indexes, 1));
+    } 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;
+        indexes[t++] = a;
+        indexes[t++] = b;
+        indexes[t++] = c;
+        if (isQuad) {
+          const d = indices[j + 3].i;
+          indexes[t++] = a;
+          indexes[t++] = c;
+          indexes[t++] = d;
+        }
+      }
+      geometry.setIndex(new ctx.BufferAttribute(indexes, 1));
+    }
+  } else if (faceIndices) {
+    console.error("BlendLoader - no indices data found, but face indices are present", faceIndices);
+  }
+  if (geometry.attributes.position && !geometry.attributes.normal)
+    geometry.computeVertexNormals();
+  return geometry;
+}
+function createBufferGeometryOld(mesh, ctx) {
   const faces = Array.isArray(mesh.mpoly) ? mesh.mpoly : [mesh.mpoly], loops = mesh.mloop, uv = mesh.mloopuv, vertices = mesh.mvert;
-  const geometry = new BufferGeometry();
+  const geometry = new ctx.BufferGeometry();
   if (!faces) return geometry;
   const size = faces.reduce((acc, face) => acc + Math.floor(face.totloop * 3 / 2), 0);
   const indices = new Uint32Array(size);
@@ -583,6 +827,7 @@ function createBufferGeometry(mesh, origin) {
   const normals = new Float32Array(size * 3);
   const positions = new Float32Array(size * 3);
   let currentIndex = 0;
+  let computeNormals = false;
   for (const face of faces) {
     const len = face.totloop;
     const start = face.loopstart;
@@ -596,12 +841,16 @@ function createBufferGeometry(mesh, origin) {
         const loop = loops[index];
         const vert = vertices[loop.v];
         indices[currentIndex] = currentIndex;
-        positions[currentIndex * 3 + 0] = vert.co[0] + origin[0];
-        positions[currentIndex * 3 + 1] = vert.co[2] + origin[2];
-        positions[currentIndex * 3 + 2] = -vert.co[1] + -0;
-        normals[currentIndex * 3 + 0] = vert.no[0];
-        normals[currentIndex * 3 + 1] = vert.no[2];
-        normals[currentIndex * 3 + 2] = -vert.no[1];
+        positions[currentIndex * 3 + 0] = vert.co[0];
+        positions[currentIndex * 3 + 1] = vert.co[2];
+        positions[currentIndex * 3 + 2] = -vert.co[1];
+        if (vert.no) {
+          normals[currentIndex * 3 + 0] = vert.no[0];
+          normals[currentIndex * 3 + 1] = vert.no[2];
+          normals[currentIndex * 3 + 2] = -vert.no[1];
+        } else {
+          computeNormals = true;
+        }
         if (uv) {
           uvs[currentIndex * 2 + 0] = uv[index].uv[0];
           uvs[currentIndex * 2 + 1] = uv[index].uv[1];
@@ -611,55 +860,113 @@ function createBufferGeometry(mesh, origin) {
       indexi += 2;
     }
   }
-  geometry.setAttribute("position", new BufferAttribute(positions, 3));
-  geometry.setIndex(new BufferAttribute(indices, 1));
-  geometry.setAttribute("normal", new BufferAttribute(normals, 3));
-  geometry.setAttribute("uv", new BufferAttribute(uvs, 2));
+  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 (computeNormals) {
+    geometry.computeVertexNormals();
+  }
   return geometry;
 }
-function createMaterial(mat) {
-  const material = new MeshPhysicalMaterial();
+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 = mat.alpha !== void 0 ? mat.alpha : 0;
+  material.opacity = 1;
   material.transparent = material.opacity < 1;
   return material;
 }
-function createMesh(object) {
-  if (!object.data) return null;
-  const geometry = createBufferGeometry(object.data, [0, 0, 0]);
+function setCreateTransform(object, obj) {
+  obj.name = object.aname;
+  obj.quaternion.set(object.quat[1], object.quat[3], -object.quat[2], object.quat[0]);
+  obj.scale.set(object.size[0], object.size[1], object.size[2]);
+  obj.position.set(object.loc[0], object.loc[2], -object.loc[1]);
+  obj.updateMatrix();
+}
+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 ? createMaterial(mat) : void 0;
-  const mesh = new Mesh(geometry, material);
+  const material = mat ? loaded.get(mat) ?? createMaterial(mat, ctx) : new ctx.MeshPhysicalMaterial();
+  if (mat) loaded.set(mat, material);
+  const mesh = new ctx.Mesh(geometry, material);
   mesh.castShadow = true;
   mesh.receiveShadow = true;
-  mesh.rotateZ(object.rot[2]);
-  mesh.rotateY(object.rot[1]);
-  mesh.rotateX(object.rot[0]);
-  mesh.scale.fromArray(object.size, 0);
-  mesh.position.fromArray([object.loc[0], object.loc[2], -object.loc[1]], 0);
   return mesh;
 }
 const blenderObjectTypes = {
+  empty: 0,
   mesh: 1,
-  lamp: 10
+  lamp: 10,
+  camera: 11
 };
-async function createObjects(file) {
+async function createObjects(file, ctx) {
   const objects = [];
-  const blendObjects = file.objects.Object;
+  const childMap = /* @__PURE__ */ new Map();
+  const objMap = /* @__PURE__ */ new Map();
+  const blendObjects = file.objects.Object ?? [];
+  const loaded = /* @__PURE__ */ new WeakMap();
   for (const object of blendObjects) {
+    if (loaded.has(object)) {
+      console.warn("BlendLoader - duplicate object");
+      continue;
+    }
+    let obj = void 0;
     switch (object.type) {
+      case blenderObjectTypes.empty:
+        obj = new ctx.Object3D();
+        break;
       case blenderObjectTypes.mesh:
-        objects.push(createMesh(object));
+        obj = createMesh(object, loaded, ctx);
         break;
       case blenderObjectTypes.lamp:
-        objects.push(createLight(object));
+        obj = createLight(object, ctx);
+        break;
+      case blenderObjectTypes.camera:
+        obj = createCamera(object, ctx);
         break;
       default:
-        console.warn("Unsupported object type", object.type);
+        obj = new ctx.Object3D();
+        console.warn("Unsupported object type", object.type, object, obj);
+    }
+    if (obj) {
+      setCreateTransform(object, obj);
+      const exChildren = childMap.get(object);
+      if (exChildren) {
+        for (const exChild of exChildren) {
+          obj.add(exChild);
+        }
+        childMap.delete(object);
+      }
+      objMap.set(object, obj);
+      if (object.parent === object) {
+        console.error("invalid, parent same as object, adding to root", object);
+        objects.push(obj);
+      } else if (!object.parent) {
+        objects.push(obj);
+      } else {
+        const parent = objMap.get(object.parent);
+        if (!parent) {
+          const chi = childMap.get(object.parent) ?? [];
+          chi.push(obj);
+          childMap.set(object, chi);
+        } else {
+          parent.add(obj);
+        }
+      }
+      loaded.set(object, obj);
     }
   }
+  if (childMap.size) {
+    const vals = [...childMap.values()].flat();
+    console.warn("unknown objects with parents, adding to root", vals, childMap);
+    objects.push(...vals);
+  }
   return objects.filter((o) => !!o);
 }
 const _BlendLoadPlugin = class _BlendLoadPlugin extends BaseImporterPlugin {
@@ -670,13 +977,26 @@ const _BlendLoadPlugin = class _BlendLoadPlugin extends BaseImporterPlugin {
         this.setResponseType("arraybuffer");
         const res = await super.loadAsync(url, onProgress);
         const blend = await parseBlend(res);
-        const objects = await createObjects(blend);
+        const ctx = {
+          Object3D: Object3D2,
+          Mesh: Mesh2,
+          MeshPhysicalMaterial: PhysicalMaterial,
+          PerspectiveCamera: PerspectiveCamera0,
+          OrthographicCamera: OrthographicCamera0,
+          PointLight: PointLight2,
+          BufferGeometry: BufferGeometry2,
+          BufferAttribute
+        };
+        const objects = await createObjects(blend, ctx);
         const root = new Object3D();
         root.add(...objects);
         blend.scene = root;
         return blend;
       }
-      transform(res, _) {
+      transform(res, options) {
+        if (typeof options.onBlendLoad === "function") {
+          options.onBlendLoad(res);
+        }
         return res.scene;
       }
     }, ["blend"], ["application/x-blender"], true);