minerender 2.1.0-alpha.89 → 2.1.0-alpha.90

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(blockState2) {
-    const defaults = blockState2.key ? await BlockStates.getDefaultState(blockState2.key) : void 0;
+  static async defaults(blockState3) {
+    const defaults = blockState3.key ? await BlockStates.getDefaultState(blockState3.key) : void 0;
     const state = {};
     if (defaults && Object.keys(defaults).length > 0) {
       for (const key in defaults) state[key] = defaults[key].default;
-    } else if (blockState2.variants) {
-      const variant = Object.keys(blockState2.variants)[0];
+    } else if (blockState3.variants) {
+      const variant = Object.keys(blockState3.variants)[0];
       if (variant) {
         for (const property of variant.split(",")) {
           const [key, value] = property.split("=");
           state[key] = value;
         }
       }
-    } 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"));
+    } else if (blockState3.multipart) {
+      const condition = blockState3.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(blockState2, state, choose = this.choose) {
-    return this.matching(blockState2, state).map(choose);
+  static select(blockState3, state, choose = this.choose) {
+    return this.matching(blockState3, state).map(choose);
   }
   /** Returns matching model groups before choosing weighted alternatives. */
-  static matching(blockState2, state) {
+  static matching(blockState3, state) {
     const out = [];
-    if (blockState2.variants) {
-      if (Object.keys(blockState2.variants).length === 1 && "" in blockState2.variants) {
-        out.push(blockState2.variants[""]);
+    if (blockState3.variants) {
+      if (Object.keys(blockState3.variants).length === 1 && "" in blockState3.variants) {
+        out.push(blockState3.variants[""]);
       } else {
-        for (const variantKey in blockState2.variants) {
+        for (const variantKey in blockState3.variants) {
           const matches = variantKey.split(",").every((property) => {
             const [key, value] = property.split("=");
             return `${state[key]}` === `${value}`;
           });
-          if (matches) out.push(blockState2.variants[variantKey]);
+          if (matches) out.push(blockState3.variants[variantKey]);
         }
       }
-    } else if (blockState2.multipart) {
-      for (const part of blockState2.multipart) {
+    } else if (blockState3.multipart) {
+      for (const part of blockState3.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(blockState2, options) {
+  constructor(blockState3, options) {
     super(options);
-    this.blockState = blockState2;
+    this.blockState = blockState3;
     this.isBlockObject = true;
     this._previousState = {};
     this._state = {};
@@ -23749,6 +23749,155 @@ function isBlockObject(obj) {
 init_FluidGeometry();
 init_FluidModelObject();
 
+// src/model/multiblock/LitematicaParser.ts
+init_MineRenderError();
+var LitematicaParser = class {
+  /**
+   * Parses decoded NBT, preserving subregion placement and omitting air.
+   * Later entries in regions replace earlier cells, including with air.
+   * Size encloses all region bounds; positions retain the schematic origin.
+   * Metadata and scheduled ticks are not imported. Named regions can be placed individually.
+   */
+  static async parse(nbt) {
+    const tags = nbt.value;
+    const version2 = integer2(tags.Version, "Version");
+    if (version2 < 5 || version2 > 7) throw new MineRenderError(`Unsupported Litematica version ${version2}; expected 5, 6, or 7`);
+    const dataVersion = tags.MinecraftDataVersion === void 0 ? void 0 : integer2(tags.MinecraftDataVersion, "MinecraftDataVersion");
+    const blocks = /* @__PURE__ */ new Map();
+    const regions = [];
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    for (const [name, tag] of Object.entries(compound(tags.Regions, "Regions"))) {
+      const region = readRegion(compound(tag, `region ${name}`), name, dataVersion, blocks);
+      regions.push(region);
+      for (let axis = 0; axis < 3; axis++) {
+        const start = minimum(region.position[axis], region.signedSize[axis]);
+        min[axis] = Math.min(min[axis], start);
+        max[axis] = Math.max(max[axis], start + region.size[axis]);
+      }
+    }
+    return {
+      size: regions.length ? min.map((value, axis) => max[axis] - value) : [0, 0, 0],
+      blocks: [...blocks.values()],
+      entities: regions.flatMap((region) => region.entities ?? []),
+      dataVersion,
+      regions
+    };
+  }
+};
+function readRegion(tags, name, dataVersion, combined) {
+  const position = blockPosition(compound(tags.Position, `region ${name} Position`));
+  const signedSize = blockPosition(compound(tags.Size, `region ${name} Size`));
+  if (signedSize.some((value) => value === 0)) throw new MineRenderError(`Litematica region ${name} dimensions must be nonzero`);
+  const size = signedSize.map(Math.abs);
+  const min = position.map((value, axis) => minimum(value, signedSize[axis]));
+  const [width, height, length] = size;
+  const volume = width * height * length;
+  const palette = compounds(tags.BlockStatePalette, "BlockStatePalette").map(blockState);
+  if (!palette.length) throw new MineRenderError(`Litematica region ${name} has no block palette`);
+  const bits = Math.max(2, Math.ceil(Math.log2(palette.length)));
+  if (!Number.isSafeInteger(volume * bits)) throw new MineRenderError(`Litematica region ${name} volume is too large`);
+  const packed = tags.BlockStates;
+  const expected = Math.ceil(volume * bits / 64);
+  if (packed?.type !== "longArray" || !Array.isArray(packed.value) || packed.value.length !== expected) {
+    throw new MineRenderError(`Litematica region ${name} BlockStates must contain ${expected} longs`);
+  }
+  const words = packed.value.map((pair) => {
+    if (!Array.isArray(pair) || pair.length !== 2 || !pair.every((value) => Number.isInteger(value) && value >= -2147483648 && value <= 4294967295)) {
+      throw new MineRenderError(`Litematica region ${name} has an invalid BlockStates long`);
+    }
+    return [pair[0] >>> 0, pair[1] >>> 0];
+  });
+  const blockEntities = /* @__PURE__ */ new Map();
+  for (const tile of compounds(tags.TileEntities, "TileEntities")) {
+    const pos = blockPosition(tile);
+    if (pos.some((value2, axis) => value2 < 0 || value2 >= size[axis])) {
+      throw new MineRenderError(`Litematica region ${name} block entity is outside its dimensions`);
+    }
+    const index = pos[0] + pos[2] * width + pos[1] * width * length;
+    if (blockEntities.has(index)) throw new MineRenderError(`Duplicate Litematica block entity at index ${index}`);
+    const value = { ...tile };
+    for (const [axis, key] of ["x", "y", "z"].entries()) value[key] = { type: "int", value: pos[axis] + min[axis] };
+    blockEntities.set(index, { type: "compound", value });
+  }
+  const blocks = [];
+  const mask = 2 ** bits - 1;
+  for (let index = 0; index < volume; index++) {
+    const word = Math.floor(index * bits / 64);
+    const shift = index * bits % 64;
+    const [high, low] = words[word];
+    let value = shift < 32 ? low >>> shift : high >>> shift - 32;
+    if (shift < 32 && shift + bits > 32) value |= high << 32 - shift;
+    if (shift + bits > 64) value |= words[word + 1][1] << 64 - shift;
+    const id = (value & mask) >>> 0;
+    const state = palette[id];
+    if (!state) throw new MineRenderError(`Litematica region ${name} palette index ${id} does not exist`);
+    const pos = [
+      index % width + min[0],
+      Math.floor(index / (width * length)) + min[1],
+      Math.floor(index / width) % length + min[2]
+    ];
+    const key = pos.join(",");
+    if (["minecraft:air", "minecraft:cave_air", "minecraft:void_air"].includes(state.type)) {
+      combined.delete(key);
+      continue;
+    }
+    const block = { type: state.type, properties: { ...state.properties }, position: pos, nbt: blockEntities.get(index) };
+    blocks.push(block);
+    combined.set(key, block);
+  }
+  const entities = compounds(tags.Entities, "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(`Litematica region ${name} entity Pos must contain three doubles`);
+    }
+    const absolute = pos.value.value.map((value2, axis) => value2 + position[axis]);
+    const value = { ...entity, Pos: { type: "list", value: { type: "double", value: [...absolute] } } };
+    return { position: absolute, nbt: { type: "compound", value } };
+  });
+  return { name, position, signedSize, size, blocks, entities, dataVersion };
+}
+function minimum(position, size) {
+  return position + Math.min(0, size + 1);
+}
+function integer2(tag, name) {
+  if (tag?.type !== "int" || !Number.isInteger(tag.value) || tag.value < -2147483648 || tag.value > 2147483647) {
+    throw new MineRenderError(`Litematica ${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(`Litematica ${name} must be a compound`);
+  }
+  return tag.value;
+}
+function blockPosition(tags) {
+  return ["x", "y", "z"].map((axis) => integer2(tags[axis], axis));
+}
+function compounds(tag, 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(`Litematica ${name} must be a compound list`);
+}
+function blockState(tags) {
+  const name = tags.Name;
+  if (name?.type !== "string" || !/^(?:[a-z0-9_.-]+:)?[a-z0-9_./-]+$/.test(name.value)) {
+    throw new MineRenderError("Litematica palette entry must have a block Name");
+  }
+  const properties = {};
+  if (tags.Properties !== void 0) {
+    for (const [key, tag] of Object.entries(compound(tags.Properties, "block Properties"))) {
+      if (tag?.type !== "string") throw new MineRenderError("Litematica block properties must be strings");
+      Object.defineProperty(properties, key, { value: tag.value, enumerable: true, writable: true, configurable: true });
+    }
+  }
+  return { type: name.value.includes(":") ? name.value : `minecraft:${name.value}`, properties };
+}
+
 // src/model/multiblock/SchematicParser.ts
 init_MineRenderError();
 
@@ -25549,12 +25698,12 @@ var SpongeSchematicParser = class {
    * 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");
+    const tags = nbt.value.Schematic === void 0 ? nbt.value : compound2(nbt.value.Schematic, "Schematic");
+    const version2 = integer3(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 dataVersion = integer3(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) {
@@ -25564,19 +25713,19 @@ var SpongeSchematicParser = class {
     });
     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");
+    const container = version2 === 2 ? tags : tags.Blocks === void 0 ? void 0 : compound2(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;
+      const paletteMax = version2 === 2 && tags.PaletteMax !== void 0 ? integer3(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");
+      for (const [state, tag] of Object.entries(compound2(paletteTag, "Palette"))) {
+        const id = integer3(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));
+        palette.set(id, blockState2(state));
       }
       const [width, height, length] = size;
       const volume = width * height * length;
@@ -25642,13 +25791,13 @@ var SpongeSchematicParser = class {
     return { size, blocks, entities, dataVersion };
   }
 };
-function integer2(tag, name) {
+function integer3(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) {
+function compound2(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`);
   }
@@ -25669,7 +25818,7 @@ function compoundList2(tags, name) {
   }
   throw new MineRenderError(`Sponge schematic ${name} must be a compound list`);
 }
-function blockState(state) {
+function blockState2(state) {
   const match = /^((?:[a-z0-9_.-]+:)?[a-z0-9_./-]+)(?:\[([^\[\]]*)\])?$/.exec(state);
   if (!match) throw new MineRenderError(`Invalid Sponge schematic block state ${state}`);
   const properties = {};
@@ -25686,7 +25835,7 @@ 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") };
+  const value = version2 === 2 ? extra : entity.Data === void 0 ? {} : { ...compound2(entity.Data, "entity Data") };
   value.id = { type: "string", value: id.value.includes(":") ? id.value : `minecraft:${id.value}` };
   return value;
 }
@@ -26915,8 +27064,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(blockState2, options, parent = this) {
-    return this.addSceneObject(blockState2, () => new BlockObject(blockState2, options), options, parent);
+  async addBlock(blockState3, options, parent = this) {
+    return this.addSceneObject(blockState3, () => new BlockObject(blockState3, options), options, parent);
   }
   /**
    * Loads a skin and adds an initialized player model.
@@ -28973,8 +29122,8 @@ async function abortable2(promise, signal) {
   }
 }
 var AnvilWorldSource = class {
-  constructor(readRegion, options = {}) {
-    this.readRegion = readRegion;
+  constructor(readRegion2, options = {}) {
+    this.readRegion = readRegion2;
     this.regions = /* @__PURE__ */ new Map();
     this.pending = /* @__PURE__ */ new Map();
     this.cachedBytes = 0;
@@ -29129,18 +29278,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(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());
+  async get(blockState3, properties = {}) {
+    if (!blockState3.variants || blockState3.multipart) return void 0;
+    let states = this.states.get(blockState3);
+    if (!states) this.states.set(blockState3, 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(blockState2, properties));
+    const prepared = await cached(states, key, () => this.prepare(blockState3, properties));
     if (!prepared) return void 0;
     return prepared.templates.get(BlockStateResolver.choose(prepared.variants));
   }
-  async prepare(blockState2, properties) {
-    const state = { ...await BlockStateResolver.defaults(blockState2), ...properties };
-    const groups = BlockStateResolver.matching(blockState2, state);
+  async prepare(blockState3, properties) {
+    const state = { ...await BlockStateResolver.defaults(blockState3), ...properties };
+    const groups = BlockStateResolver.matching(blockState3, state);
     if (groups.length !== 1) return void 0;
     const variants = groups[0];
     const choices = Array.isArray(variants) ? variants : [variants];
@@ -29152,7 +29301,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(blockState2.key, state, model);
+      const tints = await BlockTints.get(blockState3.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]);
@@ -29858,10 +30007,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 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 };
+        const blockState3 = await BlockStates.get(AssetKey.parse("blockstates", stored.type));
+        const perBlock = !blockState3 || !this.sectionModels || !!getFluidKind(blockState3.key, stored.properties) || !!(blockState3.key && BlockEntities.entry(await BlockEntities.getIndex(blockState3.key.root), blockState3.key.toNamespacedString()));
+        if (!perBlock) await this.sectionModels.get(blockState3, stored.properties);
+        return { blockState: blockState3, perBlock };
       })();
       resolutions.set(key, resolved);
       void resolved.catch(() => void 0);
@@ -29886,17 +30035,17 @@ var Chunk = class _Chunk {
         if (!readBlock) continue;
         const stored = readBlock();
         const key = ChunkData.paletteKey(stored);
-        const { blockState: blockState2, perBlock } = await resolutions.get(key);
-        if (!blockState2) {
+        const { blockState: blockState3, perBlock } = await resolutions.get(key);
+        if (!blockState3) {
           this.data.set(index, void 0);
           continue;
         }
-        const template = perBlock ? void 0 : await this.sectionModels.get(blockState2, stored.properties);
+        const template = perBlock ? void 0 : await this.sectionModels.get(blockState3, stored.properties);
         if (template) {
           this.sectionBlocks.set(index, { index, template, cullMask: 0 });
           this.meshDirty = true;
         } else {
-          object3 = await this.scene.addBlock(blockState2, {
+          object3 = await this.scene.addBlock(blockState3, {
             mergeMeshes: true,
             instanceMeshes: true,
             maxInstanceCount: 2e3,
@@ -30263,6 +30412,7 @@ export {
   InstanceManager,
   InstanceReference,
   ItemTints,
+  LitematicaParser,
   MapControls,
   Materials,
   Meshes,