minecraft-renderer 0.1.37 → 0.1.39

package/src/three/worldRendererThree.ts

@@ -67,7 +67,7 @@ export class WorldRendererThree extends WorldRendererCommon {
   cameraContainer!: THREE.Object3D
   media: ThreeJsMedia
   get waitingChunksToDisplay() {
-    return {} as { [chunkKey: string]: string[] }
+    return this.chunkMeshManager.waitingChunksToDisplay
   }
   waypoints: WaypointsRenderer
   cinimaticScript: CinimaticScriptRunner
@@ -82,7 +82,14 @@ export class WorldRendererThree extends WorldRendererCommon {
   camera!: THREE.PerspectiveCamera
   renderTimeAvg = 0
   private pendingSectionUpdates = new Map<string, { geometry: MesherGeometryOutput, key: string, type: string }>()
-  private pendingSectionBufferStartTime: number | null = null
+  /**
+   * Per-section buffering timestamps for `applyPendingSectionUpdates`.
+   * Each section gets its own deadline so a continuous stream of updates
+   * (e.g. server-side block changes from explosions, pistons, fluid ticks)
+   * does not flush freshly added sections together with stale ones via a
+   * single global timer.
+   */
+  private pendingSectionBufferStartTimes = new Map<string, number>()
   private static readonly MAX_SECTION_UPDATE_BUFFER_MS = 500
   // Memory usage tracking (in bytes)
   get estimatedMemoryUsage() {
@@ -747,42 +754,57 @@ export class WorldRendererThree extends WorldRendererCommon {
   }
 
   finishChunk(chunkKey: string) {
-    // Existing sections are buffered and flushed from applyPendingSectionUpdates().
+    // Reveal all sections of this chunk that were held invisible by the
+    // "Batch Chunks Display" (`_renderByChunks`) option. No-op when the
+    // option is off — `waitingChunksToDisplay` is empty in that case.
+    this.chunkMeshManager.finishChunkDisplay(chunkKey)
   }
 
   private applyPendingSectionUpdates() {
     if (this.pendingSectionUpdates.size === 0) return
 
     const now = performance.now()
-    const sinceFirst = now - (this.pendingSectionBufferStartTime ?? now)
+    const sectionHeight = this.getSectionHeight()
+    const ready: string[] = []
 
-    if (sinceFirst < WorldRendererThree.MAX_SECTION_UPDATE_BUFFER_MS) {
-      const sectionHeight = this.getSectionHeight()
-      for (const key of this.pendingSectionUpdates.keys()) {
+    for (const key of this.pendingSectionUpdates.keys()) {
+      const startedAt = this.pendingSectionBufferStartTimes.get(key) ?? now
+      const sinceFirst = now - startedAt
+
+      if (sinceFirst < WorldRendererThree.MAX_SECTION_UPDATE_BUFFER_MS) {
+        // Still within this section's grace window — wait if any neighbor is
+        // currently being re-meshed so we don't briefly expose a hole between
+        // the just-updated section and a stale neighbor (sky-flicker bug).
         const [sx, sy, sz] = key.split(',').map(Number)
         const neighborKeys = [
           `${sx - 16},${sy},${sz}`, `${sx + 16},${sy},${sz}`,
           `${sx},${sy - sectionHeight},${sz}`, `${sx},${sy + sectionHeight},${sz}`,
           `${sx},${sy},${sz - 16}`, `${sx},${sy},${sz + 16}`,
         ]
-
+        let neighborBusy = false
         for (const neighborKey of neighborKeys) {
           if (
             this.sectionsWaiting.has(neighborKey) &&
             !this.pendingSectionUpdates.has(neighborKey) &&
             this.sectionObjects[neighborKey]
           ) {
-            return
+            neighborBusy = true
+            break
           }
         }
+        if (neighborBusy) continue
       }
+
+      ready.push(key)
     }
 
-    const updates = [...this.pendingSectionUpdates.values()]
-    this.pendingSectionUpdates.clear()
-    this.pendingSectionBufferStartTime = null
+    if (ready.length === 0) return
+
+    for (const key of ready) {
+      const update = this.pendingSectionUpdates.get(key)!
+      this.pendingSectionUpdates.delete(key)
+      this.pendingSectionBufferStartTimes.delete(key)
 
-    for (const update of updates) {
       const chunkCoords = update.key.split(',')
       const chunkKey = `${chunkCoords[0]},${chunkCoords[2]}`
 
@@ -805,12 +827,9 @@ export class WorldRendererThree extends WorldRendererCommon {
     for (const key of [...this.pendingSectionUpdates.keys()]) {
       if (key.startsWith(`${x},`) && key.endsWith(`,${z}`)) {
         this.pendingSectionUpdates.delete(key)
+        this.pendingSectionBufferStartTimes.delete(key)
       }
     }
-
-    if (this.pendingSectionUpdates.size === 0) {
-      this.pendingSectionBufferStartTime = null
-    }
   }
 
   handleWorkerMessage(data: { geometry: MesherGeometryOutput, key, type }): void {
@@ -819,15 +838,17 @@ export class WorldRendererThree extends WorldRendererCommon {
       const chunkKey = `${chunkCoords[0]},${chunkCoords[2]}`
       if (!this.loadedChunks[chunkKey] || !this.active) {
         this.pendingSectionUpdates.delete(data.key)
-        if (this.pendingSectionUpdates.size === 0) {
-          this.pendingSectionBufferStartTime = null
-        }
+        this.pendingSectionBufferStartTimes.delete(data.key)
         return
       }
 
       if (this.sectionObjects[data.key]) {
         this.pendingSectionUpdates.set(data.key, data)
-        this.pendingSectionBufferStartTime ??= performance.now()
+        // Per-section deadline: only set if we don't already have one, so
+        // repeated updates to the same section don't postpone its flush.
+        if (!this.pendingSectionBufferStartTimes.has(data.key)) {
+          this.pendingSectionBufferStartTimes.set(data.key, performance.now())
+        }
         return
       }
 
@@ -1137,6 +1158,7 @@ export class WorldRendererThree extends WorldRendererCommon {
       chunksRenderDistanceOverride !== undefined
     ) {
       for (const [key, object] of Object.entries(this.sectionObjects)) {
+        if (object._waitingForChunkDisplay) continue
         const [x, y, z] = key.split(',').map(Number)
         const isVisible =
           // eslint-disable-next-line no-constant-binary-expression, sonarjs/no-redundant-boolean
@@ -1149,9 +1171,11 @@ export class WorldRendererThree extends WorldRendererCommon {
         object.visible = isVisible
       }
     } else {
-      for (const object of Object.values(this.sectionObjects)) {
-        object.visible = true
-      }
+      // No debug visibility override active — defer to the manager so the
+      // performance-based override distance (set by `recordRenderTime` /
+      // `autoLowerRenderDistance`) is honored, instead of force-showing every
+      // section every frame and clobbering it.
+      this.chunkMeshManager.updateSectionsVisibility()
     }
   }
 
@@ -1322,20 +1346,16 @@ export class WorldRendererThree extends WorldRendererCommon {
   }
 
   updateShowChunksBorder(value: boolean) {
-    for (const object of Object.values(this.sectionObjects)) {
-      for (const child of object.children) {
-        if (child.name === 'helper') {
-          child.visible = value
-        }
-      }
-    }
+    // Lazily create helpers on the first toggle (they are not created upfront
+    // for sections streamed in while the option was off).
+    this.chunkMeshManager.updateAllBoxHelpers(value)
   }
 
   resetWorld() {
     super.resetWorld()
 
     this.pendingSectionUpdates.clear()
-    this.pendingSectionBufferStartTime = null
+    this.pendingSectionBufferStartTimes.clear()
     this.chunkMeshManager.dispose()
     this.chunkMeshManager = new ChunkMeshManager(this, this.scene, this.material, this.worldSizeParams.worldHeight, this.viewDistance)
 
@@ -1366,6 +1386,11 @@ export class WorldRendererThree extends WorldRendererCommon {
       textures[key].dispose()
       delete textures[key]
     }
+    // Sign / head textures moved to ChunkMeshManager.signHeadsRenderer in PR
+    // #16; without invalidating that cache here, sign edits (and any other
+    // block-entity NBT change picked up via setSectionDirty) would re-render
+    // with the stale cached canvas until a full world reset.
+    this.chunkMeshManager.cleanSignChunkTextures(x, z)
   }
 
   readdChunks() {
@@ -1399,6 +1424,13 @@ export class WorldRendererThree extends WorldRendererCommon {
         this.chunkMeshManager.releaseSection(key)
       }
     }
+    // Drop near-first reveal state and re-check any farther chunks
+    // that may have been blocked by this column.
+    this.chunkMeshManager.onChunkRemovedFromGate(`${x},${z}`)
+  }
+
+  protected onViewerChunkPositionChanged(): void {
+    this.chunkMeshManager.tryRevealPending()
   }
 
   setSectionDirty(...args: Parameters<WorldRendererCommon['setSectionDirty']>) {
@@ -1422,7 +1454,7 @@ export class WorldRendererThree extends WorldRendererCommon {
 
   destroy(): void {
     this.pendingSectionUpdates.clear()
-    this.pendingSectionBufferStartTime = null
+    this.pendingSectionBufferStartTimes.clear()
     this.chunkMeshManager.dispose()
     this.disposeModules()
     this.fireworksLegacy.destroy()

package/src/wasm-lib/render-from-wasm.ts

@@ -64,6 +64,7 @@ interface CachedBlockModel {
   blockProps: Record<string, any>
   models: any // BlockModelPartsResolved
   isCube: boolean
+  boundingBox: string
   // Precomputed per-model variant
   modelVariants: Array<{
     model: any
@@ -86,10 +87,51 @@ interface WasmBlockFaceData {
   light_data: number[][]
 }
 
-interface WasmGeometryOutput {
+export interface WasmGeometryOutput {
   blocks: WasmBlockFaceData[]
   block_count: number
   block_iterations: number
+  /**
+   * Per-(x,z) max non-invisible block Y for the meshed column, indexed as
+   * `z * 16 + x`. Sentinel value `-32768` = no block in that column.
+   *
+   * Populated by Rust `Mesher::generate_with_world` (see
+   * `wasm-mesher/src/mesher.rs`, field `heightmap`). serde_wasm_bindgen
+   * serializes `Vec<i16>` as a plain JS `number[]`, which is why the type
+   * here is `ArrayLike<number>` rather than `Int16Array` — the runtime
+   * adapter `extractColumnHeightmap` handles both shapes.
+   *
+   * Used at runtime by `mesherWasm.ts` `processColumnTick`: every column
+   * tick the WASM heightmap is extracted via `extractColumnHeightmap` and
+   * posted to the main thread as a `'heightmap'` message. JS
+   * `computeHeightmap` is now only a fallback (length mismatch / missing
+   * field) and a safety-net for empty columns at chunk load. Empty-column
+   * semantics are aligned: both Rust and JS use `-32768` (see
+   * `EMPTY_COLUMN_HEIGHTMAP_SENTINEL`).
+   */
+  heightmap?: ArrayLike<number> | null
+}
+
+/**
+ * Extract a 256-entry Int16Array heightmap from a full-column WASM mesher
+ * result, indexed as `z * 16 + x` (matching the JS `computeHeightmap`
+ * convention). Returns `null` when the WASM output does not carry a
+ * heightmap or carries one of unexpected length — in that case the
+ * caller MUST fall back to JS `computeHeightmap` rather than guess.
+ *
+ * This adapter is the single place that converts Rust's `Vec<i16>` heightmap
+ * shape into a transferable typed array. Tests exercise this same adapter so
+ * future runtime usage and parity assertions cannot drift apart.
+ */
+export function extractColumnHeightmap(
+  wasmOutput: { heightmap?: ArrayLike<number> | null } | null | undefined
+): Int16Array | null {
+  const raw = wasmOutput?.heightmap
+  if (!raw || raw.length !== 256) return null
+  if (raw instanceof Int16Array) return new Int16Array(raw)
+  const out = new Int16Array(256)
+  for (let i = 0; i < 256; i++) out[i] = raw[i]
+  return out
 }
 
 /**
@@ -181,6 +223,7 @@ function getCachedBlockModel(
       models,
       modelVariants,
       isCube,
+      boundingBox: blockObj.boundingBox,
     }
 
     cache.set(cacheKey, cached)
@@ -697,6 +740,11 @@ export function renderWasmOutputToGeometry(
         globalShift = vecsub3(globalShift, matmul3(globalMatrix, globalShift))
       }
 
+      // Mirror JS mesher: doAO = model.ao ?? block.boundingBox !== 'empty'.
+      // When false, faces are emitted full-bright without AO/light sampling and without
+      // triangle-flip reordering (matches JS `light = 1` and standard winding).
+      const doAO = (model as any).ao ?? cachedModel.boundingBox !== 'empty'
+
       for (const element of model.elements ?? []) {
         let localMatrix = null as any
         let localShift = null as any
@@ -723,8 +771,12 @@ export function renderWasmOutputToGeometry(
             Math.round(transformedDir[2]),
           ]
           const dirKey = `${transformedDirI[0]},${transformedDirI[1]},${transformedDirI[2]}`
+          // faceIdx may be undefined for diagonal-rotated faces (e.g. signs at 45/135/225/315 deg).
+          // Such faces are not representable in the 6-axis WASM visible_faces / ao_data / light_data
+          // arrays. We still emit them (mirrors JS mesher behavior); cullface and AO/light data
+          // lookups are skipped, and the model-lighting fallback below derives AO/light by
+          // sampling neighbors via transformedDirI (its rounded form, same as for cardinal axes).
           const faceIdx = dirKeyToIndex[dirKey]
-          if (faceIdx === undefined) continue
 
           const minx = element.from[0]
           const miny = element.from[1]
@@ -733,13 +785,13 @@ export function renderWasmOutputToGeometry(
           const maxy = element.to[1]
           const maxz = element.to[2]
 
-          if (matchingEFace.cullface) {
+          if (matchingEFace.cullface && faceIdx !== undefined) {
             if ((block.visible_faces & (1 << faceIdx)) === 0) {
               continue
             }
           }
 
-          const faceDataIndex = wasmFaceToDataIndex[faceIdx]
+          const faceDataIndex = faceIdx === undefined ? undefined : wasmFaceToDataIndex[faceIdx]
           const aoValuesRaw = faceDataIndex === undefined ? undefined : block.ao_data[faceDataIndex]
           const lightValuesRaw = faceDataIndex === undefined ? undefined : block.light_data[faceDataIndex]
 
@@ -787,8 +839,13 @@ export function renderWasmOutputToGeometry(
 
             let ao = 3
             let cornerLightResult = 15
+            let light: number
 
-            if (useModelLighting) {
+            if (!doAO) {
+              // JS parity: skip AO/light sampling, emit full-bright vertex.
+              computedAoValues[cornerIdx] = 3
+              light = 1
+            } else if (useModelLighting) {
               const cursor = new Vec3(bx, by, bz)
 
               const dx = pos[0] * 2 - 1
@@ -849,9 +906,11 @@ export function renderWasmOutputToGeometry(
               cornerLightResult = baseLight * 15
             }
 
-            const light = (ao + 1) / 4 * (cornerLightResult / 15)
+            if (doAO) {
+              light = (ao + 1) / 4 * (cornerLightResult / 15)
+            }
 
-            colors.push(tint[0] * light, tint[1] * light, tint[2] * light)
+            colors.push(tint[0] * light!, tint[1] * light!, tint[2] * light!)
 
             const baseu = (pos[3] - 0.5) * uvcs - (pos[4] - 0.5) * uvsn + 0.5
             const basev = (pos[3] - 0.5) * uvsn + (pos[4] - 0.5) * uvcs + 0.5
@@ -865,7 +924,7 @@ export function renderWasmOutputToGeometry(
           const aoValues = computedAoValues
 
           let tri1: number[], tri2: number[]
-          if (aoValues[0] + aoValues[3] >= aoValues[1] + aoValues[2]) {
+          if (doAO && aoValues[0] + aoValues[3] >= aoValues[1] + aoValues[2]) {
             tri1 = [baseIndex, baseIndex + 3, baseIndex + 2]
             tri2 = [baseIndex, baseIndex + 1, baseIndex + 3]
           } else {
@@ -915,15 +974,101 @@ export function renderWasmOutputToGeometry(
     },
   }
 
-  console.log(`[WASM] Final geometry summary:`)
-  console.log(`[WASM]   Total vertices: ${positions.length / 3}`)
-  console.log(`[WASM]   Total triangles: ${indices.length / 3}`)
-  console.log(`[WASM]   Positions: [${positions.slice(0, 12).join(',')}...] (first 4 vertices)`)
-  console.log(`[WASM]   Indices: [${indices.slice(0, 12).join(',')}...] (first 2 faces)`)
+  log(`[WASM] Final geometry summary:`)
+  log(`[WASM]   Total vertices: ${positions.length / 3}`)
+  log(`[WASM]   Total triangles: ${indices.length / 3}`)
+  log(`[WASM]   Positions: [${positions.slice(0, 12).join(',')}...] (first 4 vertices)`)
+  log(`[WASM]   Indices: [${indices.slice(0, 12).join(',')}...] (first 2 faces)`)
 
   return result
 }
 
+/**
+ * Split a single full-column WASM mesher result into per-section
+ * `ExportedSection` outputs by filtering `wasmResult.blocks` per requested
+ * section's Y range and invoking `renderWasmOutputToGeometry` once per
+ * section.
+ *
+ * Why split at the block level (and not after geometry generation):
+ *   - Liquids (water/lava), signs/heads/banners metadata, AO/light arrays
+ *     and index numbering are computed inside `renderWasmOutputToGeometry`.
+ *     Splitting *finished* vertex/index buffers would silently break those.
+ *   - Filtering blocks by Y range and re-running the post-processor per
+ *     section keeps the output identical to the existing per-section path.
+ *
+ * Y=15/16 (and any other inter-section) seam handling:
+ *   - The Rust mesher produced `wasmResult` over the full column, so each
+ *     block's `visible_faces`, `ao_data` and `light_data` already account
+ *     for its true neighbors — including the block above at the section
+ *     seam (e.g. a Y=15 top face is correctly suppressed when Y=16 is
+ *     opaque, even though Y=16 lives in the next render section).
+ *   - This helper therefore does NOT need to widen the per-section block
+ *     window: a strict `[sy*sectionHeight, sy*sectionHeight + sectionHeight)`
+ *     filter on `block.position[1]` is sufficient. The neighbor information
+ *     is already baked into each block's per-face mask/AO/light arrays.
+ *
+ * Empty sections: sections with no blocks in range still get a call into
+ * `renderWasmOutputToGeometry` with an empty `blocks` array, so the
+ * returned `ExportedSection` shape matches what the per-section path
+ * produces for an empty section (empty positions/normals/colors/uvs/
+ * indices arrays).
+ *
+ * Note: this pure helper is not gated internally; callers decide whether
+ * column meshing is enabled.
+ */
+export function splitColumnWasmOutputToSections(
+  fullColumnOutput: WasmGeometryOutput,
+  requestedSectionKeys: Array<{ x: number, y: number, z: number }>,
+  ctx: { version: string, world?: World, sectionHeight?: number }
+): Map<string, { exported: ExportedSection, blocksCount: number }> {
+  const { version, world } = ctx
+  const sectionHeight = ctx.sectionHeight ?? 16
+
+  // Bucket blocks by section Y once, so we don't re-scan the full column
+  // for every requested section. Bucket key = section-relative chunk Y
+  // (i.e. floor(by / sectionHeight)).
+  const blocksByChunkY = new Map<number, WasmBlockFaceData[]>()
+  for (const block of fullColumnOutput.blocks) {
+    const by = block.position[1]
+    const chunkY = Math.floor(by / sectionHeight)
+    let bucket = blocksByChunkY.get(chunkY)
+    if (!bucket) {
+      bucket = []
+      blocksByChunkY.set(chunkY, bucket)
+    }
+    bucket.push(block)
+  }
+
+  const out = new Map<string, { exported: ExportedSection, blocksCount: number }>()
+  for (const { x, y, z } of requestedSectionKeys) {
+    // `y` here is the section's world-Y origin (multiple of sectionHeight),
+    // matching the convention used by `mesherWasm.ts` (section keys are
+    // `${chunkX*16},${sectionY},${chunkZ*16}` with sectionY a world-Y
+    // multiple of 16). Translate to chunk-Y bucket index.
+    const chunkY = Math.floor(y / sectionHeight)
+    const sectionBlocks = blocksByChunkY.get(chunkY) ?? []
+
+    const sectionView: WasmGeometryOutput = {
+      blocks: sectionBlocks,
+      block_count: sectionBlocks.length,
+      block_iterations: fullColumnOutput.block_iterations,
+    }
+
+    const sectionKey = `${x},${y},${z}`
+    const sectionPosition = { x: x + 8, y: y + 8, z: z + 8 }
+    const exported = renderWasmOutputToGeometry(
+      sectionView,
+      version,
+      sectionKey,
+      sectionPosition,
+      world
+    )
+    out.set(sectionKey, { exported, blocksCount: sectionBlocks.length })
+  }
+
+  return out
+}
+
 /**
  * Convert WASM output to exported geometry format
  */

package/wasm/wasm_mesher.d.ts

@@ -7,16 +7,16 @@
  * Input: Serialized chunk data as TypedArrays
  * Output: Geometry data (positions, normals, colors, uvs, indices)
  */
-export function generate_geometry(section_x: number, section_y: number, section_z: number, section_height: number, world_min_y: number, world_max_y: number, block_states: Uint16Array, block_light: Uint8Array, sky_light: Uint8Array, biomes: Uint8Array, 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;
+export function generate_geometry(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, block_states: Uint16Array, block_light: Uint8Array, sky_light: Uint8Array, biomes: Uint8Array, 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;
 
-export function generate_geometry_multi(section_x: number, section_y: number, section_z: number, section_height: number, world_min_y: number, world_max_y: number, chunk_xs: Int32Array, chunk_zs: Int32Array, block_states: Uint16Array, block_light: Uint8Array, sky_light: Uint8Array, biomes: Uint8Array, 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;
+export function generate_geometry_multi(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, chunk_xs: Int32Array, chunk_zs: Int32Array, block_states: Uint16Array, block_light: Uint8Array, sky_light: Uint8Array, biomes: Uint8Array, 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;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
-  readonly generate_geometry: (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) => any;
-  readonly generate_geometry_multi: (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) => any;
+  readonly generate_geometry: (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) => any;
+  readonly generate_geometry_multi: (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) => any;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_externrefs: WebAssembly.Table;

package/wasm/wasm_mesher.js

@@ -1,15 +1,5 @@
 let wasm;
 
-function _assertBoolean(n) {
-    if (typeof(n) !== 'boolean') {
-        throw new Error(`expected a boolean argument, found ${typeof(n)}`);
-    }
-}
-
-function _assertNum(n) {
-    if (typeof(n) !== 'number') throw new Error(`expected a number argument, found ${typeof(n)}`);
-}
-
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -112,22 +102,6 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
-function logError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        let error = (function () {
-            try {
-                return e instanceof Error ? `${e.message}\n\nStack:\n${e.stack}` : e.toString();
-            } catch(_) {
-                return "<failed to stringify thrown value>";
-            }
-        }());
-        console.error("wasm-bindgen: imported JS function that was not marked as `catch` threw an error:", error);
-        throw e;
-    }
-}
-
 function passArray16ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 2, 2) >>> 0;
     getUint16ArrayMemory0().set(arg, ptr / 2);
@@ -150,7 +124,6 @@ function passArray8ToWasm0(arg, malloc) {
 }
 
 function passStringToWasm0(arg, malloc, realloc) {
-    if (typeof(arg) !== 'string') throw new Error(`expected a string argument, found ${typeof(arg)}`);
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
         const ptr = malloc(buf.length, 1) >>> 0;
@@ -178,7 +151,7 @@ function passStringToWasm0(arg, malloc, realloc) {
         ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
         const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
         const ret = cachedTextEncoder.encodeInto(arg, view);
-        if (ret.read !== arg.length) throw new Error('failed to pass whole string');
+
         offset += ret.written;
         ptr = realloc(ptr, len, offset, 1) >>> 0;
     }
@@ -227,6 +200,7 @@ let WASM_VECTOR_LEN = 0;
  * @param {number} section_height
  * @param {number} world_min_y
  * @param {number} world_max_y
+ * @param {number} section_data_start_y
  * @param {Uint16Array} block_states
  * @param {Uint8Array} block_light
  * @param {Uint8Array} sky_light
@@ -241,13 +215,7 @@ let WASM_VECTOR_LEN = 0;
  * @param {number} sky_light_value
  * @returns {any}
  */
-export function generate_geometry(section_x, section_y, section_z, section_height, world_min_y, world_max_y, block_states, block_light, sky_light, biomes, invisible_blocks, transparent_blocks, no_ao_blocks, cull_identical_blocks, occluding_blocks, enable_lighting, smooth_lighting, sky_light_value) {
-    _assertNum(section_x);
-    _assertNum(section_y);
-    _assertNum(section_z);
-    _assertNum(section_height);
-    _assertNum(world_min_y);
-    _assertNum(world_max_y);
+export function generate_geometry(section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, block_states, block_light, sky_light, biomes, invisible_blocks, transparent_blocks, no_ao_blocks, cull_identical_blocks, occluding_blocks, enable_lighting, smooth_lighting, sky_light_value) {
     const ptr0 = passArray16ToWasm0(block_states, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray8ToWasm0(block_light, wasm.__wbindgen_malloc);
@@ -266,10 +234,7 @@ export function generate_geometry(section_x, section_y, section_z, section_heigh
     const len7 = WASM_VECTOR_LEN;
     const ptr8 = passArray16ToWasm0(occluding_blocks, wasm.__wbindgen_malloc);
     const len8 = WASM_VECTOR_LEN;
-    _assertBoolean(enable_lighting);
-    _assertBoolean(smooth_lighting);
-    _assertNum(sky_light_value);
-    const ret = wasm.generate_geometry(section_x, section_y, section_z, section_height, world_min_y, world_max_y, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, enable_lighting, smooth_lighting, sky_light_value);
+    const ret = wasm.generate_geometry(section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, enable_lighting, smooth_lighting, sky_light_value);
     return ret;
 }
 
@@ -280,6 +245,7 @@ export function generate_geometry(section_x, section_y, section_z, section_heigh
  * @param {number} section_height
  * @param {number} world_min_y
  * @param {number} world_max_y
+ * @param {number} section_data_start_y
  * @param {Int32Array} chunk_xs
  * @param {Int32Array} chunk_zs
  * @param {Uint16Array} block_states
@@ -296,13 +262,7 @@ export function generate_geometry(section_x, section_y, section_z, section_heigh
  * @param {number} sky_light_value
  * @returns {any}
  */
-export function generate_geometry_multi(section_x, section_y, section_z, section_height, world_min_y, world_max_y, chunk_xs, chunk_zs, block_states, block_light, sky_light, biomes, invisible_blocks, transparent_blocks, no_ao_blocks, cull_identical_blocks, occluding_blocks, enable_lighting, smooth_lighting, sky_light_value) {
-    _assertNum(section_x);
-    _assertNum(section_y);
-    _assertNum(section_z);
-    _assertNum(section_height);
-    _assertNum(world_min_y);
-    _assertNum(world_max_y);
+export function generate_geometry_multi(section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, chunk_xs, chunk_zs, block_states, block_light, sky_light, biomes, invisible_blocks, transparent_blocks, no_ao_blocks, cull_identical_blocks, occluding_blocks, enable_lighting, smooth_lighting, sky_light_value) {
     const ptr0 = passArray32ToWasm0(chunk_xs, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray32ToWasm0(chunk_zs, wasm.__wbindgen_malloc);
@@ -325,10 +285,7 @@ export function generate_geometry_multi(section_x, section_y, section_z, section
     const len9 = WASM_VECTOR_LEN;
     const ptr10 = passArray16ToWasm0(occluding_blocks, wasm.__wbindgen_malloc);
     const len10 = WASM_VECTOR_LEN;
-    _assertBoolean(enable_lighting);
-    _assertBoolean(smooth_lighting);
-    _assertNum(sky_light_value);
-    const ret = wasm.generate_geometry_multi(section_x, section_y, section_z, section_height, world_min_y, world_max_y, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, ptr9, len9, ptr10, len10, enable_lighting, smooth_lighting, sky_light_value);
+    const ret = wasm.generate_geometry_multi(section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, ptr9, len9, ptr10, len10, enable_lighting, smooth_lighting, sky_light_value);
     return ret;
 }
 
@@ -367,10 +324,10 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
-    imports.wbg.__wbg_Error_52673b7de5a0ca89 = function() { return logError(function (arg0, arg1) {
+    imports.wbg.__wbg_Error_52673b7de5a0ca89 = function(arg0, arg1) {
         const ret = Error(getStringFromWasm0(arg0, arg1));
         return ret;
-    }, arguments) };
+    };
     imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
         const ret = debugString(arg1);
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -381,35 +338,35 @@ function __wbg_get_imports() {
     imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
-    imports.wbg.__wbg_new_1ba21ce319a06297 = function() { return logError(function () {
+    imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
         const ret = new Object();
         return ret;
-    }, arguments) };
-    imports.wbg.__wbg_new_25f239778d6112b9 = function() { return logError(function () {
+    };
+    imports.wbg.__wbg_new_25f239778d6112b9 = function() {
         const ret = new Array();
         return ret;
-    }, arguments) };
-    imports.wbg.__wbg_set_3f1d0b984ed272ed = function() { return logError(function (arg0, arg1, arg2) {
+    };
+    imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
         arg0[arg1] = arg2;
-    }, arguments) };
-    imports.wbg.__wbg_set_7df433eea03a5c14 = function() { return logError(function (arg0, arg1, arg2) {
+    };
+    imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
         arg0[arg1 >>> 0] = arg2;
-    }, arguments) };
-    imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function() { return logError(function (arg0, arg1) {
+    };
+    imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);
         return ret;
-    }, arguments) };
-    imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function() { return logError(function (arg0) {
+    };
+    imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
         // Cast intrinsic for `U64 -> Externref`.
         const ret = BigInt.asUintN(64, arg0);
         return ret;
-    }, arguments) };
-    imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function() { return logError(function (arg0) {
+    };
+    imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
         // Cast intrinsic for `F64 -> Externref`.
         const ret = arg0;
         return ret;
-    }, arguments) };
+    };
     imports.wbg.__wbindgen_init_externref_table = function() {
         const table = wasm.__wbindgen_externrefs;
         const offset = table.grow(4);