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

package/dist/bundle.js

@@ -79134,51 +79134,6 @@ ${key}` : key;
     }
   });
 
-  // src/model/ModelCulling.ts
-  var ModelCulling;
-  var init_ModelCulling = __esm({
-    "src/model/ModelCulling.ts"() {
-      init_dirname();
-      init_buffer2();
-      init_process2();
-      init_three_module();
-      init_CubeFace();
-      ModelCulling = class {
-        static toLocalMask(worldMask, rotation) {
-          let localMask = 0;
-          for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
-            const normal = new Vector3(...offset).applyEuler(rotation);
-            const worldFace = CUBE_FACE_OFFSETS.findIndex(([x4, y5, z4]) => Math.abs(normal.x - x4) < 1e-6 && Math.abs(normal.y - y5) < 1e-6 && Math.abs(normal.z - z4) < 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 vertex2 = 0; vertex2 < 4; vertex2++) {
-              const uvIndex = (faceIndex * 4 + vertex2) * 2;
-              const x4 = element.mappedUv[uvIndex] * atlas.image.width;
-              const y5 = (1 - element.mappedUv[uvIndex + 1]) * atlas.image.height;
-              if (x4 < position[0] - 1e-6 || x4 > position[0] + size[0] + 1e-6 || y5 < position[1] - 1e-6 || y5 > position[1] + size[1] + 1e-6) return false;
-            }
-            return true;
-          });
-        }
-      };
-    }
-  });
-
   // src/three/BufferGeometryUtils.js
   function computeTangents(geometry) {
     geometry.computeTangents();
@@ -79718,11 +79673,56 @@ ${key}` : key;
     }
   });
 
+  // src/model/ModelCulling.ts
+  var ModelCulling;
+  var init_ModelCulling = __esm({
+    "src/model/ModelCulling.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_three_module();
+      init_CubeFace();
+      ModelCulling = class {
+        static toLocalMask(worldMask, rotation) {
+          let localMask = 0;
+          for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
+            const normal = new Vector3(...offset).applyEuler(rotation);
+            const worldFace = CUBE_FACE_OFFSETS.findIndex(([x4, y5, z4]) => Math.abs(normal.x - x4) < 1e-6 && Math.abs(normal.y - y5) < 1e-6 && Math.abs(normal.z - z4) < 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 vertex2 = 0; vertex2 < 4; vertex2++) {
+              const uvIndex = (faceIndex * 4 + vertex2) * 2;
+              const x4 = element.mappedUv[uvIndex] * atlas.image.width;
+              const y5 = (1 - element.mappedUv[uvIndex + 1]) * atlas.image.height;
+              if (x4 < position[0] - 1e-6 || x4 > position[0] + size[0] + 1e-6 || y5 < position[1] - 1e-6 || y5 > position[1] + size[1] + 1e-6) return false;
+            }
+            return true;
+          });
+        }
+      };
+    }
+  });
+
   // src/model/scene/ModelObject.ts
   function isModelObject(obj) {
     return obj.isModelObject;
   }
-  var import_ts_deepmerge5, p12, _ModelObject, ModelObject;
+  var import_ts_deepmerge5, p10, _ModelObject, ModelObject;
   var init_ModelObject = __esm({
     "src/model/scene/ModelObject.ts"() {
       init_dirname();
@@ -79739,7 +79739,7 @@ ${key}` : key;
       init_CubeFace();
       init_DisplayTransforms();
       init_ModelCulling();
-      p12 = prefix("ModelObject");
+      p10 = prefix("ModelObject");
       _ModelObject = class _ModelObject extends SceneObject {
         constructor(originalModel, options) {
           super(options);
@@ -79818,10 +79818,10 @@ ${key}` : key;
                 }
               });
             } else {
-              console.debug(p12, this.atlas.model, "has no elements");
+              console.debug(p10, this.atlas.model, "has no elements");
             }
           } else {
-            console.debug(p12, "Missing atlas for", this);
+            console.debug(p10, "Missing atlas for", this);
           }
           if (this.options.mergeMeshes) {
             let combinedGeo;
@@ -86352,9 +86352,24 @@ property list uchar int vertex_index
   init_three_module();
   init_AssetKey();
   init_ModelTextures();
+  init_Models();
   init_Caching();
   init_SceneObject();
   init_Materials();
+  init_ModelObject();
+  init_DisplayPosition();
+
+  // src/model/GuiLight.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  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 });
@@ -86369,13 +86384,34 @@ property list uchar int vertex_index
     async init() {
       if (this.initialized) return;
       try {
+        let depth = 0;
         for (const [index, layer] of this.textureLayers.entries()) {
+          const [x4, y5] = 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(x4 + width2 / 2, -y5 - height2 / 2, 0);
+            item.scale.set(width2 / 16, height2 / 16, width2 / 16);
+            item.updateMatrix();
+            const bounds = new 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 Vector2(x4, y5));
+            this.bounds.expandByPoint(new Vector2(x4 + width2, y5 + height2));
+            this.bounds.expandByPoint(new Vector2(bounds.min.x, -bounds.max.y));
+            this.bounds.expandByPoint(new 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 [x4, y5] = layer.position ?? [0, 0];
           const geometry = new PlaneGeometry(width, height);
           this.geometries.add(geometry);
           const uv = geometry.getAttribute("uv");
@@ -86388,12 +86424,14 @@ property list uchar int vertex_index
           }
           const mesh = new Mesh(geometry, material);
           mesh.name = `mesh:${layer.name ?? index}`;
-          mesh.position.set(x4 + width / 2, -y5 - height / 2, 0);
+          mesh.position.set(x4 + width / 2, -y5 - height / 2, depth);
           mesh.renderOrder = index;
           this.add(mesh);
           this.bounds.expandByPoint(new Vector2(x4, y5));
           this.bounds.expandByPoint(new Vector2(x4 + width, y5 + height));
+          depth += 0.01;
         }
+        for (const child of this.children) child.position.z -= depth - 0.01;
         this.initialized = true;
         this.notifyDirty();
       } catch (error) {
@@ -86401,6 +86439,32 @@ property list uchar int vertex_index
         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}`;
@@ -86452,7 +86516,7 @@ property list uchar int vertex_index
   init_util();
   init_log();
   init_three();
-  var p10 = prefix("SceneInspector");
+  var p11 = prefix("SceneInspector");
   var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
   var SceneInspector = class {
     constructor(renderer) {
@@ -86546,7 +86610,7 @@ property list uchar int vertex_index
     }
     selectObject(targetObject, targetIntersection, instance = this.getIntersectionInstance(targetIntersection)) {
       this.selectedObject = targetObject;
-      console.log(p10, "selected", targetObject);
+      console.log(p11, "selected", targetObject);
       this.redraw(targetObject, targetIntersection, instance);
     }
     redraw(targetObject, targetIntersection, instance) {
@@ -86781,7 +86845,7 @@ property list uchar int vertex_index
     }
     init() {
       this.statsContainer.classList.add("minerender-stats");
-      setInterval(() => {
+      this.interval = setInterval(() => {
         for (let line of this.lines) {
           line.update();
         }
@@ -86790,6 +86854,13 @@ property list uchar int vertex_index
     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);
@@ -86809,7 +86880,7 @@ property list uchar int vertex_index
   init_buffer2();
   init_process2();
   init_log();
-  var p11 = prefix("InstanceManager");
+  var p12 = prefix("InstanceManager");
   var InstanceManager = class {
     constructor() {
       this.isInstanceManager = true;
@@ -86817,7 +86888,7 @@ property list uchar int vertex_index
     }
     async get(key) {
       if (key in this.instanceCache) {
-        console.debug(p11, "key in cache", key);
+        console.debug(p12, "key in cache", key);
         return (await this.instanceCache[key]).nextInstance();
       }
       return void 0;
@@ -86826,7 +86897,7 @@ property list uchar int vertex_index
       if (key in this.instanceCache) {
         return await this.get(key);
       }
-      console.debug(p11, "key not in cache", key);
+      console.debug(p12, "key not in cache", key);
       const pending = Promise.resolve().then(supplier).then((obj) => obj.nextInstance());
       this.instanceCache[key] = pending;
       try {
@@ -86871,16 +86942,6 @@ property list uchar int vertex_index
   init_buffer2();
   init_process2();
 
-  // src/model/GuiLight.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-  var GuiLight = /* @__PURE__ */ ((GuiLight2) => {
-    GuiLight2["FRONT"] = "front";
-    GuiLight2["SIDE"] = "side";
-    return GuiLight2;
-  })(GuiLight || {});
-
   // src/model/Model.ts
   init_dirname();
   init_buffer2();
@@ -92921,7 +92982,10 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
     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 = () => {
@@ -92932,7 +92996,14 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       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();
@@ -93107,15 +93178,39 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       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
@@ -93126,6 +93221,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       if (this._disposed) return;
       this.stop();
       this._disposed = true;
+      this._frameCallbacks.clear();
       if (this._resizeListener) {
         window.removeEventListener("resize", this._resizeListener);
         this._resizeListener = void 0;
@@ -93160,18 +93256,25 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       this.renderer.forceContextLoss();
     }
     animate(t5 = 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 && t5 + 0.1 < next) return;
         this._nextFrameTime = next !== void 0 && t5 - next < interval ? next + interval : t5 + interval;
       }
+      for (const [callback, subscription] of [...this._frameCallbacks]) {
+        if (this._frameCallbacks.get(callback) !== subscription) continue;
+        const previous = subscription.previous;
+        subscription.previous = t5;
+        callback({ time: t5 / 1e3, delta: previous === void 0 ? 0 : (t5 - previous) / 1e3 });
+        if (!this._running) return;
+      }
       this.drawFrame();
     }
     drawFrame() {