minecraft-renderer 0.1.41 → 0.1.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.41",
+  "version": "0.1.43",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",

package/src/lib/worldrendererCommon.ts

@@ -628,6 +628,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
       worldMinY: this.worldMinYRender,
       worldMaxY: this.worldMinYRender + this.worldSizeParams.worldHeight,
       disableConversionCache: this.worldRendererConfig.disableMesherConversionCache,
+      computeWireframeEdges: this.worldRendererConfig.futuristicReveal === true,
     }
   }
 

package/src/mesher-legacy/mesher.ts

@@ -1,7 +1,7 @@
 //@ts-nocheck
 import { Vec3 } from 'vec3'
 import { World } from '../mesher-shared/world'
-import { getSectionGeometry, setBlockStatesData as setMesherData } from '../mesher-shared/models'
+import { getSectionGeometry, setBlockStatesData as setMesherData, computeWireframeEdgesJS } from '../mesher-shared/models'
 import { BlockStateModelInfo } from '../mesher-shared/shared'
 import { handleGetHeightmap, EMPTY_COLUMN_HEIGHTMAP_SENTINEL } from '../mesher-shared/computeHeightmap'
 
@@ -208,7 +208,16 @@ setInterval(() => {
     if (chunk?.getSection(new Vec3(x, y, z))) {
       const start = performance.now()
       const geometry = getSectionGeometry(x, y, z, world)
+      if (geometry.positions.length > 0 && geometry.indices.length > 0 && world.config.computeWireframeEdges) {
+        const wireframeF32 = computeWireframeEdgesJS(geometry.positions as number[], geometry.indices as number[])
+        if (wireframeF32.length > 0) {
+          geometry.wireframePositions = wireframeF32
+        }
+      }
       const transferable = [geometry.positions?.buffer, geometry.normals?.buffer, geometry.colors?.buffer, geometry.uvs?.buffer].filter(Boolean)
+      if (geometry.wireframePositions) {
+        transferable.push(geometry.wireframePositions.buffer)
+      }
       //@ts-expect-error
       postMessage({ type: 'geometry', key, geometry, workerIndex }, transferable)
       processTime = performance.now() - start

package/src/mesher-shared/models.ts

@@ -794,3 +794,44 @@ export const setBlockStatesData = (blockstatesModels, blocksAtlas: any, _needTil
     }
   }
 }
+
+export function computeWireframeEdgesJS(positions: Float32Array | number[], indices: Uint32Array | Uint16Array | number[]): Float32Array {
+  const pos = positions instanceof Float32Array ? positions : new Float32Array(positions as number[])
+  const idx = indices instanceof Uint32Array ? indices : (indices instanceof Uint16Array ? new Uint32Array(indices) : new Uint32Array(indices as number[]))
+
+  const linePositions: number[] = []
+  const edgeSet = new Set<number>()
+
+  for (let i = 0; i < idx.length; i += 3) {
+    const i0 = idx[i]!
+    const i1 = idx[i + 1]!
+    const i2 = idx[i + 2]!
+
+    addEdgeJS(pos, i0, i1, linePositions, edgeSet)
+    addEdgeJS(pos, i1, i2, linePositions, edgeSet)
+    addEdgeJS(pos, i2, i0, linePositions, edgeSet)
+  }
+
+  return new Float32Array(linePositions)
+}
+
+function addEdgeJS(
+  positions: Float32Array,
+  i0: number,
+  i1: number,
+  linePositions: number[],
+  edgeSet: Set<number>
+): void {
+  const minI = i0 < i1 ? i0 : i1
+  const maxI = i0 < i1 ? i1 : i0
+  // Pack two indices into a single number (safe while indices < 2^24 — far above per-section vertex counts).
+  const key = minI * 0x1000000 + maxI
+
+  if (edgeSet.has(key)) return
+  edgeSet.add(key)
+
+  linePositions.push(
+    positions[i0 * 3]!, positions[i0 * 3 + 1]!, positions[i0 * 3 + 2]!,
+    positions[i1 * 3]!, positions[i1 * 3 + 1]!, positions[i1 * 3 + 2]!
+  )
+}

package/src/mesher-shared/shared.ts

@@ -19,6 +19,7 @@ export const defaultMesherConfig = {
   clipWorldBelowY: undefined as undefined | number,
   disableBlockEntityTextures: false,
   disableConversionCache: false,
+  computeWireframeEdges: false,
 }
 
 export type CustomBlockModels = {
@@ -60,6 +61,7 @@ export type MesherGeometryOutput = {
   // isFull: boolean
   hadErrors: boolean
   blocksCount: number
+  wireframePositions?: Float32Array
   customBlockModels?: CustomBlockModels
 }
 

package/src/three/modules/sciFiWorldReveal.ts

@@ -433,6 +433,12 @@ export class SciFiWorldRevealModule implements RendererModuleController {
    * Create wireframe geometry from mesh geometry
    */
   private createWireframeGeometry(geometry: MesherGeometryOutput): THREE.BufferGeometry {
+    if (geometry.wireframePositions && geometry.wireframePositions.length > 0) {
+      const wireframeGeom = new THREE.BufferGeometry()
+      wireframeGeom.setAttribute('position', new THREE.Float32BufferAttribute(geometry.wireframePositions, 3))
+      return wireframeGeom
+    }
+
     const positions = geometry.positions as Float32Array
     const indices = geometry.indices as Uint32Array | Uint16Array
 

package/src/three/worldRendererThree.ts

@@ -909,7 +909,7 @@ export class WorldRendererThree extends WorldRendererCommon {
     const yOffset = this.playerStateReactive.eyeHeight
 
     this.updateCamera(pos?.offset(0, yOffset, 0) ?? null, yaw, pitch)
-    this.media.tryIntersectMedia()
+    // this.media.tryIntersectMedia()
     this.updateCameraSectionPos()
   }
 

package/src/wasm-mesher/runtime-build/wasm_mesher.d.ts

@@ -2,6 +2,29 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/**
+ * Compute wireframe edge positions from a triangle mesh.
+ *
+ * Takes flat position and index arrays from an assembled mesh and returns a
+ * flat array of line-segment positions (x1,y1,z1,x2,y2,z2, ...) representing
+ * the unique edges of the mesh. Edge deduplication uses a `HashSet<(u32,u32)>`
+ * keyed on (min_vertex_index, max_vertex_index).
+ *
+ * `positions` — flat `Float32Array` of vertex positions (3 floats per vertex).
+ * `indices`  — flat `Uint32Array` of triangle indices (3 indices per triangle).
+ *              For 16-bit index arrays, prefer [`compute_wireframe_edges_u16`]
+ *              to avoid an extra JS-side `Uint32Array` allocation.
+ */
+export function computeWireframeEdges(positions: Float32Array, indices: Uint32Array): Float32Array;
+
+/**
+ * Same as [`compute_wireframe_edges`] but accepts a `Uint16Array` of indices.
+ *
+ * Avoids the JS-side `new Uint32Array(uint16)` allocation when the assembled
+ * section uses 16-bit indices (typical for sections with < 65k vertices).
+ */
+export function computeWireframeEdgesU16(positions: Float32Array, indices: Uint16Array): Float32Array;
+
 /**
  * VITALY's path: parse 1.18+ dump + light → run the mesher → return ONLY the final
  * geometry. Avoids marshalling the intermediate ~300KB block_states/biomes/lights
@@ -27,6 +50,24 @@ export function generateGeometryFromDump118(section_x: number, section_y: number
  */
 export function generateGeometryFromMapChunkV18Plus(raw_packet: Uint8Array, num_sections: number, max_bits_per_block: number, max_bits_per_biome: number, protocol: number, section_x: number, section_y: number, section_z: number, section_height: number, world_min_y: number, world_max_y: number, section_data_start_y: number, invisible_blocks: Uint16Array, transparent_blocks: Uint16Array, no_ao_blocks: Uint16Array, cull_identical_blocks: Uint16Array, occluding_blocks: Uint16Array, enable_lighting: boolean, smooth_lighting: boolean, sky_light_value: number): any;
 
+/**
+ * Fused multi-column parse+mesh for 1.18+ raw map_chunk.
+ *
+ * Parses multiple raw packets inside Rust and meshes them in a single
+ * `mesher.generate_multi` call with correct per-neighbor AO/lighting.
+ * No typed arrays are materialised on the JS heap.
+ *
+ * `raw_packets` — `Array<Uint8Array>`, one raw packet per column.
+ * Reuses the existing JS-side per-column buffers (zero concat, zero alloc).
+ *
+ * `num_sections_list` — per-column section count (terrain height varies).
+ *
+ * Invariant: `chunk_xs[0]` / `chunk_zs[0]` is the **target** column whose
+ * geometry is emitted. Neighbour columns provide border data to the mesher
+ * but do not contribute directly to the output.
+ */
+export function generateGeometryFromMapChunkV18PlusMulti(raw_packets: Array<any>, num_sections_list: Uint32Array, max_bits_per_block: number, max_bits_per_biome: number, protocol: number, chunk_xs: Int32Array, chunk_zs: Int32Array, section_x: number, section_y: number, section_z: number, section_height: number, world_min_y: number, world_max_y: number, section_data_start_y: number, invisible_blocks: Uint16Array, transparent_blocks: Uint16Array, no_ao_blocks: Uint16Array, cull_identical_blocks: Uint16Array, occluding_blocks: Uint16Array, enable_lighting: boolean, smooth_lighting: boolean, sky_light_value: number): any;
+
 /**
  * Fused parse+mesh for 1.16 / 1.17 chunk sections.
  *
@@ -41,6 +82,27 @@ export function generateGeometryFromMapChunkV18Plus(raw_packet: Uint8Array, num_
  */
 export function generateGeometryFromParsedV16V17(chunk_data: Uint8Array, bit_map_lo_hi: Uint32Array, num_sections: number, max_bits_per_block: number, biomes_cells: Int32Array, default_biome: number, sky_light: Uint8Array, block_light: Uint8Array, section_x: number, section_y: number, section_z: number, section_height: number, world_min_y: number, world_max_y: number, section_data_start_y: number, invisible_blocks: Uint16Array, transparent_blocks: Uint16Array, no_ao_blocks: Uint16Array, cull_identical_blocks: Uint16Array, occluding_blocks: Uint16Array, enable_lighting: boolean, smooth_lighting: boolean, sky_light_value: number): any;
 
+/**
+ * Fused multi-column parse+mesh for 1.16 / 1.17 chunk sections.
+ *
+ * Parses multiple columns inside Rust and meshes them in one
+ * `mesher.generate_multi` call.  Block states and biomes never leave WASM
+ * memory; light arrays are passed by reference from the JS-side
+ * update-light caches.
+ *
+ * `chunk_data_list` — `Array<Uint8Array>`, one chunk_data buffer per column.
+ * `bit_map_lo_hi` — flat `&[u32]` of length `chunkCount * 2`; each pair
+ *                    (lo, hi) is the section mask for one column.
+ * `num_sections_list` — per-column section count.
+ * `biomes_cells_list` — `Array<Int32Array>`, may contain empty arrays for
+ *                        columns without captured biomes.
+ * `sky_light_list` / `block_light_list` — `Array<Uint8Array>`, may contain
+ *   empty arrays for columns where update_light has not arrived yet.
+ *
+ * Invariant: `chunk_xs[0]` / `chunk_zs[0]` is the target column.
+ */
+export function generateGeometryFromParsedV16V17Multi(chunk_data_list: Array<any>, bit_map_lo_hi: Uint32Array, num_sections_list: Uint32Array, max_bits_per_block: number, biomes_cells_list: Array<any>, default_biome: number, sky_light_list: Array<any>, block_light_list: Array<any>, chunk_xs: Int32Array, chunk_zs: Int32Array, section_x: number, section_y: number, section_z: number, section_height: number, world_min_y: number, world_max_y: number, section_data_start_y: number, invisible_blocks: Uint16Array, transparent_blocks: Uint16Array, no_ao_blocks: Uint16Array, cull_identical_blocks: Uint16Array, occluding_blocks: Uint16Array, enable_lighting: boolean, smooth_lighting: boolean, sky_light_value: number): any;
+
 /**
  * Main entry point for generating geometry
  *
@@ -177,6 +239,10 @@ export interface InitOutput {
   readonly parseMapChunkV18Plus: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
   readonly parseChunkSectionsV16V17: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => any;
   readonly generateGeometryFromParsedV16V17: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number) => any;
+  readonly generateGeometryFromMapChunkV18PlusMulti: (a: any, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number) => any;
+  readonly generateGeometryFromParsedV16V17Multi: (a: any, b: number, c: number, d: number, e: number, f: number, g: any, h: number, i: any, j: any, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number, h1: number) => any;
+  readonly computeWireframeEdges: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly computeWireframeEdgesU16: (a: number, b: number, c: number, d: number) => [number, number];
   readonly parseUpdateLightV17: (a: number, b: number, c: number) => any;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;

package/src/wasm-mesher/runtime-build/wasm_mesher.js

@@ -71,6 +71,16 @@ function debugString(val) {
     return className;
 }
 
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayI32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getInt32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU16FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
@@ -89,6 +99,22 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
+let cachedInt32ArrayMemory0 = null;
+function getInt32ArrayMemory0() {
+    if (cachedInt32ArrayMemory0 === null || cachedInt32ArrayMemory0.byteLength === 0) {
+        cachedInt32ArrayMemory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32ArrayMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return decodeText(ptr, len);
@@ -148,6 +174,13 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayF32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getFloat32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -214,6 +247,53 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
+/**
+ * Compute wireframe edge positions from a triangle mesh.
+ *
+ * Takes flat position and index arrays from an assembled mesh and returns a
+ * flat array of line-segment positions (x1,y1,z1,x2,y2,z2, ...) representing
+ * the unique edges of the mesh. Edge deduplication uses a `HashSet<(u32,u32)>`
+ * keyed on (min_vertex_index, max_vertex_index).
+ *
+ * `positions` — flat `Float32Array` of vertex positions (3 floats per vertex).
+ * `indices`  — flat `Uint32Array` of triangle indices (3 indices per triangle).
+ *              For 16-bit index arrays, prefer [`compute_wireframe_edges_u16`]
+ *              to avoid an extra JS-side `Uint32Array` allocation.
+ * @param {Float32Array} positions
+ * @param {Uint32Array} indices
+ * @returns {Float32Array}
+ */
+export function computeWireframeEdges(positions, indices) {
+    const ptr0 = passArrayF32ToWasm0(positions, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray32ToWasm0(indices, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.computeWireframeEdges(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+
+/**
+ * Same as [`compute_wireframe_edges`] but accepts a `Uint16Array` of indices.
+ *
+ * Avoids the JS-side `new Uint32Array(uint16)` allocation when the assembled
+ * section uses 16-bit indices (typical for sections with < 65k vertices).
+ * @param {Float32Array} positions
+ * @param {Uint16Array} indices
+ * @returns {Float32Array}
+ */
+export function computeWireframeEdgesU16(positions, indices) {
+    const ptr0 = passArrayF32ToWasm0(positions, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray16ToWasm0(indices, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.computeWireframeEdgesU16(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+
 /**
  * VITALY's path: parse 1.18+ dump + light → run the mesher → return ONLY the final
  * geometry. Avoids marshalling the intermediate ~300KB block_states/biomes/lights
@@ -328,6 +408,66 @@ export function generateGeometryFromMapChunkV18Plus(raw_packet, num_sections, ma
     return ret;
 }
 
+/**
+ * Fused multi-column parse+mesh for 1.18+ raw map_chunk.
+ *
+ * Parses multiple raw packets inside Rust and meshes them in a single
+ * `mesher.generate_multi` call with correct per-neighbor AO/lighting.
+ * No typed arrays are materialised on the JS heap.
+ *
+ * `raw_packets` — `Array<Uint8Array>`, one raw packet per column.
+ * Reuses the existing JS-side per-column buffers (zero concat, zero alloc).
+ *
+ * `num_sections_list` — per-column section count (terrain height varies).
+ *
+ * Invariant: `chunk_xs[0]` / `chunk_zs[0]` is the **target** column whose
+ * geometry is emitted. Neighbour columns provide border data to the mesher
+ * but do not contribute directly to the output.
+ * @param {Array<any>} raw_packets
+ * @param {Uint32Array} num_sections_list
+ * @param {number} max_bits_per_block
+ * @param {number} max_bits_per_biome
+ * @param {number} protocol
+ * @param {Int32Array} chunk_xs
+ * @param {Int32Array} chunk_zs
+ * @param {number} section_x
+ * @param {number} section_y
+ * @param {number} section_z
+ * @param {number} section_height
+ * @param {number} world_min_y
+ * @param {number} world_max_y
+ * @param {number} section_data_start_y
+ * @param {Uint16Array} invisible_blocks
+ * @param {Uint16Array} transparent_blocks
+ * @param {Uint16Array} no_ao_blocks
+ * @param {Uint16Array} cull_identical_blocks
+ * @param {Uint16Array} occluding_blocks
+ * @param {boolean} enable_lighting
+ * @param {boolean} smooth_lighting
+ * @param {number} sky_light_value
+ * @returns {any}
+ */
+export function generateGeometryFromMapChunkV18PlusMulti(raw_packets, num_sections_list, max_bits_per_block, max_bits_per_biome, protocol, chunk_xs, chunk_zs, section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, invisible_blocks, transparent_blocks, no_ao_blocks, cull_identical_blocks, occluding_blocks, enable_lighting, smooth_lighting, sky_light_value) {
+    const ptr0 = passArray32ToWasm0(num_sections_list, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray32ToWasm0(chunk_xs, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray32ToWasm0(chunk_zs, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passArray16ToWasm0(invisible_blocks, wasm.__wbindgen_malloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ptr4 = passArray16ToWasm0(transparent_blocks, wasm.__wbindgen_malloc);
+    const len4 = WASM_VECTOR_LEN;
+    const ptr5 = passArray16ToWasm0(no_ao_blocks, wasm.__wbindgen_malloc);
+    const len5 = WASM_VECTOR_LEN;
+    const ptr6 = passArray16ToWasm0(cull_identical_blocks, wasm.__wbindgen_malloc);
+    const len6 = WASM_VECTOR_LEN;
+    const ptr7 = passArray16ToWasm0(occluding_blocks, wasm.__wbindgen_malloc);
+    const len7 = WASM_VECTOR_LEN;
+    const ret = wasm.generateGeometryFromMapChunkV18PlusMulti(raw_packets, ptr0, len0, max_bits_per_block, max_bits_per_biome, protocol, ptr1, len1, ptr2, len2, section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, enable_lighting, smooth_lighting, sky_light_value);
+    return ret;
+}
+
 /**
  * Fused parse+mesh for 1.16 / 1.17 chunk sections.
  *
@@ -389,6 +529,74 @@ export function generateGeometryFromParsedV16V17(chunk_data, bit_map_lo_hi, num_
     return ret;
 }
 
+/**
+ * Fused multi-column parse+mesh for 1.16 / 1.17 chunk sections.
+ *
+ * Parses multiple columns inside Rust and meshes them in one
+ * `mesher.generate_multi` call.  Block states and biomes never leave WASM
+ * memory; light arrays are passed by reference from the JS-side
+ * update-light caches.
+ *
+ * `chunk_data_list` — `Array<Uint8Array>`, one chunk_data buffer per column.
+ * `bit_map_lo_hi` — flat `&[u32]` of length `chunkCount * 2`; each pair
+ *                    (lo, hi) is the section mask for one column.
+ * `num_sections_list` — per-column section count.
+ * `biomes_cells_list` — `Array<Int32Array>`, may contain empty arrays for
+ *                        columns without captured biomes.
+ * `sky_light_list` / `block_light_list` — `Array<Uint8Array>`, may contain
+ *   empty arrays for columns where update_light has not arrived yet.
+ *
+ * Invariant: `chunk_xs[0]` / `chunk_zs[0]` is the target column.
+ * @param {Array<any>} chunk_data_list
+ * @param {Uint32Array} bit_map_lo_hi
+ * @param {Uint32Array} num_sections_list
+ * @param {number} max_bits_per_block
+ * @param {Array<any>} biomes_cells_list
+ * @param {number} default_biome
+ * @param {Array<any>} sky_light_list
+ * @param {Array<any>} block_light_list
+ * @param {Int32Array} chunk_xs
+ * @param {Int32Array} chunk_zs
+ * @param {number} section_x
+ * @param {number} section_y
+ * @param {number} section_z
+ * @param {number} section_height
+ * @param {number} world_min_y
+ * @param {number} world_max_y
+ * @param {number} section_data_start_y
+ * @param {Uint16Array} invisible_blocks
+ * @param {Uint16Array} transparent_blocks
+ * @param {Uint16Array} no_ao_blocks
+ * @param {Uint16Array} cull_identical_blocks
+ * @param {Uint16Array} occluding_blocks
+ * @param {boolean} enable_lighting
+ * @param {boolean} smooth_lighting
+ * @param {number} sky_light_value
+ * @returns {any}
+ */
+export function generateGeometryFromParsedV16V17Multi(chunk_data_list, bit_map_lo_hi, num_sections_list, max_bits_per_block, biomes_cells_list, default_biome, sky_light_list, block_light_list, chunk_xs, chunk_zs, section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, invisible_blocks, transparent_blocks, no_ao_blocks, cull_identical_blocks, occluding_blocks, enable_lighting, smooth_lighting, sky_light_value) {
+    const ptr0 = passArray32ToWasm0(bit_map_lo_hi, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray32ToWasm0(num_sections_list, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray32ToWasm0(chunk_xs, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passArray32ToWasm0(chunk_zs, wasm.__wbindgen_malloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ptr4 = passArray16ToWasm0(invisible_blocks, wasm.__wbindgen_malloc);
+    const len4 = WASM_VECTOR_LEN;
+    const ptr5 = passArray16ToWasm0(transparent_blocks, wasm.__wbindgen_malloc);
+    const len5 = WASM_VECTOR_LEN;
+    const ptr6 = passArray16ToWasm0(no_ao_blocks, wasm.__wbindgen_malloc);
+    const len6 = WASM_VECTOR_LEN;
+    const ptr7 = passArray16ToWasm0(cull_identical_blocks, wasm.__wbindgen_malloc);
+    const len7 = WASM_VECTOR_LEN;
+    const ptr8 = passArray16ToWasm0(occluding_blocks, wasm.__wbindgen_malloc);
+    const len8 = WASM_VECTOR_LEN;
+    const ret = wasm.generateGeometryFromParsedV16V17Multi(chunk_data_list, ptr0, len0, ptr1, len1, max_bits_per_block, biomes_cells_list, default_biome, sky_light_list, block_light_list, ptr2, len2, ptr3, len3, section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, enable_lighting, smooth_lighting, sky_light_value);
+    return ret;
+}
+
 /**
  * Main entry point for generating geometry
  *
@@ -750,6 +958,30 @@ function __wbg_get_imports() {
     imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
+    imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
+        const ret = arg0[arg1 >>> 0];
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_Int32Array_b6281022039fba32 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Int32Array;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_Uint8Array_da54ccc9d3e09434 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Uint8Array;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
     imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
         const ret = arg0.length;
         return ret;
@@ -758,6 +990,10 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
+    imports.wbg.__wbg_length_ab53989976907f11 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
     imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
         const ret = new Object();
         return ret;
@@ -766,6 +1002,10 @@ function __wbg_get_imports() {
         const ret = new Array();
         return ret;
     };
+    imports.wbg.__wbg_new_with_length_1e8603a5c71d4e06 = function(arg0) {
+        const ret = new Int32Array(arg0 >>> 0);
+        return ret;
+    };
     imports.wbg.__wbg_new_with_length_aa5eaf41d35235e5 = function(arg0) {
         const ret = new Uint8Array(arg0 >>> 0);
         return ret;
@@ -774,6 +1014,12 @@ function __wbg_get_imports() {
         const ret = new Uint16Array(arg0 >>> 0);
         return ret;
     };
+    imports.wbg.__wbg_prototypesetcall_dd07c344a74d4bfd = function(arg0, arg1, arg2) {
+        Int32Array.prototype.set.call(getArrayI32FromWasm0(arg0, arg1), arg2);
+    };
+    imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
+        Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+    };
     imports.wbg.__wbg_set_169e13b608078b7b = function(arg0, arg1, arg2) {
         arg0.set(getArrayU8FromWasm0(arg1, arg2));
     };
@@ -822,6 +1068,8 @@ function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
     cachedDataViewMemory0 = null;
+    cachedFloat32ArrayMemory0 = null;
+    cachedInt32ArrayMemory0 = null;
     cachedUint16ArrayMemory0 = null;
     cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;

package/src/wasm-mesher/runtime-build/wasm_mesher_bg.wasm.d.ts

@@ -14,6 +14,10 @@ export const generateGeometryFromMapChunkV18Plus: (a: number, b: number, c: numb
 export const parseMapChunkV18Plus: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
 export const parseChunkSectionsV16V17: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => any;
 export const generateGeometryFromParsedV16V17: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number) => any;
+export const generateGeometryFromMapChunkV18PlusMulti: (a: any, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number) => any;
+export const generateGeometryFromParsedV16V17Multi: (a: any, b: number, c: number, d: number, e: number, f: number, g: any, h: number, i: any, j: any, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number, h1: number) => any;
+export const computeWireframeEdges: (a: number, b: number, c: number, d: number) => [number, number];
+export const computeWireframeEdgesU16: (a: number, b: number, c: number, d: number) => [number, number];
 export const parseUpdateLightV17: (a: number, b: number, c: number) => any;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;