minerender 2.1.0-alpha.54 → 2.1.0-alpha.59

package/dist/bundle.js

@@ -32176,7 +32176,9 @@ var MineRender = (() => {
             this.defaultBlockStatesCache,
             this.blockTintCache,
             this.entityModelCache,
-            this.entityTextureCache
+            this.entityTextureCache,
+            this.entityAnimationCache,
+            this.blockEntityIndexCache
           ];
         }
         static clear() {
@@ -32221,6 +32223,8 @@ var MineRender = (() => {
       _Caching.blockTintCache = _Caching.createAssetCache();
       _Caching.entityModelCache = _Caching.createAssetCache();
       _Caching.entityTextureCache = _Caching.createAssetCache();
+      _Caching.entityAnimationCache = _Caching.createAssetCache();
+      _Caching.blockEntityIndexCache = _Caching.createAssetCache();
       Caching = _Caching;
     }
   });
@@ -34072,6 +34076,11 @@ var MineRender = (() => {
     mesh.add(wireframe);
     let axes = new AxesHelper(1);
     mesh.add(axes);
+    return () => {
+      wireGeo.dispose();
+      wireMat.dispose();
+      axes.dispose();
+    };
   }
   var init_model = __esm({
     "src/util/model.ts"() {
@@ -83042,6 +83051,7 @@ ${key}` : key;
     BUILTIN_GENERATED: () => BUILTIN_GENERATED,
     BasicAssetKey: () => BasicAssetKey,
     BatchedExecutor: () => BatchedExecutor,
+    BlockEntities: () => BlockEntities,
     BlockObject: () => BlockObject,
     BlockStateResolver: () => BlockStateResolver,
     BlockStates: () => BlockStates,
@@ -83065,7 +83075,9 @@ ${key}` : key;
     DefaultBlockStates: () => DefaultBlockStates,
     DisplayPosition: () => DisplayPosition,
     DisplayTransforms: () => DisplayTransforms,
+    ENTITY_ANIMATION_CHANNELS: () => ENTITY_ANIMATION_CHANNELS,
     Entities: () => Entities,
+    EntityAnimationPlayer: () => EntityAnimationPlayer,
     EntityObject: () => EntityObject,
     Env: () => Env,
     FluidModelObject: () => FluidModelObject,
@@ -83139,6 +83151,7 @@ ${key}` : key;
     createCanvas: () => createCanvas,
     createFluidGeometry: () => createFluidGeometry,
     createImage: () => createImage,
+    entityAnimationTime: () => entityAnimationTime,
     estimateBytesUsed: () => estimateBytesUsed,
     getBlockFluidState: () => getBlockFluidState,
     getFluidKind: () => getFluidKind,
@@ -83172,6 +83185,8 @@ ${key}` : key;
     prefix: () => prefix,
     probeImageSize: () => probeImageSize,
     registerBrowserEnv: () => registerBrowserEnv,
+    sampleEntityAnimation: () => sampleEntityAnimation,
+    sampleEntityKeyframes: () => sampleEntityKeyframes,
     sampleFluid: () => sampleFluid,
     serializeBoxGeometryKey: () => serializeBoxGeometryKey,
     serializeImageKey: () => serializeImageKey,
@@ -83543,6 +83558,62 @@ ${key}` : key;
   init_AssetKey();
   init_AssetLoader();
   init_Assets();
+
+  // src/assets/BlockEntities.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_three_module();
+  init_AssetKey();
+  init_AssetLoader();
+  init_source();
+  init_Caching();
+  var BlockEntities = class {
+    /**
+     * Loads the block index of a version. Versions and sources without one yield an empty index, and so does
+     * a failed load: the index is optional, and blocks must not retry or fail with it one by one. The empty
+     * result is cached like any other; `Caching.clear()` or `AssetLoader.setVersion()` forces a new attempt.
+     */
+    static async getIndex(root) {
+      const key = new AssetKey("entity-models", "blocks", void 0, void 0, void 0, ".json", root);
+      key.rootType = void 0;
+      const index = await Caching.blockEntityIndexCache.get(key.serialize(), async () => {
+        try {
+          return await AssetLoader.get(key, "json" /* JSON */) ?? {};
+        } catch (error) {
+          console.warn("Could not load the block entity index; block entities are drawn as plain block models", error);
+          return {};
+        }
+      });
+      return index ?? {};
+    }
+    /** The index entry of a block ID such as `minecraft:chest`. */
+    static entry(index, block) {
+      const entry = Object.prototype.hasOwnProperty.call(index, block) ? index[block] : void 0;
+      return Array.isArray(entry?.parts) ? entry : void 0;
+    }
+    /** Selects the parts and placement for a block ID such as `minecraft:chest`; undefined when nothing is drawn. */
+    static resolve(index, block, state = {}) {
+      const entry = this.entry(index, block);
+      if (!entry) return void 0;
+      const value = (property) => String(state[property]).toLowerCase();
+      const parts = entry.parts.filter((part) => Object.entries(part.when ?? {}).every(([property, values]) => String(values).split("|").includes(value(property))));
+      if (!parts.length) return void 0;
+      let rotation = 0;
+      if (entry.rotation) {
+        const selected = value(entry.rotation.property);
+        rotation = "degrees" in entry.rotation ? entry.rotation.degrees[selected] : Number(selected) * entry.rotation.step;
+        if (!Number.isFinite(rotation)) rotation = 0;
+      }
+      return { parts, rotation, translation: entry.translation ?? [0, 0, 0] };
+    }
+    /** Placement in block space (0..16 per axis), applied on top of the model's own transform. */
+    static matrix(resolved, matrix = new Matrix4()) {
+      return matrix.makeTranslation(8, 0, 8).multiply(new Matrix4().makeRotationY(resolved.rotation * Math.PI / 180)).multiply(new Matrix4().makeTranslation(resolved.translation[0] - 8, resolved.translation[1], resolved.translation[2] - 8));
+    }
+  };
+
+  // src/assets/index.ts
   init_BlockStates();
 
   // src/assets/Entities.ts
@@ -83616,6 +83687,15 @@ ${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.
+     */
+    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 file = await Caching.entityAnimationCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
+      return file?.animations;
+    }
     static async resolveTexture(modelKey) {
       const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
       const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json");
@@ -83731,6 +83811,51 @@ ${key}` : key;
   init_buffer2();
   init_process2();
 
+  // src/entity/EntityAnimation.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  var ENTITY_ANIMATION_CHANNELS = ["position", "rotation", "scale"];
+  function catmullRom(delta, p0, p1, p22, p32) {
+    return 0.5 * (2 * p1 + (p22 - p0) * delta + (2 * p0 - 5 * p1 + 4 * p22 - p32) * delta * delta + (3 * p1 - p0 - 3 * p22 + p32) * delta * delta * delta);
+  }
+  function sampleEntityKeyframes(keyframes, time) {
+    if (keyframes.length === 0) return [0, 0, 0];
+    let low = 0, high = keyframes.length;
+    while (low < high) {
+      const middle = low + high >>> 1;
+      if (time <= keyframes[middle].time) high = middle;
+      else low = middle + 1;
+    }
+    const a4 = Math.max(0, low - 1);
+    const b4 = Math.min(keyframes.length - 1, a4 + 1);
+    const from = keyframes[a4];
+    const to = keyframes[b4];
+    const delta = a4 === b4 ? 0 : Math.min(1, Math.max(0, (time - from.time) / (to.time - from.time)));
+    if (to.interpolation === "catmullrom") {
+      const before = keyframes[Math.max(0, a4 - 1)].value;
+      const after = keyframes[Math.min(keyframes.length - 1, b4 + 1)].value;
+      return [0, 1, 2].map((i4) => catmullRom(delta, before[i4], from.value[i4], to.value[i4], after[i4]));
+    }
+    const target = to.pre ?? to.value;
+    return [0, 1, 2].map((i4) => from.value[i4] + (target[i4] - from.value[i4]) * delta);
+  }
+  function entityAnimationTime(animation, time, loop = animation.loop) {
+    return loop && animation.length > 0 ? time % animation.length : time;
+  }
+  function sampleEntityAnimation(animation, time, loop = animation.loop) {
+    const elapsed = entityAnimationTime(animation, time, loop);
+    const pose = {};
+    for (const [name2, bone] of Object.entries(animation.bones)) {
+      const sampled = pose[name2] = {};
+      for (const channel of ENTITY_ANIMATION_CHANNELS) {
+        const keyframes = bone[channel];
+        if (keyframes?.length) sampled[channel] = sampleEntityKeyframes(keyframes, elapsed);
+      }
+    }
+    return pose;
+  }
+
   // src/entity/EntityModel.ts
   init_dirname();
   init_buffer2();
@@ -83741,6 +83866,80 @@ ${key}` : key;
   init_buffer2();
   init_process2();
 
+  // src/entity/scene/EntityAnimationPlayer.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  var ZERO = [0, 0, 0];
+  var EntityAnimationPlayer = class {
+    constructor() {
+      this.parts = [];
+      this._time = 0;
+      this.loop = false;
+      this.speed = 1;
+    }
+    get animation() {
+      return this._animation;
+    }
+    get time() {
+      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.
+     */
+    play(layers, animation, options = {}) {
+      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() });
+        }
+      }
+      this.apply();
+    }
+    /** Restores the default poses. Returns whether an animation was active. */
+    stop() {
+      if (!this._animation) return false;
+      for (const part of this.parts) {
+        part.object.position.copy(part.position);
+        part.object.rotation.copy(part.rotation);
+        part.object.scale.copy(part.scale);
+      }
+      this.clear();
+      return true;
+    }
+    /** Forgets the animation without touching the parts, for parts that no longer exist. */
+    clear() {
+      this.parts = [];
+      this._animation = void 0;
+      this._time = 0;
+    }
+    setTime(seconds) {
+      if (!this._animation) return false;
+      this._time = seconds;
+      this.apply();
+      return true;
+    }
+    advance(deltaSeconds) {
+      return this.setTime(this._time + deltaSeconds * this.speed);
+    }
+    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]);
+      }
+    }
+  };
+
   // src/entity/scene/EntityObject.ts
   init_dirname();
   init_buffer2();
@@ -83761,11 +83960,16 @@ ${key}` : key;
       this.entity = entity;
       this.isEntityObject = true;
       this.meshesCreated = false;
+      this.geometries = /* @__PURE__ */ new Set();
+      this.disposeWireframes = [];
       /** Scrolling materials are owned: their texture offset follows this entity's age. */
       this.scrollMaterials = [];
       /** Entity age in ticks, as vanilla's `ageInTicks`; drives the scrolling render modes. */
       this.age = 0;
+      this.animationPlayer = new EntityAnimationPlayer();
       this.options = (0, import_ts_deepmerge4.default)({}, _EntityObject.DEFAULT_OPTIONS, options ?? {});
+      this.addEventListener("added", () => this.updateScrollSubscription());
+      this.addEventListener("removed", () => this.updateScrollSubscription());
     }
     async init() {
       this.createMeshes();
@@ -83776,6 +83980,10 @@ ${key}` : key;
     }
     disposeAndRemoveAllChildren() {
       this.clearScrollMaterials();
+      for (const geometry of this.geometries) geometry.dispose();
+      this.geometries.clear();
+      for (const dispose of this.disposeWireframes.splice(0)) dispose();
+      this.animationPlayer.clear();
       super.disposeAndRemoveAllChildren();
     }
     clearScrollMaterials() {
@@ -83786,6 +83994,19 @@ ${key}` : key;
         material.dispose();
       }
     }
+    updateScrollSubscription() {
+      if (this.parent && this.scrollMaterials.length) {
+        if (this.scrollTicker === void 0) {
+          this.scrollTicker = Ticker.add(() => {
+            this.age++;
+            this.updateScroll();
+          });
+        }
+      } else {
+        Ticker.remove(this.scrollTicker);
+        this.scrollTicker = void 0;
+      }
+    }
     /** Applies the entity age to the scrolling materials; the ticker calls this 20 times per second. */
     updateScroll() {
       for (const { offset, speed } of this.scrollMaterials) {
@@ -83793,6 +84014,39 @@ ${key}` : key;
       }
       this.notifyDirty();
     }
+    //<editor-fold desc="ANIMATION">
+    /** The animation started by {@link playAnimation}, until {@link stopAnimation} or disposal. */
+    get animation() {
+      return this.animationPlayer.animation;
+    }
+    /** Seconds since the animation started, before looping. */
+    get animationTime() {
+      return this.animationPlayer.time;
+    }
+    /**
+     * 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.
+     * The object owns no clock: call {@link advanceAnimation} per frame, or {@link setAnimationTime}.
+     */
+    playAnimation(animation, options) {
+      this.createMeshes();
+      const layers = Object.keys(this.entityLayers).map((name2) => this.getLayerGroup(name2)).filter((layer) => !!layer);
+      this.animationPlayer.play(layers, animation, options);
+      this.notifyDirty();
+    }
+    /** Stops the animation and restores the default pose. */
+    stopAnimation() {
+      if (this.animationPlayer.stop()) 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();
+    }
+    /** 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();
+    }
+    //</editor-fold>
     getLayerGroup(name2) {
       return super.getGroupByName(`layer:${name2}`);
     }
@@ -83863,6 +84117,7 @@ ${key}` : key;
           depth + growZ * 2,
           uv
         ).clone();
+        this.geometries.add(geometry);
         geometry.translate(cube.origin[0] + width / 2, cube.origin[1] + height / 2, cube.origin[2] + depth / 2);
         if (inward && Math.min(width + growX * 2, height + growY * 2, depth + growZ * 2) > 0) {
           const index = Array.from(geometry.getIndex().array);
@@ -83871,7 +84126,7 @@ ${key}` : key;
         const mesh = this.createMesh(name2, geometry, material);
         mesh.renderOrder = renderOrder;
         anchor.add(mesh);
-        if (this.options.wireframe) addWireframeToMesh(geometry, mesh);
+        if (this.options.wireframe) this.disposeWireframes.push(addWireframeToMesh(geometry, mesh));
       }
       for (const [childName, child] of Object.entries(part.children)) {
         this.createPart(childName, child, anchor, size, material, renderOrder, inward);
@@ -83905,11 +84160,8 @@ ${key}` : key;
         this.clearScrollMaterials();
       } else if (this.scrollMaterials.length) {
         this.updateScroll();
-        this.scrollTicker = Ticker.add(() => {
-          this.age++;
-          this.updateScroll();
-        });
       }
+      this.updateScrollSubscription();
       this.notifyDirty();
     }
   };
@@ -87400,6 +87652,9 @@ property list uchar int vertex_index
       this._variants = [];
       this._models = [];
       this._cullMask = 0;
+      this._entities = [];
+      this._entityPlacement = new Matrix4();
+      this._entityGeneration = 0;
       this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
     }
     async init() {
@@ -87419,6 +87674,8 @@ property list uchar int vertex_index
     }
     clearModels() {
       this.removeModels(this._models.splice(0));
+      this._entityGeneration++;
+      this.removeEntities(this._entities.splice(0));
       this._fluidKey = void 0;
       this._fluidModel = void 0;
       this._isInstanced = false;
@@ -87430,6 +87687,57 @@ property list uchar int vertex_index
         if (!isInstanceReference(model)) model.dispose();
       }
     }
+    removeEntities(entities) {
+      for (const entity of entities) {
+        entity.removeFromScene();
+        entity.dispose();
+      }
+    }
+    /** Entity models drawn for this block instead of its block model; they are scene children, unlike the block. */
+    get blockEntities() {
+      return this._entities;
+    }
+    /**
+     * 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.
+     */
+    async createBlockEntities() {
+      const key = this.blockState.key;
+      if (!key || this.options.displayPosition) return false;
+      const generation = this._entityGeneration;
+      const created = [];
+      let resolved;
+      try {
+        resolved = BlockEntities.resolve(await BlockEntities.getIndex(key.root), key.toNamespacedString(), this.state);
+        if (!resolved) return false;
+        for (const part of resolved.parts) {
+          const [namespace, path] = part.model.includes(":") ? part.model.split(":") : [key.namespace, part.model];
+          const texture = part.textureLocation === void 0 ? void 0 : AssetKey.parse("textures", part.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+          if (texture) texture.root = key.root;
+          const entity = await Entities.getEntity(new BasicAssetKey(namespace, path), texture, { layer: part.layer });
+          if (!entity) throw new MineRenderError(`Missing entity model ${part.model}`);
+          created.push(await this.scene.addEntity(entity, { wireframe: this.options.wireframe }));
+        }
+      } catch (error) {
+        console.warn(`Could not draw block entity ${key.toNamespacedString()}, using its block model`, error);
+        this.removeEntities(created);
+        return false;
+      }
+      if (generation !== this._entityGeneration) {
+        this.removeEntities(created);
+        return true;
+      }
+      BlockEntities.matrix(resolved, this._entityPlacement);
+      this._entities = created;
+      this.placeEntities();
+      return true;
+    }
+    placeEntities() {
+      const matrix = new Matrix4().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(this._entityPlacement);
+      for (const entity of this._entities) {
+        matrix.decompose(entity.position, entity.quaternion, entity.scale);
+      }
+    }
     get isOccluding() {
       return this._models.some((model) => {
         const object = isInstanceReference(model) ? model.instanceable : model;
@@ -87541,13 +87849,20 @@ property list uchar int vertex_index
         await this.updateFluid(this._fluidSampler);
         return;
       }
+      const hasEntities = await this.createBlockEntities();
       const variantsToCreate = await this.mapStateToVariant(this.state);
       this._variants = variantsToCreate;
       for (let blockStateVariant of variantsToCreate) {
+        if (hasEntities && !await this.hasGeometry(blockStateVariant)) continue;
         this._models.push(await this.createVariant(blockStateVariant));
       }
       await this.updateFluid(this._fluidSampler);
     }
+    async hasGeometry(variant) {
+      const modelKey = AssetKey.parse("models", variant.model);
+      modelKey.root = this.blockState.key?.root;
+      return !!(await Models.getMerged(modelKey))?.elements?.length;
+    }
     getSingleVariant(variants) {
       return BlockStateResolver.choose(variants);
     }
@@ -87667,6 +87982,7 @@ property list uchar int vertex_index
       for (let model of this._models) {
         model.setPosition(position);
       }
+      this.placeEntities();
       this.notifyDirty();
     }
     //TODO: should override rotation + scale methods
@@ -94553,7 +94869,8 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
           this.data.set(index, void 0);
           return void 0;
         }
-        const template = getFluidKind(blockState.key, stored.properties) ? void 0 : await this.sectionModels?.get(blockState, stored.properties);
+        const perBlock = !this.sectionModels || getFluidKind(blockState.key, stored.properties) || blockState.key && BlockEntities.entry(await BlockEntities.getIndex(blockState.key.root), blockState.key.toNamespacedString());
+        const template = perBlock ? void 0 : await this.sectionModels.get(blockState, stored.properties);
         if (template) {
           this.sectionBlocks.set(index, { index, template, cullMask: 0 });
           this.meshDirty = true;