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

package/dist/bundle.js

@@ -21996,8 +21996,8 @@ var MineRender = (() => {
         }
       }
     }
-    function vertexAttribPointer(index, size, type, normalized, stride, offset, integer2) {
-      if (integer2 === true) {
+    function vertexAttribPointer(index, size, type, normalized, stride, offset, integer3) {
+      if (integer3 === 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 integer2 = type === gl.INT || type === gl.UNSIGNED_INT || geometryAttribute.gpuType === IntType;
+            const integer3 = 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,
-                  integer2
+                  integer3
                 );
               }
             } else {
@@ -22075,7 +22075,7 @@ var MineRender = (() => {
                   normalized,
                   size * bytesPerElement,
                   size / programAttribute.locationSize * i4 * bytesPerElement,
-                  integer2
+                  integer3
                 );
               }
             }
@@ -106592,6 +106592,7 @@ ${shader.fragmentShader}`.replace(
     SkinTextures: () => SkinTextures,
     Skins: () => Skins,
     SpecialItems: () => SpecialItems,
+    SpongeSchematicParser: () => SpongeSchematicParser,
     StructureParser: () => StructureParser,
     TextureAtlas: () => TextureAtlas,
     TextureLoader: () => TextureLoader2,
@@ -111367,46 +111368,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(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);
           }
@@ -111545,9 +111546,9 @@ property list uchar int vertex_index
   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 = {};
@@ -113742,6 +113743,160 @@ property list uchar int vertex_index
     throw new MineRenderError(`Schematic ${name2} must be a compound list`);
   }
 
+  // src/model/multiblock/SpongeSchematicParser.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  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 version3 = integer2(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 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) {
+          throw new MineRenderError(`Sponge schematic ${name2} 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 = version3 === 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 = version3 === 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[version3 === 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, version3);
+          for (const [axis, name2] of ["x", "y", "z"].entries()) {
+            value[name2] = { 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, version3);
+        value.Pos = { type: "list", value: { type: "double", value: [...position] } };
+        return { position, nbt: { type: "compound", value } };
+      });
+      return { size, blocks, entities, dataVersion };
+    }
+  };
+  function integer2(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) {
+    if (tag?.type !== "compound" || !tag.value || typeof tag.value !== "object" || Array.isArray(tag.value)) {
+      throw new MineRenderError(`Sponge schematic ${name2} must be a compound`);
+    }
+    return tag.value;
+  }
+  function intPosition(tag, name2) {
+    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 ${name2} must contain three ints`);
+    }
+    return [...tag.value];
+  }
+  function compoundList2(tags, name2) {
+    const tag = tags[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(`Sponge schematic ${name2} 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, version3) {
+    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") };
+    value.id = { type: "string", value: id.value.includes(":") ? id.value : `minecraft:${id.value}` };
+    return value;
+  }
+
   // src/model/multiblock/StructureParser.ts
   init_dirname();
   init_buffer2();
@@ -115001,8 +115156,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(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.
@@ -119255,18 +119410,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(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(([a4], [b4]) => a4.localeCompare(b4)));
-      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];
@@ -119278,7 +119433,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(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]);
@@ -119993,10 +120148,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 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);
@@ -120021,17 +120176,17 @@ gl_FragDepth=readDepth(vUv);
           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,