@threepipe/plugin-blend-importer 0.0.2 → 0.0.5

package/dist/index.js

@@ -1,18 +1,1013 @@
-/**
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("threepipe")) : typeof define === "function" && define.amd ? define(["exports", "threepipe"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["@threepipe/plugin-blend-importer"] = {}, global.threepipe));
+})(this, function(exports2, threepipe) {
+  "use strict";/**
  * @license
- * @threepipe/plugin-blend-importer v0.0.2
- * Copyright 2022-2024 repalash <palash@shaders.app>
+ * @threepipe/plugin-blend-importer v0.0.5
+ * Copyright 2022-2025 repalash <palash@shaders.app>
  * Apache-2.0 License
- * See ./dependencies.txt for bundled third-party dependencies and licenses.
+ * See ./dependencies.txt for any bundled third-party dependencies and licenses.
  */
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("threepipe")):"function"==typeof define&&define.amd?define(["exports","threepipe"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self)["@threepipe/plugin-blend-importer"]={},e.threepipe)}(this,(function(e,t){"use strict";const n=826363460,r=1111772741;let s=null;const _={loadBlendFromArrayBuffer:function(e){_.ready=!1,s.onmessage({data:e})},ready:!0,onParseReady:function(){}};s=new function(){let e=null,t=null,s=!1,_=0,i=[],o=0,a=null,l={},d=null,u=null,c=null;const h=this;var f=function(e){this.AB=e,this.byte=new Uint8Array(e),this.dv=new DataView(e),this.objects={},this.memory_lookup={},this.object_array=[],this.template=null};function p(e){return{get:function(){let t=this.__blender_file__.getPointer(this.__data_address__+e,this.__blender_file__);const n=this.__blender_file__.memory_lookup[t],r=[];if(n){const e=n.__data_address__;let s=0;for(;;){t=this.__blender_file__.getPointer(e+8*s,this.__blender_file__);let n=this.__blender_file__.memory_lookup[t];if(!n)break;r.push(n),s++}}return r},set:function(){}}}function b(e,t,n,r,s,_,i,o){if(_)Object.defineProperty(e,t,function(e,t,n){return{get:function(){if(t>1){let r=[],s=0,_=e;for(;s<t;){let e=this.__blender_file__.getPointer(this.__data_address__+_,this.__blender_file__);r.push(this.__blender_file__.memory_lookup[e]),_+=n,s++}return r}{let t=this.__blender_file__.getPointer(this.__data_address__+e,this.__blender_file__);return this.__blender_file__.memory_lookup[t]}},set:function(){}}}(r,s,i)),r+=i*s;else{switch(n){case"double":Object.defineProperty(e,t,function(e,t,n){return{get:function(){return t>1?new Float64Array(this.__blender_file__.AB,this.__data_address__+e,n):this.__blender_file__.dv.getFloat64(this.__data_address__+e,this.__blender_file__.template.endianess)},set:function(n){t>1||this.__blender_file__.dv.setFloat64(this.__data_address__+e,n,this.__blender_file__.template.endianess)}}}(r,s,o>>3));break;case"float":Object.defineProperty(e,t,function(e,t,n){return{get:function(){return t>1?new Float32Array(this.__blender_file__.AB,this.__data_address__+e,n):this.__blender_file__.dv.getFloat32(this.__data_address__+e,this.__blender_file__.template.endianess)},set:function(n){t>1||this.__blender_file__.dv.setFloat32(this.__data_address__+e,n,this.__blender_file__.template.endianess)}}}(r,s,o>>2));break;case"int":Object.defineProperty(e,t,function(e,t,n){return{get:function(){return t>1?new Int32Array(this.__blender_file__.AB,this.__data_address__+e,n):this.__blender_file__.dv.getInt32(this.__data_address__+e,this.__blender_file__.template.endianess)},set:function(n){t>1||this.__blender_file__.dv.setInt32(this.__data_address__+e,n,this.__blender_file__.template.endianess)}}}(r,s,o>>2));break;case"short":case"ushort":Object.defineProperty(e,t,function(e,t,n){return{get:function(){return t>1?new Int16Array(this.__blender_file__.AB,this.__data_address__+e,n):this.__blender_file__.dv.getInt16(this.__data_address__+e,this.__blender_file__.template.endianess)},set:function(n){t>1||this.__blender_file__.dv.setInt16(this.__data_address__+e,n,this.__blender_file__.template.endianess)}}}(r,s,o>>1));break;case"char":case"uchar":Object.defineProperty(e,t,function(e,t,n){return{get:function(){if(t>1){let t=this.__data_address__+e,r=t,s=0;for(;0!=this.__blender_file__.byte[r]&&s++<n;)r++;return m(this.__blender_file__.AB,t,r)}return this.__blender_file__.byte[this.__data_address__+e]},set:function(r){if(t>1){const t=r+"";let s=0;const _=t.length;for(;s<n;)this.__blender_file__.byte[this.__data_address__+e+s]=s<_?0|t.charCodeAt(s):0,s++}else this.__blender_file__.byte[this.__data_address__+e]=0|r}}}(r,s,o));break;default:e[t]={},e.__list__.push(t,n,o,r,s,_)}e._length+=o,r+=o}return r}f.prototype={addObject:function(e){this.object_array.push(e),this.objects[e.blender_name]||(this.objects[e.blender_name]=[]),this.objects[e.blender_name].push(e)},getPointer:function(e){const t=this.dv.getUint32(e,this.template.endianess);if(this.template.pointer_size>4){const n=this.dv.getUint32(e+4,this.template.endianess);return this.template.endianess?t+"l|h"+n:n+"h|l"+t}return t}},h.onmessage=function(p){"object"==typeof p.data&&(c=null,e=null,s=!1,_=0,i=[],o=0,a=null,t=p.data,c=t.slice(),e=new DataView(t),d=new f(c),function(){let c=0,h=0,f=0,p=0,b="",g=0,A=0,w=0;if(d.memory_lookup={},i=[],o=0,"BLENDER"!==m(t,o,7))return u="File supplied is not a .blend compatible Blender file.";o+=7,_="_"==m(t,o++,o)?4:8,s="V"!==m(t,o++,o);const S=m(t,o,o+3);l[S]||(l[S]=new y(S));if(a=l[S],d.template=a,o+=3,!a.SDNA_SET)for(a.endianess=s,a.pointer_size=_,h=o;;){if(p=e.getInt32(h+_+8,s),b=m(t,h,h+4).replace(/\u0000/g,""),g=e.getInt32(h+4,!0),h+=16+_,"DNA1"===b){c=0;let n=[],r=[],_=[],o="";for(h+=8,c=e.getInt32(h,!0),h+=4,A=0;A<c;){for(o="";0!==e.getInt8(h);)o+=m(t,h,h+1),h++;r.push(o),h++,A++}for(h%4>0&&(h=4-h%4+h),h+=4,c=e.getInt32(h,!0),h+=4,A=0;A<c;){for(o="";0!==e.getInt8(h);)o+=m(t,h,h+1),h++;n.push(o),h++,A++}for(h%4>0&&(h=4-h%4+h),h+=4,A=0;A<c;)_.push(e.getInt16(h,s)),h+=2,A++;h%4>0&&(h=4-h%4+h),h+=4;const l=e.getInt32(h,s);for(h+=4,A=0;A<l;){const t=n[e.getInt16(h,s)];h+=2;const o=[];for(c=e.getInt16(h,s),h+=2,w=0,i.push(t);w<c;)o.push(r[e.getInt16(h+2,s)],n[e.getInt16(h,s)],_[e.getInt16(h,s)]),h+=4,w++;a.getSDNAStructureConstructor(t,o),A++}a.SDNA_SET=!0,a.SDNA_NAMES=i;break}h+=g}for(;;){o%4>0&&(o=4-o%4+o),f=o,p=e.getInt32(o+_+8,s);let t=e.getUint32(o,s);if(h=o+16+_,o+=e.getInt32(o+4,!0)+16+_,t===n);else{if(t===r)break;{const t=f+_+16,n=a.getSDNAStructureConstructor(a.SDNA_NAMES[p]),r=e.getInt32(f+4,s);if(c=e.getInt32(f+12+_,s),c>0){let e=new n;const s=n.prototype._length,_=d.getPointer(f+8);if(e.address=_+"",e.setData(_,t,t+r,d),c>1){let r=[];r.push(e);for(let i=1;i<c;i++)e=new n,e.setData(_,t+s*i,t+s*i+s,d),r.push(e);d.memory_lookup[_]=r}else d.memory_lookup[_]=e}}}}}(),h.postMessage(d,u))};const y=function(e){this.version=e,this.SDNA_SET=!1,this.byte_size=0,this.struct_index=0,this.structs={},this.SDNA={},this.endianess=!1};y.prototype={getSDNAStructureConstructor:function(e,t){if(t){const n=Function("function "+e+"(){}; return "+e)();n.prototype=new g,n.prototype.blender_name=e,n.prototype.__pointers=[],n.prototype.__list__=[];let r=0;for(let s=0;s<t.length;s+=3){let i=t[s];const o=i,a=t[s+1];let l=t[s+2],d=0,u=null,c=1,h=1,f=!1,y=0;const g=this.SDNA[e]={constructor:n};if((u=i.match(/(\*?)(\*?)(\w+)(\[(\w*)\])?(\[(\w*)\])?/))&&(i=u[3],u[1]&&(y=10,n.prototype.__pointers.push(i)),u[2]&&(f=!0),u[4]&&(u[6]?(h=parseInt(u[5]),c=parseInt(u[7])):c=parseInt(u[5])),d=c*l,l=d*h),g[o]={type:a,length:l,isArray:c>0},f)Object.defineProperty(n.prototype,i,p(r)),r+=_;else if(h>1){const e=new Array(h);for(let t=0;t<h;t++){let s=`__${i}[${t}]__`;e[t]=s,r=b(n.prototype,s,a,r,c,y,_,d)}Object.defineProperty(n.prototype,i,{get:function(e){return function(){const t=[];for(let n=0;n<e.length;n++)t.push(this[e[n]]);return t}}(e)})}else r=b(n.prototype,i,a,r,c,y,_,l)}return this.SDNA[e].constructor}return this.SDNA[e]?this.SDNA[e].constructor:null}};var g=function(){this.__blender_file__=null,this.__list__=null,this.__super_array_list__=null,this.blender_name="",this.__pointers=null,this.address=null,this.length=0,this.__data_address__=0,this.blender_name="",this._length=0};function m(e,t,n){return String.fromCharCode.apply(String,new Uint8Array(e,t,n-t))}g.prototype={setData:function(e,t,n,r){if(null===this.__list__)return this;r.addObject(this),this.__blender_file__=r;const s=this.__list__;let _,i,o,l,d,u=0,c=0,h="";if(this.__data_address__=t,null===s)return this;for(c=0;c<s.length;c+=6)if(h=s[c],_=s[c+1],o=s[c+4],s[c+5],l=this.__data_address__+s[c+3],o>1)for(this[h]=[],u=0;u<o;)a.getSDNAStructureConstructor(_)?(d=a.getSDNAStructureConstructor(_),this[h].push((new d).setData(0,l,l+i/o,r))):this[h].push(null),l+=i/o,u++;else a.getSDNAStructureConstructor(_)?(d=a.getSDNAStructureConstructor(_),this[h]=(new d).setData(0,l,i+l,r)):this[h]=null;return this.__list__=null,this},get aname(){return this.id?this.id.name.slice(2):void 0}}},s.postMessage=function(e){_.onParseReady(e)};const i={point:0,sun:1,spot:0,hemi:0,area:0};function o(e){const n=e.data,r=[e.loc[0],e.loc[2],-e.loc[1]],s=255*n.r<<16|255*n.g<<8|255*n.b<<0,_=n.energy;let o=null;switch(n.type){case i.point:o=new t.PointLight(s,_,0),o.position.fromArray(r,0),o.castShadow=!0;break;case i.sun:o=new t.PointLight(s,_,0),o.position.fromArray(r,0),o.castShadow=!0,o.shadow.mapSize.width=1024,o.shadow.mapSize.height=1024,o.shadow.camera.near=.01,o.shadow.camera.far=500;break;default:console.warn("Unsupported light type",n.type)}return o}function a(e){if(!e.data)return null;const n=function(e,n){const r=Array.isArray(e.mpoly)?e.mpoly:[e.mpoly],s=e.mloop,_=e.mloopuv,i=e.mvert,o=new t.BufferGeometry;if(!r)return o;const a=r.reduce(((e,t)=>e+Math.floor(3*t.totloop/2)),0),l=new Uint32Array(a),d=new Float32Array(2*a),u=new Float32Array(3*a),c=new Float32Array(3*a);let h=0;for(const e of r){const t=e.totloop,r=e.loopstart;let o=1;for(;o<t;){let e=0;for(let a=0;a<3;a++){e=r,o-1+a<t&&(e+=o-1+a);const f=i[s[e].v];l[h]=h,c[3*h+0]=f.co[0]+n[0],c[3*h+1]=f.co[2]+n[2],c[3*h+2]=-f.co[1]-n[1],u[3*h+0]=f.no[0],u[3*h+1]=f.no[2],u[3*h+2]=-f.no[1],_&&(d[2*h+0]=_[e].uv[0],d[2*h+1]=_[e].uv[1]),h++}o+=2}}return o.setAttribute("position",new t.BufferAttribute(c,3)),o.setIndex(new t.BufferAttribute(l,1)),o.setAttribute("normal",new t.BufferAttribute(u,3)),o.setAttribute("uv",new t.BufferAttribute(d,2)),o}(e.data,[0,0,0]),r=e.data.mat[0],s=r?function(e){const n=new t.MeshPhysicalMaterial;return n.color.setRGB(e.r,e.g,e.b),n.roughness=void 0!==e.roughness?e.roughness:.4,n.metalness=void 0!==e.metallic?e.metallic:0,n.opacity=void 0!==e.alpha?e.alpha:0,n.transparent=n.opacity<1,n}(r):void 0,_=new t.Mesh(n,s);return _.castShadow=!0,_.receiveShadow=!0,_.rotateZ(e.rot[2]),_.rotateY(e.rot[1]),_.rotateX(e.rot[0]),_.scale.fromArray(e.size,0),_.position.fromArray([e.loc[0],e.loc[2],-e.loc[1]],0),_}const l=1,d=10;class u extends t.BaseImporterPlugin{constructor(){super(),this._importer=new t.Importer(class extends t.FileLoader{async loadAsync(e,n){this.setResponseType("arraybuffer");const r=await super.loadAsync(e,n),s=
-/**
-     * JS.Blend
-     * Original Repo: https://github.com/acweathersby/js.blend
-     * Slightly modified for three.js and js updates, minor refactor.
-     * Object-creation part re-written for latest three.js and typescript
-     * MIT License
-     * Copyright (c) 2020 Anthony C, Weathersby
-     * @license
-     */await async function(e,t=""){return new Promise(((n,r)=>{_.onParseReady=(e,t)=>{t?r(t):n(e)},_.loadBlendFromArrayBuffer(e,t)}))}(r),i=await async function(e){const t=[],n=e.objects.Object;for(const e of n)switch(e.type){case l:t.push(a(e));break;case d:t.push(o(e));break;default:console.warn("Unsupported object type",e.type)}return t.filter((e=>!!e))}(s),u=new t.Object3D;return u.add(...i),s.scene=u,s}transform(e,t){return e.scene}},["blend"],["application/x-blender"],!0)}}u.PluginType="BlendLoadPlugin",e.BlendLoadPlugin=u}));
+
+  let worker = null;
+  const return_object = {
+    loadBlendFromArrayBuffer: function(array_buffer) {
+      return_object.ready = false;
+      {
+        worker.onmessage({
+          data: array_buffer
+        });
+      }
+    },
+    // loadBlendFromBlob: function (blob) {
+    //     FR.onload = function () {
+    //         return_object.loadBlendFromArrayBuffer(this.result);
+    //     };
+    //     FR.readAsArrayBuffer(blob);
+    // },
+    ready: true,
+    onParseReady: function() {
+    }
+  };
+  function worker_code() {
+    let data = null, _data = null, BIG_ENDIAN = false, pointer_size = 0, struct_names = [], offset = 0, current_SDNA_template = null, templates = {}, FILE = null, ERROR = null, AB = null;
+    const self2 = this;
+    function parseFile(msg) {
+      if (typeof msg.data == "object") {
+        AB = null;
+        data = null;
+        BIG_ENDIAN = false;
+        pointer_size = 0;
+        struct_names = [];
+        offset = 0;
+        current_SDNA_template = null;
+        _data = msg.data;
+        AB = _data.slice();
+        data = new DataView(_data);
+        FILE = new BLENDER_FILE(AB);
+        readFile();
+        self2.postMessage(FILE, ERROR);
+      }
+    }
+    const BLENDER_FILE = function(AB2) {
+      this.AB = AB2;
+      this.byte = new Uint8Array(AB2);
+      this.dv = new DataView(AB2);
+      this.objects = {};
+      this.memory_lookup = {}, this.object_array = [];
+      this.template = null;
+    };
+    BLENDER_FILE.prototype = {
+      addObject: function(obj) {
+        this.object_array.push(obj);
+        if (!this.objects[obj.blender_name]) this.objects[obj.blender_name] = [];
+        this.objects[obj.blender_name].push(obj);
+      },
+      getPointer: function(offset2) {
+        const pointerLow = this.dv.getUint32(offset2, this.template.endianess);
+        if (this.template.pointer_size > 4) {
+          const pointerHigh = this.dv.getUint32(offset2 + 4, this.template.endianess);
+          if (this.template.endianess) {
+            return pointerLow + "l|h" + pointerHigh;
+          } else {
+            return pointerHigh + "h|l" + pointerLow;
+          }
+        } else {
+          return pointerLow;
+        }
+      }
+    };
+    self2.onmessage = parseFile;
+    function float64Prop(offset2, Blender_Array_Length, length) {
+      return {
+        get: function() {
+          return Blender_Array_Length > 1 ? new Float64Array(this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getFloat64(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
+        },
+        set: function(float) {
+          if (Blender_Array_Length > 1) ;
+          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) {
+      return {
+        get: function() {
+          return Blender_Array_Length > 1 ? new Float32Array(this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getFloat32(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
+        },
+        set: function(float) {
+          if (Blender_Array_Length > 1) ;
+          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) {
+      return {
+        get: function() {
+          return Blender_Array_Length > 1 ? new Int32Array(this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getInt32(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
+        },
+        set: function(float) {
+          if (Blender_Array_Length > 1) ;
+          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) {
+      return {
+        get: function() {
+          return Blender_Array_Length > 1 ? new Int16Array(this.__blender_file__.AB, this.__data_address__ + offset2, length) : this.__blender_file__.dv.getInt16(this.__data_address__ + offset2, this.__blender_file__.template.endianess);
+        },
+        set: function(float) {
+          if (Blender_Array_Length > 1) ;
+          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() {
+          if (Blender_Array_Length > 1) {
+            let start = this.__data_address__ + offset2;
+            let end = start;
+            let buffer_guard = 0;
+            while (this.__blender_file__.byte[end] != 0 && buffer_guard++ < length) end++;
+            return toString(this.__blender_file__.AB, start, end);
+          }
+          return this.__blender_file__.byte[this.__data_address__ + offset2];
+        },
+        set: function(byte) {
+          if (Blender_Array_Length > 1) {
+            const string = byte + "";
+            let i = 0;
+            const l = string.length;
+            while (i < length) {
+              if (i < l) {
+                this.__blender_file__.byte[this.__data_address__ + offset2 + i] = string.charCodeAt(i) | 0;
+              } else {
+                this.__blender_file__.byte[this.__data_address__ + offset2 + i] = 0;
+              }
+              i++;
+            }
+          } else {
+            this.__blender_file__.byte[this.__data_address__ + offset2] = byte | 0;
+          }
+        },
+        enumerable: true,
+        configurable: true
+      };
+    }
+    function pointerProp2(offset2) {
+      return {
+        get: function() {
+          let pointer = this.__blender_file__.getPointer(this.__data_address__ + offset2, this.__blender_file__);
+          const link = this.__blender_file__.memory_lookup[pointer];
+          const results = [];
+          if (link) {
+            const address = link.__data_address__;
+            let j = 0;
+            while (true) {
+              pointer = this.__blender_file__.getPointer(address + j * 8, this.__blender_file__);
+              let obj = this.__blender_file__.memory_lookup[pointer];
+              if (!obj) break;
+              results.push(obj);
+              j++;
+            }
+          }
+          return results;
+        },
+        set: function() {
+        },
+        enumerable: true,
+        configurable: true
+      };
+    }
+    function pointerProp(offset2, Blender_Array_Length, length) {
+      return {
+        get: function() {
+          if (Blender_Array_Length > 1) {
+            let array = [];
+            let j = 0;
+            let off = offset2;
+            while (j < Blender_Array_Length) {
+              let pointer = this.__blender_file__.getPointer(this.__data_address__ + off, this.__blender_file__);
+              array.push(this.__blender_file__.memory_lookup[pointer]);
+              off += length;
+              j++;
+            }
+            return array;
+          } else {
+            let pointer = this.__blender_file__.getPointer(this.__data_address__ + offset2, this.__blender_file__);
+            return this.__blender_file__.memory_lookup[pointer];
+          }
+        },
+        set: function() {
+        },
+        enumerable: true,
+        configurable: true
+      };
+    }
+    function compileProp(obj, name, type, offset2, array_size, IS_POINTER, pointer_size2, length) {
+      if (!IS_POINTER) {
+        switch (type) {
+          case "double":
+            Object.defineProperty(obj, name, float64Prop(offset2, array_size, length >> 3));
+            break;
+          case "float":
+            Object.defineProperty(obj, name, floatProp(offset2, array_size, length >> 2));
+            break;
+          case "int":
+            Object.defineProperty(obj, name, intProp(offset2, array_size, length >> 2));
+            break;
+          case "short":
+            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));
+            break;
+          default:
+            obj[name] = {};
+            obj.__list__.push(name, type, length, offset2, array_size, IS_POINTER);
+        }
+        obj._length += length;
+        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;
+    }
+    const MASTER_SDNA_SCHEMA = function(version) {
+      this.version = version;
+      this.SDNA_SET = false;
+      this.byte_size = 0;
+      this.struct_index = 0;
+      this.structs = {};
+      this.SDNA = {};
+      this.endianess = false;
+    };
+    MASTER_SDNA_SCHEMA.prototype = {
+      getSDNAStructureConstructor: function(name, struct) {
+        if (struct) {
+          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;
+            if (match = _name.match(/(\*?)(\*?)(\w+)(\[(\w*)\])?(\[(\w*)\])?/)) {
+              _name = match[3];
+              if (match[1]) {
+                Pointer_Match = 10;
+                blen_struct.prototype.__pointers.push(_name);
+              }
+              if (match[2]) {
+                PointerToArray = true;
+              }
+              if (match[4]) {
+                if (match[6]) {
+                  Suparray_match = parseInt(match[5]);
+                  Blender_Array_Length = parseInt(match[7]);
+                } else {
+                  Blender_Array_Length = parseInt(match[5]);
+                }
+              }
+              array_length = Blender_Array_Length * length;
+              length = array_length * Suparray_match;
+            }
+            DNA[n] = {
+              type,
+              length,
+              isArray: Blender_Array_Length > 0
+            };
+            if (PointerToArray) {
+              Object.defineProperty(blen_struct.prototype, _name, pointerProp2(offset2));
+              offset2 += pointer_size;
+            } else if (Suparray_match > 1) {
+              const array_names = new Array(Suparray_match);
+              for (let j = 0; j < Suparray_match; j++) {
+                let array_name_ = `__${_name}[${j}]__`;
+                array_names[j] = array_name_;
+                offset2 = compileProp(blen_struct.prototype, array_name_, type, offset2, Blender_Array_Length, Pointer_Match, pointer_size, array_length);
+              }
+              Object.defineProperty(blen_struct.prototype, _name, {
+                get: /* @__PURE__ */ function(array_names2) {
+                  return function() {
+                    const array = [];
+                    for (let i2 = 0; i2 < array_names2.length; i2++) {
+                      array.push(this[array_names2[i2]]);
+                    }
+                    return array;
+                  };
+                }(array_names),
+                enumerable: true,
+                configurable: true
+              });
+            } else {
+              offset2 = compileProp(blen_struct.prototype, _name, type, offset2, Blender_Array_Length, Pointer_Match, pointer_size, length);
+            }
+          }
+          return this.SDNA[name].constructor;
+        } else {
+          if (!this.SDNA[name]) {
+            return null;
+          }
+          return this.SDNA[name].constructor;
+        }
+      }
+    };
+    const BLENDER_STRUCTURE = function() {
+      this.__blender_file__ = null;
+      this.__list__ = null;
+      this.__super_array_list__ = null;
+      this.blender_name = "";
+      this.__pointers = null;
+      this.address = null;
+      this.length = 0;
+      this.__data_address__ = 0;
+      this.blender_name = "";
+      this._length = 0;
+    };
+    BLENDER_STRUCTURE.prototype = {
+      setData: function(pointer, _data_offset, data_block_length, BLENDER_FILE2) {
+        if (this.__list__ === null) return this;
+        BLENDER_FILE2.addObject(this);
+        this.__blender_file__ = BLENDER_FILE2;
+        const struct = this.__list__;
+        let j = 0, i = 0, name = "", type, length, Blender_Array_Length, offset2, constructor;
+        this.__data_address__ = _data_offset;
+        if (struct === null) return this;
+        for (i = 0; i < struct.length; i += 6) {
+          name = struct[i];
+          type = struct[i + 1];
+          Blender_Array_Length = struct[i + 4];
+          struct[i + 5];
+          offset2 = this.__data_address__ + struct[i + 3];
+          if (Blender_Array_Length > 1) {
+            this[name] = [];
+            j = 0;
+            while (j < Blender_Array_Length) {
+              if (current_SDNA_template.getSDNAStructureConstructor(type)) {
+                constructor = current_SDNA_template.getSDNAStructureConstructor(type);
+                this[name].push(new constructor().setData(0, offset2, offset2 + length / Blender_Array_Length, BLENDER_FILE2));
+              } else this[name].push(null);
+              offset2 += length / Blender_Array_Length;
+              j++;
+            }
+          } else {
+            if (current_SDNA_template.getSDNAStructureConstructor(type)) {
+              constructor = current_SDNA_template.getSDNAStructureConstructor(type);
+              this[name] = new constructor().setData(0, offset2, length + offset2, BLENDER_FILE2);
+            } else this[name] = null;
+          }
+        }
+        this.__list__ = null;
+        return this;
+      },
+      get aname() {
+        if (this.id) return this.id.name.slice(2);
+        else return void 0;
+      }
+    };
+    function toString(buffer, _in, _out) {
+      return String.fromCharCode.apply(String, new Uint8Array(buffer, _in, _out - _in));
+    }
+    function readFile() {
+      let count = 0;
+      let offset2 = 0;
+      let data_offset = 0;
+      let sdna_index = 0;
+      let code = "";
+      let block_length = 0;
+      let curr_count = 0;
+      let curr_count2 = 0;
+      FILE.memory_lookup = {};
+      struct_names = [];
+      offset = 0;
+      const magic = toString(_data, offset, 7);
+      if (magic !== "BLENDER") return ERROR = "File supplied is not a .blend compatible Blender file.";
+      offset += 7;
+      pointer_size = toString(_data, offset++, offset) == "_" ? 4 : 8;
+      BIG_ENDIAN = toString(_data, offset++, offset) !== "V";
+      const version = toString(_data, offset, offset + 3);
+      if (!templates[version]) {
+        templates[version] = new MASTER_SDNA_SCHEMA(version);
+      }
+      current_SDNA_template = templates[version];
+      FILE.template = current_SDNA_template;
+      offset += 3;
+      if (!current_SDNA_template.SDNA_SET) {
+        current_SDNA_template.endianess = BIG_ENDIAN;
+        current_SDNA_template.pointer_size = pointer_size;
+        offset2 = offset;
+        while (true) {
+          sdna_index = data.getInt32(offset2 + pointer_size + 8, BIG_ENDIAN);
+          code = toString(_data, offset2, offset2 + 4).replace(/\u0000/g, "");
+          block_length = data.getInt32(offset2 + 4, true);
+          offset2 += 16 + pointer_size;
+          if (code === "DNA1") {
+            count = 0;
+            let types = [], names = [], lengths = [], curr_name = "";
+            offset2 += 8;
+            count = data.getInt32(offset2, true);
+            offset2 += 4;
+            curr_count = 0;
+            while (curr_count < count) {
+              curr_name = "";
+              while (data.getInt8(offset2) !== 0) {
+                curr_name += toString(_data, offset2, offset2 + 1);
+                offset2++;
+              }
+              names.push(curr_name);
+              offset2++;
+              curr_count++;
+            }
+            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.getUint32(offset2, true);
+            offset2 += 4;
+            curr_count = 0;
+            while (curr_count < count) {
+              curr_name = "";
+              while (data.getInt8(offset2) !== 0) {
+                curr_name += toString(_data, offset2, offset2 + 1);
+                offset2++;
+              }
+              types.push(curr_name);
+              offset2++;
+              curr_count++;
+            }
+            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) {
+              lengths.push(data.getInt16(offset2, BIG_ENDIAN));
+              offset2 += 2;
+              curr_count++;
+            }
+            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;
+            curr_count = 0;
+            while (curr_count < structure_count) {
+              const struct_name = types[data.getInt16(offset2, BIG_ENDIAN)];
+              offset2 += 2;
+              const obj = [];
+              count = data.getInt16(offset2, BIG_ENDIAN);
+              offset2 += 2;
+              curr_count2 = 0;
+              struct_names.push(struct_name);
+              while (curr_count2 < count) {
+                obj.push(names[data.getInt16(offset2 + 2, BIG_ENDIAN)], types[data.getInt16(offset2, BIG_ENDIAN)], lengths[data.getInt16(offset2, BIG_ENDIAN)]);
+                offset2 += 4;
+                curr_count2++;
+              }
+              current_SDNA_template.getSDNAStructureConstructor(struct_name, obj);
+              curr_count++;
+            }
+            current_SDNA_template.SDNA_SET = true;
+            current_SDNA_template.SDNA_NAMES = struct_names;
+            break;
+          }
+          offset2 += block_length;
+        }
+      }
+      while (true) {
+        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);
+        const code_str = toString(_data, offset, offset + 4);
+        offset2 = offset + 16 + pointer_size;
+        const blockLength = data.getInt32(offset + 4, true);
+        if (blockLength < 0 || offset + blockLength + 16 + pointer_size > data.byteLength) {
+          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 && constructor) {
+            let obj = new constructor();
+            const length = constructor.prototype._length;
+            const address = FILE.getPointer(data_offset + 8);
+            obj.address = address + "";
+            obj.setData(address, data_start, data_start + size, FILE);
+            if (count > 1) {
+              let array = [];
+              array.push(obj);
+              for (let u = 1; u < count; u++) {
+                obj = new constructor();
+                obj.setData(address, data_start + length * u, data_start + length * u + length, FILE);
+                array.push(obj);
+              }
+              FILE.memory_lookup[address] = array;
+            } else {
+              FILE.memory_lookup[address] = obj;
+            }
+          }
+        }
+      }
+    }
+  }
+  worker = new worker_code();
+  worker.postMessage = function(message, err) {
+    return_object.onParseReady(message, err);
+  };
+  /**
+   * JS.Blend
+   * Original Repo: https://github.com/acweathersby/js.blend
+   * Slightly modified for three.js and js updates, minor refactor.
+   * Object-creation part re-written for latest three.js and typescript
+   * MIT License
+   * Copyright (c) 2020 Anthony C, Weathersby
+   * @license
+   */
+  async function parseBlend(buffer, name = "") {
+    return new Promise((res, rej) => {
+      return_object.onParseReady = (file, error) => {
+        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
+  };
+  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 = void 0;
+    switch (ldata.type) {
+      case blenderLightTypes.point:
+        light = new ctx.PointLight(color, intensity, distance);
+        light.position.fromArray(position, 0);
+        light.castShadow = true;
+        break;
+      case blenderLightTypes.sun:
+        light = new ctx.PointLight(color, intensity, distance);
+        light.position.fromArray(position, 0);
+        light.castShadow = true;
+        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 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 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);
+    const uvs = new Float32Array(size * 2);
+    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;
+      let indexi = 1;
+      while (indexi < len) {
+        let index = 0;
+        for (let l = 0; l < 3; l++) {
+          index = start;
+          if (indexi - 1 + l < len)
+            index += indexi - 1 + l;
+          const loop = loops[index];
+          const vert = vertices[loop.v];
+          indices[currentIndex] = currentIndex;
+          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];
+          }
+          currentIndex++;
+        }
+        indexi += 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, ctx) {
+    const material = new ctx.MeshPhysicalMaterial();
+    material.color.setRGB(mat.r, mat.g, mat.b);
+    material.roughness = mat.roughness !== void 0 ? mat.roughness : 0.4;
+    material.metalness = mat.metallic !== void 0 ? mat.metallic : 0;
+    material.opacity = 1;
+    material.transparent = material.opacity < 1;
+    return material;
+  }
+  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 ? 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;
+    return mesh;
+  }
+  const blenderObjectTypes = {
+    empty: 0,
+    mesh: 1,
+    lamp: 10,
+    camera: 11
+  };
+  async function createObjects(file, ctx) {
+    const objects = [];
+    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:
+          obj = createMesh(object, loaded, ctx);
+          break;
+        case blenderObjectTypes.lamp:
+          obj = createLight(object, ctx);
+          break;
+        case blenderObjectTypes.camera:
+          obj = createCamera(object, ctx);
+          break;
+        default:
+          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 {
+    constructor() {
+      super();
+      this._importer = new threepipe.Importer(class extends threepipe.FileLoader {
+        async loadAsync(url, onProgress) {
+          this.setResponseType("arraybuffer");
+          const res = await super.loadAsync(url, onProgress);
+          const blend = await parseBlend(res);
+          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, options) {
+          if (typeof options.onBlendLoad === "function") {
+            options.onBlendLoad(res);
+          }
+          return res.scene;
+        }
+      }, ["blend"], ["application/x-blender"], true);
+    }
+  };
+  _BlendLoadPlugin.PluginType = "BlendLoadPlugin";
+  let BlendLoadPlugin = _BlendLoadPlugin;
+  exports2.BlendLoadPlugin = BlendLoadPlugin;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});
 //# sourceMappingURL=index.js.map