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

package/dist/browser/index.mjs

@@ -3459,6 +3459,9 @@ var init_InstanceReference = __esm({
       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);
       }
@@ -3513,6 +3516,7 @@ var init_SceneObject = __esm({
         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);
       }
@@ -3707,6 +3711,7 @@ var init_SceneObject = __esm({
       removeInstanceAt(index) {
         if (!this.instanceReferences.has(index)) return;
         const mesh = this.instanceMesh;
+        this.hiddenInstanceMatrices.delete(index);
         this.setMatrixAt(index, new Matrix44().makeScale(0, 0, 0));
         this.instanceReferences.delete(index);
         this.freeInstanceIndices.push(index);
@@ -3739,18 +3744,46 @@ var init_SceneObject = __esm({
       //<editor-fold desc="TRANSFORMATION">
       getMatrixAt(index, matrix = new Matrix44()) {
         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 Matrix44().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 Vector36();
@@ -3890,6 +3923,7 @@ var init_SceneObject = __esm({
           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();
@@ -9137,6 +9171,21 @@ var _BlockObject = class _BlockObject extends SceneObject {
   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.
@@ -9170,6 +9219,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     BlockEntities.matrix(resolved, this._entityPlacement);
     this._entities = created;
     this.placeEntities();
+    this.setVisible(this.visible);
     return true;
   }
   placeEntities() {
@@ -9179,6 +9229,9 @@ var _BlockObject = class _BlockObject extends SceneObject {
     }
   }
   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;
@@ -9234,6 +9287,9 @@ var _BlockObject = class _BlockObject extends SceneObject {
     this._models = replacements;
     this._cullMask = worldMask;
     this.removeModels(previous.filter((model) => !replacements.includes(model)));
+    if (!this.visible) {
+      this.setVisible(false);
+    }
     this.notifyDirty();
   }
   get state() {
@@ -9269,6 +9325,9 @@ var _BlockObject = class _BlockObject extends SceneObject {
     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() {
@@ -9297,6 +9356,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
       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);
@@ -11134,7 +11194,11 @@ var legacyBlocks_default = {
 
 // 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");
@@ -11176,15 +11240,16 @@ var SchematicParser = class {
       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({
@@ -14088,6 +14153,16 @@ var MineRenderWorld = class {
     const chunk = Chunk.isAir(value) ? this.getChunkAt(pos) : this.getOrCreateChunkAt(pos);
     return chunk?.setBlockInChunkAt(chunk.worldPosToChunkPos(pos), value, pos, onBlocksChanged);
   }
+  async setBlockVisibleAt(posOrX, yOrVisible, z, visible) {
+    if (typeof posOrX === "number") {
+      return this.setBlockVisibleAt(new Vector316(posOrX, yOrVisible, z), visible);
+    }
+    if (isTripleArray(posOrX)) {
+      return this.setBlockVisibleAt(new Vector316(...posOrX), yOrVisible);
+    }
+    this.validatePosBounds(posOrX);
+    await this.getChunkAt(posOrX)?.setBlockVisibleAt(posOrX, yOrVisible);
+  }
   async placeMultiBlock(multiblock, useBatches = true, executor) {
     const changes = /* @__PURE__ */ new Map();
     try {
@@ -14203,12 +14278,14 @@ var MineRenderWorld = class {
             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((x, y, z) => {
                 const neighbor = pos.clone().add(new Vector316(x, y, z));
                 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,
@@ -14395,6 +14472,7 @@ var Chunk = class _Chunk {
     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 = x;
@@ -14432,6 +14510,7 @@ var Chunk = class _Chunk {
       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();
@@ -14473,9 +14552,31 @@ var Chunk = class _Chunk {
       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));
@@ -14491,7 +14592,10 @@ var Chunk = class _Chunk {
   }
   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) {
@@ -14511,6 +14615,7 @@ var Chunk = class _Chunk {
     this.sectionMesh = void 0;
     this.meshDirty = false;
     this.renderedBlocks.clear();
+    this.hiddenBlocks.clear();
     this.data.clear();
     await onBlocksChanged?.(positions);
   }