minerender 2.1.0-alpha.61 → 2.1.0-alpha.63

package/dist/browser/index.mjs

@@ -3236,11 +3236,11 @@ var init_Entities = __esm({
         return { ...layers[names[0]], id: model.id, layers, ...model.transform && { transform: model.transform } };
       }
       /**
-       * Vanilla's keyframe animations of a model by name, or undefined when the model or the selected version has none.
+       * Native and sampled vanilla clips by name, or undefined when the model or selected version has none.
        */
       static async getAnimations(modelKey) {
         const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
-        const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models/animations", ".json");
+        const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models/animations", ".json", isAssetKey(modelKey) ? modelKey.root : void 0);
         const file = await Caching.entityAnimationCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
         return file?.animations;
       }
@@ -3290,7 +3290,7 @@ function sampleEntityKeyframes(keyframes, time) {
   let low = 0, high = keyframes.length;
   while (low < high) {
     const middle = low + high >>> 1;
-    if (time <= keyframes[middle].time) high = middle;
+    if (time < keyframes[middle].time) high = middle;
     else low = middle + 1;
   }
   const a = Math.max(0, low - 1);
@@ -3329,6 +3329,7 @@ var init_EntityAnimation = __esm({
 });
 
 // src/entity/scene/EntityAnimationPlayer.ts
+import { Euler as Euler3, Vector3 as Vector35 } from "three";
 var ZERO, EntityAnimationPlayer;
 var init_EntityAnimationPlayer = __esm({
   "src/entity/scene/EntityAnimationPlayer.ts"() {
@@ -3348,25 +3349,45 @@ var init_EntityAnimationPlayer = __esm({
         return this._time;
       }
       /**
-       * Starts an animation on the named parts below each layer root. The current pose of a part becomes its default;
-       * bones without a matching part are skipped.
+       * Starts an animation on matching named parts. Supplied baked poses are the baseline for offsets;
+       * without them, the current pose is used. Stopping restores the pose from before playback.
        */
-      play(layers, animation, options = {}) {
+      play(layers, animation, options = {}, poses) {
         this.stop();
         this._animation = animation;
         this._time = options.time ?? 0;
         this.loop = options.loop ?? animation.loop;
         this.speed = options.speed ?? 1;
         for (const layer of layers) {
-          for (const bone of Object.keys(animation.bones)) {
-            const object = layer.getObjectByName(`group:${bone}`);
-            if (!object) continue;
-            this.parts.push({ bone, object, position: object.position.clone(), rotation: object.rotation.clone(), scale: object.scale.clone() });
+          const objects = [];
+          if (poses) {
+            layer.traverse((object) => {
+              if (poses.has(object)) objects.push(object);
+            });
+          } else {
+            for (const bone of Object.keys(animation.bones)) {
+              const object = layer.getObjectByName(`group:${bone}`);
+              if (object) objects.push(object);
+            }
+          }
+          for (const object of objects) {
+            const bone = object.name.slice("group:".length);
+            const pose = poses?.get(object);
+            this.parts.push({
+              bone,
+              object,
+              position: object.position.clone(),
+              rotation: object.rotation.clone(),
+              scale: object.scale.clone(),
+              basePosition: pose ? new Vector35(...pose.offset) : object.position.clone(),
+              baseRotation: pose ? new Euler3(...pose.rotation, "ZYX") : object.rotation.clone(),
+              baseScale: pose ? new Vector35(...pose.scale ?? [1, 1, 1]) : object.scale.clone()
+            });
           }
         }
         this.apply();
       }
-      /** Restores the default poses. Returns whether an animation was active. */
+      /** Restores the poses from before playback. Returns whether an animation was active. */
       stop() {
         if (!this._animation) return false;
         for (const part of this.parts) {
@@ -3395,10 +3416,10 @@ var init_EntityAnimationPlayer = __esm({
       apply() {
         const pose = sampleEntityAnimation(this._animation, this._time, this.loop);
         for (const part of this.parts) {
-          const { position = ZERO, rotation = ZERO, scale = ZERO } = pose[part.bone];
-          part.object.position.set(part.position.x + position[0], part.position.y + position[1], part.position.z + position[2]);
-          part.object.rotation.set(part.rotation.x + rotation[0], part.rotation.y + rotation[1], part.rotation.z + rotation[2], part.rotation.order);
-          part.object.scale.set(part.scale.x + scale[0], part.scale.y + scale[1], part.scale.z + scale[2]);
+          const { position = ZERO, rotation = ZERO, scale = ZERO } = pose[part.bone] ?? {};
+          part.object.position.set(part.basePosition.x + position[0], part.basePosition.y + position[1], part.basePosition.z + position[2]);
+          part.object.rotation.set(part.baseRotation.x + rotation[0], part.baseRotation.y + rotation[1], part.baseRotation.z + rotation[2], part.baseRotation.order);
+          part.object.scale.set(part.baseScale.x + scale[0], part.baseScale.y + scale[1], part.baseScale.z + scale[2]);
         }
       }
     };
@@ -3438,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);
       }
@@ -3465,7 +3489,7 @@ var init_InstanceReference = __esm({
 });
 
 // src/renderer/SceneObject.ts
-import { Color as Color2, Euler as Euler3, InstancedBufferAttribute, InstancedMesh, MathUtils, Matrix4 as Matrix44, Mesh as Mesh3, Object3D as Object3D2, Quaternion as Quaternion3, Vector3 as Vector35 } from "three";
+import { Color as Color2, Euler as Euler4, InstancedBufferAttribute, InstancedMesh, MathUtils, Matrix4 as Matrix44, Mesh as Mesh3, Object3D as Object3D2, Quaternion as Quaternion3, Vector3 as Vector36 } from "three";
 function isSceneObject(obj) {
   return obj.isSceneObject;
 }
@@ -3492,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);
       }
@@ -3686,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);
@@ -3718,23 +3744,51 @@ 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 Vector35();
+        const oldPosition = new Vector36();
         const oldRotation = new Quaternion3();
-        const oldScale = new Vector35();
+        const oldScale = new Vector36();
         const matrix = new Matrix44();
         if (!scale || !rotation || !position) {
           this.getMatrixAt(index, matrix).decompose(oldPosition, oldRotation, oldScale);
@@ -3750,7 +3804,7 @@ var init_SceneObject = __esm({
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         this.setPositionRotationScaleAt(index, position);
       }
-      getPositionAt(index, vector = new Vector35()) {
+      getPositionAt(index, vector = new Vector36()) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         const matrix = this.getMatrixAt(index);
         vector.setFromMatrixPosition(matrix);
@@ -3760,17 +3814,17 @@ var init_SceneObject = __esm({
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         this.setPositionRotationScaleAt(index, void 0, rotation, void 0);
       }
-      getRotationAt(index, euler = new Euler3()) {
+      getRotationAt(index, euler = new Euler4()) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         const rotation = new Quaternion3();
-        this.getMatrixAt(index).decompose(new Vector35(), rotation, new Vector35());
+        this.getMatrixAt(index).decompose(new Vector36(), rotation, new Vector36());
         return euler.setFromQuaternion(rotation);
       }
       setScaleAt(index, scale) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         this.setPositionRotationScaleAt(index, void 0, void 0, scale);
       }
-      getScaleAt(index, vector = new Vector35()) {
+      getScaleAt(index, vector = new Vector36()) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         const matrix = this.getMatrixAt(index);
         vector.setFromMatrixScale(matrix);
@@ -3869,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();
@@ -3902,7 +3957,7 @@ var init_SceneObject = __esm({
 });
 
 // src/entity/scene/EntityObject.ts
-import { Color as Color3, Euler as Euler4, Matrix4 as Matrix45, Object3D as Object3D3 } from "three";
+import { Color as Color3, Euler as Euler5, Matrix4 as Matrix45, Object3D as Object3D3 } from "three";
 function isEntityObject(obj) {
   return obj.isEntityObject;
 }
@@ -3932,7 +3987,8 @@ var init_EntityObject = __esm({
         this.scrollMaterials = [];
         /** Entity age in ticks, as vanilla's `ageInTicks`; drives the scrolling render modes. */
         this.age = 0;
-        this.animationPlayer = new EntityAnimationPlayer();
+        this.animationPlayers = [];
+        this.partPoses = /* @__PURE__ */ new Map();
         this.options = (0, import_ts_deepmerge4.default)({}, _EntityObject.DEFAULT_OPTIONS, options ?? {});
         this.addEventListener("added", () => this.updateScrollSubscription());
         this.addEventListener("removed", () => this.updateScrollSubscription());
@@ -3949,7 +4005,8 @@ var init_EntityObject = __esm({
         for (const geometry of this.geometries) geometry.dispose();
         this.geometries.clear();
         for (const dispose of this.disposeWireframes.splice(0)) dispose();
-        this.animationPlayer.clear();
+        for (const player of this.animationPlayers.splice(0)) player.clear();
+        this.partPoses.clear();
         super.disposeAndRemoveAllChildren();
       }
       clearScrollMaterials() {
@@ -3981,36 +4038,61 @@ var init_EntityObject = __esm({
         this.notifyDirty();
       }
       //<editor-fold desc="ANIMATION">
-      /** The animation started by {@link playAnimation}, until {@link stopAnimation} or disposal. */
+      /** The first active clip, until playback is stopped or the object is disposed. */
       get animation() {
-        return this.animationPlayer.animation;
+        return this.animationPlayers[0]?.animation;
+      }
+      /** Clips playing together, each targeting a separate geometry layer. */
+      get activeAnimations() {
+        return this.animationPlayers.map((player) => player.animation);
       }
       /** Seconds since the animation started, before looping. */
       get animationTime() {
-        return this.animationPlayer.time;
+        return this.animationPlayers[0]?.time ?? 0;
       }
       /**
-       * Poses the object from a keyframe animation of {@link Entities.getAnimations}, replacing the current one.
-       * Parts of every layer are matched by name and their current pose is the default the offsets add to.
+       * Plays a clip from {@link Entities.getAnimations}, replacing all active clips.
+       * Offsets apply to the baked pose in the clip's layer (`main` by default), including repeated draws of that layer.
        * The object owns no clock: call {@link advanceAnimation} per frame, or {@link setAnimationTime}.
        */
       playAnimation(animation, options) {
+        this.playAnimations([animation], options);
+      }
+      /** Plays one clip per selected geometry layer, with a shared clock and no blending between clips. */
+      playAnimations(animations, options) {
+        const targets = /* @__PURE__ */ new Set();
+        const selections = animations.map((animation) => {
+          const layer = animation.layer ?? "main";
+          if (targets.has(layer)) throw new Error(`Multiple animations target layer "${layer}"`);
+          targets.add(layer);
+          const names = Object.keys(this.entityLayers).filter((name) => name.split("#")[0] === layer);
+          if (!names.length) throw new Error(`Entity ${this.entity.id} has no selected animation layer "${layer}"`);
+          return { animation, names };
+        });
         this.createMeshes();
-        const layers = Object.keys(this.entityLayers).map((name) => this.getLayerGroup(name)).filter((layer) => !!layer);
-        this.animationPlayer.play(layers, animation, options);
+        this.stopAnimation();
+        for (const { animation, names } of selections) {
+          const player = new EntityAnimationPlayer();
+          player.play(names.map((name) => this.getLayerGroup(name)), animation, options, this.partPoses);
+          this.animationPlayers.push(player);
+        }
         this.notifyDirty();
       }
-      /** Stops the animation and restores the default pose. */
+      /** Stops all clips and restores the poses from before playback. */
       stopAnimation() {
-        if (this.animationPlayer.stop()) this.notifyDirty();
+        const players = this.animationPlayers.splice(0);
+        for (const player of players) player.stop();
+        if (players.length) this.notifyDirty();
       }
       /** Poses the object at an explicit time in seconds. Has no effect without an animation. */
       setAnimationTime(seconds) {
-        if (this.animationPlayer.setTime(seconds)) this.notifyDirty();
+        for (const player of this.animationPlayers) player.setTime(seconds);
+        if (this.animationPlayers.length) this.notifyDirty();
       }
       /** Advances the animation by a frame delta in seconds, scaled by its speed. Has no effect without an animation. */
       advanceAnimation(deltaSeconds) {
-        if (this.animationPlayer.advance(deltaSeconds)) this.notifyDirty();
+        for (const player of this.animationPlayers) player.advance(deltaSeconds);
+        if (this.animationPlayers.length) this.notifyDirty();
       }
       //</editor-fold>
       getLayerGroup(name) {
@@ -4049,7 +4131,7 @@ var init_EntityObject = __esm({
             const matrix = new Matrix45();
             if ("scale" in op) matrix.makeScale(...op.scale);
             else if ("translate" in op) matrix.makeTranslation(...op.translate);
-            else matrix.makeRotationFromEuler(new Euler4(...op.rotate, "ZYX"));
+            else matrix.makeRotationFromEuler(new Euler5(...op.rotate, "ZYX"));
             modelRoot.matrix.multiply(matrix);
           }
           modelRoot.matrixAutoUpdate = false;
@@ -4070,6 +4152,7 @@ var init_EntityObject = __esm({
         anchor.position.fromArray(part.pose.offset);
         anchor.rotation.set(...part.pose.rotation, "ZYX");
         anchor.scale.fromArray(part.pose.scale ?? [1, 1, 1]);
+        this.partPoses.set(anchor, part.pose);
         parent.add(anchor);
         const size = part.texture ?? textureSize;
         for (const cube of part.cubes) {
@@ -4146,7 +4229,7 @@ import {
   TriangleFanDrawMode,
   TriangleStripDrawMode,
   TrianglesDrawMode,
-  Vector3 as Vector39
+  Vector3 as Vector310
 } from "three";
 function computeTangents(geometry) {
   geometry.computeTangents();
@@ -4465,15 +4548,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new Vector39();
-  const _vB = new Vector39();
-  const _vC = new Vector39();
-  const _tempA = new Vector39();
-  const _tempB = new Vector39();
-  const _tempC = new Vector39();
-  const _morphA = new Vector39();
-  const _morphB = new Vector39();
-  const _morphC = new Vector39();
+  const _vA = new Vector310();
+  const _vB = new Vector310();
+  const _vC = new Vector310();
+  const _tempA = new Vector310();
+  const _tempB = new Vector310();
+  const _tempC = new Vector310();
+  const _morphA = new Vector310();
+  const _morphB = new Vector310();
+  const _morphC = new Vector310();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4683,7 +4766,7 @@ var init_BufferGeometryUtils = __esm({
 });
 
 // src/model/ModelCulling.ts
-import { Vector3 as Vector310 } from "three";
+import { Vector3 as Vector311 } from "three";
 var ModelCulling;
 var init_ModelCulling = __esm({
   "src/model/ModelCulling.ts"() {
@@ -4692,7 +4775,7 @@ var init_ModelCulling = __esm({
       static toLocalMask(worldMask, rotation) {
         let localMask = 0;
         for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
-          const normal = new Vector310(...offset).applyEuler(rotation);
+          const normal = new Vector311(...offset).applyEuler(rotation);
           const worldFace = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
           if (worldFace < 0) return 0;
           if (worldMask & 1 << worldFace) localMask |= 1 << localFace;
@@ -4919,7 +5002,7 @@ var init_ItemTints = __esm({
 });
 
 // src/model/scene/ModelObject.ts
-import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute5, Color as Color8, Euler as Euler6, Matrix4 as Matrix49 } from "three";
+import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute5, Color as Color8, Euler as Euler7, Matrix4 as Matrix49 } from "three";
 function isModelObject(obj) {
   return obj.isModelObject;
 }
@@ -5023,7 +5106,7 @@ var init_ModelObject = __esm({
                 elGeo.clearGroups();
               }
               if (this.options.uvLockRotation) {
-                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new Euler6(...this.options.uvLockRotation));
+                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new Euler7(...this.options.uvLockRotation));
               }
               if (this.options.tints) {
                 const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -5684,7 +5767,7 @@ import {
   Color as Color4,
   Matrix3,
   Vector2 as Vector22,
-  Vector3 as Vector36
+  Vector3 as Vector37
 } from "three";
 var OBJExporter = class {
   parse(object) {
@@ -5692,9 +5775,9 @@ var OBJExporter = class {
     let indexVertex = 0;
     let indexVertexUvs = 0;
     let indexNormals = 0;
-    const vertex = new Vector36();
+    const vertex = new Vector37();
     const color = new Color4();
-    const normal = new Vector36();
+    const normal = new Vector37();
     const uv = new Vector22();
     const face = [];
     function parseMesh(mesh) {
@@ -5823,7 +5906,7 @@ var OBJExporter = class {
 // ../../node_modules/three/examples/jsm/exporters/PLYExporter.js
 import {
   Matrix3 as Matrix32,
-  Vector3 as Vector37,
+  Vector3 as Vector38,
   Color as Color5
 } from "three";
 var PLYExporter = class {
@@ -5916,7 +5999,7 @@ property list uchar int vertex_index
 `;
     }
     header += "end_header\n";
-    const vertex = new Vector37();
+    const vertex = new Vector38();
     const normalMatrixWorld = new Matrix32();
     let result = null;
     if (options.binary === true) {
@@ -6115,7 +6198,7 @@ import {
   Source,
   SRGBColorSpace as SRGBColorSpace4,
   CompressedTexture,
-  Vector3 as Vector38,
+  Vector3 as Vector39,
   Quaternion as Quaternion4
 } from "three";
 
@@ -6576,7 +6659,7 @@ var GLTFWriter = class {
   isNormalizedNormalAttribute(normal) {
     const cache = this.cache;
     if (cache.attributesNormalized.has(normal)) return false;
-    const v = new Vector38();
+    const v = new Vector39();
     for (let i = 0, il = normal.count; i < il; i++) {
       if (Math.abs(v.fromBufferAttribute(normal, i).length() - 1) > 5e-4) return false;
     }
@@ -6593,7 +6676,7 @@ var GLTFWriter = class {
     const cache = this.cache;
     if (cache.attributesNormalized.has(normal)) return cache.attributesNormalized.get(normal);
     const attribute = normal.clone();
-    const v = new Vector38();
+    const v = new Vector39();
     for (let i = 0, il = attribute.count; i < il; i++) {
       v.fromBufferAttribute(attribute, i);
       if (v.x === 0 && v.y === 0 && v.z === 0) {
@@ -7860,9 +7943,9 @@ var GLTFMeshGpuInstancing = class {
     const rotationAttr = new Float32Array(mesh.count * 4);
     const scaleAttr = new Float32Array(mesh.count * 3);
     const matrix = new Matrix46();
-    const position = new Vector38();
+    const position = new Vector39();
     const quaternion = new Quaternion4();
-    const scale = new Vector38();
+    const scale = new Vector39();
     for (let i = 0; i < mesh.count; i++) {
       mesh.getMatrixAt(i, matrix);
       matrix.decompose(position, quaternion, scale);
@@ -8855,7 +8938,7 @@ init_SpecialItems();
 init_BlockStates();
 init_MineRenderError();
 init_util();
-import { Euler as Euler7 } from "three";
+import { Euler as Euler8 } from "three";
 function matchesCondition(condition, state) {
   return Object.entries(condition).every(([key, value]) => {
     if (Array.isArray(value)) {
@@ -8930,7 +9013,7 @@ var BlockStateResolver = class {
     return variants[variants.length - 1];
   }
   static rotation(variant) {
-    const rotation = new Euler7();
+    const rotation = new Euler8();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -9025,7 +9108,7 @@ var import_ts_deepmerge6 = __toESM(require_dist());
 init_MineRenderError();
 init_InstanceReference();
 init_AssetKey();
-import { Euler as Euler8, Matrix4 as Matrix411, Quaternion as Quaternion5, Vector3 as Vector311 } from "three";
+import { Euler as Euler9, Matrix4 as Matrix411, Quaternion as Quaternion5, Vector3 as Vector312 } from "three";
 init_ModelCulling();
 init_FluidGeometry();
 init_Entities();
@@ -9088,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.
@@ -9121,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() {
@@ -9130,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;
@@ -9143,12 +9245,12 @@ var _BlockObject = class _BlockObject extends SceneObject {
   getModelCullMask(model, worldMask) {
     const object = isInstanceReference(model) ? model.instanceable : model;
     if (object.options.displayPosition) return 0;
-    const position = new Vector311();
+    const position = new Vector312();
     const rotation = new Quaternion5();
-    const scale = new Vector311();
+    const scale = new Vector312();
     this.getModelMatrix(model).decompose(position, rotation, scale);
-    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new Vector311(1, 1, 1)) > 1e-10) return 0;
-    return ModelCulling.toLocalMask(worldMask, new Euler8().setFromQuaternion(rotation));
+    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new Vector312(1, 1, 1)) > 1e-10) return 0;
+    return ModelCulling.toLocalMask(worldMask, new Euler9().setFromQuaternion(rotation));
   }
   async setCullMask(worldMask) {
     worldMask &= 63;
@@ -9185,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() {
@@ -9220,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() {
@@ -9248,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);
@@ -12398,7 +12507,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera as PerspectiveCamera2, SRGBColorSpace as SRGBColorSpace6, Vector3 as Vector313, WebGLRenderer as WebGLRenderer2 } from "three";
+import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera as PerspectiveCamera2, SRGBColorSpace as SRGBColorSpace6, Vector3 as Vector314, WebGLRenderer as WebGLRenderer2 } from "three";
 var import_ts_deepmerge9 = __toESM(require_dist());
 init_util();
 init_Model();
@@ -12414,7 +12523,7 @@ import {
   Spherical,
   TOUCH,
   Vector2 as Vector25,
-  Vector3 as Vector312
+  Vector3 as Vector313
 } from "three";
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
@@ -12428,7 +12537,7 @@ var OrbitControls = class extends EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new Vector312();
+    this.target = new Vector313();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -12480,10 +12589,10 @@ var OrbitControls = class extends EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new Vector312();
-      const quat = new Quaternion6().setFromUnitVectors(object.up, new Vector312(0, 1, 0));
+      const offset = new Vector313();
+      const quat = new Quaternion6().setFromUnitVectors(object.up, new Vector313(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new Vector312();
+      const lastPosition = new Vector313();
       const lastQuaternion = new Quaternion6();
       const twoPI = 2 * Math.PI;
       return function update() {
@@ -12573,7 +12682,7 @@ var OrbitControls = class extends EventDispatcher {
     const spherical = new Spherical();
     const sphericalDelta = new Spherical();
     let scale = 1;
-    const panOffset = new Vector312();
+    const panOffset = new Vector313();
     let zoomChanged = false;
     const rotateStart = new Vector25();
     const rotateEnd = new Vector25();
@@ -12599,7 +12708,7 @@ var OrbitControls = class extends EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new Vector312();
+      const v = new Vector313();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -12607,7 +12716,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new Vector312();
+      const v = new Vector313();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -12620,7 +12729,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new Vector312();
+      const offset = new Vector313();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -13437,8 +13546,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
       top: void 0,
       bottom: void 0
     },
-    position: new Vector313(50, 50, 50),
-    lookingAt: new Vector313(0, 0, 0)
+    position: new Vector314(50, 50, 50),
+    lookingAt: new Vector314(0, 0, 0)
   },
   render: {
     fpsLimit: 60,
@@ -13903,13 +14012,13 @@ var AnvilParser = class {
 };
 
 // src/world/Chunk.ts
-import { Vector3 as Vector316 } from "three";
+import { Vector3 as Vector317 } from "three";
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
 init_Model();
-import { Vector3 as Vector315 } from "three";
+import { Vector3 as Vector316 } from "three";
 init_BatchedExecutor();
 init_AssetKey();
 init_BlockStates();
@@ -13919,7 +14028,7 @@ init_CubeFace();
 init_AssetKey();
 init_Models();
 init_CubeFace();
-import { Matrix4 as Matrix412, Vector3 as Vector314 } from "three";
+import { Matrix4 as Matrix412, Vector3 as Vector315 } from "three";
 init_ModelCulling();
 init_ModelObject();
 init_UVMapper();
@@ -13987,7 +14096,7 @@ var SectionModels = class {
         const cullFaces = CUBE_FACES.map((face) => {
           const local = CUBE_FACES.findIndex((name) => name === atlas.model.elements[0].faces[face]?.cullface);
           if (local < 0) return 0;
-          const normal = new Vector314(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+          const normal = new Vector315(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
           const world = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
           return 1 << world;
         });
@@ -14017,20 +14126,20 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector315(posOrX, y, z));
+      return this.getBlockAt(new Vector316(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector315(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector316(posOrX[0], posOrX[1], posOrX[2]));
     }
     this.validatePosBounds(posOrX);
     return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector315(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector316(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector315(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector316(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -14039,6 +14148,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 {
@@ -14051,7 +14170,7 @@ var MineRenderWorld = class {
     const collect = async (positions2) => {
       for (const pos of positions2) changes.set(pos.toArray().join(","), pos);
     };
-    const place = (block) => this.placeBlock(new Vector315(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new Vector316(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     for (const block of multiblock.blocks) {
       if (Chunk.isAir(block)) continue;
@@ -14129,13 +14248,13 @@ var MineRenderWorld = class {
     for (const pos of positions) {
       this.pendingCulling.set(pos.toArray().join(","), pos.clone());
       for (const offset of CUBE_FACE_OFFSETS) {
-        const neighbor = pos.clone().add(new Vector315(...offset));
+        const neighbor = pos.clone().add(new Vector316(...offset));
         this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
       }
       for (let y = -1; y <= 1; y++) {
         for (let z = -1; z <= 1; z++) {
           for (let x = -1; x <= 1; x++) {
-            const neighbor = pos.clone().add(new Vector315(x, y, z));
+            const neighbor = pos.clone().add(new Vector316(x, y, z));
             if (this.getBlockAt(neighbor)?.object?.fluidKind) {
               this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
             }
@@ -14154,12 +14273,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 Vector315(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,
@@ -14169,7 +14290,7 @@ var MineRenderWorld = class {
             }
             let mask = 0;
             for (const [face, offset] of CUBE_FACE_OFFSETS.entries()) {
-              const neighbor = pos.clone().add(new Vector315(...offset));
+              const neighbor = pos.clone().add(new Vector316(...offset));
               if (this.getChunkAt(neighbor)?.isOccludingAt(neighbor)) {
                 mask |= 1 << face;
               }
@@ -14203,14 +14324,14 @@ var MineRenderWorld = class {
     return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
-    return new Vector315(
+    return new Vector316(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new Vector315(
+    return new Vector316(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -14346,6 +14467,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;
@@ -14354,10 +14476,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector316(posOrX, y, z));
+      return this.getBlockAt(new Vector317(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector316(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector317(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -14365,10 +14487,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector316(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector317(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector316(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector317(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -14383,6 +14505,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();
@@ -14424,9 +14547,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));
@@ -14442,7 +14587,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) {
@@ -14454,7 +14602,7 @@ var Chunk = class _Chunk {
   }
   async clear(onBlocksChanged = this.onBlocksChanged) {
     const positions = [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new Vector316(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new Vector317(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     ));
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
@@ -14462,6 +14610,7 @@ var Chunk = class _Chunk {
     this.sectionMesh = void 0;
     this.meshDirty = false;
     this.renderedBlocks.clear();
+    this.hiddenBlocks.clear();
     this.data.clear();
     await onBlocksChanged?.(positions);
   }
@@ -14478,14 +14627,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new Vector316(
+    return new Vector317(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new Vector316(
+    return new Vector317(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z