minerender 2.1.0-alpha.47 → 2.1.0-alpha.49

package/dist/browser/index.mjs

@@ -799,7 +799,7 @@ var init_Textures = __esm({
 });
 
 // src/Materials.ts
-import { Color, DoubleSide, FrontSide, MeshBasicMaterial, MeshStandardMaterial, ShaderMaterial } from "three";
+import { Color, DoubleSide, FrontSide, MeshBasicMaterial, MeshStandardMaterial, ShaderChunk, ShaderMaterial } from "three";
 var _Materials, Materials;
 var init_Materials = __esm({
   "src/Materials.ts"() {
@@ -838,6 +838,31 @@ var init_Materials = __esm({
           alphaTest: 0.5
         });
       }
+      static createGuiCanvasMaterial(canvas) {
+        const material = new MeshBasicMaterial({
+          map: Textures.createCanvasTexture(canvas),
+          transparent: true,
+          depthWrite: false,
+          side: DoubleSide,
+          toneMapped: false
+        });
+        material.onBeforeCompile = (shader) => {
+          for (const [stage, direction] of [["vertex", "out"], ["fragment", "in"]]) {
+            const chunk = `uv_pars_${stage}`;
+            shader[`${stage}Shader`] = shader[`${stage}Shader`].replace(
+              `#include <${chunk}>`,
+              ShaderChunk[chunk].replace("varying vec2 vMapUv;", `
+                        #if __VERSION__ >= 300
+                        centroid ${direction} vec2 vMapUv;
+                        #else
+                        varying vec2 vMapUv;
+                        #endif
+                    `)
+            );
+          }
+        };
+        return material;
+      }
       static createShadedCanvasMaterial(canvas, transparent = false, shade = false) {
         const vertShader = `
             uniform bool SHADE;
@@ -2983,6 +3008,10 @@ var init_SceneObject = __esm({
       async init() {
       }
       notifyDirty() {
+        this.traverseAncestors((parent) => {
+          const scene = parent;
+          if (scene.isMineRenderScene) scene.dirty = true;
+        });
         this.dispatchEvent(changeEvent);
       }
       //<editor-fold desc="GROUPS">
@@ -3326,6 +3355,7 @@ var init_SceneObject = __esm({
           } else {
             object.visible = !object.visible;
           }
+          this.notifyDirty();
           return object.visible;
         }
         this.notifyDirty();
@@ -3358,8 +3388,8 @@ var init_SceneObject = __esm({
         this.notifyDirty();
       }
       removeFromScene() {
-        this._scene?.remove(this);
         this.notifyDirty();
+        this.removeFromParent();
       }
       //</editor-fold>
     };
@@ -4880,11 +4910,100 @@ function isEntityObject(obj) {
 // src/error/index.ts
 init_MineRenderError();
 
+// src/gui/GuiHelper.ts
+var GuiHelper = class {
+  static inventorySlot(slot, origin = [0, 0], offset = [18, 18], rowSize = 9) {
+    const [column, row] = typeof slot === "number" ? [slot % rowSize, Math.floor(slot / rowSize)] : slot;
+    return [origin[0] + column * offset[0], origin[1] + row * offset[1]];
+  }
+};
+
 // src/gui/scene/GuiObject.ts
+init_AssetKey();
+init_ModelTextures();
+init_Caching();
 init_SceneObject();
+init_Materials();
+import { Box2, Mesh as Mesh4, PlaneGeometry, Vector2 as Vector22 } from "three";
 var GuiObject = class extends SceneObject {
-  //TODO
+  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 Box2();
+    this.geometries = /* @__PURE__ */ new Set();
+    this.ownedMaterials = /* @__PURE__ */ new Set();
+    this.initialized = false;
+  }
+  async init() {
+    if (this.initialized) return;
+    try {
+      for (const [index, layer] of this.textureLayers.entries()) {
+        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 PlaneGeometry(width, height);
+        this.geometries.add(geometry);
+        const uv = geometry.getAttribute("uv");
+        for (let i = 0; i < uv.count; i++) {
+          uv.setXY(
+            i,
+            (cropX + uv.getX(i) * cropWidth) / image.width,
+            1 - (cropY + (1 - uv.getY(i)) * cropHeight) / image.height
+          );
+        }
+        const mesh = new Mesh4(geometry, material);
+        mesh.name = `mesh:${layer.name ?? index}`;
+        mesh.position.set(x + width / 2, -y - height / 2, 0);
+        mesh.renderOrder = index;
+        this.add(mesh);
+        this.bounds.expandByPoint(new Vector22(x, y));
+        this.bounds.expandByPoint(new Vector22(x + width, y + height));
+      }
+      this.initialized = true;
+      this.notifyDirty();
+    } catch (error) {
+      this.disposeAndRemoveAllChildren();
+      throw error;
+    }
+  }
+  async loadMaterial(key) {
+    const assetKey = key.serialize();
+    const materialKey = `gui:${assetKey}`;
+    const cached2 = Caching.materialCache.getIfPresent(materialKey);
+    if (cached2) return cached2;
+    const pending = ModelTextures.get(key);
+    const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKey);
+    const image = await pending;
+    if (!image) throw new Error(`Could not load GUI texture ${key.toNamespacedString()}`);
+    const create = () => Materials.createGuiCanvasMaterial(image.data.canvas);
+    if (cachedAsset && Caching.textureAssetCache.getIfPresent(assetKey) === cachedAsset) {
+      return Caching.materialCache.get(materialKey, create);
+    }
+    const material = create();
+    this.ownedMaterials.add(material);
+    return material;
+  }
+  disposeAndRemoveAllChildren() {
+    for (const geometry of this.geometries) geometry.dispose();
+    this.geometries.clear();
+    for (const material of this.ownedMaterials) {
+      material.map.dispose();
+      material.dispose();
+    }
+    this.ownedMaterials.clear();
+    this.bounds.makeEmpty();
+    this.initialized = false;
+    super.disposeAndRemoveAllChildren();
+  }
 };
+function isGuiObject(obj) {
+  return obj.isGuiObject;
+}
 
 // src/index.ts
 init_image();
@@ -4892,7 +5011,7 @@ init_image();
 // src/inspector/SceneInspector.ts
 init_SceneObject();
 init_util();
-import { Raycaster, Vector2 as Vector22 } from "three";
+import { Raycaster, Vector2 as Vector23 } from "three";
 init_log();
 init_three();
 var p7 = prefix("SceneInspector");
@@ -4900,7 +5019,7 @@ var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
     this.renderer = renderer;
-    this.mouse = new Vector22();
+    this.mouse = new Vector23();
     this.listeners = new AbortController();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
@@ -8373,7 +8492,7 @@ init_util();
 init_Caching();
 init_CacheKey();
 init_MineRenderError();
-import { DataTexture, DoubleSide as DoubleSide3, FrontSide as FrontSide2, MeshBasicMaterial as MeshBasicMaterial3, SRGBColorSpace as SRGBColorSpace3 } from "three";
+import { DataTexture, DoubleSide as DoubleSide3, FrontSide as FrontSide2, MeshBasicMaterial as MeshBasicMaterial4, SRGBColorSpace as SRGBColorSpace3 } from "three";
 
 // src/skin/SkinImage.ts
 init_Caching();
@@ -8458,7 +8577,7 @@ var SkinTextures = class {
     texture.colorSpace = SRGBColorSpace3;
     texture.flipY = true;
     texture.needsUpdate = true;
-    return new MeshBasicMaterial3({ map: texture, transparent, side: transparent ? DoubleSide3 : FrontSide2, alphaTest: transparent ? 0.1 : 0 });
+    return new MeshBasicMaterial4({ map: texture, transparent, side: transparent ? DoubleSide3 : FrontSide2, alphaTest: transparent ? 0.1 : 0 });
   }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -8801,6 +8920,14 @@ var _MineRenderScene = class _MineRenderScene extends Scene2 {
   async addEntity(entity, options, parent = this) {
     return this.addSceneObject(entity, () => new EntityObject(entity, options), options, parent);
   }
+  async addGui(layers, options, parent = this) {
+    const obj = new GuiObject(layers, options);
+    obj.scene = this;
+    await obj.init();
+    parent.add(obj);
+    this.dirty = true;
+    return obj;
+  }
 };
 _MineRenderScene.DEFAULT_OPTIONS = (0, import_ts_deepmerge8.default)({}, {});
 var MineRenderScene = _MineRenderScene;
@@ -8823,7 +8950,7 @@ import {
   Quaternion as Quaternion5,
   Spherical,
   TOUCH,
-  Vector2 as Vector23,
+  Vector2 as Vector24,
   Vector3 as Vector39
 } from "three";
 var _changeEvent = { type: "change" };
@@ -8985,15 +9112,15 @@ var OrbitControls = class extends EventDispatcher {
     let scale = 1;
     const panOffset = new Vector39();
     let zoomChanged = false;
-    const rotateStart = new Vector23();
-    const rotateEnd = new Vector23();
-    const rotateDelta = new Vector23();
-    const panStart = new Vector23();
-    const panEnd = new Vector23();
-    const panDelta = new Vector23();
-    const dollyStart = new Vector23();
-    const dollyEnd = new Vector23();
-    const dollyDelta = new Vector23();
+    const rotateStart = new Vector24();
+    const rotateEnd = new Vector24();
+    const rotateDelta = new Vector24();
+    const panStart = new Vector24();
+    const panEnd = new Vector24();
+    const panDelta = new Vector24();
+    const dollyStart = new Vector24();
+    const dollyEnd = new Vector24();
+    const dollyDelta = new Vector24();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -9439,7 +9566,7 @@ var OrbitControls = class extends EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new Vector23();
+        position = new Vector24();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -9478,6 +9605,10 @@ var _Renderer = class _Renderer {
       this._dirty = true;
     };
     this.options = (0, import_ts_deepmerge9.default)({}, _Renderer.DEFAULT_OPTIONS, options ?? {});
+    const pixelRatio = this.options.render.pixelRatio ?? 1;
+    if (!Number.isFinite(pixelRatio) || pixelRatio <= 0) {
+      throw new RangeError("render.pixelRatio must be a finite positive number");
+    }
     this._animationLoop = this.animate.bind(this);
     this._frameInterval = this.options.render.fpsLimit > 0 ? 1e3 / this.options.render.fpsLimit : void 0;
     this._scene = this.createScene();
@@ -9527,6 +9658,7 @@ var _Renderer = class _Renderer {
     renderer.shadowMap.enabled = true;
     renderer.shadowMap.type = PCFSoftShadowMap;
     renderer.outputColorSpace = SRGBColorSpace4;
+    renderer.setPixelRatio(this.options.render.pixelRatio ?? 1);
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
   }
@@ -9782,6 +9914,7 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
   },
   render: {
     fpsLimit: 60,
+    pixelRatio: 1,
     stats: false,
     antialias: true,
     shade: true,
@@ -10569,7 +10702,7 @@ var MineRenderWorld = class {
 // src/world/SectionMesh.ts
 init_CanvasCompat();
 init_Materials();
-import { BufferGeometry as BufferGeometry4, Float32BufferAttribute as Float32BufferAttribute5, Group, Mesh as Mesh7 } from "three";
+import { BufferGeometry as BufferGeometry4, Float32BufferAttribute as Float32BufferAttribute5, Group, Mesh as Mesh8 } from "three";
 var SectionMesh = class _SectionMesh extends Group {
   constructor() {
     super(...arguments);
@@ -10654,7 +10787,7 @@ var SectionMesh = class _SectionMesh extends Group {
       const material = Materials.createShadedCanvasMaterial(canvas, false);
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
-      const mesh = new Mesh7(geometry, material);
+      const mesh = new Mesh8(geometry, material);
       section.add(mesh);
       section.ownedMeshes.push({ mesh, texture });
     }
@@ -10868,6 +11001,7 @@ export {
   Env,
   FluidModelObject,
   Geometries,
+  GuiHelper,
   GuiLight,
   GuiObject,
   HostedAssetSource,
@@ -10945,6 +11079,7 @@ export {
   isDisposable,
   isDoubleArray,
   isEntityObject,
+  isGuiObject,
   isInstanceManager,
   isInstanceReference,
   isInstanceable,