minerender 2.1.0-alpha.88 → 2.1.0-alpha.89

package/dist/browser/index.mjs

@@ -23192,46 +23192,46 @@ function matchesCondition(condition, state) {
 }
 var BlockStateResolver = class {
   /** Loads vanilla property defaults, falling back to preview values inferred from the blockstate file. */
-  static async defaults(blockState) {
-    const defaults = blockState.key ? await BlockStates.getDefaultState(blockState.key) : void 0;
+  static async defaults(blockState2) {
+    const defaults = blockState2.key ? await BlockStates.getDefaultState(blockState2.key) : void 0;
     const state = {};
     if (defaults && Object.keys(defaults).length > 0) {
       for (const key in defaults) state[key] = defaults[key].default;
-    } else if (blockState.variants) {
-      const variant = Object.keys(blockState.variants)[0];
+    } else if (blockState2.variants) {
+      const variant = Object.keys(blockState2.variants)[0];
       if (variant) {
         for (const property of variant.split(",")) {
           const [key, value] = property.split("=");
           state[key] = value;
         }
       }
-    } else if (blockState.multipart) {
-      const condition = blockState.multipart.map((part) => part.when).find((when) => when !== void 0 && Object.values(when).every((value) => typeof value === "string"));
+    } else if (blockState2.multipart) {
+      const condition = blockState2.multipart.map((part) => part.when).find((when) => when !== void 0 && Object.values(when).every((value) => typeof value === "string"));
       for (const [key, value] of Object.entries(condition ?? {})) state[key] = value.split("|")[0];
     }
     return state;
   }
   /** Selects matching models. Supply `choose` to control selection within each alternatives array. */
-  static select(blockState, state, choose = this.choose) {
-    return this.matching(blockState, state).map(choose);
+  static select(blockState2, state, choose = this.choose) {
+    return this.matching(blockState2, state).map(choose);
   }
   /** Returns matching model groups before choosing weighted alternatives. */
-  static matching(blockState, state) {
+  static matching(blockState2, state) {
     const out = [];
-    if (blockState.variants) {
-      if (Object.keys(blockState.variants).length === 1 && "" in blockState.variants) {
-        out.push(blockState.variants[""]);
+    if (blockState2.variants) {
+      if (Object.keys(blockState2.variants).length === 1 && "" in blockState2.variants) {
+        out.push(blockState2.variants[""]);
       } else {
-        for (const variantKey in blockState.variants) {
+        for (const variantKey in blockState2.variants) {
           const matches = variantKey.split(",").every((property) => {
             const [key, value] = property.split("=");
             return `${state[key]}` === `${value}`;
           });
-          if (matches) out.push(blockState.variants[variantKey]);
+          if (matches) out.push(blockState2.variants[variantKey]);
         }
       }
-    } else if (blockState.multipart) {
-      for (const part of blockState.multipart) {
+    } else if (blockState2.multipart) {
+      for (const part of blockState2.multipart) {
         if (part.apply && (!part.when || matchesCondition(part.when, state))) {
           out.push(part.apply);
         }
@@ -23359,9 +23359,9 @@ init_ModelCulling();
 init_FluidGeometry();
 init_Entities();
 var _BlockObject = class _BlockObject extends SceneObject {
-  constructor(blockState, options) {
+  constructor(blockState2, options) {
     super(options);
-    this.blockState = blockState;
+    this.blockState = blockState2;
     this.isBlockObject = true;
     this._previousState = {};
     this._state = {};
@@ -25540,6 +25540,157 @@ function compoundList(tags, name) {
   throw new MineRenderError(`Schematic ${name} must be a compound list`);
 }
 
+// src/model/multiblock/SpongeSchematicParser.ts
+init_MineRenderError();
+var SpongeSchematicParser = class {
+  /**
+   * Parses decoded NBT with a local block palette, omitting air blocks.
+   * Applies Offset to block and entity positions; size remains the source dimensions.
+   * Biomes and metadata are not imported, and DataVersion does not trigger migration.
+   */
+  static async parse(nbt) {
+    const tags = nbt.value.Schematic === void 0 ? nbt.value : compound(nbt.value.Schematic, "Schematic");
+    const version2 = integer2(tags.Version, "Version");
+    if (version2 !== 2 && version2 !== 3) {
+      throw new MineRenderError(`Unsupported Sponge schematic version ${version2}; expected 2 or 3`);
+    }
+    const dataVersion = integer2(tags.DataVersion, "DataVersion");
+    const size = ["Width", "Height", "Length"].map((name) => {
+      const tag = tags[name];
+      if (tag?.type !== "short" || !Number.isInteger(tag.value) || tag.value < -32768 || tag.value > 65535 || tag.value === 0) {
+        throw new MineRenderError(`Sponge schematic ${name} must be a positive unsigned short`);
+      }
+      return tag.value & 65535;
+    });
+    const offset = tags.Offset === void 0 ? [0, 0, 0] : intPosition(tags.Offset, "Offset");
+    const blocks = [];
+    const container = version2 === 2 ? tags : tags.Blocks === void 0 ? void 0 : compound(tags.Blocks, "Blocks");
+    if (container) {
+      const paletteTag = container.Palette;
+      if (!paletteTag) throw new MineRenderError("Sponge schematic requires a local Palette; global block IDs are not supported");
+      const palette = /* @__PURE__ */ new Map();
+      const paletteMax = version2 === 2 && tags.PaletteMax !== void 0 ? integer2(tags.PaletteMax, "PaletteMax") : void 0;
+      if (paletteMax !== void 0 && paletteMax <= 0) throw new MineRenderError("Sponge schematic PaletteMax must be positive");
+      for (const [state, tag] of Object.entries(compound(paletteTag, "Palette"))) {
+        const id = integer2(tag, "Palette index");
+        if (id < 0 || palette.has(id) || paletteMax !== void 0 && id >= paletteMax) {
+          throw new MineRenderError(`Invalid or duplicate Sponge schematic palette index ${id}`);
+        }
+        palette.set(id, blockState(state));
+      }
+      const [width, height, length] = size;
+      const volume = width * height * length;
+      const data = container[version2 === 2 ? "BlockData" : "Data"];
+      if (data?.type !== "byteArray" || !Array.isArray(data.value) || data.value.length < volume) {
+        throw new MineRenderError(`Sponge schematic block data must contain ${volume} varints`);
+      }
+      const blockEntities = /* @__PURE__ */ new Map();
+      for (const entity of compoundList2(container, "BlockEntities")) {
+        const pos = intPosition(entity.Pos, "BlockEntities Pos");
+        if (pos.some((value2, axis) => value2 < 0 || value2 >= size[axis])) {
+          throw new MineRenderError("Sponge schematic block entity position is outside its dimensions");
+        }
+        const index = pos[0] + pos[2] * width + pos[1] * width * length;
+        if (blockEntities.has(index)) throw new MineRenderError(`Duplicate Sponge schematic block entity at index ${index}`);
+        const value = entityData(entity, version2);
+        for (const [axis, name] of ["x", "y", "z"].entries()) {
+          value[name] = { type: "int", value: pos[axis] + offset[axis] };
+        }
+        blockEntities.set(index, { type: "compound", value });
+      }
+      let cursor = 0;
+      for (let index = 0; index < volume; index++) {
+        let id = 0;
+        for (let shift = 0; ; shift += 7) {
+          const byte = data.value[cursor++];
+          if (!Number.isInteger(byte) || byte < -128 || byte > 255) {
+            throw new MineRenderError(`Invalid or truncated Sponge schematic varint at index ${index}`);
+          }
+          const unsigned = byte & 255;
+          if (shift === 28 && unsigned > 7) {
+            throw new MineRenderError(`Sponge schematic varint exceeds a nonnegative int at index ${index}`);
+          }
+          id += (unsigned & 127) * 2 ** shift;
+          if ((unsigned & 128) === 0) break;
+        }
+        const state = palette.get(id);
+        if (!state) throw new MineRenderError(`Sponge schematic palette index ${id} does not exist`);
+        if (["minecraft:air", "minecraft:cave_air", "minecraft:void_air"].includes(state.type)) continue;
+        blocks.push({
+          type: state.type,
+          properties: { ...state.properties },
+          position: [
+            index % width + offset[0],
+            Math.floor(index / (width * length)) + offset[1],
+            Math.floor(index / width) % length + offset[2]
+          ],
+          nbt: blockEntities.get(index)
+        });
+      }
+      if (cursor !== data.value.length) throw new MineRenderError("Sponge schematic block data has trailing bytes");
+    }
+    const entities = compoundList2(tags, "Entities").map((entity) => {
+      const pos = entity.Pos;
+      if (pos?.type !== "list" || pos.value.type !== "double" || pos.value.value.length !== 3 || !pos.value.value.every(Number.isFinite)) {
+        throw new MineRenderError("Sponge schematic entity Pos must contain three doubles");
+      }
+      const position = pos.value.value.map((value2, axis) => value2 + offset[axis]);
+      const value = entityData(entity, version2);
+      value.Pos = { type: "list", value: { type: "double", value: [...position] } };
+      return { position, nbt: { type: "compound", value } };
+    });
+    return { size, blocks, entities, dataVersion };
+  }
+};
+function integer2(tag, name) {
+  if (tag?.type !== "int" || !Number.isInteger(tag.value) || tag.value < -2147483648 || tag.value > 2147483647) {
+    throw new MineRenderError(`Sponge schematic ${name} must be an int`);
+  }
+  return tag.value;
+}
+function compound(tag, name) {
+  if (tag?.type !== "compound" || !tag.value || typeof tag.value !== "object" || Array.isArray(tag.value)) {
+    throw new MineRenderError(`Sponge schematic ${name} must be a compound`);
+  }
+  return tag.value;
+}
+function intPosition(tag, name) {
+  if (tag?.type !== "intArray" || !Array.isArray(tag.value) || tag.value.length !== 3 || !tag.value.every((value) => Number.isInteger(value) && value >= -2147483648 && value <= 2147483647)) {
+    throw new MineRenderError(`Sponge schematic ${name} must contain three ints`);
+  }
+  return [...tag.value];
+}
+function compoundList2(tags, name) {
+  const tag = tags[name];
+  if (tag === void 0) return [];
+  if (tag.type === "list" && Array.isArray(tag.value.value)) {
+    if (tag.value.value.length === 0) return [];
+    if (tag.value.type === "compound") return tag.value.value;
+  }
+  throw new MineRenderError(`Sponge schematic ${name} must be a compound list`);
+}
+function blockState(state) {
+  const match = /^((?:[a-z0-9_.-]+:)?[a-z0-9_./-]+)(?:\[([^\[\]]*)\])?$/.exec(state);
+  if (!match) throw new MineRenderError(`Invalid Sponge schematic block state ${state}`);
+  const properties = {};
+  if (match[2]) {
+    for (const entry of match[2].split(",")) {
+      const pair = /^([a-z0-9_]+)=([^\s=,\[\]]+)$/.exec(entry);
+      if (!pair || Object.prototype.hasOwnProperty.call(properties, pair[1])) throw new MineRenderError(`Invalid Sponge schematic block state ${state}`);
+      Object.defineProperty(properties, pair[1], { value: pair[2], enumerable: true, writable: true, configurable: true });
+    }
+  }
+  return { type: match[1].includes(":") ? match[1] : `minecraft:${match[1]}`, properties };
+}
+function entityData(entity, version2) {
+  const id = entity.Id;
+  if (id?.type !== "string" || !id.value) throw new MineRenderError("Sponge schematic entity Id must be a nonempty string");
+  const { Id, Pos, ...extra } = entity;
+  const value = version2 === 2 ? extra : entity.Data === void 0 ? {} : { ...compound(entity.Data, "entity Data") };
+  value.id = { type: "string", value: id.value.includes(":") ? id.value : `minecraft:${id.value}` };
+  return value;
+}
+
 // src/model/multiblock/StructureParser.ts
 init_MineRenderError();
 var StructureParser = class {
@@ -26764,8 +26915,8 @@ var _MineRenderScene = class _MineRenderScene extends Scene4 {
    * Set `options.initialState` to choose block properties such as `facing` or `axis`.
    * Use the returned object's `setPosition` method to move all of its model parts.
    */
-  async addBlock(blockState, options, parent = this) {
-    return this.addSceneObject(blockState, () => new BlockObject(blockState, options), options, parent);
+  async addBlock(blockState2, options, parent = this) {
+    return this.addSceneObject(blockState2, () => new BlockObject(blockState2, options), options, parent);
   }
   /**
    * Loads a skin and adds an initialized player model.
@@ -28978,18 +29129,18 @@ var SectionModels = class {
     if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("maxAtlasSize must be a positive integer");
   }
   /** Returns a cube template, or `undefined` when the block requires an individual render object. */
-  async get(blockState, properties = {}) {
-    if (!blockState.variants || blockState.multipart) return void 0;
-    let states = this.states.get(blockState);
-    if (!states) this.states.set(blockState, states = /* @__PURE__ */ new Map());
+  async get(blockState2, properties = {}) {
+    if (!blockState2.variants || blockState2.multipart) return void 0;
+    let states = this.states.get(blockState2);
+    if (!states) this.states.set(blockState2, states = /* @__PURE__ */ new Map());
     const key = JSON.stringify(Object.entries(properties).sort(([a], [b]) => a.localeCompare(b)));
-    const prepared = await cached(states, key, () => this.prepare(blockState, properties));
+    const prepared = await cached(states, key, () => this.prepare(blockState2, properties));
     if (!prepared) return void 0;
     return prepared.templates.get(BlockStateResolver.choose(prepared.variants));
   }
-  async prepare(blockState, properties) {
-    const state = { ...await BlockStateResolver.defaults(blockState), ...properties };
-    const groups = BlockStateResolver.matching(blockState, state);
+  async prepare(blockState2, properties) {
+    const state = { ...await BlockStateResolver.defaults(blockState2), ...properties };
+    const groups = BlockStateResolver.matching(blockState2, state);
     if (groups.length !== 1) return void 0;
     const variants = groups[0];
     const choices = Array.isArray(variants) ? variants : [variants];
@@ -29001,7 +29152,7 @@ var SectionModels = class {
       const atlas = await UVMapper.getAtlas(model);
       const rotation = BlockStateResolver.rotation(variant);
       if (!atlas || atlas.hasAnimation || !ModelCulling.isOpaqueFullCube(atlas) || atlas.image.width > this.maxAtlasSize || atlas.image.height > this.maxAtlasSize || ModelCulling.toLocalMask(63, rotation) !== 63) return void 0;
-      const tints = await BlockTints.get(blockState.key, state, model);
+      const tints = await BlockTints.get(blockState2.key, state, model);
       let models = this.models.get(model);
       if (!models) this.models.set(model, models = /* @__PURE__ */ new Map());
       const key = JSON.stringify([rotation.x, rotation.y, rotation.z, variant.uvlock, tints]);
@@ -29707,10 +29858,10 @@ var Chunk = class _Chunk {
       if (resolutions.has(key)) continue;
       const stored = { type: block.type, properties: block.properties ? { ...block.properties } : void 0 };
       const resolved = (async () => {
-        const blockState = await BlockStates.get(AssetKey.parse("blockstates", stored.type));
-        const perBlock = !blockState || !this.sectionModels || !!getFluidKind(blockState.key, stored.properties) || !!(blockState.key && BlockEntities.entry(await BlockEntities.getIndex(blockState.key.root), blockState.key.toNamespacedString()));
-        if (!perBlock) await this.sectionModels.get(blockState, stored.properties);
-        return { blockState, perBlock };
+        const blockState2 = await BlockStates.get(AssetKey.parse("blockstates", stored.type));
+        const perBlock = !blockState2 || !this.sectionModels || !!getFluidKind(blockState2.key, stored.properties) || !!(blockState2.key && BlockEntities.entry(await BlockEntities.getIndex(blockState2.key.root), blockState2.key.toNamespacedString()));
+        if (!perBlock) await this.sectionModels.get(blockState2, stored.properties);
+        return { blockState: blockState2, perBlock };
       })();
       resolutions.set(key, resolved);
       void resolved.catch(() => void 0);
@@ -29735,17 +29886,17 @@ var Chunk = class _Chunk {
         if (!readBlock) continue;
         const stored = readBlock();
         const key = ChunkData.paletteKey(stored);
-        const { blockState, perBlock } = await resolutions.get(key);
-        if (!blockState) {
+        const { blockState: blockState2, perBlock } = await resolutions.get(key);
+        if (!blockState2) {
           this.data.set(index, void 0);
           continue;
         }
-        const template = perBlock ? void 0 : await this.sectionModels.get(blockState, stored.properties);
+        const template = perBlock ? void 0 : await this.sectionModels.get(blockState2, stored.properties);
         if (template) {
           this.sectionBlocks.set(index, { index, template, cullMask: 0 });
           this.meshDirty = true;
         } else {
-          object3 = await this.scene.addBlock(blockState, {
+          object3 = await this.scene.addBlock(blockState2, {
             mergeMeshes: true,
             instanceMeshes: true,
             maxInstanceCount: 2e3,
@@ -30151,6 +30302,7 @@ export {
   SkinTextures,
   Skins,
   SpecialItems,
+  SpongeSchematicParser,
   StructureParser,
   TextureAtlas,
   TextureLoader,