minerender 2.1.0-alpha.73 → 2.1.0-alpha.75

package/dist/bundle.js

@@ -42539,7 +42539,7 @@ void main() {
           };
           return material;
         }
-        static createShadedCanvasMaterial(canvas, transparent = false, shade = false) {
+        static createShadedCanvasMaterial(canvas, transparent = false, shade = false, boundUvs = false) {
           const vertShader = `
             uniform bool SHADE;
             
@@ -42549,6 +42549,10 @@ void main() {
             #else
             varying vec2 vUv;
             #endif
+            #ifdef BOUND_UVS
+            attribute vec4 uvBounds;
+            flat out vec4 vUvBounds;
+            #endif
             varying vec3 vTint;
             varying float light;
             varying float lift;
@@ -42584,13 +42588,17 @@ void main() {
                 }
                 
                 vUv = uv;
+                #ifdef BOUND_UVS
+                vUvBounds = uvBounds;
+                #endif
                 vTint = color;
                
+                vec4 mvPosition = vec4(position, 1.0);
                 #ifdef USE_INSTANCING
-                    gl_Position = projectionMatrix * viewMatrix * modelMatrix * instanceMatrix * vec4(position, 1.0);
-                #else
-                    gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+                    mvPosition = instanceMatrix * mvPosition;
                 #endif
+                mvPosition = modelViewMatrix * mvPosition;
+                gl_Position = projectionMatrix * mvPosition;
                 
             }
         `;
@@ -42610,13 +42618,22 @@ void main() {
             #else
             varying vec2 vUv;
             #endif
+            #ifdef BOUND_UVS
+            flat in vec4 vUvBounds;
+            #endif
             varying vec3 vTint;
             varying float light;
             varying float lift;
 
             void main(void)
             {
-                vec4 color = texture2D(map, vUv);
+                #ifdef BOUND_UVS
+                // Keep edge samples inside their texture even without centroid interpolation.
+                vec2 mapUv = clamp(vUv, vUvBounds.xy, vUvBounds.zw);
+                #else
+                vec2 mapUv = vUv;
+                #endif
+                vec4 color = texture2D(map, mapUv);
                 color.rgb *= vTint;
                 
                 if (color.a < 0.01) discard;
@@ -42637,7 +42654,8 @@ void main() {
             }
         `;
           try {
-            return new ShaderMaterial({
+            const material = new ShaderMaterial({
+              defines: boundUvs ? { BOUND_UVS: true } : {},
               uniforms: {
                 SHADE: { value: true },
                 BRIGHTNESS: { value: 1 },
@@ -42655,6 +42673,8 @@ void main() {
               side: transparent ? DoubleSide : FrontSide,
               alphaTest: 0.5
             });
+            Object.assign(material.defaultAttributeValues, { uvBounds: [0, 0, 1, 1] });
+            return material;
           } catch (e6) {
             console.warn(e6);
           }
@@ -87904,6 +87924,37 @@ ${key}` : key;
         static facesToUv(faces, originalTextureSize, actualTextureSize) {
           return new Float32BufferAttribute(this.facesToUvArray(faces, originalTextureSize, actualTextureSize), 2);
         }
+        /** Bounds texture sampling to texel centres without changing cropped face UVs. */
+        static setAtlasUvBounds(geometry, faces, atlas) {
+          const uv = geometry.getAttribute("uv");
+          const bounds = new Float32Array(uv.count * 4);
+          for (const [faceIndex, faceName] of CUBE_FACES.entries()) {
+            const texture = faces[faceName]?.texture?.substring(1);
+            const position = texture && atlas.positions[texture];
+            const size = texture && atlas.sizes[texture];
+            let minU = Infinity, minV = Infinity, maxU = -Infinity, maxV = -Infinity;
+            if (position && size) {
+              minU = position[0] / atlas.image.width;
+              maxU = (position[0] + size[0]) / atlas.image.width;
+              minV = 1 - (position[1] + size[1]) / atlas.image.height;
+              maxV = 1 - position[1] / atlas.image.height;
+            } else {
+              for (let corner = 0; corner < 4; corner++) {
+                const index = faceIndex * 4 + corner;
+                minU = Math.min(minU, uv.getX(index));
+                minV = Math.min(minV, uv.getY(index));
+                maxU = Math.max(maxU, uv.getX(index));
+                maxV = Math.max(maxV, uv.getY(index));
+              }
+            }
+            const insetU = Math.min(0.5 / atlas.image.width, (maxU - minU) / 2);
+            const insetV = Math.min(0.5 / atlas.image.height, (maxV - minV) / 2);
+            for (let corner = 0; corner < 4; corner++) {
+              bounds.set([minU + insetU, minV + insetV, maxU - insetU, maxV - insetV], (faceIndex * 4 + corner) * 4);
+            }
+          }
+          geometry.setAttribute("uvBounds", new Float32BufferAttribute(bounds, 4));
+        }
         static lockUvs(geometry, faces, atlas, rotation) {
           const uv = geometry.getAttribute("uv");
           for (let faceIndex = 0; faceIndex < CUBE_FACES.length; faceIndex++) {
@@ -90345,6 +90396,7 @@ ${shader.fragmentShader}`.replace(
                 if (this.options.uvLockRotation) {
                   UVMapper.lockUvs(elGeo, el.faces, this.atlas, new Euler(...this.options.uvLockRotation));
                 }
+                UVMapper.setAtlasUvBounds(elGeo, el.faces, this.atlas);
                 if (this.options.tints) {
                   const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
                   for (const [faceIndex, faceName] of CUBE_FACES.entries()) {
@@ -90410,7 +90462,7 @@ ${shader.fragmentShader}`.replace(
         }
         applyTextures() {
           if (this.atlas) {
-            const mat = Materials.createShadedCanvasMaterial(this.atlas.image.canvas, this.atlas.hasTransparency, false);
+            const mat = Materials.createShadedCanvasMaterial(this.atlas.image.canvas, this.atlas.hasTransparency, false, true);
             this.atlasMaterial = mat;
             this.atlasTexture = mat.uniforms?.map?.value ?? mat.map;
             this.iterateAllMeshes((mesh) => {
@@ -105471,13 +105523,7 @@ gl_FragDepth=readDepth(vUv);
     async placeChunk(chunk, executor) {
       const changes = /* @__PURE__ */ new Map();
       try {
-        const previous = [...this._chunks.entries()].filter(([, section]) => section.x === chunk.x && section.z === chunk.z);
-        for (const [key, section] of previous) {
-          this._chunks.delete(key);
-          await section.clear(async (positions) => {
-            for (const pos of positions) changes.set(pos.toArray().join(","), pos);
-          });
-        }
+        await this.clearChunkColumn(chunk.x, chunk.z, changes);
         for (const section of chunk.sections) {
           const blocks = [];
           for (let index = 0; index < 4096; index++) {
@@ -105497,6 +105543,31 @@ gl_FragDepth=readDepth(vUv);
         await this.updateCulling([...changes.values()]);
       }
     }
+    /**
+     * Removes all sections at integer chunk-column coordinates, then refreshes neighboring faces and fluids.
+     * Coordinates match AnvilChunk.x/z, not block positions. Missing columns are ignored.
+     */
+    async unloadChunkColumn(x4, z4) {
+      if (!Number.isInteger(x4) || !Number.isInteger(z4)) {
+        throw new RangeError("Chunk column coordinates must be integers");
+      }
+      await this.culling;
+      const changes = /* @__PURE__ */ new Map();
+      try {
+        await this.clearChunkColumn(x4, z4, changes);
+      } finally {
+        await this.updateCulling([...changes.values()]);
+      }
+    }
+    async clearChunkColumn(x4, z4, changes) {
+      const previous = [...this._chunks.entries()].filter(([, section]) => section.x === x4 && section.z === z4);
+      for (const [key, section] of previous) {
+        this._chunks.delete(key);
+        await section.clear(async (positions) => {
+          for (const pos of positions) changes.set(pos.toArray().join(","), pos);
+        });
+      }
+    }
     async clear() {
       await this.culling;
       const chunks = [...this._chunks.values()];
@@ -105668,14 +105739,17 @@ gl_FragDepth=readDepth(vUv);
         for (const { atlas, x: x4, y: y5 } of page.placements) {
           context.drawImage(atlas.image.canvas, x4, y5);
         }
-        const positions = [], normals = [], uvs = [], colors = [], indices = [];
+        const positions = [], normals = [], uvs = [], uvBounds = [], colors = [], indices = [];
         for (const { index, template, cullMask } of page.entries) {
           const position = template.geometry.getAttribute("position");
           const normal = template.geometry.getAttribute("normal");
           const uv = template.geometry.getAttribute("uv");
+          const bounds = template.geometry.getAttribute("uvBounds");
           const color2 = template.geometry.getAttribute("color");
           const sourceIndices = template.geometry.getIndex();
           const placement = locations.get(template.atlas).placement;
+          const mapU = (u4) => (placement.x + u4 * template.atlas.image.width) / page.width;
+          const mapV = (v5) => 1 - (placement.y + (1 - v5) * template.atlas.image.height) / page.height;
           const offsetX = index % 16 * 16;
           const offsetY = Math.floor(index / 256) * 16;
           const offsetZ = Math.floor(index / 16) % 16 * 16;
@@ -105686,9 +105760,12 @@ gl_FragDepth=readDepth(vUv);
               const vertex2 = face * 4 + corner;
               positions.push(position.getX(vertex2) + offsetX, position.getY(vertex2) + offsetY, position.getZ(vertex2) + offsetZ);
               normals.push(normal.getX(vertex2), normal.getY(vertex2), normal.getZ(vertex2));
-              uvs.push(
-                (placement.x + uv.getX(vertex2) * template.atlas.image.width) / page.width,
-                1 - (placement.y + (1 - uv.getY(vertex2)) * template.atlas.image.height) / page.height
+              uvs.push(mapU(uv.getX(vertex2)), mapV(uv.getY(vertex2)));
+              uvBounds.push(
+                mapU(bounds?.getX(vertex2) ?? 0),
+                mapV(bounds?.getY(vertex2) ?? 0),
+                mapU(bounds?.getZ(vertex2) ?? 1),
+                mapV(bounds?.getW(vertex2) ?? 1)
               );
               colors.push(color2?.getX(vertex2) ?? 1, color2?.getY(vertex2) ?? 1, color2?.getZ(vertex2) ?? 1);
             }
@@ -105699,11 +105776,12 @@ gl_FragDepth=readDepth(vUv);
         geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
         geometry.setAttribute("normal", new Float32BufferAttribute(normals, 3));
         geometry.setAttribute("uv", new Float32BufferAttribute(uvs, 2));
+        geometry.setAttribute("uvBounds", new Float32BufferAttribute(uvBounds, 4));
         geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
         geometry.setIndex(indices);
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
-        const material = Materials.createShadedCanvasMaterial(canvas, false);
+        const material = Materials.createShadedCanvasMaterial(canvas, false, false, true);
         material.vertexColors = true;
         const texture = material.uniforms?.map?.value ?? material.map;
         const mesh = new Mesh(geometry, material);