@threepipe/plugin-blend-importer 0.0.4 → 0.0.6

package/dist/index.js

@@ -1,16 +1,14 @@
 (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) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("threepipe"), require("three")) : typeof define === "function" && define.amd ? define(["exports", "threepipe", "three"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["@threepipe/plugin-blend-importer"] = {}, global.threepipe, global.threepipe));
+})(this, function(exports2, threepipe, three) {
   "use strict";/**
  * @license
- * @threepipe/plugin-blend-importer v0.0.4
+ * @threepipe/plugin-blend-importer v0.0.6
  * 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,200 @@
   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) {
+      const sensorWidth = cdata.sensor_x || 36;
+      const sensorHeight = cdata.sensor_y || 24;
+      const lens = cdata.lens || 50;
+      const fov = 2 * Math.atan(sensorHeight / (2 * lens)) * (180 / Math.PI);
+      camera = new ctx.PerspectiveCamera(
+        fov,
+        sensorWidth / sensorHeight,
+        cdata.clipsta || 0.1,
+        cdata.clipend || 1e3
+      );
+      if ("shiftx" in cdata) camera.userData.shiftX = cdata.shiftx;
+      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
+      );
+      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 +829,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 +843,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,57 +862,1891 @@
         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 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;
   }
+  function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+  }
+  class Quaternion {
+    constructor(x = 0, y = 0, z = 0, w = 1) {
+      this.isQuaternion = true;
+      this._x = x;
+      this._y = y;
+      this._z = z;
+      this._w = w;
+    }
+    static slerpFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) {
+      let x0 = src0[srcOffset0 + 0], y0 = src0[srcOffset0 + 1], z0 = src0[srcOffset0 + 2], w0 = src0[srcOffset0 + 3];
+      const x1 = src1[srcOffset1 + 0], y1 = src1[srcOffset1 + 1], z1 = src1[srcOffset1 + 2], w1 = src1[srcOffset1 + 3];
+      if (t === 0) {
+        dst[dstOffset + 0] = x0;
+        dst[dstOffset + 1] = y0;
+        dst[dstOffset + 2] = z0;
+        dst[dstOffset + 3] = w0;
+        return;
+      }
+      if (t === 1) {
+        dst[dstOffset + 0] = x1;
+        dst[dstOffset + 1] = y1;
+        dst[dstOffset + 2] = z1;
+        dst[dstOffset + 3] = w1;
+        return;
+      }
+      if (w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1) {
+        let s = 1 - t;
+        const cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1, dir = cos >= 0 ? 1 : -1, sqrSin = 1 - cos * cos;
+        if (sqrSin > Number.EPSILON) {
+          const sin = Math.sqrt(sqrSin), len = Math.atan2(sin, cos * dir);
+          s = Math.sin(s * len) / sin;
+          t = Math.sin(t * len) / sin;
+        }
+        const tDir = t * dir;
+        x0 = x0 * s + x1 * tDir;
+        y0 = y0 * s + y1 * tDir;
+        z0 = z0 * s + z1 * tDir;
+        w0 = w0 * s + w1 * tDir;
+        if (s === 1 - t) {
+          const f = 1 / Math.sqrt(x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0);
+          x0 *= f;
+          y0 *= f;
+          z0 *= f;
+          w0 *= f;
+        }
+      }
+      dst[dstOffset] = x0;
+      dst[dstOffset + 1] = y0;
+      dst[dstOffset + 2] = z0;
+      dst[dstOffset + 3] = w0;
+    }
+    static multiplyQuaternionsFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1) {
+      const x0 = src0[srcOffset0];
+      const y0 = src0[srcOffset0 + 1];
+      const z0 = src0[srcOffset0 + 2];
+      const w0 = src0[srcOffset0 + 3];
+      const x1 = src1[srcOffset1];
+      const y1 = src1[srcOffset1 + 1];
+      const z1 = src1[srcOffset1 + 2];
+      const w1 = src1[srcOffset1 + 3];
+      dst[dstOffset] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
+      dst[dstOffset + 1] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
+      dst[dstOffset + 2] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
+      dst[dstOffset + 3] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
+      return dst;
+    }
+    get x() {
+      return this._x;
+    }
+    set x(value) {
+      this._x = value;
+      this._onChangeCallback();
+    }
+    get y() {
+      return this._y;
+    }
+    set y(value) {
+      this._y = value;
+      this._onChangeCallback();
+    }
+    get z() {
+      return this._z;
+    }
+    set z(value) {
+      this._z = value;
+      this._onChangeCallback();
+    }
+    get w() {
+      return this._w;
+    }
+    set w(value) {
+      this._w = value;
+      this._onChangeCallback();
+    }
+    set(x, y, z, w) {
+      this._x = x;
+      this._y = y;
+      this._z = z;
+      this._w = w;
+      this._onChangeCallback();
+      return this;
+    }
+    clone() {
+      return new this.constructor(this._x, this._y, this._z, this._w);
+    }
+    copy(quaternion) {
+      this._x = quaternion.x;
+      this._y = quaternion.y;
+      this._z = quaternion.z;
+      this._w = quaternion.w;
+      this._onChangeCallback();
+      return this;
+    }
+    setFromEuler(euler, update = true) {
+      const x = euler._x, y = euler._y, z = euler._z, order = euler._order;
+      const cos = Math.cos;
+      const sin = Math.sin;
+      const c1 = cos(x / 2);
+      const c2 = cos(y / 2);
+      const c3 = cos(z / 2);
+      const s1 = sin(x / 2);
+      const s2 = sin(y / 2);
+      const s3 = sin(z / 2);
+      switch (order) {
+        case "XYZ":
+          this._x = s1 * c2 * c3 + c1 * s2 * s3;
+          this._y = c1 * s2 * c3 - s1 * c2 * s3;
+          this._z = c1 * c2 * s3 + s1 * s2 * c3;
+          this._w = c1 * c2 * c3 - s1 * s2 * s3;
+          break;
+        case "YXZ":
+          this._x = s1 * c2 * c3 + c1 * s2 * s3;
+          this._y = c1 * s2 * c3 - s1 * c2 * s3;
+          this._z = c1 * c2 * s3 - s1 * s2 * c3;
+          this._w = c1 * c2 * c3 + s1 * s2 * s3;
+          break;
+        case "ZXY":
+          this._x = s1 * c2 * c3 - c1 * s2 * s3;
+          this._y = c1 * s2 * c3 + s1 * c2 * s3;
+          this._z = c1 * c2 * s3 + s1 * s2 * c3;
+          this._w = c1 * c2 * c3 - s1 * s2 * s3;
+          break;
+        case "ZYX":
+          this._x = s1 * c2 * c3 - c1 * s2 * s3;
+          this._y = c1 * s2 * c3 + s1 * c2 * s3;
+          this._z = c1 * c2 * s3 - s1 * s2 * c3;
+          this._w = c1 * c2 * c3 + s1 * s2 * s3;
+          break;
+        case "YZX":
+          this._x = s1 * c2 * c3 + c1 * s2 * s3;
+          this._y = c1 * s2 * c3 + s1 * c2 * s3;
+          this._z = c1 * c2 * s3 - s1 * s2 * c3;
+          this._w = c1 * c2 * c3 - s1 * s2 * s3;
+          break;
+        case "XZY":
+          this._x = s1 * c2 * c3 - c1 * s2 * s3;
+          this._y = c1 * s2 * c3 - s1 * c2 * s3;
+          this._z = c1 * c2 * s3 + s1 * s2 * c3;
+          this._w = c1 * c2 * c3 + s1 * s2 * s3;
+          break;
+        default:
+          console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: " + order);
+      }
+      if (update === true) this._onChangeCallback();
+      return this;
+    }
+    setFromAxisAngle(axis, angle) {
+      const halfAngle = angle / 2, s = Math.sin(halfAngle);
+      this._x = axis.x * s;
+      this._y = axis.y * s;
+      this._z = axis.z * s;
+      this._w = Math.cos(halfAngle);
+      this._onChangeCallback();
+      return this;
+    }
+    setFromRotationMatrix(m) {
+      const te = m.elements, m11 = te[0], m12 = te[4], m13 = te[8], m21 = te[1], m22 = te[5], m23 = te[9], m31 = te[2], m32 = te[6], m33 = te[10], trace = m11 + m22 + m33;
+      if (trace > 0) {
+        const s = 0.5 / Math.sqrt(trace + 1);
+        this._w = 0.25 / s;
+        this._x = (m32 - m23) * s;
+        this._y = (m13 - m31) * s;
+        this._z = (m21 - m12) * s;
+      } else if (m11 > m22 && m11 > m33) {
+        const s = 2 * Math.sqrt(1 + m11 - m22 - m33);
+        this._w = (m32 - m23) / s;
+        this._x = 0.25 * s;
+        this._y = (m12 + m21) / s;
+        this._z = (m13 + m31) / s;
+      } else if (m22 > m33) {
+        const s = 2 * Math.sqrt(1 + m22 - m11 - m33);
+        this._w = (m13 - m31) / s;
+        this._x = (m12 + m21) / s;
+        this._y = 0.25 * s;
+        this._z = (m23 + m32) / s;
+      } else {
+        const s = 2 * Math.sqrt(1 + m33 - m11 - m22);
+        this._w = (m21 - m12) / s;
+        this._x = (m13 + m31) / s;
+        this._y = (m23 + m32) / s;
+        this._z = 0.25 * s;
+      }
+      this._onChangeCallback();
+      return this;
+    }
+    setFromUnitVectors(vFrom, vTo) {
+      let r = vFrom.dot(vTo) + 1;
+      if (r < Number.EPSILON) {
+        r = 0;
+        if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) {
+          this._x = -vFrom.y;
+          this._y = vFrom.x;
+          this._z = 0;
+          this._w = r;
+        } else {
+          this._x = 0;
+          this._y = -vFrom.z;
+          this._z = vFrom.y;
+          this._w = r;
+        }
+      } else {
+        this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
+        this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
+        this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
+        this._w = r;
+      }
+      return this.normalize();
+    }
+    angleTo(q) {
+      return 2 * Math.acos(Math.abs(clamp(this.dot(q), -1, 1)));
+    }
+    rotateTowards(q, step) {
+      const angle = this.angleTo(q);
+      if (angle === 0) return this;
+      const t = Math.min(1, step / angle);
+      this.slerp(q, t);
+      return this;
+    }
+    identity() {
+      return this.set(0, 0, 0, 1);
+    }
+    invert() {
+      return this.conjugate();
+    }
+    conjugate() {
+      this._x *= -1;
+      this._y *= -1;
+      this._z *= -1;
+      this._onChangeCallback();
+      return this;
+    }
+    dot(v) {
+      return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
+    }
+    lengthSq() {
+      return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
+    }
+    length() {
+      return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w);
+    }
+    normalize() {
+      let l = this.length();
+      if (l === 0) {
+        this._x = 0;
+        this._y = 0;
+        this._z = 0;
+        this._w = 1;
+      } else {
+        l = 1 / l;
+        this._x = this._x * l;
+        this._y = this._y * l;
+        this._z = this._z * l;
+        this._w = this._w * l;
+      }
+      this._onChangeCallback();
+      return this;
+    }
+    multiply(q) {
+      return this.multiplyQuaternions(this, q);
+    }
+    premultiply(q) {
+      return this.multiplyQuaternions(q, this);
+    }
+    multiplyQuaternions(a, b) {
+      const qax = a._x, qay = a._y, qaz = a._z, qaw = a._w;
+      const qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w;
+      this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
+      this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
+      this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
+      this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
+      this._onChangeCallback();
+      return this;
+    }
+    slerp(qb, t) {
+      if (t === 0) return this;
+      if (t === 1) return this.copy(qb);
+      const x = this._x, y = this._y, z = this._z, w = this._w;
+      let cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;
+      if (cosHalfTheta < 0) {
+        this._w = -qb._w;
+        this._x = -qb._x;
+        this._y = -qb._y;
+        this._z = -qb._z;
+        cosHalfTheta = -cosHalfTheta;
+      } else {
+        this.copy(qb);
+      }
+      if (cosHalfTheta >= 1) {
+        this._w = w;
+        this._x = x;
+        this._y = y;
+        this._z = z;
+        return this;
+      }
+      const sqrSinHalfTheta = 1 - cosHalfTheta * cosHalfTheta;
+      if (sqrSinHalfTheta <= Number.EPSILON) {
+        const s = 1 - t;
+        this._w = s * w + t * this._w;
+        this._x = s * x + t * this._x;
+        this._y = s * y + t * this._y;
+        this._z = s * z + t * this._z;
+        this.normalize();
+        return this;
+      }
+      const sinHalfTheta = Math.sqrt(sqrSinHalfTheta);
+      const halfTheta = Math.atan2(sinHalfTheta, cosHalfTheta);
+      const ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta, ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
+      this._w = w * ratioA + this._w * ratioB;
+      this._x = x * ratioA + this._x * ratioB;
+      this._y = y * ratioA + this._y * ratioB;
+      this._z = z * ratioA + this._z * ratioB;
+      this._onChangeCallback();
+      return this;
+    }
+    slerpQuaternions(qa, qb, t) {
+      return this.copy(qa).slerp(qb, t);
+    }
+    random() {
+      const u1 = Math.random();
+      const sqrt1u1 = Math.sqrt(1 - u1);
+      const sqrtu1 = Math.sqrt(u1);
+      const u2 = 2 * Math.PI * Math.random();
+      const u3 = 2 * Math.PI * Math.random();
+      return this.set(
+        sqrt1u1 * Math.cos(u2),
+        sqrtu1 * Math.sin(u3),
+        sqrtu1 * Math.cos(u3),
+        sqrt1u1 * Math.sin(u2)
+      );
+    }
+    equals(quaternion) {
+      return quaternion._x === this._x && quaternion._y === this._y && quaternion._z === this._z && quaternion._w === this._w;
+    }
+    fromArray(array, offset = 0) {
+      this._x = array[offset];
+      this._y = array[offset + 1];
+      this._z = array[offset + 2];
+      this._w = array[offset + 3];
+      this._onChangeCallback();
+      return this;
+    }
+    toArray(array = [], offset = 0) {
+      array[offset] = this._x;
+      array[offset + 1] = this._y;
+      array[offset + 2] = this._z;
+      array[offset + 3] = this._w;
+      return array;
+    }
+    fromBufferAttribute(attribute, index) {
+      this._x = attribute.getX(index);
+      this._y = attribute.getY(index);
+      this._z = attribute.getZ(index);
+      this._w = attribute.getW(index);
+      this._onChangeCallback();
+      return this;
+    }
+    toJSON() {
+      return this.toArray();
+    }
+    _onChange(callback) {
+      this._onChangeCallback = callback;
+      return this;
+    }
+    _onChangeCallback() {
+    }
+    *[Symbol.iterator]() {
+      yield this._x;
+      yield this._y;
+      yield this._z;
+      yield this._w;
+    }
+  }
+  const WebGLCoordinateSystem = 2e3;
+  const WebGPUCoordinateSystem = 2001;
+  class Vector3 {
+    constructor(x = 0, y = 0, z = 0) {
+      Vector3.prototype.isVector3 = true;
+      this.x = x;
+      this.y = y;
+      this.z = z;
+    }
+    set(x, y, z) {
+      if (z === void 0) z = this.z;
+      this.x = x;
+      this.y = y;
+      this.z = z;
+      return this;
+    }
+    setScalar(scalar) {
+      this.x = scalar;
+      this.y = scalar;
+      this.z = scalar;
+      return this;
+    }
+    setX(x) {
+      this.x = x;
+      return this;
+    }
+    setY(y) {
+      this.y = y;
+      return this;
+    }
+    setZ(z) {
+      this.z = z;
+      return this;
+    }
+    setComponent(index, value) {
+      switch (index) {
+        case 0:
+          this.x = value;
+          break;
+        case 1:
+          this.y = value;
+          break;
+        case 2:
+          this.z = value;
+          break;
+        default:
+          throw new Error("index is out of range: " + index);
+      }
+      return this;
+    }
+    getComponent(index) {
+      switch (index) {
+        case 0:
+          return this.x;
+        case 1:
+          return this.y;
+        case 2:
+          return this.z;
+        default:
+          throw new Error("index is out of range: " + index);
+      }
+    }
+    clone() {
+      return new this.constructor(this.x, this.y, this.z);
+    }
+    copy(v) {
+      this.x = v.x;
+      this.y = v.y;
+      this.z = v.z;
+      return this;
+    }
+    add(v) {
+      this.x += v.x;
+      this.y += v.y;
+      this.z += v.z;
+      return this;
+    }
+    addScalar(s) {
+      this.x += s;
+      this.y += s;
+      this.z += s;
+      return this;
+    }
+    addVectors(a, b) {
+      this.x = a.x + b.x;
+      this.y = a.y + b.y;
+      this.z = a.z + b.z;
+      return this;
+    }
+    addScaledVector(v, s) {
+      this.x += v.x * s;
+      this.y += v.y * s;
+      this.z += v.z * s;
+      return this;
+    }
+    sub(v) {
+      this.x -= v.x;
+      this.y -= v.y;
+      this.z -= v.z;
+      return this;
+    }
+    subScalar(s) {
+      this.x -= s;
+      this.y -= s;
+      this.z -= s;
+      return this;
+    }
+    subVectors(a, b) {
+      this.x = a.x - b.x;
+      this.y = a.y - b.y;
+      this.z = a.z - b.z;
+      return this;
+    }
+    multiply(v) {
+      this.x *= v.x;
+      this.y *= v.y;
+      this.z *= v.z;
+      return this;
+    }
+    multiplyScalar(scalar) {
+      this.x *= scalar;
+      this.y *= scalar;
+      this.z *= scalar;
+      return this;
+    }
+    multiplyVectors(a, b) {
+      this.x = a.x * b.x;
+      this.y = a.y * b.y;
+      this.z = a.z * b.z;
+      return this;
+    }
+    applyEuler(euler) {
+      return this.applyQuaternion(_quaternion$1.setFromEuler(euler));
+    }
+    applyAxisAngle(axis, angle) {
+      return this.applyQuaternion(_quaternion$1.setFromAxisAngle(axis, angle));
+    }
+    applyMatrix3(m) {
+      const x = this.x, y = this.y, z = this.z;
+      const e = m.elements;
+      this.x = e[0] * x + e[3] * y + e[6] * z;
+      this.y = e[1] * x + e[4] * y + e[7] * z;
+      this.z = e[2] * x + e[5] * y + e[8] * z;
+      return this;
+    }
+    applyNormalMatrix(m) {
+      return this.applyMatrix3(m).normalize();
+    }
+    applyMatrix4(m) {
+      const x = this.x, y = this.y, z = this.z;
+      const e = m.elements;
+      const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
+      this.x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * w;
+      this.y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * w;
+      this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w;
+      return this;
+    }
+    applyQuaternion(q) {
+      const vx = this.x, vy = this.y, vz = this.z;
+      const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
+      const tx = 2 * (qy * vz - qz * vy);
+      const ty = 2 * (qz * vx - qx * vz);
+      const tz = 2 * (qx * vy - qy * vx);
+      this.x = vx + qw * tx + qy * tz - qz * ty;
+      this.y = vy + qw * ty + qz * tx - qx * tz;
+      this.z = vz + qw * tz + qx * ty - qy * tx;
+      return this;
+    }
+    project(camera) {
+      return this.applyMatrix4(camera.matrixWorldInverse).applyMatrix4(camera.projectionMatrix);
+    }
+    unproject(camera) {
+      return this.applyMatrix4(camera.projectionMatrixInverse).applyMatrix4(camera.matrixWorld);
+    }
+    transformDirection(m) {
+      const x = this.x, y = this.y, z = this.z;
+      const e = m.elements;
+      this.x = e[0] * x + e[4] * y + e[8] * z;
+      this.y = e[1] * x + e[5] * y + e[9] * z;
+      this.z = e[2] * x + e[6] * y + e[10] * z;
+      return this.normalize();
+    }
+    divide(v) {
+      this.x /= v.x;
+      this.y /= v.y;
+      this.z /= v.z;
+      return this;
+    }
+    divideScalar(scalar) {
+      return this.multiplyScalar(1 / scalar);
+    }
+    min(v) {
+      this.x = Math.min(this.x, v.x);
+      this.y = Math.min(this.y, v.y);
+      this.z = Math.min(this.z, v.z);
+      return this;
+    }
+    max(v) {
+      this.x = Math.max(this.x, v.x);
+      this.y = Math.max(this.y, v.y);
+      this.z = Math.max(this.z, v.z);
+      return this;
+    }
+    clamp(min, max) {
+      this.x = Math.max(min.x, Math.min(max.x, this.x));
+      this.y = Math.max(min.y, Math.min(max.y, this.y));
+      this.z = Math.max(min.z, Math.min(max.z, this.z));
+      return this;
+    }
+    clampScalar(minVal, maxVal) {
+      this.x = Math.max(minVal, Math.min(maxVal, this.x));
+      this.y = Math.max(minVal, Math.min(maxVal, this.y));
+      this.z = Math.max(minVal, Math.min(maxVal, this.z));
+      return this;
+    }
+    clampLength(min, max) {
+      const length = this.length();
+      return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
+    }
+    floor() {
+      this.x = Math.floor(this.x);
+      this.y = Math.floor(this.y);
+      this.z = Math.floor(this.z);
+      return this;
+    }
+    ceil() {
+      this.x = Math.ceil(this.x);
+      this.y = Math.ceil(this.y);
+      this.z = Math.ceil(this.z);
+      return this;
+    }
+    round() {
+      this.x = Math.round(this.x);
+      this.y = Math.round(this.y);
+      this.z = Math.round(this.z);
+      return this;
+    }
+    roundToZero() {
+      this.x = Math.trunc(this.x);
+      this.y = Math.trunc(this.y);
+      this.z = Math.trunc(this.z);
+      return this;
+    }
+    negate() {
+      this.x = -this.x;
+      this.y = -this.y;
+      this.z = -this.z;
+      return this;
+    }
+    dot(v) {
+      return this.x * v.x + this.y * v.y + this.z * v.z;
+    }
+    // TODO lengthSquared?
+    lengthSq() {
+      return this.x * this.x + this.y * this.y + this.z * this.z;
+    }
+    length() {
+      return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+    }
+    manhattanLength() {
+      return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z);
+    }
+    normalize() {
+      return this.divideScalar(this.length() || 1);
+    }
+    setLength(length) {
+      return this.normalize().multiplyScalar(length);
+    }
+    lerp(v, alpha) {
+      this.x += (v.x - this.x) * alpha;
+      this.y += (v.y - this.y) * alpha;
+      this.z += (v.z - this.z) * alpha;
+      return this;
+    }
+    lerpVectors(v1, v2, alpha) {
+      this.x = v1.x + (v2.x - v1.x) * alpha;
+      this.y = v1.y + (v2.y - v1.y) * alpha;
+      this.z = v1.z + (v2.z - v1.z) * alpha;
+      return this;
+    }
+    cross(v) {
+      return this.crossVectors(this, v);
+    }
+    crossVectors(a, b) {
+      const ax = a.x, ay = a.y, az = a.z;
+      const bx = b.x, by = b.y, bz = b.z;
+      this.x = ay * bz - az * by;
+      this.y = az * bx - ax * bz;
+      this.z = ax * by - ay * bx;
+      return this;
+    }
+    projectOnVector(v) {
+      const denominator = v.lengthSq();
+      if (denominator === 0) return this.set(0, 0, 0);
+      const scalar = v.dot(this) / denominator;
+      return this.copy(v).multiplyScalar(scalar);
+    }
+    projectOnPlane(planeNormal) {
+      _vector.copy(this).projectOnVector(planeNormal);
+      return this.sub(_vector);
+    }
+    reflect(normal) {
+      return this.sub(_vector.copy(normal).multiplyScalar(2 * this.dot(normal)));
+    }
+    angleTo(v) {
+      const denominator = Math.sqrt(this.lengthSq() * v.lengthSq());
+      if (denominator === 0) return Math.PI / 2;
+      const theta = this.dot(v) / denominator;
+      return Math.acos(clamp(theta, -1, 1));
+    }
+    distanceTo(v) {
+      return Math.sqrt(this.distanceToSquared(v));
+    }
+    distanceToSquared(v) {
+      const dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;
+      return dx * dx + dy * dy + dz * dz;
+    }
+    manhattanDistanceTo(v) {
+      return Math.abs(this.x - v.x) + Math.abs(this.y - v.y) + Math.abs(this.z - v.z);
+    }
+    setFromSpherical(s) {
+      return this.setFromSphericalCoords(s.radius, s.phi, s.theta);
+    }
+    setFromSphericalCoords(radius, phi, theta) {
+      const sinPhiRadius = Math.sin(phi) * radius;
+      this.x = sinPhiRadius * Math.sin(theta);
+      this.y = Math.cos(phi) * radius;
+      this.z = sinPhiRadius * Math.cos(theta);
+      return this;
+    }
+    setFromCylindrical(c) {
+      return this.setFromCylindricalCoords(c.radius, c.theta, c.y);
+    }
+    setFromCylindricalCoords(radius, theta, y) {
+      this.x = radius * Math.sin(theta);
+      this.y = y;
+      this.z = radius * Math.cos(theta);
+      return this;
+    }
+    setFromMatrixPosition(m) {
+      const e = m.elements;
+      this.x = e[12];
+      this.y = e[13];
+      this.z = e[14];
+      return this;
+    }
+    setFromMatrixScale(m) {
+      const sx = this.setFromMatrixColumn(m, 0).length();
+      const sy = this.setFromMatrixColumn(m, 1).length();
+      const sz = this.setFromMatrixColumn(m, 2).length();
+      this.x = sx;
+      this.y = sy;
+      this.z = sz;
+      return this;
+    }
+    setFromMatrixColumn(m, index) {
+      return this.fromArray(m.elements, index * 4);
+    }
+    setFromMatrix3Column(m, index) {
+      return this.fromArray(m.elements, index * 3);
+    }
+    setFromEuler(e) {
+      this.x = e._x;
+      this.y = e._y;
+      this.z = e._z;
+      return this;
+    }
+    setFromColor(c) {
+      this.x = c.r;
+      this.y = c.g;
+      this.z = c.b;
+      return this;
+    }
+    equals(v) {
+      return v.x === this.x && v.y === this.y && v.z === this.z;
+    }
+    fromArray(array, offset = 0) {
+      this.x = array[offset];
+      this.y = array[offset + 1];
+      this.z = array[offset + 2];
+      return this;
+    }
+    toArray(array = [], offset = 0) {
+      array[offset] = this.x;
+      array[offset + 1] = this.y;
+      array[offset + 2] = this.z;
+      return array;
+    }
+    fromBufferAttribute(attribute, index) {
+      this.x = attribute.getX(index);
+      this.y = attribute.getY(index);
+      this.z = attribute.getZ(index);
+      return this;
+    }
+    random() {
+      this.x = Math.random();
+      this.y = Math.random();
+      this.z = Math.random();
+      return this;
+    }
+    randomDirection() {
+      const u = (Math.random() - 0.5) * 2;
+      const t = Math.random() * Math.PI * 2;
+      const f = Math.sqrt(1 - u ** 2);
+      this.x = f * Math.cos(t);
+      this.y = f * Math.sin(t);
+      this.z = u;
+      return this;
+    }
+    *[Symbol.iterator]() {
+      yield this.x;
+      yield this.y;
+      yield this.z;
+    }
+  }
+  const _vector = /* @__PURE__ */ new Vector3();
+  const _quaternion$1 = /* @__PURE__ */ new Quaternion();
+  class Matrix4 {
+    constructor(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44) {
+      Matrix4.prototype.isMatrix4 = true;
+      this.elements = [
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1
+      ];
+      if (n11 !== void 0) {
+        this.set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44);
+      }
+    }
+    set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44) {
+      const te = this.elements;
+      te[0] = n11;
+      te[4] = n12;
+      te[8] = n13;
+      te[12] = n14;
+      te[1] = n21;
+      te[5] = n22;
+      te[9] = n23;
+      te[13] = n24;
+      te[2] = n31;
+      te[6] = n32;
+      te[10] = n33;
+      te[14] = n34;
+      te[3] = n41;
+      te[7] = n42;
+      te[11] = n43;
+      te[15] = n44;
+      return this;
+    }
+    identity() {
+      this.set(
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1
+      );
+      return this;
+    }
+    clone() {
+      return new Matrix4().fromArray(this.elements);
+    }
+    copy(m) {
+      const te = this.elements;
+      const me = m.elements;
+      te[0] = me[0];
+      te[1] = me[1];
+      te[2] = me[2];
+      te[3] = me[3];
+      te[4] = me[4];
+      te[5] = me[5];
+      te[6] = me[6];
+      te[7] = me[7];
+      te[8] = me[8];
+      te[9] = me[9];
+      te[10] = me[10];
+      te[11] = me[11];
+      te[12] = me[12];
+      te[13] = me[13];
+      te[14] = me[14];
+      te[15] = me[15];
+      return this;
+    }
+    copyPosition(m) {
+      const te = this.elements, me = m.elements;
+      te[12] = me[12];
+      te[13] = me[13];
+      te[14] = me[14];
+      return this;
+    }
+    setFromMatrix3(m) {
+      const me = m.elements;
+      this.set(
+        me[0],
+        me[3],
+        me[6],
+        0,
+        me[1],
+        me[4],
+        me[7],
+        0,
+        me[2],
+        me[5],
+        me[8],
+        0,
+        0,
+        0,
+        0,
+        1
+      );
+      return this;
+    }
+    extractBasis(xAxis, yAxis, zAxis) {
+      xAxis.setFromMatrixColumn(this, 0);
+      yAxis.setFromMatrixColumn(this, 1);
+      zAxis.setFromMatrixColumn(this, 2);
+      return this;
+    }
+    makeBasis(xAxis, yAxis, zAxis) {
+      this.set(
+        xAxis.x,
+        yAxis.x,
+        zAxis.x,
+        0,
+        xAxis.y,
+        yAxis.y,
+        zAxis.y,
+        0,
+        xAxis.z,
+        yAxis.z,
+        zAxis.z,
+        0,
+        0,
+        0,
+        0,
+        1
+      );
+      return this;
+    }
+    extractRotation(m) {
+      const te = this.elements;
+      const me = m.elements;
+      const scaleX = 1 / _v1.setFromMatrixColumn(m, 0).length();
+      const scaleY = 1 / _v1.setFromMatrixColumn(m, 1).length();
+      const scaleZ = 1 / _v1.setFromMatrixColumn(m, 2).length();
+      te[0] = me[0] * scaleX;
+      te[1] = me[1] * scaleX;
+      te[2] = me[2] * scaleX;
+      te[3] = 0;
+      te[4] = me[4] * scaleY;
+      te[5] = me[5] * scaleY;
+      te[6] = me[6] * scaleY;
+      te[7] = 0;
+      te[8] = me[8] * scaleZ;
+      te[9] = me[9] * scaleZ;
+      te[10] = me[10] * scaleZ;
+      te[11] = 0;
+      te[12] = 0;
+      te[13] = 0;
+      te[14] = 0;
+      te[15] = 1;
+      return this;
+    }
+    makeRotationFromEuler(euler) {
+      const te = this.elements;
+      const x = euler.x, y = euler.y, z = euler.z;
+      const a = Math.cos(x), b = Math.sin(x);
+      const c = Math.cos(y), d = Math.sin(y);
+      const e = Math.cos(z), f = Math.sin(z);
+      if (euler.order === "XYZ") {
+        const ae = a * e, af = a * f, be = b * e, bf = b * f;
+        te[0] = c * e;
+        te[4] = -c * f;
+        te[8] = d;
+        te[1] = af + be * d;
+        te[5] = ae - bf * d;
+        te[9] = -b * c;
+        te[2] = bf - ae * d;
+        te[6] = be + af * d;
+        te[10] = a * c;
+      } else if (euler.order === "YXZ") {
+        const ce = c * e, cf = c * f, de = d * e, df = d * f;
+        te[0] = ce + df * b;
+        te[4] = de * b - cf;
+        te[8] = a * d;
+        te[1] = a * f;
+        te[5] = a * e;
+        te[9] = -b;
+        te[2] = cf * b - de;
+        te[6] = df + ce * b;
+        te[10] = a * c;
+      } else if (euler.order === "ZXY") {
+        const ce = c * e, cf = c * f, de = d * e, df = d * f;
+        te[0] = ce - df * b;
+        te[4] = -a * f;
+        te[8] = de + cf * b;
+        te[1] = cf + de * b;
+        te[5] = a * e;
+        te[9] = df - ce * b;
+        te[2] = -a * d;
+        te[6] = b;
+        te[10] = a * c;
+      } else if (euler.order === "ZYX") {
+        const ae = a * e, af = a * f, be = b * e, bf = b * f;
+        te[0] = c * e;
+        te[4] = be * d - af;
+        te[8] = ae * d + bf;
+        te[1] = c * f;
+        te[5] = bf * d + ae;
+        te[9] = af * d - be;
+        te[2] = -d;
+        te[6] = b * c;
+        te[10] = a * c;
+      } else if (euler.order === "YZX") {
+        const ac = a * c, ad = a * d, bc = b * c, bd = b * d;
+        te[0] = c * e;
+        te[4] = bd - ac * f;
+        te[8] = bc * f + ad;
+        te[1] = f;
+        te[5] = a * e;
+        te[9] = -b * e;
+        te[2] = -d * e;
+        te[6] = ad * f + bc;
+        te[10] = ac - bd * f;
+      } else if (euler.order === "XZY") {
+        const ac = a * c, ad = a * d, bc = b * c, bd = b * d;
+        te[0] = c * e;
+        te[4] = -f;
+        te[8] = d * e;
+        te[1] = ac * f + bd;
+        te[5] = a * e;
+        te[9] = ad * f - bc;
+        te[2] = bc * f - ad;
+        te[6] = b * e;
+        te[10] = bd * f + ac;
+      }
+      te[3] = 0;
+      te[7] = 0;
+      te[11] = 0;
+      te[12] = 0;
+      te[13] = 0;
+      te[14] = 0;
+      te[15] = 1;
+      return this;
+    }
+    makeRotationFromQuaternion(q) {
+      return this.compose(_zero, q, _one);
+    }
+    lookAt(eye, target, up) {
+      const te = this.elements;
+      _z.subVectors(eye, target);
+      if (_z.lengthSq() === 0) {
+        _z.z = 1;
+      }
+      _z.normalize();
+      _x.crossVectors(up, _z);
+      if (_x.lengthSq() === 0) {
+        if (Math.abs(up.z) === 1) {
+          _z.x += 1e-4;
+        } else {
+          _z.z += 1e-4;
+        }
+        _z.normalize();
+        _x.crossVectors(up, _z);
+      }
+      _x.normalize();
+      _y.crossVectors(_z, _x);
+      te[0] = _x.x;
+      te[4] = _y.x;
+      te[8] = _z.x;
+      te[1] = _x.y;
+      te[5] = _y.y;
+      te[9] = _z.y;
+      te[2] = _x.z;
+      te[6] = _y.z;
+      te[10] = _z.z;
+      return this;
+    }
+    multiply(m) {
+      return this.multiplyMatrices(this, m);
+    }
+    premultiply(m) {
+      return this.multiplyMatrices(m, this);
+    }
+    multiplyMatrices(a, b) {
+      const ae = a.elements;
+      const be = b.elements;
+      const te = this.elements;
+      const a11 = ae[0], a12 = ae[4], a13 = ae[8], a14 = ae[12];
+      const a21 = ae[1], a22 = ae[5], a23 = ae[9], a24 = ae[13];
+      const a31 = ae[2], a32 = ae[6], a33 = ae[10], a34 = ae[14];
+      const a41 = ae[3], a42 = ae[7], a43 = ae[11], a44 = ae[15];
+      const b11 = be[0], b12 = be[4], b13 = be[8], b14 = be[12];
+      const b21 = be[1], b22 = be[5], b23 = be[9], b24 = be[13];
+      const b31 = be[2], b32 = be[6], b33 = be[10], b34 = be[14];
+      const b41 = be[3], b42 = be[7], b43 = be[11], b44 = be[15];
+      te[0] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;
+      te[4] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;
+      te[8] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;
+      te[12] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;
+      te[1] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;
+      te[5] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;
+      te[9] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;
+      te[13] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;
+      te[2] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;
+      te[6] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;
+      te[10] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;
+      te[14] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;
+      te[3] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;
+      te[7] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;
+      te[11] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;
+      te[15] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;
+      return this;
+    }
+    multiplyScalar(s) {
+      const te = this.elements;
+      te[0] *= s;
+      te[4] *= s;
+      te[8] *= s;
+      te[12] *= s;
+      te[1] *= s;
+      te[5] *= s;
+      te[9] *= s;
+      te[13] *= s;
+      te[2] *= s;
+      te[6] *= s;
+      te[10] *= s;
+      te[14] *= s;
+      te[3] *= s;
+      te[7] *= s;
+      te[11] *= s;
+      te[15] *= s;
+      return this;
+    }
+    determinant() {
+      const te = this.elements;
+      const n11 = te[0], n12 = te[4], n13 = te[8], n14 = te[12];
+      const n21 = te[1], n22 = te[5], n23 = te[9], n24 = te[13];
+      const n31 = te[2], n32 = te[6], n33 = te[10], n34 = te[14];
+      const n41 = te[3], n42 = te[7], n43 = te[11], n44 = te[15];
+      return n41 * (+n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34) + n42 * (+n11 * n23 * n34 - n11 * n24 * n33 + n14 * n21 * n33 - n13 * n21 * n34 + n13 * n24 * n31 - n14 * n23 * n31) + n43 * (+n11 * n24 * n32 - n11 * n22 * n34 - n14 * n21 * n32 + n12 * n21 * n34 + n14 * n22 * n31 - n12 * n24 * n31) + n44 * (-n13 * n22 * n31 - n11 * n23 * n32 + n11 * n22 * n33 + n13 * n21 * n32 - n12 * n21 * n33 + n12 * n23 * n31);
+    }
+    transpose() {
+      const te = this.elements;
+      let tmp;
+      tmp = te[1];
+      te[1] = te[4];
+      te[4] = tmp;
+      tmp = te[2];
+      te[2] = te[8];
+      te[8] = tmp;
+      tmp = te[6];
+      te[6] = te[9];
+      te[9] = tmp;
+      tmp = te[3];
+      te[3] = te[12];
+      te[12] = tmp;
+      tmp = te[7];
+      te[7] = te[13];
+      te[13] = tmp;
+      tmp = te[11];
+      te[11] = te[14];
+      te[14] = tmp;
+      return this;
+    }
+    setPosition(x, y, z) {
+      const te = this.elements;
+      if (x.isVector3) {
+        te[12] = x.x;
+        te[13] = x.y;
+        te[14] = x.z;
+      } else {
+        te[12] = x;
+        te[13] = y;
+        te[14] = z;
+      }
+      return this;
+    }
+    invert() {
+      const te = this.elements, n11 = te[0], n21 = te[1], n31 = te[2], n41 = te[3], n12 = te[4], n22 = te[5], n32 = te[6], n42 = te[7], n13 = te[8], n23 = te[9], n33 = te[10], n43 = te[11], n14 = te[12], n24 = te[13], n34 = te[14], n44 = te[15], t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44, t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44, t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44, t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
+      const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
+      if (det === 0) return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+      const detInv = 1 / det;
+      te[0] = t11 * detInv;
+      te[1] = (n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44) * detInv;
+      te[2] = (n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44) * detInv;
+      te[3] = (n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43) * detInv;
+      te[4] = t12 * detInv;
+      te[5] = (n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44) * detInv;
+      te[6] = (n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44) * detInv;
+      te[7] = (n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43) * detInv;
+      te[8] = t13 * detInv;
+      te[9] = (n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44) * detInv;
+      te[10] = (n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44) * detInv;
+      te[11] = (n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43) * detInv;
+      te[12] = t14 * detInv;
+      te[13] = (n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34) * detInv;
+      te[14] = (n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34) * detInv;
+      te[15] = (n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33) * detInv;
+      return this;
+    }
+    scale(v) {
+      const te = this.elements;
+      const x = v.x, y = v.y, z = v.z;
+      te[0] *= x;
+      te[4] *= y;
+      te[8] *= z;
+      te[1] *= x;
+      te[5] *= y;
+      te[9] *= z;
+      te[2] *= x;
+      te[6] *= y;
+      te[10] *= z;
+      te[3] *= x;
+      te[7] *= y;
+      te[11] *= z;
+      return this;
+    }
+    getMaxScaleOnAxis() {
+      const te = this.elements;
+      const scaleXSq = te[0] * te[0] + te[1] * te[1] + te[2] * te[2];
+      const scaleYSq = te[4] * te[4] + te[5] * te[5] + te[6] * te[6];
+      const scaleZSq = te[8] * te[8] + te[9] * te[9] + te[10] * te[10];
+      return Math.sqrt(Math.max(scaleXSq, scaleYSq, scaleZSq));
+    }
+    makeTranslation(x, y, z) {
+      if (x.isVector3) {
+        this.set(
+          1,
+          0,
+          0,
+          x.x,
+          0,
+          1,
+          0,
+          x.y,
+          0,
+          0,
+          1,
+          x.z,
+          0,
+          0,
+          0,
+          1
+        );
+      } else {
+        this.set(
+          1,
+          0,
+          0,
+          x,
+          0,
+          1,
+          0,
+          y,
+          0,
+          0,
+          1,
+          z,
+          0,
+          0,
+          0,
+          1
+        );
+      }
+      return this;
+    }
+    makeRotationX(theta) {
+      const c = Math.cos(theta), s = Math.sin(theta);
+      this.set(
+        1,
+        0,
+        0,
+        0,
+        0,
+        c,
+        -s,
+        0,
+        0,
+        s,
+        c,
+        0,
+        0,
+        0,
+        0,
+        1
+      );
+      return this;
+    }
+    makeRotationY(theta) {
+      const c = Math.cos(theta), s = Math.sin(theta);
+      this.set(
+        c,
+        0,
+        s,
+        0,
+        0,
+        1,
+        0,
+        0,
+        -s,
+        0,
+        c,
+        0,
+        0,
+        0,
+        0,
+        1
+      );
+      return this;
+    }
+    makeRotationZ(theta) {
+      const c = Math.cos(theta), s = Math.sin(theta);
+      this.set(
+        c,
+        -s,
+        0,
+        0,
+        s,
+        c,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1
+      );
+      return this;
+    }
+    makeRotationAxis(axis, angle) {
+      const c = Math.cos(angle);
+      const s = Math.sin(angle);
+      const t = 1 - c;
+      const x = axis.x, y = axis.y, z = axis.z;
+      const tx = t * x, ty = t * y;
+      this.set(
+        tx * x + c,
+        tx * y - s * z,
+        tx * z + s * y,
+        0,
+        tx * y + s * z,
+        ty * y + c,
+        ty * z - s * x,
+        0,
+        tx * z - s * y,
+        ty * z + s * x,
+        t * z * z + c,
+        0,
+        0,
+        0,
+        0,
+        1
+      );
+      return this;
+    }
+    makeScale(x, y, z) {
+      this.set(
+        x,
+        0,
+        0,
+        0,
+        0,
+        y,
+        0,
+        0,
+        0,
+        0,
+        z,
+        0,
+        0,
+        0,
+        0,
+        1
+      );
+      return this;
+    }
+    makeShear(xy, xz, yx, yz, zx, zy) {
+      this.set(
+        1,
+        yx,
+        zx,
+        0,
+        xy,
+        1,
+        zy,
+        0,
+        xz,
+        yz,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1
+      );
+      return this;
+    }
+    compose(position, quaternion, scale) {
+      const te = this.elements;
+      const x = quaternion._x, y = quaternion._y, z = quaternion._z, w = quaternion._w;
+      const x2 = x + x, y2 = y + y, z2 = z + z;
+      const xx = x * x2, xy = x * y2, xz = x * z2;
+      const yy = y * y2, yz = y * z2, zz = z * z2;
+      const wx = w * x2, wy = w * y2, wz = w * z2;
+      const sx = scale.x, sy = scale.y, sz = scale.z;
+      te[0] = (1 - (yy + zz)) * sx;
+      te[1] = (xy + wz) * sx;
+      te[2] = (xz - wy) * sx;
+      te[3] = 0;
+      te[4] = (xy - wz) * sy;
+      te[5] = (1 - (xx + zz)) * sy;
+      te[6] = (yz + wx) * sy;
+      te[7] = 0;
+      te[8] = (xz + wy) * sz;
+      te[9] = (yz - wx) * sz;
+      te[10] = (1 - (xx + yy)) * sz;
+      te[11] = 0;
+      te[12] = position.x;
+      te[13] = position.y;
+      te[14] = position.z;
+      te[15] = 1;
+      return this;
+    }
+    decompose(position, quaternion, scale) {
+      const te = this.elements;
+      let sx = _v1.set(te[0], te[1], te[2]).length();
+      const sy = _v1.set(te[4], te[5], te[6]).length();
+      const sz = _v1.set(te[8], te[9], te[10]).length();
+      const det = this.determinant();
+      if (det < 0) sx = -sx;
+      position.x = te[12];
+      position.y = te[13];
+      position.z = te[14];
+      _m1.copy(this);
+      const invSX = 1 / sx;
+      const invSY = 1 / sy;
+      const invSZ = 1 / sz;
+      _m1.elements[0] *= invSX;
+      _m1.elements[1] *= invSX;
+      _m1.elements[2] *= invSX;
+      _m1.elements[4] *= invSY;
+      _m1.elements[5] *= invSY;
+      _m1.elements[6] *= invSY;
+      _m1.elements[8] *= invSZ;
+      _m1.elements[9] *= invSZ;
+      _m1.elements[10] *= invSZ;
+      quaternion.setFromRotationMatrix(_m1);
+      scale.x = sx;
+      scale.y = sy;
+      scale.z = sz;
+      return this;
+    }
+    makePerspective(left, right, top, bottom, near, far, coordinateSystem = WebGLCoordinateSystem) {
+      const te = this.elements;
+      const x = 2 * near / (right - left);
+      const y = 2 * near / (top - bottom);
+      const a = (right + left) / (right - left);
+      const b = (top + bottom) / (top - bottom);
+      let c, d;
+      if (coordinateSystem === WebGLCoordinateSystem) {
+        c = -(far + near) / (far - near);
+        d = -2 * far * near / (far - near);
+      } else if (coordinateSystem === WebGPUCoordinateSystem) {
+        c = -far / (far - near);
+        d = -far * near / (far - near);
+      } else {
+        throw new Error("THREE.Matrix4.makePerspective(): Invalid coordinate system: " + coordinateSystem);
+      }
+      te[0] = x;
+      te[4] = 0;
+      te[8] = a;
+      te[12] = 0;
+      te[1] = 0;
+      te[5] = y;
+      te[9] = b;
+      te[13] = 0;
+      te[2] = 0;
+      te[6] = 0;
+      te[10] = c;
+      te[14] = d;
+      te[3] = 0;
+      te[7] = 0;
+      te[11] = -1;
+      te[15] = 0;
+      return this;
+    }
+    makeOrthographic(left, right, top, bottom, near, far, coordinateSystem = WebGLCoordinateSystem) {
+      const te = this.elements;
+      const w = 1 / (right - left);
+      const h = 1 / (top - bottom);
+      const p = 1 / (far - near);
+      const x = (right + left) * w;
+      const y = (top + bottom) * h;
+      let z, zInv;
+      if (coordinateSystem === WebGLCoordinateSystem) {
+        z = (far + near) * p;
+        zInv = -2 * p;
+      } else if (coordinateSystem === WebGPUCoordinateSystem) {
+        z = near * p;
+        zInv = -1 * p;
+      } else {
+        throw new Error("THREE.Matrix4.makeOrthographic(): Invalid coordinate system: " + coordinateSystem);
+      }
+      te[0] = 2 * w;
+      te[4] = 0;
+      te[8] = 0;
+      te[12] = -x;
+      te[1] = 0;
+      te[5] = 2 * h;
+      te[9] = 0;
+      te[13] = -y;
+      te[2] = 0;
+      te[6] = 0;
+      te[10] = zInv;
+      te[14] = -z;
+      te[3] = 0;
+      te[7] = 0;
+      te[11] = 0;
+      te[15] = 1;
+      return this;
+    }
+    equals(matrix) {
+      const te = this.elements;
+      const me = matrix.elements;
+      for (let i = 0; i < 16; i++) {
+        if (te[i] !== me[i]) return false;
+      }
+      return true;
+    }
+    fromArray(array, offset = 0) {
+      for (let i = 0; i < 16; i++) {
+        this.elements[i] = array[i + offset];
+      }
+      return this;
+    }
+    toArray(array = [], offset = 0) {
+      const te = this.elements;
+      array[offset] = te[0];
+      array[offset + 1] = te[1];
+      array[offset + 2] = te[2];
+      array[offset + 3] = te[3];
+      array[offset + 4] = te[4];
+      array[offset + 5] = te[5];
+      array[offset + 6] = te[6];
+      array[offset + 7] = te[7];
+      array[offset + 8] = te[8];
+      array[offset + 9] = te[9];
+      array[offset + 10] = te[10];
+      array[offset + 11] = te[11];
+      array[offset + 12] = te[12];
+      array[offset + 13] = te[13];
+      array[offset + 14] = te[14];
+      array[offset + 15] = te[15];
+      return array;
+    }
+  }
+  const _v1 = /* @__PURE__ */ new Vector3();
+  const _m1 = /* @__PURE__ */ new Matrix4();
+  const _zero = /* @__PURE__ */ new Vector3(0, 0, 0);
+  const _one = /* @__PURE__ */ new Vector3(1, 1, 1);
+  const _x = /* @__PURE__ */ new Vector3();
+  const _y = /* @__PURE__ */ new Vector3();
+  const _z = /* @__PURE__ */ new Vector3();
+  const _matrix = /* @__PURE__ */ new Matrix4();
+  const _quaternion = /* @__PURE__ */ new Quaternion();
+  class Euler {
+    constructor(x = 0, y = 0, z = 0, order = Euler.DEFAULT_ORDER) {
+      this.isEuler = true;
+      this._x = x;
+      this._y = y;
+      this._z = z;
+      this._order = order;
+    }
+    get x() {
+      return this._x;
+    }
+    set x(value) {
+      this._x = value;
+      this._onChangeCallback();
+    }
+    get y() {
+      return this._y;
+    }
+    set y(value) {
+      this._y = value;
+      this._onChangeCallback();
+    }
+    get z() {
+      return this._z;
+    }
+    set z(value) {
+      this._z = value;
+      this._onChangeCallback();
+    }
+    get order() {
+      return this._order;
+    }
+    set order(value) {
+      this._order = value;
+      this._onChangeCallback();
+    }
+    set(x, y, z, order = this._order) {
+      this._x = x;
+      this._y = y;
+      this._z = z;
+      this._order = order;
+      this._onChangeCallback();
+      return this;
+    }
+    clone() {
+      return new this.constructor(this._x, this._y, this._z, this._order);
+    }
+    copy(euler) {
+      this._x = euler._x;
+      this._y = euler._y;
+      this._z = euler._z;
+      this._order = euler._order;
+      this._onChangeCallback();
+      return this;
+    }
+    setFromRotationMatrix(m, order = this._order, update = true) {
+      const te = m.elements;
+      const m11 = te[0], m12 = te[4], m13 = te[8];
+      const m21 = te[1], m22 = te[5], m23 = te[9];
+      const m31 = te[2], m32 = te[6], m33 = te[10];
+      switch (order) {
+        case "XYZ":
+          this._y = Math.asin(clamp(m13, -1, 1));
+          if (Math.abs(m13) < 0.9999999) {
+            this._x = Math.atan2(-m23, m33);
+            this._z = Math.atan2(-m12, m11);
+          } else {
+            this._x = Math.atan2(m32, m22);
+            this._z = 0;
+          }
+          break;
+        case "YXZ":
+          this._x = Math.asin(-clamp(m23, -1, 1));
+          if (Math.abs(m23) < 0.9999999) {
+            this._y = Math.atan2(m13, m33);
+            this._z = Math.atan2(m21, m22);
+          } else {
+            this._y = Math.atan2(-m31, m11);
+            this._z = 0;
+          }
+          break;
+        case "ZXY":
+          this._x = Math.asin(clamp(m32, -1, 1));
+          if (Math.abs(m32) < 0.9999999) {
+            this._y = Math.atan2(-m31, m33);
+            this._z = Math.atan2(-m12, m22);
+          } else {
+            this._y = 0;
+            this._z = Math.atan2(m21, m11);
+          }
+          break;
+        case "ZYX":
+          this._y = Math.asin(-clamp(m31, -1, 1));
+          if (Math.abs(m31) < 0.9999999) {
+            this._x = Math.atan2(m32, m33);
+            this._z = Math.atan2(m21, m11);
+          } else {
+            this._x = 0;
+            this._z = Math.atan2(-m12, m22);
+          }
+          break;
+        case "YZX":
+          this._z = Math.asin(clamp(m21, -1, 1));
+          if (Math.abs(m21) < 0.9999999) {
+            this._x = Math.atan2(-m23, m22);
+            this._y = Math.atan2(-m31, m11);
+          } else {
+            this._x = 0;
+            this._y = Math.atan2(m13, m33);
+          }
+          break;
+        case "XZY":
+          this._z = Math.asin(-clamp(m12, -1, 1));
+          if (Math.abs(m12) < 0.9999999) {
+            this._x = Math.atan2(m32, m22);
+            this._y = Math.atan2(m13, m11);
+          } else {
+            this._x = Math.atan2(-m23, m33);
+            this._y = 0;
+          }
+          break;
+        default:
+          console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: " + order);
+      }
+      this._order = order;
+      if (update === true) this._onChangeCallback();
+      return this;
+    }
+    setFromQuaternion(q, order, update) {
+      _matrix.makeRotationFromQuaternion(q);
+      return this.setFromRotationMatrix(_matrix, order, update);
+    }
+    setFromVector3(v, order = this._order) {
+      return this.set(v.x, v.y, v.z, order);
+    }
+    reorder(newOrder) {
+      _quaternion.setFromEuler(this);
+      return this.setFromQuaternion(_quaternion, newOrder);
+    }
+    equals(euler) {
+      return euler._x === this._x && euler._y === this._y && euler._z === this._z && euler._order === this._order;
+    }
+    fromArray(array) {
+      this._x = array[0];
+      this._y = array[1];
+      this._z = array[2];
+      if (array[3] !== void 0) this._order = array[3];
+      this._onChangeCallback();
+      return this;
+    }
+    toArray(array = [], offset = 0) {
+      array[offset] = this._x;
+      array[offset + 1] = this._y;
+      array[offset + 2] = this._z;
+      array[offset + 3] = this._order;
+      return array;
+    }
+    _onChange(callback) {
+      this._onChangeCallback = callback;
+      return this;
+    }
+    _onChangeCallback() {
+    }
+    *[Symbol.iterator]() {
+      yield this._x;
+      yield this._y;
+      yield this._z;
+      yield this._order;
+    }
+  }
+  Euler.DEFAULT_ORDER = "XYZ";
   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) {
+        setTransform(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("BlendLoader - 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("BlendLoader - unknown objects with parents, adding to root", vals, childMap);
+      objects.push(...vals);
+    }
     return objects.filter((o) => !!o);
   }
+  const eulerModes = {
+    [1]: "XYZ",
+    [2]: "XZY",
+    [3]: "YXZ",
+    [4]: "YZX",
+    [5]: "ZXY",
+    [6]: "ZYX"
+  };
+  function setTransform(object, obj) {
+    obj.name = object.aname;
+    obj.scale.set(object.size[0], object.size[2], object.size[1]);
+    obj.position.set(object.loc[0], object.loc[2], -object.loc[1]);
+    if (!object.rotmode || object.rotmode === 0) {
+      obj.quaternion.set(object.quat[1], object.quat[3], -object.quat[2], object.quat[0]);
+    } else {
+      const order = eulerModes[object.rotmode] ?? "XYZ";
+      const quat = new three.Quaternion().setFromEuler(new Euler(object.rot[0], object.rot[1], object.rot[2], order.split("").reverse().join("")));
+      obj.quaternion.set(quat.x, quat.z, -quat.y, quat.w);
+    }
+    if (object.type === blenderObjectTypes.camera)
+      obj.quaternion.multiply(new three.Quaternion().setFromAxisAngle(new three.Vector3(1, 0, 0), -Math.PI / 2));
+    obj.updateMatrix();
+    if (obj.setDirty) obj.setDirty();
+  }
   const _BlendLoadPlugin = class _BlendLoadPlugin extends threepipe.BaseImporterPlugin {
     constructor() {
       super();
@@ -673,13 +2755,28 @@
           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);
+          root.userData.autoScaled = true;
+          root.userData.autoCentered = true;
           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);