@threepipe/plugin-blend-importer 0.0.4 → 0.0.5

package/dist/index.js

@@ -3,14 +3,12 @@
 })(this, function(exports2, threepipe) {
   "use strict";/**
  * @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.
  */
 
-  const DNA1 = 826363460;
-  const ENDB = 1111772741;
   let worker = null;
   const return_object = {
     loadBlendFromArrayBuffer: function(array_buffer) {
@@ -51,7 +49,7 @@
         self2.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);
@@ -90,7 +88,9 @@
           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) {
@@ -103,7 +103,9 @@
           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) {
@@ -116,7 +118,9 @@
           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) {
@@ -129,9 +133,26 @@
           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() {
@@ -160,7 +181,9 @@
           } else {
             this.__blender_file__.byte[this.__data_address__ + offset2] = byte | 0;
           }
-        }
+        },
+        enumerable: true,
+        configurable: true
       };
     }
     function pointerProp2(offset2) {
@@ -183,7 +206,9 @@
           return results;
         },
         set: function() {
-        }
+        },
+        enumerable: true,
+        configurable: true
       };
     }
     function pointerProp(offset2, Blender_Array_Length, length) {
@@ -206,7 +231,9 @@
           }
         },
         set: function() {
-        }
+        },
+        enumerable: true,
+        configurable: true
       };
     }
     function compileProp(obj, name, type, offset2, array_size, IS_POINTER, pointer_size2, length) {
@@ -222,9 +249,11 @@
             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));
@@ -237,6 +266,7 @@
         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;
@@ -253,19 +283,20 @@
     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]) {
@@ -310,7 +341,9 @@
                     }
                     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);
@@ -325,7 +358,7 @@
         }
       }
     };
-    var BLENDER_STRUCTURE = function() {
+    const BLENDER_STRUCTURE = function() {
       this.__blender_file__ = null;
       this.__list__ = null;
       this.__super_array_list__ = null;
@@ -393,7 +426,8 @@
       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";
@@ -430,9 +464,17 @@
               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) {
@@ -445,7 +487,15 @@
               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) {
@@ -453,7 +503,15 @@
               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;
@@ -482,22 +540,56 @@
         }
       }
       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);
@@ -521,8 +613,8 @@
     }
   }
   worker = new worker_code();
-  worker.postMessage = function(message) {
-    return_object.onParseReady(message);
+  worker.postMessage = function(message, err) {
+    return_object.onParseReady(message, err);
   };
   /**
    * JS.Blend
@@ -536,49 +628,201 @@
   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 threepipe.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 threepipe.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 threepipe.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);
@@ -586,6 +830,7 @@
     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;
@@ -599,12 +844,16 @@
           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];
@@ -614,55 +863,113 @@
         indexi += 2;
       }
     }
-    geometry.setAttribute("position", new threepipe.BufferAttribute(positions, 3));
-    geometry.setIndex(new threepipe.BufferAttribute(indices, 1));
-    geometry.setAttribute("normal", new threepipe.BufferAttribute(normals, 3));
-    geometry.setAttribute("uv", new threepipe.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 threepipe.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 threepipe.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 threepipe.BaseImporterPlugin {
@@ -673,13 +980,26 @@
           this.setResponseType("arraybuffer");
           const res = await super.loadAsync(url, onProgress);
           const blend = await parseBlend(res);
-          const objects = await createObjects(blend);
+          const ctx = {
+            Object3D: threepipe.Object3D2,
+            Mesh: threepipe.Mesh2,
+            MeshPhysicalMaterial: threepipe.PhysicalMaterial,
+            PerspectiveCamera: threepipe.PerspectiveCamera0,
+            OrthographicCamera: threepipe.OrthographicCamera0,
+            PointLight: threepipe.PointLight2,
+            BufferGeometry: threepipe.BufferGeometry2,
+            BufferAttribute: threepipe.BufferAttribute
+          };
+          const objects = await createObjects(blend, ctx);
           const root = new threepipe.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);