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

package/dist/bundle.js

@@ -21996,8 +21996,8 @@ var MineRender = (() => {
         }
       }
     }
-    function vertexAttribPointer(index, size, type, normalized, stride, offset, integer3) {
-      if (integer3 === true) {
+    function vertexAttribPointer(index, size, type, normalized, stride, offset, integer4) {
+      if (integer4 === true) {
         gl.vertexAttribIPointer(index, size, type, stride, offset);
       } else {
         gl.vertexAttribPointer(index, size, type, normalized, stride, offset);
@@ -22024,7 +22024,7 @@ var MineRender = (() => {
             const buffer2 = attribute.buffer;
             const type = attribute.type;
             const bytesPerElement = attribute.bytesPerElement;
-            const integer3 = type === gl.INT || type === gl.UNSIGNED_INT || geometryAttribute.gpuType === IntType;
+            const integer4 = type === gl.INT || type === gl.UNSIGNED_INT || geometryAttribute.gpuType === IntType;
             if (geometryAttribute.isInterleavedBufferAttribute) {
               const data = geometryAttribute.data;
               const stride = data.stride;
@@ -22050,7 +22050,7 @@ var MineRender = (() => {
                   normalized,
                   stride * bytesPerElement,
                   (offset + size / programAttribute.locationSize * i4) * bytesPerElement,
-                  integer3
+                  integer4
                 );
               }
             } else {
@@ -22075,7 +22075,7 @@ var MineRender = (() => {
                   normalized,
                   size * bytesPerElement,
                   size / programAttribute.locationSize * i4 * bytesPerElement,
-                  integer3
+                  integer4
                 );
               }
             }
@@ -106553,6 +106553,7 @@ ${shader.fragmentShader}`.replace(
     InstanceManager: () => InstanceManager,
     InstanceReference: () => InstanceReference,
     ItemTints: () => ItemTints,
+    LitematicaParser: () => LitematicaParser,
     MapControls: () => MapControls,
     Materials: () => Materials,
     Meshes: () => Meshes,
@@ -111368,46 +111369,46 @@ property list uchar int vertex_index
   }
   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);
           }
@@ -111546,9 +111547,9 @@ property list uchar int vertex_index
   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 = {};
@@ -111944,6 +111945,158 @@ property list uchar int vertex_index
   init_buffer2();
   init_process2();
 
+  // src/model/multiblock/LitematicaParser.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  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 version3 = integer2(tags.Version, "Version");
+      if (version3 < 5 || version3 > 7) throw new MineRenderError(`Unsupported Litematica version ${version3}; 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 max2 = [-Infinity, -Infinity, -Infinity];
+      for (const [name2, tag] of Object.entries(compound(tags.Regions, "Regions"))) {
+        const region = readRegion(compound(tag, `region ${name2}`), name2, 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);
+          max2[axis] = Math.max(max2[axis], start + region.size[axis]);
+        }
+      }
+      return {
+        size: regions.length ? min.map((value, axis) => max2[axis] - value) : [0, 0, 0],
+        blocks: [...blocks.values()],
+        entities: regions.flatMap((region) => region.entities ?? []),
+        dataVersion,
+        regions
+      };
+    }
+  };
+  function readRegion(tags, name2, dataVersion, combined) {
+    const position = blockPosition(compound(tags.Position, `region ${name2} Position`));
+    const signedSize = blockPosition(compound(tags.Size, `region ${name2} Size`));
+    if (signedSize.some((value) => value === 0)) throw new MineRenderError(`Litematica region ${name2} 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 ${name2} has no block palette`);
+    const bits2 = Math.max(2, Math.ceil(Math.log2(palette.length)));
+    if (!Number.isSafeInteger(volume * bits2)) throw new MineRenderError(`Litematica region ${name2} volume is too large`);
+    const packed = tags.BlockStates;
+    const expected = Math.ceil(volume * bits2 / 64);
+    if (packed?.type !== "longArray" || !Array.isArray(packed.value) || packed.value.length !== expected) {
+      throw new MineRenderError(`Litematica region ${name2} 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 ${name2} 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 ${name2} 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 ** bits2 - 1;
+    for (let index = 0; index < volume; index++) {
+      const word = Math.floor(index * bits2 / 64);
+      const shift = index * bits2 % 64;
+      const [high, low] = words[word];
+      let value = shift < 32 ? low >>> shift : high >>> shift - 32;
+      if (shift < 32 && shift + bits2 > 32) value |= high << 32 - shift;
+      if (shift + bits2 > 64) value |= words[word + 1][1] << 64 - shift;
+      const id = (value & mask) >>> 0;
+      const state = palette[id];
+      if (!state) throw new MineRenderError(`Litematica region ${name2} 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 ${name2} 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: name2, position, signedSize, size, blocks, entities, dataVersion };
+  }
+  function minimum(position, size) {
+    return position + Math.min(0, size + 1);
+  }
+  function integer2(tag, name2) {
+    if (tag?.type !== "int" || !Number.isInteger(tag.value) || tag.value < -2147483648 || tag.value > 2147483647) {
+      throw new MineRenderError(`Litematica ${name2} must be an int`);
+    }
+    return tag.value;
+  }
+  function compound(tag, name2) {
+    if (tag?.type !== "compound" || !tag.value || typeof tag.value !== "object" || Array.isArray(tag.value)) {
+      throw new MineRenderError(`Litematica ${name2} must be a compound`);
+    }
+    return tag.value;
+  }
+  function blockPosition(tags) {
+    return ["x", "y", "z"].map((axis) => integer2(tags[axis], axis));
+  }
+  function compounds(tag, name2) {
+    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 ${name2} must be a compound list`);
+  }
+  function blockState(tags) {
+    const name2 = tags.Name;
+    if (name2?.type !== "string" || !/^(?:[a-z0-9_.-]+:)?[a-z0-9_./-]+$/.test(name2.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: name2.value.includes(":") ? name2.value : `minecraft:${name2.value}`, properties };
+  }
+
   // src/model/multiblock/MultiBlockStructure.ts
   init_dirname();
   init_buffer2();
@@ -113755,12 +113908,12 @@ property list uchar int vertex_index
      * 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 version3 = integer2(tags.Version, "Version");
+      const tags = nbt.value.Schematic === void 0 ? nbt.value : compound2(nbt.value.Schematic, "Schematic");
+      const version3 = integer3(tags.Version, "Version");
       if (version3 !== 2 && version3 !== 3) {
         throw new MineRenderError(`Unsupported Sponge schematic version ${version3}; expected 2 or 3`);
       }
-      const dataVersion = integer2(tags.DataVersion, "DataVersion");
+      const dataVersion = integer3(tags.DataVersion, "DataVersion");
       const size = ["Width", "Height", "Length"].map((name2) => {
         const tag = tags[name2];
         if (tag?.type !== "short" || !Number.isInteger(tag.value) || tag.value < -32768 || tag.value > 65535 || tag.value === 0) {
@@ -113770,19 +113923,19 @@ property list uchar int vertex_index
       });
       const offset = tags.Offset === void 0 ? [0, 0, 0] : intPosition(tags.Offset, "Offset");
       const blocks = [];
-      const container = version3 === 2 ? tags : tags.Blocks === void 0 ? void 0 : compound(tags.Blocks, "Blocks");
+      const container = version3 === 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 = version3 === 2 && tags.PaletteMax !== void 0 ? integer2(tags.PaletteMax, "PaletteMax") : void 0;
+        const paletteMax = version3 === 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;
@@ -113848,13 +114001,13 @@ property list uchar int vertex_index
       return { size, blocks, entities, dataVersion };
     }
   };
-  function integer2(tag, name2) {
+  function integer3(tag, name2) {
     if (tag?.type !== "int" || !Number.isInteger(tag.value) || tag.value < -2147483648 || tag.value > 2147483647) {
       throw new MineRenderError(`Sponge schematic ${name2} must be an int`);
     }
     return tag.value;
   }
-  function compound(tag, name2) {
+  function compound2(tag, name2) {
     if (tag?.type !== "compound" || !tag.value || typeof tag.value !== "object" || Array.isArray(tag.value)) {
       throw new MineRenderError(`Sponge schematic ${name2} must be a compound`);
     }
@@ -113875,7 +114028,7 @@ property list uchar int vertex_index
     }
     throw new MineRenderError(`Sponge schematic ${name2} 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 = {};
@@ -113892,7 +114045,7 @@ property list uchar int vertex_index
     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 = version3 === 2 ? extra : entity.Data === void 0 ? {} : { ...compound(entity.Data, "entity Data") };
+    const value = version3 === 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;
   }
@@ -115156,8 +115309,8 @@ property list uchar int vertex_index
      * 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.
@@ -119240,8 +119393,8 @@ gl_FragDepth=readDepth(vUv);
     }
   }
   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;
@@ -119410,18 +119563,18 @@ gl_FragDepth=readDepth(vUv);
       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(([a4], [b4]) => a4.localeCompare(b4)));
-      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];
@@ -119433,7 +119586,7 @@ gl_FragDepth=readDepth(vUv);
         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]);
@@ -120148,10 +120301,10 @@ gl_FragDepth=readDepth(vUv);
         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);
@@ -120176,17 +120329,17 @@ gl_FragDepth=readDepth(vUv);
           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,