minerender 2.1.0-alpha.94 → 2.1.0-alpha.95

package/dist/browser/index.mjs

@@ -23211,7 +23211,7 @@ function matchesCondition(condition, state) {
     return typeof value === "string" && state[key] !== void 0 && value.split("|").includes(`${state[key]}`);
   });
 }
-var BlockStateResolver = class {
+var BlockStateResolver = class _BlockStateResolver {
   /** Loads vanilla property defaults, falling back to preview values inferred from the blockstate file. */
   static async defaults(blockState3) {
     const defaults = blockState3.key ? await BlockStates.getDefaultState(blockState3.key) : void 0;
@@ -23234,7 +23234,7 @@ var BlockStateResolver = class {
   }
   /** Selects matching models. Supply `choose` to control selection within each alternatives array. */
   static select(blockState3, state, choose = this.choose) {
-    return this.matching(blockState3, state).map(choose);
+    return this.matching(blockState3, state).map((variants) => choose(variants));
   }
   /** Returns matching model groups before choosing weighted alternatives. */
   static matching(blockState3, state) {
@@ -23260,8 +23260,8 @@ var BlockStateResolver = class {
     }
     return out;
   }
-  /** Selects a random alternative using positive integer weights, each defaulting to 1. */
-  static choose(variants) {
+  /** Selects by positive integer weights (default 1); world block coordinates make the choice repeatable. */
+  static choose(variants, position) {
     if (!Array.isArray(variants)) return variants;
     if (!variants.length) throw new MineRenderError("Blockstate variant arrays must not be empty");
     const total = variants.reduce((sum, variant) => {
@@ -23271,13 +23271,29 @@ var BlockStateResolver = class {
       }
       return sum + weight;
     }, 0);
-    let choice = Math.random() * total;
+    let choice = position === void 0 ? Math.random() * total : _BlockStateResolver.positionSample(position, total);
     for (const variant of variants) {
       choice -= variant.weight ?? 1;
       if (choice < 0) return variant;
     }
     return variants[variants.length - 1];
   }
+  static positionSample(position, bound) {
+    if (bound > 2147483647) {
+      throw new MineRenderError("Position-based blockstate variant total weight must not exceed 2147483647");
+    }
+    let mixed = BigInt(Math.imul(position[0], 3129871)) ^ BigInt(position[2]) * 116129781n ^ BigInt(position[1]);
+    mixed = BigInt.asIntN(64, mixed * mixed * 42317861n + mixed * 11n) >> 16n;
+    let seed = (mixed ^ 0x5deece66dn) & 0xffffffffffffn;
+    let bits, value;
+    do {
+      seed = seed * 0x5deece66dn + 11n & 0xffffffffffffn;
+      bits = Number(seed >> 17n);
+      if ((bound & bound - 1) === 0) return Number(BigInt(bound) * BigInt(bits) >> 31n);
+      value = bits % bound;
+    } while ((bits - value + bound - 1 | 0) < 0);
+    return value;
+  }
   /** Converts blockstate rotations in degrees into the Euler rotation used by model rendering. */
   static rotation(variant) {
     const rotation = new Euler9();
@@ -23397,6 +23413,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     this._entityPlacement = new Matrix411();
     this._entityGeneration = 0;
     this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
+    this.variantPosition = options?.variantPosition ? [...options.variantPosition] : void 0;
   }
   async init() {
     if (this.options.applyDefaultState) {
@@ -23633,7 +23650,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     return !!(await Models.getMerged(modelKey))?.elements?.length;
   }
   getSingleVariant(variants) {
-    return BlockStateResolver.choose(variants);
+    return BlockStateResolver.choose(variants, this.variantPosition);
   }
   // @deprecated
   async createAVariant(variants, instanceInfo) {
@@ -29534,13 +29551,14 @@ var SectionModels = class {
     if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("maxAtlasSize must be a positive integer");
   }
   /** Returns templates for the matched parts, or `undefined` when the block needs an individual render object. */
-  async get(blockState3, properties = {}) {
+  async get(blockState3, properties = {}, position) {
+    const variantPosition = position ? [...position] : 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(blockState3, properties));
     if (!prepared) return void 0;
-    return prepared.groups.map((group) => prepared.templates.get(BlockStateResolver.choose(group)));
+    return prepared.groups.map((group) => prepared.templates.get(BlockStateResolver.choose(group, variantPosition)));
   }
   async prepare(blockState3, properties) {
     const state = { ...await BlockStateResolver.defaults(blockState3), ...properties };
@@ -30329,7 +30347,8 @@ var Chunk = class _Chunk {
           this.data.set(index, void 0);
           continue;
         }
-        const templates = perBlock ? void 0 : await this.sectionModels.get(blockState3, stored.properties);
+        const variantPosition = worldPos.toArray();
+        const templates = perBlock ? void 0 : await this.sectionModels.get(blockState3, stored.properties, variantPosition);
         if (templates) {
           this.sectionBlocks.set(index, templates.map((template) => ({ index, template, cullMask: 0 })));
           this.meshDirty = true;
@@ -30338,7 +30357,8 @@ var Chunk = class _Chunk {
             mergeMeshes: true,
             instanceMeshes: true,
             maxInstanceCount: 2e3,
-            initialState: stored.properties
+            initialState: stored.properties,
+            variantPosition
           });
           object3.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
         }