minerender 2.1.0-alpha.62 → 2.1.0-alpha.64

package/dist/bundle.js

@@ -79155,6 +79155,9 @@ ${key}` : key;
         setMatrix(matrix) {
           this.activeInstanceable.setMatrixAt(this.index, matrix);
         }
+        setVisible(visible) {
+          this.activeInstanceable.setInstanceVisibleAt(this.index, visible);
+        }
         setPositionRotationScale(position, rotation, scale) {
           this.activeInstanceable.setPositionRotationScaleAt(this.index, position, rotation, scale);
         }
@@ -79212,6 +79215,7 @@ ${key}` : key;
           this._instanceCounter = 0;
           this.instanceReferences = /* @__PURE__ */ new Map();
           this.freeInstanceIndices = [];
+          this.hiddenInstanceMatrices = /* @__PURE__ */ new Map();
           this.options = (0, import_ts_deepmerge3.default)({}, _SceneObject.DEFAULT_OPTIONS, options ?? {});
           console.log("SceneObject options", this.options);
         }
@@ -79406,6 +79410,7 @@ ${key}` : key;
         removeInstanceAt(index) {
           if (!this.instanceReferences.has(index)) return;
           const mesh = this.instanceMesh;
+          this.hiddenInstanceMatrices.delete(index);
           this.setMatrixAt(index, new Matrix4().makeScale(0, 0, 0));
           this.instanceReferences.delete(index);
           this.freeInstanceIndices.push(index);
@@ -79438,18 +79443,46 @@ ${key}` : key;
         //<editor-fold desc="TRANSFORMATION">
         getMatrixAt(index, matrix = new Matrix4()) {
           if (!this.instanceReferences.has(index)) throw new MineRenderError("Instance is not active");
+          const hidden = this.hiddenInstanceMatrices.get(index);
+          if (hidden) {
+            return matrix.copy(hidden);
+          }
           this.instanceMesh.getMatrixAt(index, matrix);
           return matrix;
         }
         setMatrixAt(index, matrix) {
           if (!this.instanceReferences.has(index)) throw new MineRenderError("Instance is not active");
           const mesh = this.instanceMesh;
-          mesh.setMatrixAt(index, matrix);
+          const hidden = this.hiddenInstanceMatrices.get(index);
+          if (hidden) {
+            hidden.copy(matrix);
+          }
+          mesh.setMatrixAt(index, hidden ? new Matrix4().makeScale(0, 0, 0) : matrix);
           mesh.instanceMatrix.needsUpdate = true;
           mesh.boundingBox = null;
           mesh.boundingSphere = null;
           this.notifyDirty();
         }
+        setInstanceVisibleAt(index, visible) {
+          if (!this.instanceReferences.has(index)) {
+            throw new MineRenderError("Instance is not active");
+          }
+          const hidden = this.hiddenInstanceMatrices.get(index);
+          if (visible) {
+            if (!hidden) {
+              return;
+            }
+            this.hiddenInstanceMatrices.delete(index);
+            this.setMatrixAt(index, hidden);
+          } else {
+            if (hidden) {
+              return;
+            }
+            const matrix = this.getMatrixAt(index);
+            this.hiddenInstanceMatrices.set(index, matrix);
+            this.setMatrixAt(index, matrix);
+          }
+        }
         setPositionRotationScaleAt(index, position, rotation, scale) {
           if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
           const oldPosition = new Vector3();
@@ -79589,6 +79622,7 @@ ${key}` : key;
             if (this._scene) this._scene.stats.instanceCount -= this.instanceReferences.size;
             this.instanceReferences.clear();
             this.freeInstanceIndices.length = 0;
+            this.hiddenInstanceMatrices.clear();
             this._instanceCounter = 0;
             this.instanceMesh.count = 0;
             this.instanceMesh.dispose();
@@ -88039,6 +88073,21 @@ property list uchar int vertex_index
     get blockEntities() {
       return this._entities;
     }
+    /** Sets visibility for this block's model instances and block entities. */
+    setVisible(visible) {
+      this.visible = visible;
+      for (const model of this._models) {
+        if (isInstanceReference(model)) {
+          model.setVisible(visible);
+        } else {
+          model.visible = visible;
+        }
+      }
+      for (const entity of this._entities) {
+        entity.visible = visible;
+      }
+      this.notifyDirty();
+    }
     /**
      * Draws the block through the dataset's block-entity index. Returns false, leaving nothing behind,
      * when the block is not listed or one of its models cannot be loaded.
@@ -88072,6 +88121,7 @@ property list uchar int vertex_index
       BlockEntities.matrix(resolved, this._entityPlacement);
       this._entities = created;
       this.placeEntities();
+      this.setVisible(this.visible);
       return true;
     }
     placeEntities() {
@@ -88081,6 +88131,9 @@ property list uchar int vertex_index
       }
     }
     get isOccluding() {
+      if (!this.visible) {
+        return false;
+      }
       return this._models.some((model) => {
         const object = isInstanceReference(model) ? model.instanceable : model;
         return object.isOpaqueFullCube && this.getModelCullMask(model, 63) === 63;
@@ -88136,6 +88189,9 @@ property list uchar int vertex_index
       this._models = replacements;
       this._cullMask = worldMask;
       this.removeModels(previous.filter((model) => !replacements.includes(model)));
+      if (!this.visible) {
+        this.setVisible(false);
+      }
       this.notifyDirty();
     }
     get state() {
@@ -88171,6 +88227,9 @@ property list uchar int vertex_index
       this._isInstanced || (this._isInstanced = isInstanceReference(replacement));
       this._instanceCounter = this._isInstanced ? 1 : 0;
       if (previous) this.removeModels([previous]);
+      if (!this.visible) {
+        this.setVisible(false);
+      }
       this.notifyDirty();
     }
     nextInstance() {
@@ -88199,6 +88258,7 @@ property list uchar int vertex_index
         this._models.push(await this.createVariant(blockStateVariant));
       }
       await this.updateFluid(this._fluidSampler);
+      this.setVisible(this.visible);
     }
     async hasGeometry(variant) {
       const modelKey = AssetKey.parse("models", variant.model);
@@ -90052,7 +90112,11 @@ property list uchar int vertex_index
 
   // src/model/multiblock/SchematicParser.ts
   var SchematicParser = class {
-    static async parse(nbt) {
+    /**
+     * Parses a legacy schematic using custom mappings before the bundled defaults.
+     * Keys are `id:metadata`; values are block states such as `minecraft:oak_log[axis=x]`.
+     */
+    static async parse(nbt, customMappings = {}) {
       const tags = nbt.value;
       if (tags.Materials?.type !== "string" || tags.Materials.value !== "Alpha") {
         throw new MineRenderError("Schematic Materials must be Alpha");
@@ -90094,15 +90158,16 @@ property list uchar int vertex_index
         const high = packed >> (index & 1) * 4 & 15;
         const id = high << 8 | ids.value[index] & 255;
         const metadata = data.value[index] & 255;
-        const mapped = mapping[`${id}:${metadata}`];
+        const key = `${id}:${metadata}`;
+        const mapped = customMappings[key] ?? mapping[key];
         if (!mapped) throw new MineRenderError(`Unsupported legacy block ${id}:${metadata} at schematic index ${index}`);
         const [type, state] = mapped.split("[");
         if (type === "minecraft:air") continue;
         const properties = {};
         if (state) {
           for (const property of state.slice(0, -1).split(",")) {
-            const [key, value] = property.split("=");
-            properties[key] = value;
+            const [key2, value] = property.split("=");
+            properties[key2] = value;
           }
         }
         blocks.push({
@@ -94859,6 +94924,16 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       const chunk = Chunk.isAir(value) ? this.getChunkAt(pos) : this.getOrCreateChunkAt(pos);
       return chunk?.setBlockInChunkAt(chunk.worldPosToChunkPos(pos), value, pos, onBlocksChanged);
     }
+    async setBlockVisibleAt(posOrX, yOrVisible, z4, visible) {
+      if (typeof posOrX === "number") {
+        return this.setBlockVisibleAt(new Vector3(posOrX, yOrVisible, z4), visible);
+      }
+      if (isTripleArray(posOrX)) {
+        return this.setBlockVisibleAt(new Vector3(...posOrX), yOrVisible);
+      }
+      this.validatePosBounds(posOrX);
+      await this.getChunkAt(posOrX)?.setBlockVisibleAt(posOrX, yOrVisible);
+    }
     async placeMultiBlock(multiblock, useBatches = true, executor) {
       const changes = /* @__PURE__ */ new Map();
       try {
@@ -94974,12 +95049,14 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
               if (!chunk) continue;
               changed.add(chunk);
               const block = chunk.getBlockAt(pos);
-              if (!block) continue;
+              if (!block || !chunk.isBlockVisibleAt(pos)) {
+                continue;
+              }
               if (block.object?.fluidKind) {
                 await block.object.updateFluid((x4, y5, z4) => {
                   const neighbor = pos.clone().add(new Vector3(x4, y5, z4));
                   const section = this.getChunkAt(neighbor);
-                  const object = section?.getBlockAt(neighbor)?.object;
+                  const object = section?.isBlockVisibleAt(neighbor) ? section.getBlockAt(neighbor)?.object : void 0;
                   return {
                     fluid: object?.fluidKind,
                     level: object?.fluidLevel,
@@ -95169,6 +95246,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       this.data = new ChunkData();
       this.renderedBlocks = /* @__PURE__ */ new Map();
       this.sectionBlocks = /* @__PURE__ */ new Map();
+      this.hiddenBlocks = /* @__PURE__ */ new Set();
       this.meshDirty = false;
       this.scene = scene;
       this.x = x4;
@@ -95206,6 +95284,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
         worldPos = this.chunkPosToWorldPos(pos);
       }
       const index = _Chunk.chunkPosToBlockIndex(pos);
+      this.hiddenBlocks.delete(index);
       this.data.set(index, block);
       const readBlock = this.data.snapshot(index);
       this.renderedBlocks.get(index)?.object?.removeFromScene();
@@ -95247,9 +95326,31 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
         await onBlocksChanged?.([worldPos]);
       }
     }
+    async setBlockVisibleAt(pos, visible) {
+      const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
+      const block = this.renderedBlocks.get(index);
+      if (!block || visible === !this.hiddenBlocks.has(index)) {
+        return;
+      }
+      if (visible) {
+        this.hiddenBlocks.delete(index);
+      } else {
+        this.hiddenBlocks.add(index);
+      }
+      block.object?.setVisible(visible);
+      if (this.sectionBlocks.has(index)) {
+        this.meshDirty = true;
+      }
+      this.scene.dirty = true;
+      await this.onBlocksChanged?.([pos]);
+    }
+    isBlockVisibleAt(pos) {
+      const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
+      return this.renderedBlocks.has(index) && !this.hiddenBlocks.has(index);
+    }
     isOccludingAt(pos) {
       const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
-      return this.sectionBlocks.has(index) || (this.renderedBlocks.get(index)?.object?.isOccluding ?? false);
+      return !this.hiddenBlocks.has(index) && (this.sectionBlocks.has(index) || (this.renderedBlocks.get(index)?.object?.isOccluding ?? false));
     }
     async setCullMaskAt(pos, mask) {
       const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
@@ -95265,7 +95366,10 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
     }
     rebuildSectionMesh() {
       if (!this.meshDirty) return;
-      const next = this.sectionBlocks.size ? SectionMesh.build([...this.sectionBlocks.values()], this.sectionModels.maxAtlasSize) : void 0;
+      const next = this.sectionBlocks.size ? SectionMesh.build(
+        [...this.sectionBlocks.values()].filter((entry) => !this.hiddenBlocks.has(entry.index)),
+        this.sectionModels.maxAtlasSize
+      ) : void 0;
       this.sectionMesh?.dispose();
       this.sectionMesh = next;
       if (next) {
@@ -95285,6 +95389,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       this.sectionMesh = void 0;
       this.meshDirty = false;
       this.renderedBlocks.clear();
+      this.hiddenBlocks.clear();
       this.data.clear();
       await onBlocksChanged?.(positions);
     }