minerender 2.1.0-alpha.67 → 2.1.0-alpha.68

package/dist/browser/index.mjs

@@ -4247,8 +4247,8 @@ var init_EntityObject = __esm({
 // src/three/BufferGeometryUtils.js
 import {
   BufferAttribute as BufferAttribute4,
-  BufferGeometry as BufferGeometry2,
-  Float32BufferAttribute as Float32BufferAttribute4,
+  BufferGeometry as BufferGeometry3,
+  Float32BufferAttribute as Float32BufferAttribute5,
   InterleavedBuffer,
   InterleavedBufferAttribute,
   TriangleFanDrawMode,
@@ -4267,7 +4267,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new BufferGeometry2();
+  const mergedGeometry = new BufferGeometry3();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -4776,8 +4776,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new Float32BufferAttribute4(modifiedPosition, 3);
-  const morphedNormalAttribute = new Float32BufferAttribute4(modifiedNormal, 3);
+  const morphedPositionAttribute = new Float32BufferAttribute5(modifiedPosition, 3);
+  const morphedNormalAttribute = new Float32BufferAttribute5(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -5270,7 +5270,7 @@ var init_fluidBlocks = __esm({
 });
 
 // src/model/fluid/FluidGeometry.ts
-import { BufferGeometry as BufferGeometry4, Float32BufferAttribute as Float32BufferAttribute5 } from "three";
+import { BufferGeometry as BufferGeometry5, Float32BufferAttribute as Float32BufferAttribute6 } from "three";
 function getBlockFluidState(key, state) {
   const rule = key && fluidRules[key.toNamespacedString()];
   if (rule) return {
@@ -5288,7 +5288,7 @@ function ownHeight(sample) {
   return (level === 0 || level >= 8 ? 8 : 8 - level) / 9;
 }
 function createFluidGeometry(kind, sample) {
-  const geometry = new BufferGeometry4();
+  const geometry = new BufferGeometry5();
   const positions = [], normals = [], uvs = [], indices = [];
   const self = sample(0, 0, 0);
   const height = (x, z) => {
@@ -5387,9 +5387,9 @@ function createFluidGeometry(kind, sample) {
       1
     );
   }
-  geometry.setAttribute("position", new Float32BufferAttribute5(positions, 3));
-  geometry.setAttribute("normal", new Float32BufferAttribute5(normals, 3));
-  geometry.setAttribute("uv", new Float32BufferAttribute5(uvs, 2));
+  geometry.setAttribute("position", new Float32BufferAttribute6(positions, 3));
+  geometry.setAttribute("normal", new Float32BufferAttribute6(normals, 3));
+  geometry.setAttribute("uv", new Float32BufferAttribute6(uvs, 2));
   geometry.setIndex(indices);
   return geometry;
 }
@@ -8793,6 +8793,85 @@ var GuiHelper = class {
   }
 };
 
+// src/gui/GuiTextureGeometry.ts
+import { BufferGeometry as BufferGeometry2, Float32BufferAttribute as Float32BufferAttribute4, PlaneGeometry } from "three";
+function createGuiTextureGeometry(width, height, imageWidth, imageHeight, crop, scaling) {
+  if (crop || !scaling || scaling.type === "stretch") {
+    const [x, y, w, h] = crop ?? [0, 0, imageWidth, imageHeight];
+    const geometry = new PlaneGeometry(width, height);
+    const uv = geometry.getAttribute("uv");
+    for (let i = 0; i < uv.count; i++) {
+      uv.setXY(
+        i,
+        (x + uv.getX(i) * w) / imageWidth,
+        1 - (y + (1 - uv.getY(i)) * h) / imageHeight
+      );
+    }
+    return geometry;
+  }
+  const sw = scaling.width, sh = scaling.height;
+  if (![sw, sh].every((value) => Number.isInteger(value) && value > 0)) {
+    throw new Error("GUI sprite dimensions must be positive integers");
+  }
+  if (![width, height].every((value) => Number.isFinite(value) && value >= 0)) {
+    throw new Error("GUI output dimensions must be finite and nonnegative");
+  }
+  const positions = [], uvs = [], normals = [], indices = [];
+  function quad(x, y, w, h, u, v, uw, vh) {
+    if (w <= 0 || h <= 0) return;
+    const index = positions.length / 3;
+    const left = x - width / 2, top = height / 2 - y;
+    positions.push(left, top, 0, left + w, top, 0, left, top - h, 0, left + w, top - h, 0);
+    uvs.push(
+      u / sw,
+      1 - v / sh,
+      (u + uw) / sw,
+      1 - v / sh,
+      u / sw,
+      1 - (v + vh) / sh,
+      (u + uw) / sw,
+      1 - (v + vh) / sh
+    );
+    normals.push(0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1);
+    indices.push(index, index + 2, index + 1, index + 2, index + 3, index + 1);
+  }
+  function tile(x, y, w, h, u, v, tw, th) {
+    for (let dy = 0; dy < h; dy += th) {
+      for (let dx = 0; dx < w; dx += tw) {
+        const cw = Math.min(tw, w - dx), ch = Math.min(th, h - dy);
+        quad(x + dx, y + dy, cw, ch, u, v, cw, ch);
+      }
+    }
+  }
+  if (scaling.type === "tile") {
+    tile(0, 0, width, height, 0, 0, sw, sh);
+  } else {
+    let segments = function(size, sourceSize, start, end) {
+      if (size === sourceSize) return [[0, size, 0, sourceSize]];
+      start = Math.min(start, Math.floor(size / 2));
+      end = Math.min(end, Math.floor(size / 2));
+      return [
+        [0, start, 0, start],
+        [start, size - start - end, start, sourceSize - start - end],
+        [size - end, end, sourceSize - end, end]
+      ];
+    };
+    const border = typeof scaling.border === "number" ? { left: scaling.border, top: scaling.border, right: scaling.border, bottom: scaling.border } : scaling.border;
+    if (!border || typeof scaling.border === "number" && scaling.border <= 0 || ![border.left, border.top, border.right, border.bottom].every((value) => Number.isInteger(value) && value >= 0) || border.left + border.right >= sw || border.top + border.bottom >= sh) {
+      throw new Error("GUI nine-slice borders must be nonnegative integers with a nonempty center");
+    }
+    const columns = segments(width, sw, border.left, border.right);
+    const rows = segments(height, sh, border.top, border.bottom);
+    for (const [y, h, v, vh] of rows) {
+      for (const [x, w, u, uw] of columns) {
+        if (w <= 0 || h <= 0) continue;
+        (scaling.stretch_inner ? quad : tile)(x, y, w, h, u, v, uw, vh);
+      }
+    }
+  }
+  return new BufferGeometry2().setAttribute("position", new Float32BufferAttribute4(positions, 3)).setAttribute("normal", new Float32BufferAttribute4(normals, 3)).setAttribute("uv", new Float32BufferAttribute4(uvs, 2)).setIndex(indices);
+}
+
 // src/gui/scene/GuiObject.ts
 init_AssetKey();
 init_ModelTextures();
@@ -8803,7 +8882,7 @@ init_Materials();
 init_ModelObject();
 init_DisplayPosition();
 init_GuiLight();
-import { Box2, Box3 as Box32, Matrix4 as Matrix410, Mesh as Mesh6, PlaneGeometry, Vector2 as Vector23 } from "three";
+import { Box2, Box3 as Box32, Matrix4 as Matrix410, Mesh as Mesh6, Vector2 as Vector23 } from "three";
 var GuiObject = class extends SceneObject {
   constructor(textureLayers, options) {
     super({ ...options, instanceMeshes: false, mergeMeshes: false });
@@ -8844,18 +8923,10 @@ var GuiObject = class extends SceneObject {
         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 geometry = new PlaneGeometry(width, height);
+        const scaling = layer.crop ? void 0 : (await ModelTextures.getMeta(key))?.gui?.scaling;
+        const [width, height] = layer.size ?? (layer.crop ? layer.crop.slice(2) : scaling && scaling.type !== "stretch" ? [scaling.width, scaling.height] : [image.width, image.height]);
+        const geometry = createGuiTextureGeometry(width, height, image.width, image.height, layer.crop, scaling);
         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 Mesh6(geometry, material);
         mesh.name = `mesh:${layer.name ?? index}`;
         mesh.position.set(x + width / 2, -y - height / 2, depth);
@@ -14782,7 +14853,7 @@ init_Model();
 // src/world/SectionMesh.ts
 init_CanvasCompat();
 init_Materials();
-import { BufferGeometry as BufferGeometry6, Float32BufferAttribute as Float32BufferAttribute6, Group, Mesh as Mesh9 } from "three";
+import { BufferGeometry as BufferGeometry7, Float32BufferAttribute as Float32BufferAttribute7, Group, Mesh as Mesh9 } from "three";
 var SectionMesh = class _SectionMesh extends Group {
   constructor() {
     super(...arguments);
@@ -14856,11 +14927,11 @@ var SectionMesh = class _SectionMesh extends Group {
           for (let corner = 0; corner < 6; corner++) indices.push(start + sourceIndices.getX(face * 6 + corner) - face * 4);
         }
       }
-      const geometry = new BufferGeometry6();
-      geometry.setAttribute("position", new Float32BufferAttribute6(positions, 3));
-      geometry.setAttribute("normal", new Float32BufferAttribute6(normals, 3));
-      geometry.setAttribute("uv", new Float32BufferAttribute6(uvs, 2));
-      geometry.setAttribute("color", new Float32BufferAttribute6(colors, 3));
+      const geometry = new BufferGeometry7();
+      geometry.setAttribute("position", new Float32BufferAttribute7(positions, 3));
+      geometry.setAttribute("normal", new Float32BufferAttribute7(normals, 3));
+      geometry.setAttribute("uv", new Float32BufferAttribute7(uvs, 2));
+      geometry.setAttribute("color", new Float32BufferAttribute7(colors, 3));
       geometry.setIndex(indices);
       geometry.computeBoundingBox();
       geometry.computeBoundingSphere();
@@ -15185,6 +15256,7 @@ export {
   computeTangents,
   createCanvas,
   createFluidGeometry,
+  createGuiTextureGeometry,
   createImage,
   entityAnimationTime,
   estimateBytesUsed,