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

package/dist/browser/index.d.mts

@@ -291,7 +291,7 @@ declare class Materials {
      */
     static createEntityCanvasMaterial(canvas: HTMLCanvasElement, mode?: EntityRenderMode, tint?: ColorRepresentation): MeshBasicMaterial;
     static createGuiCanvasMaterial(canvas: HTMLCanvasElement): MeshBasicMaterial;
-    static createShadedCanvasMaterial(canvas: HTMLCanvasElement, transparent?: boolean, shade?: boolean): Material;
+    static createShadedCanvasMaterial(canvas: HTMLCanvasElement, transparent?: boolean, shade?: boolean, boundUvs?: boolean): Material;
     static getImage(key: MaterialKey): Material;
     static needsUpdate(mat: Material): void;
 }
@@ -693,6 +693,8 @@ declare class UVMapper {
     static setCubeUvs(geometry: BoxGeometry, originalTextureSize: DoubleArray, actualTextureSize: DoubleArray, faces: ModelFaces): void;
     static facesToUvArray(faces: ModelFaces, originalTextureSize: DoubleArray, actualTextureSize: DoubleArray): number[];
     static facesToUv(faces: ModelFaces, originalTextureSize: DoubleArray, actualTextureSize: DoubleArray): Float32BufferAttribute;
+    /** Bounds texture sampling to texel centres without changing cropped face UVs. */
+    static setAtlasUvBounds(geometry: BoxGeometry, faces: ModelFaces, atlas: TextureAtlas): void;
     static lockUvs(geometry: BoxGeometry, faces: ModelFaces, atlas: TextureAtlas, rotation: Euler): void;
     static getAtlas(model: Model): Promise<Maybe<TextureAtlas>>;
     static fillMissingTextureKeys<T>(textures: ModelTextures, target: {
@@ -2515,6 +2517,12 @@ declare class MineRenderWorld<SectionMeshing extends boolean = false> {
     private placeBlocks;
     /** Replaces one chunk column's blocks. Entity NBT remains available on the parsed chunk. */
     placeChunk(chunk: AnvilChunk, executor?: BatchedExecutor): Promise<void>;
+    /**
+     * 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.
+     */
+    unloadChunkColumn(x: number, z: number): Promise<void>;
+    private clearChunkColumn;
     clear(): Promise<void>;
     private updateCulling;
     private getOrCreateChunkAt;

package/dist/browser/index.d.ts

@@ -291,7 +291,7 @@ declare class Materials {
      */
     static createEntityCanvasMaterial(canvas: HTMLCanvasElement, mode?: EntityRenderMode, tint?: ColorRepresentation): MeshBasicMaterial;
     static createGuiCanvasMaterial(canvas: HTMLCanvasElement): MeshBasicMaterial;
-    static createShadedCanvasMaterial(canvas: HTMLCanvasElement, transparent?: boolean, shade?: boolean): Material;
+    static createShadedCanvasMaterial(canvas: HTMLCanvasElement, transparent?: boolean, shade?: boolean, boundUvs?: boolean): Material;
     static getImage(key: MaterialKey): Material;
     static needsUpdate(mat: Material): void;
 }
@@ -693,6 +693,8 @@ declare class UVMapper {
     static setCubeUvs(geometry: BoxGeometry, originalTextureSize: DoubleArray, actualTextureSize: DoubleArray, faces: ModelFaces): void;
     static facesToUvArray(faces: ModelFaces, originalTextureSize: DoubleArray, actualTextureSize: DoubleArray): number[];
     static facesToUv(faces: ModelFaces, originalTextureSize: DoubleArray, actualTextureSize: DoubleArray): Float32BufferAttribute;
+    /** Bounds texture sampling to texel centres without changing cropped face UVs. */
+    static setAtlasUvBounds(geometry: BoxGeometry, faces: ModelFaces, atlas: TextureAtlas): void;
     static lockUvs(geometry: BoxGeometry, faces: ModelFaces, atlas: TextureAtlas, rotation: Euler): void;
     static getAtlas(model: Model): Promise<Maybe<TextureAtlas>>;
     static fillMissingTextureKeys<T>(textures: ModelTextures, target: {
@@ -2515,6 +2517,12 @@ declare class MineRenderWorld<SectionMeshing extends boolean = false> {
     private placeBlocks;
     /** Replaces one chunk column's blocks. Entity NBT remains available on the parsed chunk. */
     placeChunk(chunk: AnvilChunk, executor?: BatchedExecutor): Promise<void>;
+    /**
+     * 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.
+     */
+    unloadChunkColumn(x: number, z: number): Promise<void>;
+    private clearChunkColumn;
     clear(): Promise<void>;
     private updateCulling;
     private getOrCreateChunkAt;

package/dist/browser/index.js

@@ -982,7 +982,7 @@ var init_Materials = __esm({
         };
         return material;
       }
-      static createShadedCanvasMaterial(canvas, transparent = false, shade = false) {
+      static createShadedCanvasMaterial(canvas, transparent = false, shade = false, boundUvs = false) {
         const vertShader = `
             uniform bool SHADE;
             
@@ -992,6 +992,10 @@ var init_Materials = __esm({
             #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;
@@ -1027,13 +1031,17 @@ var init_Materials = __esm({
                 }
                 
                 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;
                 
             }
         `;
@@ -1053,13 +1061,22 @@ var init_Materials = __esm({
             #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;
@@ -1080,7 +1097,8 @@ var init_Materials = __esm({
             }
         `;
         try {
-          return new import_three5.ShaderMaterial({
+          const material = new import_three5.ShaderMaterial({
+            defines: boundUvs ? { BOUND_UVS: true } : {},
             uniforms: {
               SHADE: { value: true },
               BRIGHTNESS: { value: 1 },
@@ -1098,6 +1116,8 @@ var init_Materials = __esm({
             side: transparent ? import_three5.DoubleSide : import_three5.FrontSide,
             alphaTest: 0.5
           });
+          Object.assign(material.defaultAttributeValues, { uvBounds: [0, 0, 1, 1] });
+          return material;
         } catch (e) {
           console.warn(e);
         }
@@ -2979,6 +2999,37 @@ var init_UVMapper = __esm({
       static facesToUv(faces, originalTextureSize, actualTextureSize) {
         return new import_three9.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 import_three9.Float32BufferAttribute(bounds, 4));
+      }
       static lockUvs(geometry, faces, atlas, rotation) {
         const uv = geometry.getAttribute("uv");
         for (let faceIndex = 0; faceIndex < CUBE_FACES.length; faceIndex++) {
@@ -5376,6 +5427,7 @@ var init_ModelObject = __esm({
               if (this.options.uvLockRotation) {
                 UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three25.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()) {
@@ -5441,7 +5493,7 @@ var init_ModelObject = __esm({
       }
       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) => {
@@ -15355,13 +15407,7 @@ var MineRenderWorld = class {
   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++) {
@@ -15381,6 +15427,31 @@ var MineRenderWorld = class {
       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(x, z) {
+    if (!Number.isInteger(x) || !Number.isInteger(z)) {
+      throw new RangeError("Chunk column coordinates must be integers");
+    }
+    await this.culling;
+    const changes = /* @__PURE__ */ new Map();
+    try {
+      await this.clearChunkColumn(x, z, changes);
+    } finally {
+      await this.updateCulling([...changes.values()]);
+    }
+  }
+  async clearChunkColumn(x, z, changes) {
+    const previous = [...this._chunks.entries()].filter(([, section]) => section.x === x && section.z === 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);
+      });
+    }
+  }
   async clear() {
     await this.culling;
     const chunks = [...this._chunks.values()];
@@ -15549,14 +15620,17 @@ var SectionMesh = class _SectionMesh extends import_three40.Group {
       for (const { atlas, x, y } of page.placements) {
         context.drawImage(atlas.image.canvas, x, y);
       }
-      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 color = template.geometry.getAttribute("color");
         const sourceIndices = template.geometry.getIndex();
         const placement = locations.get(template.atlas).placement;
+        const mapU = (u) => (placement.x + u * template.atlas.image.width) / page.width;
+        const mapV = (v) => 1 - (placement.y + (1 - v) * 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;
@@ -15567,9 +15641,12 @@ var SectionMesh = class _SectionMesh extends import_three40.Group {
             const vertex = face * 4 + corner;
             positions.push(position.getX(vertex) + offsetX, position.getY(vertex) + offsetY, position.getZ(vertex) + offsetZ);
             normals.push(normal.getX(vertex), normal.getY(vertex), normal.getZ(vertex));
-            uvs.push(
-              (placement.x + uv.getX(vertex) * template.atlas.image.width) / page.width,
-              1 - (placement.y + (1 - uv.getY(vertex)) * template.atlas.image.height) / page.height
+            uvs.push(mapU(uv.getX(vertex)), mapV(uv.getY(vertex)));
+            uvBounds.push(
+              mapU(bounds?.getX(vertex) ?? 0),
+              mapV(bounds?.getY(vertex) ?? 0),
+              mapU(bounds?.getZ(vertex) ?? 1),
+              mapV(bounds?.getW(vertex) ?? 1)
             );
             colors.push(color?.getX(vertex) ?? 1, color?.getY(vertex) ?? 1, color?.getZ(vertex) ?? 1);
           }
@@ -15580,11 +15657,12 @@ var SectionMesh = class _SectionMesh extends import_three40.Group {
       geometry.setAttribute("position", new import_three40.Float32BufferAttribute(positions, 3));
       geometry.setAttribute("normal", new import_three40.Float32BufferAttribute(normals, 3));
       geometry.setAttribute("uv", new import_three40.Float32BufferAttribute(uvs, 2));
+      geometry.setAttribute("uvBounds", new import_three40.Float32BufferAttribute(uvBounds, 4));
       geometry.setAttribute("color", new import_three40.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 import_three40.Mesh(geometry, material);