minerender 2.1.0-alpha.51 → 2.1.0-alpha.53

package/dist/node/index.js

@@ -3535,48 +3535,6 @@ var init_SceneObject = __esm({
   }
 });
 
-// src/model/ModelCulling.ts
-var import_three22, ModelCulling;
-var init_ModelCulling = __esm({
-  "src/model/ModelCulling.ts"() {
-    import_three22 = require("three");
-    init_CubeFace();
-    ModelCulling = class {
-      static toLocalMask(worldMask, rotation) {
-        let localMask = 0;
-        for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
-          const normal = new import_three22.Vector3(...offset).applyEuler(rotation);
-          const worldFace = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
-          if (worldFace < 0) return 0;
-          if (worldMask & 1 << worldFace) localMask |= 1 << localFace;
-        }
-        return localMask;
-      }
-      static isOpaqueFullCube(atlas) {
-        if (!atlas || atlas.hasTransparency !== false || atlas.model.elements?.length !== 1) return false;
-        const element = atlas.model.elements[0];
-        if (element.from.length !== 3 || !element.from.every((value) => value === 0) || element.to.length !== 3 || !element.to.every((value) => value === 16) || element.rotation && element.rotation.angle !== 0 || element.mappedUv?.length !== 48 || !element.mappedUv.every(Number.isFinite)) return false;
-        if (!(atlas.image.width > 0 && atlas.image.height > 0)) return false;
-        return CUBE_FACES.every((face, faceIndex) => {
-          const texture = element.faces[face]?.texture;
-          if (!texture?.startsWith("#")) return false;
-          const key = texture.slice(1);
-          const position = atlas.positions[key];
-          const size = atlas.sizes[key];
-          if (position?.length !== 2 || !position.every(Number.isFinite) || size?.length !== 2 || !size.every((value) => value > 0 && Number.isFinite(value))) return false;
-          for (let vertex = 0; vertex < 4; vertex++) {
-            const uvIndex = (faceIndex * 4 + vertex) * 2;
-            const x = element.mappedUv[uvIndex] * atlas.image.width;
-            const y = (1 - element.mappedUv[uvIndex + 1]) * atlas.image.height;
-            if (x < position[0] - 1e-6 || x > position[0] + size[0] + 1e-6 || y < position[1] - 1e-6 || y > position[1] + size[1] + 1e-6) return false;
-          }
-          return true;
-        });
-      }
-    };
-  }
-});
-
 // src/three/BufferGeometryUtils.js
 function computeTangents(geometry) {
   geometry.computeTangents();
@@ -3589,7 +3547,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new import_three24.BufferGeometry();
+  const mergedGeometry = new import_three19.BufferGeometry();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -3713,7 +3671,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new import_three24.BufferAttribute(array, itemSize, normalized);
+  return new import_three19.BufferAttribute(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -3729,7 +3687,7 @@ function interleaveAttributes(attributes) {
     arrayLength += attribute.array.length;
     stride += attribute.itemSize;
   }
-  const interleavedBuffer = new import_three24.InterleavedBuffer(new TypedArray(arrayLength), stride);
+  const interleavedBuffer = new import_three19.InterleavedBuffer(new TypedArray(arrayLength), stride);
   let offset = 0;
   const res = [];
   const getters = ["getX", "getY", "getZ", "getW"];
@@ -3738,7 +3696,7 @@ function interleaveAttributes(attributes) {
     const attribute = attributes[j];
     const itemSize = attribute.itemSize;
     const count = attribute.count;
-    const iba = new import_three24.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
+    const iba = new import_three19.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
     res.push(iba);
     offset += itemSize;
     for (let c = 0; c < count; c++) {
@@ -3822,13 +3780,13 @@ function mergeVertices(geometry, tolerance = 1e-4) {
     const name = attributeNames[i];
     const oldAttribute = geometry.getAttribute(name);
     const buffer = new oldAttribute.array.constructor(attrArrays[name]);
-    const attribute = new import_three24.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new import_three19.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
     result.setAttribute(name, attribute);
     if (name in morphAttrsArrays) {
       for (let j = 0; j < morphAttrsArrays[name].length; j++) {
         const oldMorphAttribute = geometry.morphAttributes[name][j];
         const buffer2 = new oldMorphAttribute.array.constructor(morphAttrsArrays[name][j]);
-        const morphAttribute = new import_three24.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new import_three19.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -3837,11 +3795,11 @@ function mergeVertices(geometry, tolerance = 1e-4) {
   return result;
 }
 function toTrianglesDrawMode(geometry, drawMode) {
-  if (drawMode === import_three24.TrianglesDrawMode) {
+  if (drawMode === import_three19.TrianglesDrawMode) {
     console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
     return geometry;
   }
-  if (drawMode === import_three24.TriangleFanDrawMode || drawMode === import_three24.TriangleStripDrawMode) {
+  if (drawMode === import_three19.TriangleFanDrawMode || drawMode === import_three19.TriangleStripDrawMode) {
     let index = geometry.getIndex();
     if (index === null) {
       const indices = [];
@@ -3859,7 +3817,7 @@ function toTrianglesDrawMode(geometry, drawMode) {
     }
     const numberOfTriangles = index.count - 2;
     const newIndices = [];
-    if (drawMode === import_three24.TriangleFanDrawMode) {
+    if (drawMode === import_three19.TriangleFanDrawMode) {
       for (let i = 1; i <= numberOfTriangles; i++) {
         newIndices.push(index.getX(0));
         newIndices.push(index.getX(i));
@@ -3895,15 +3853,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new import_three24.Vector3();
-  const _vB = new import_three24.Vector3();
-  const _vC = new import_three24.Vector3();
-  const _tempA = new import_three24.Vector3();
-  const _tempB = new import_three24.Vector3();
-  const _tempC = new import_three24.Vector3();
-  const _morphA = new import_three24.Vector3();
-  const _morphB = new import_three24.Vector3();
-  const _morphC = new import_three24.Vector3();
+  const _vA = new import_three19.Vector3();
+  const _vB = new import_three19.Vector3();
+  const _vC = new import_three19.Vector3();
+  const _tempA = new import_three19.Vector3();
+  const _tempB = new import_three19.Vector3();
+  const _tempC = new import_three19.Vector3();
+  const _morphA = new import_three19.Vector3();
+  const _morphB = new import_three19.Vector3();
+  const _morphC = new import_three19.Vector3();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4098,8 +4056,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new import_three24.Float32BufferAttribute(modifiedPosition, 3);
-  const morphedNormalAttribute = new import_three24.Float32BufferAttribute(modifiedNormal, 3);
+  const morphedPositionAttribute = new import_three19.Float32BufferAttribute(modifiedPosition, 3);
+  const morphedNormalAttribute = new import_three19.Float32BufferAttribute(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -4107,10 +4065,52 @@ function computeMorphedAttributes(object) {
     morphedNormalAttribute
   };
 }
-var import_three24;
+var import_three19;
 var init_BufferGeometryUtils = __esm({
   "src/three/BufferGeometryUtils.js"() {
-    import_three24 = require("three");
+    import_three19 = require("three");
+  }
+});
+
+// src/model/ModelCulling.ts
+var import_three20, ModelCulling;
+var init_ModelCulling = __esm({
+  "src/model/ModelCulling.ts"() {
+    import_three20 = require("three");
+    init_CubeFace();
+    ModelCulling = class {
+      static toLocalMask(worldMask, rotation) {
+        let localMask = 0;
+        for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
+          const normal = new import_three20.Vector3(...offset).applyEuler(rotation);
+          const worldFace = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
+          if (worldFace < 0) return 0;
+          if (worldMask & 1 << worldFace) localMask |= 1 << localFace;
+        }
+        return localMask;
+      }
+      static isOpaqueFullCube(atlas) {
+        if (!atlas || atlas.hasTransparency !== false || atlas.model.elements?.length !== 1) return false;
+        const element = atlas.model.elements[0];
+        if (element.from.length !== 3 || !element.from.every((value) => value === 0) || element.to.length !== 3 || !element.to.every((value) => value === 16) || element.rotation && element.rotation.angle !== 0 || element.mappedUv?.length !== 48 || !element.mappedUv.every(Number.isFinite)) return false;
+        if (!(atlas.image.width > 0 && atlas.image.height > 0)) return false;
+        return CUBE_FACES.every((face, faceIndex) => {
+          const texture = element.faces[face]?.texture;
+          if (!texture?.startsWith("#")) return false;
+          const key = texture.slice(1);
+          const position = atlas.positions[key];
+          const size = atlas.sizes[key];
+          if (position?.length !== 2 || !position.every(Number.isFinite) || size?.length !== 2 || !size.every((value) => value > 0 && Number.isFinite(value))) return false;
+          for (let vertex = 0; vertex < 4; vertex++) {
+            const uvIndex = (faceIndex * 4 + vertex) * 2;
+            const x = element.mappedUv[uvIndex] * atlas.image.width;
+            const y = (1 - element.mappedUv[uvIndex + 1]) * atlas.image.height;
+            if (x < position[0] - 1e-6 || x > position[0] + size[0] + 1e-6 || y < position[1] - 1e-6 || y > position[1] + size[1] + 1e-6) return false;
+          }
+          return true;
+        });
+      }
+    };
   }
 });
 
@@ -4118,13 +4118,13 @@ var init_BufferGeometryUtils = __esm({
 function isModelObject(obj) {
   return obj.isModelObject;
 }
-var import_three25, import_ts_deepmerge5, p9, ModelObject;
+var import_three21, import_ts_deepmerge5, p7, ModelObject;
 var init_ModelObject = __esm({
   "src/model/scene/ModelObject.ts"() {
     init_SceneObject();
     init_Materials();
     init_UVMapper();
-    import_three25 = require("three");
+    import_three21 = require("three");
     init_BufferGeometryUtils();
     init_model();
     import_ts_deepmerge5 = __toESM(require_dist());
@@ -4132,7 +4132,7 @@ var init_ModelObject = __esm({
     init_CubeFace();
     init_DisplayTransforms();
     init_ModelCulling();
-    p9 = prefix("ModelObject");
+    p7 = prefix("ModelObject");
     ModelObject = class _ModelObject extends SceneObject {
       constructor(originalModel, options) {
         super(options);
@@ -4181,7 +4181,7 @@ var init_ModelObject = __esm({
                 elGeo.clearGroups();
               }
               if (this.options.uvLockRotation) {
-                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three25.Euler(...this.options.uvLockRotation));
+                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three21.Euler(...this.options.uvLockRotation));
               }
               if (this.options.tints) {
                 const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -4190,19 +4190,19 @@ var init_ModelObject = __esm({
                   if (tintIndex === void 0 || tintIndex < 0) continue;
                   const tint = this.options.tints[tintIndex];
                   if (tint === void 0) continue;
-                  const color = new import_three25.Color(tint);
+                  const color = new import_three21.Color(tint);
                   for (let vertex = 0; vertex < 4; vertex++) {
                     color.toArray(colors, (faceIndex * 4 + vertex) * 3);
                   }
                 }
-                elGeo.setAttribute("color", new import_three25.BufferAttribute(colors, 3));
+                elGeo.setAttribute("color", new import_three21.BufferAttribute(colors, 3));
               }
-              elGeo.applyMatrix4(new import_three25.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
-              elGeo.applyMatrix4(new import_three25.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
+              elGeo.applyMatrix4(new import_three21.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
+              elGeo.applyMatrix4(new import_three21.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
               if (el.rotation) {
                 applyElementRotation(el.rotation, elGeo);
               }
-              elGeo.applyMatrix4(new import_three25.Matrix4().makeTranslation(-8, -8, -8));
+              elGeo.applyMatrix4(new import_three21.Matrix4().makeTranslation(-8, -8, -8));
               if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
               if (this.options.mergeMeshes) {
                 allGeos.push(elGeo);
@@ -4214,17 +4214,17 @@ var init_ModelObject = __esm({
               }
             });
           } else {
-            console.debug(p9, this.atlas.model, "has no elements");
+            console.debug(p7, this.atlas.model, "has no elements");
           }
         } else {
-          console.debug(p9, "Missing atlas for", this);
+          console.debug(p7, "Missing atlas for", this);
         }
         if (this.options.mergeMeshes) {
           let combinedGeo;
           if (allGeos.length > 0) {
             combinedGeo = mergeBufferGeometries(allGeos);
           } else {
-            combinedGeo = new import_three25.BoxGeometry(16, 16, 16);
+            combinedGeo = new import_three21.BoxGeometry(16, 16, 16);
             if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
           }
           combinedGeo.computeBoundingBox();
@@ -7712,19 +7712,31 @@ var GuiHelper = class {
 };
 
 // src/gui/scene/GuiObject.ts
-var import_three19 = require("three");
+var import_three22 = require("three");
 init_AssetKey();
 init_ModelTextures();
+init_Models();
 init_Caching();
 init_SceneObject();
 init_Materials();
+init_ModelObject();
+init_DisplayPosition();
+
+// src/model/GuiLight.ts
+var GuiLight = /* @__PURE__ */ ((GuiLight2) => {
+  GuiLight2["FRONT"] = "front";
+  GuiLight2["SIDE"] = "side";
+  return GuiLight2;
+})(GuiLight || {});
+
+// src/gui/scene/GuiObject.ts
 var GuiObject = class extends SceneObject {
   constructor(textureLayers, options) {
     super({ ...options, instanceMeshes: false, mergeMeshes: false });
     this.textureLayers = textureLayers;
     this.isGuiObject = true;
     /** Local bounds in GUI pixels, with y growing down from the origin. */
-    this.bounds = new import_three19.Box2();
+    this.bounds = new import_three22.Box2();
     this.geometries = /* @__PURE__ */ new Set();
     this.ownedMaterials = /* @__PURE__ */ new Set();
     this.initialized = false;
@@ -7732,14 +7744,35 @@ var GuiObject = class extends SceneObject {
   async init() {
     if (this.initialized) return;
     try {
+      let depth = 0;
       for (const [index, layer] of this.textureLayers.entries()) {
+        const [x, y] = layer.position ?? [0, 0];
+        if ("item" in layer) {
+          const [width2, height2] = layer.size ?? [16, 16];
+          const item = await this.createItem(layer, index);
+          item.position.set(x + width2 / 2, -y - height2 / 2, 0);
+          item.scale.set(width2 / 16, height2 / 16, width2 / 16);
+          item.updateMatrix();
+          const bounds = new import_three22.Box3();
+          item.iterateAllMeshes((mesh2) => {
+            mesh2.geometry.computeBoundingBox();
+            bounds.union(mesh2.geometry.boundingBox);
+          });
+          bounds.applyMatrix4(item.matrix);
+          item.position.z = depth - bounds.min.z;
+          depth += bounds.max.z - bounds.min.z + 0.01;
+          this.bounds.expandByPoint(new import_three22.Vector2(x, y));
+          this.bounds.expandByPoint(new import_three22.Vector2(x + width2, y + height2));
+          this.bounds.expandByPoint(new import_three22.Vector2(bounds.min.x, -bounds.max.y));
+          this.bounds.expandByPoint(new import_three22.Vector2(bounds.max.x, -bounds.min.y));
+          continue;
+        }
         const key = typeof layer.texture === "string" ? AssetKey.parse("textures", layer.texture) : layer.texture;
         const material = await this.loadMaterial(key);
         const image = material.map.image;
         const [cropX, cropY, cropWidth, cropHeight] = layer.crop ?? [0, 0, image.width, image.height];
         const [width, height] = layer.size ?? [cropWidth, cropHeight];
-        const [x, y] = layer.position ?? [0, 0];
-        const geometry = new import_three19.PlaneGeometry(width, height);
+        const geometry = new import_three22.PlaneGeometry(width, height);
         this.geometries.add(geometry);
         const uv = geometry.getAttribute("uv");
         for (let i = 0; i < uv.count; i++) {
@@ -7749,14 +7782,16 @@ var GuiObject = class extends SceneObject {
             1 - (cropY + (1 - uv.getY(i)) * cropHeight) / image.height
           );
         }
-        const mesh = new import_three19.Mesh(geometry, material);
+        const mesh = new import_three22.Mesh(geometry, material);
         mesh.name = `mesh:${layer.name ?? index}`;
-        mesh.position.set(x + width / 2, -y - height / 2, 0);
+        mesh.position.set(x + width / 2, -y - height / 2, depth);
         mesh.renderOrder = index;
         this.add(mesh);
-        this.bounds.expandByPoint(new import_three19.Vector2(x, y));
-        this.bounds.expandByPoint(new import_three19.Vector2(x + width, y + height));
+        this.bounds.expandByPoint(new import_three22.Vector2(x, y));
+        this.bounds.expandByPoint(new import_three22.Vector2(x + width, y + height));
+        depth += 0.01;
       }
+      for (const child of this.children) child.position.z -= depth - 0.01;
       this.initialized = true;
       this.notifyDirty();
     } catch (error) {
@@ -7764,6 +7799,32 @@ var GuiObject = class extends SceneObject {
       throw error;
     }
   }
+  async createItem(layer, index) {
+    const key = typeof layer.item === "string" ? AssetKey.parse("models", layer.item) : layer.item;
+    const model = await Models.getMerged(key);
+    if (!model) throw new Error(`Could not load GUI item ${key.toNamespacedString()}`);
+    const item = new ModelObject(model, {
+      displayPosition: "gui" /* GUI */,
+      tints: layer.tints,
+      instanceMeshes: false,
+      mergeMeshes: true
+    });
+    item.name = `group:${layer.name ?? index}`;
+    this.add(item);
+    await item.init();
+    item.iterateAllMeshes((mesh) => {
+      this.geometries.add(mesh.geometry);
+      mesh.name = `mesh:${layer.name ?? index}`;
+      mesh.renderOrder = index;
+      for (const material of Array.isArray(mesh.material) ? mesh.material : [mesh.material]) {
+        material.transparent = true;
+        if (model.gui_light === "front" /* FRONT */ && material.uniforms?.SHADE) {
+          material.uniforms.SHADE.value = false;
+        }
+      }
+    });
+    return item;
+  }
   async loadMaterial(key) {
     const assetKey = key.serialize();
     const materialKey = `gui:${assetKey}`;
@@ -7802,21 +7863,21 @@ function isGuiObject(obj) {
 init_image();
 
 // src/inspector/SceneInspector.ts
-var import_three20 = require("three");
+var import_three23 = require("three");
 init_SceneObject();
 init_util();
 init_log();
 init_three();
-var p7 = prefix("SceneInspector");
+var p8 = prefix("SceneInspector");
 var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
     this.renderer = renderer;
-    this.mouse = new import_three20.Vector2();
+    this.mouse = new import_three23.Vector2();
     this.listeners = new AbortController();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
-    this.raycaster = new import_three20.Raycaster();
+    this.raycaster = new import_three23.Raycaster();
     this.init();
   }
   init() {
@@ -7901,7 +7962,7 @@ var SceneInspector = class {
   }
   selectObject(targetObject, targetIntersection, instance = this.getIntersectionInstance(targetIntersection)) {
     this.selectedObject = targetObject;
-    console.log(p7, "selected", targetObject);
+    console.log(p8, "selected", targetObject);
     this.redraw(targetObject, targetIntersection, instance);
   }
   redraw(targetObject, targetIntersection, instance) {
@@ -8133,7 +8194,7 @@ var SceneStatsDisplay = class {
   }
   init() {
     this.statsContainer.classList.add("minerender-stats");
-    setInterval(() => {
+    this.interval = setInterval(() => {
       for (let line of this.lines) {
         line.update();
       }
@@ -8142,6 +8203,13 @@ var SceneStatsDisplay = class {
   appendTo(el) {
     el.append(this.statsContainer);
   }
+  dispose() {
+    clearInterval(this.interval);
+    this.interval = void 0;
+    this.lines.length = 0;
+    this.statsContainer.replaceChildren();
+    this.statsContainer.remove();
+  }
   add(line) {
     if (typeof line !== "undefined") {
       this.lines.push(line);
@@ -8153,7 +8221,7 @@ var SceneStatsDisplay = class {
 
 // src/instance/InstanceManager.ts
 init_log();
-var p8 = prefix("InstanceManager");
+var p9 = prefix("InstanceManager");
 var InstanceManager = class {
   constructor() {
     this.isInstanceManager = true;
@@ -8161,7 +8229,7 @@ var InstanceManager = class {
   }
   async get(key) {
     if (key in this.instanceCache) {
-      console.debug(p8, "key in cache", key);
+      console.debug(p9, "key in cache", key);
       return (await this.instanceCache[key]).nextInstance();
     }
     return void 0;
@@ -8170,7 +8238,7 @@ var InstanceManager = class {
     if (key in this.instanceCache) {
       return await this.get(key);
     }
-    console.debug(p8, "key not in cache", key);
+    console.debug(p9, "key not in cache", key);
     const pending = Promise.resolve().then(supplier).then((obj) => obj.nextInstance());
     this.instanceCache[key] = pending;
     try {
@@ -8204,13 +8272,6 @@ function isInstanceable(obj) {
 init_DisplayPosition();
 init_DisplayTransforms();
 
-// src/model/GuiLight.ts
-var GuiLight = /* @__PURE__ */ ((GuiLight2) => {
-  GuiLight2["FRONT"] = "front";
-  GuiLight2["SIDE"] = "side";
-  return GuiLight2;
-})(GuiLight || {});
-
 // src/model/Model.ts
 var ITEM_GENERATED = "item/generated";
 var BUILTIN_GENERATED = "builtin/generated";
@@ -8232,7 +8293,7 @@ init_ModelGenerator();
 init_ModelMerger();
 
 // src/model/block/BlockStateResolver.ts
-var import_three23 = require("three");
+var import_three25 = require("three");
 init_BlockStates();
 init_MineRenderError();
 init_util();
@@ -8310,7 +8371,7 @@ var BlockStateResolver = class {
     return variants[variants.length - 1];
   }
   static rotation(variant) {
-    const rotation = new import_three23.Euler();
+    const rotation = new import_three25.Euler();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -12381,7 +12442,10 @@ var Renderer = class _Renderer {
   constructor(options) {
     this._dirty = true;
     this._resizeListener = void 0;
+    this._running = false;
+    this._inAnimationLoop = false;
     this._disposed = false;
+    this._frameCallbacks = /* @__PURE__ */ new Map();
     this._debugHelpers = [];
     this._eventDispatchers = /* @__PURE__ */ new Map();
     this._changeListener = () => {
@@ -12392,7 +12456,14 @@ var Renderer = class _Renderer {
     if (!Number.isFinite(pixelRatio) || pixelRatio <= 0) {
       throw new RangeError("render.pixelRatio must be a finite positive number");
     }
-    this._animationLoop = this.animate.bind(this);
+    this._animationLoop = (time) => {
+      this._inAnimationLoop = true;
+      try {
+        this.animate(time);
+      } finally {
+        this._inAnimationLoop = false;
+      }
+    };
     this._frameInterval = this.options.render.fpsLimit > 0 ? 1e3 / this.options.render.fpsLimit : void 0;
     this._scene = this.createScene();
     this._camera = this.createCamera();
@@ -12607,15 +12678,39 @@ var Renderer = class _Renderer {
     this._dirty = dirty;
     this.scene.dirty = dirty;
   }
+  /**
+   * Calls a synchronous animation update before each FPS-limited draw while started.
+   * Subscriptions keep the scene drawing without manual dirty flags. Returns an unsubscribe function.
+   * Registering the same callback twice has no effect. Image exports do not invoke callbacks.
+   */
+  onFrame(callback) {
+    if (this._disposed) return () => {
+    };
+    const subscription = this._frameCallbacks.get(callback) ?? {};
+    this._frameCallbacks.set(callback, subscription);
+    return () => {
+      if (this._frameCallbacks.get(callback) === subscription) this._frameCallbacks.delete(callback);
+    };
+  }
   start() {
     if (this._disposed) return;
     this.stop();
-    this.renderer.setAnimationLoop(this._animationLoop);
+    this._running = true;
+    if (!this._inAnimationLoop) this.renderer.setAnimationLoop(this._animationLoop);
   }
   stop() {
     if (this._disposed) return;
-    this.renderer.setAnimationLoop(null);
+    this._running = false;
+    if (this._inAnimationLoop) {
+      queueMicrotask(() => {
+        this.renderer.setAnimationLoop(null);
+        if (this._running) this.renderer.setAnimationLoop(this._animationLoop);
+      });
+    } else {
+      this.renderer.setAnimationLoop(null);
+    }
     this._nextFrameTime = void 0;
+    for (const subscription of this._frameCallbacks.values()) subscription.previous = void 0;
   }
   /**
    * Stops rendering and releases owned resources. Repeated calls have no effect, and a disposed
@@ -12626,6 +12721,7 @@ var Renderer = class _Renderer {
     if (this._disposed) return;
     this.stop();
     this._disposed = true;
+    this._frameCallbacks.clear();
     if (this._resizeListener) {
       window.removeEventListener("resize", this._resizeListener);
       this._resizeListener = void 0;
@@ -12660,18 +12756,25 @@ var Renderer = class _Renderer {
     this.renderer.forceContextLoss();
   }
   animate(t = performance.now()) {
-    if (this._disposed) return;
+    if (!this._running) return;
     if (this._controls?.enabled) {
       this._controls.update();
     }
-    if (this._disposed) return;
-    if (!this.dirty && !this.options.render.renderAlways) return;
+    if (!this._running) return;
+    if (!this.dirty && !this.options.render.renderAlways && !this._frameCallbacks.size) return;
     const interval = this._frameInterval;
     if (interval) {
       const next = this._nextFrameTime;
       if (next !== void 0 && t + 0.1 < next) return;
       this._nextFrameTime = next !== void 0 && t - next < interval ? next + interval : t + interval;
     }
+    for (const [callback, subscription] of [...this._frameCallbacks]) {
+      if (this._frameCallbacks.get(callback) !== subscription) continue;
+      const previous = subscription.previous;
+      subscription.previous = t;
+      callback({ time: t / 1e3, delta: previous === void 0 ? 0 : (t - previous) / 1e3 });
+      if (!this._running) return;
+    }
     this.drawFrame();
   }
   drawFrame() {