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

package/dist/bundle.js

@@ -78923,11 +78923,11 @@ ${key}` : key;
           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;
         }
@@ -78977,7 +78977,7 @@ ${key}` : key;
     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 a4 = Math.max(0, low - 1);
@@ -79025,6 +79025,7 @@ ${key}` : key;
       init_dirname();
       init_buffer2();
       init_process2();
+      init_three_module();
       init_EntityAnimation();
       ZERO = [0, 0, 0];
       EntityAnimationPlayer = class {
@@ -79041,25 +79042,45 @@ ${key}` : key;
           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 Vector3(...pose.offset) : object.position.clone(),
+                baseRotation: pose ? new Euler(...pose.rotation, "ZYX") : object.rotation.clone(),
+                baseScale: pose ? new Vector3(...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) {
@@ -79088,10 +79109,10 @@ ${key}` : key;
         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]);
           }
         }
       };
@@ -79134,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);
         }
@@ -79191,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);
         }
@@ -79385,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);
@@ -79417,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();
@@ -79568,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();
@@ -79634,7 +79689,8 @@ ${key}` : key;
           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());
@@ -79651,7 +79707,8 @@ ${key}` : key;
           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() {
@@ -79683,36 +79740,61 @@ ${key}` : key;
           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((name2) => name2.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((name2) => this.getLayerGroup(name2)).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((name2) => this.getLayerGroup(name2)), 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(name2) {
@@ -79772,6 +79854,7 @@ ${key}` : key;
           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) {
@@ -87990,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.
@@ -88023,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() {
@@ -88032,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;
@@ -88087,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() {
@@ -88122,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() {
@@ -88150,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);
@@ -94810,6 +94919,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 {
@@ -94925,12 +95044,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,
@@ -95120,6 +95241,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;
@@ -95157,6 +95279,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();
@@ -95198,9 +95321,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));
@@ -95216,7 +95361,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) {
@@ -95236,6 +95384,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);
     }