minecraft-renderer 0.1.21 → 0.1.23

package/src/three/worldRendererThree.ts

@@ -33,7 +33,7 @@ import { DEFAULT_TEMPERATURE, SkyboxRenderer } from './skyboxRenderer'
 import { FireworksManager } from './fireworks'
 import { downloadWorldGeometry } from './worldGeometryExport'
 import { WorldBlockGeometry } from './worldBlockGeometry'
-import type { RendererModuleManifest, RegisteredModule } from './rendererModuleSystem'
+import type { RendererModuleManifest, RegisteredModule, RendererModuleController } from './rendererModuleSystem'
 import { BUILTIN_MODULES } from './modules/index'
 
 type SectionKey = string
@@ -73,7 +73,7 @@ export class WorldRendererThree extends WorldRendererCommon {
     return this.worldBlockGeometry.estimatedMemoryUsage
   }
   // Module system
-  private modules = new Map<string, RegisteredModule>()
+  private modules = {} as Record<string, RegisteredModule>
   sectionsOffsetsAnimations = {} as {
     [chunkKey: string]: {
       time: number,
@@ -170,7 +170,7 @@ export class WorldRendererThree extends WorldRendererCommon {
    * Register a renderer module
    */
   registerModule(manifest: RendererModuleManifest): void {
-    if (this.modules.has(manifest.id)) {
+    if (manifest.id in this.modules) {
       console.warn(`Module ${manifest.id} is already registered`)
       return
     }
@@ -181,12 +181,13 @@ export class WorldRendererThree extends WorldRendererCommon {
       manifest,
       controller,
       enabled: false,
+      toggle: () => this.toggleModule(manifest.id),
     }
 
-    this.modules.set(manifest.id, registered)
+    this.modules[manifest.id] = registered
 
     if (manifest.enabledDefault) {
-      this.enableModule(manifest.id)
+      this.toggleModule(manifest.id, true)
     }
   }
 
@@ -195,7 +196,7 @@ export class WorldRendererThree extends WorldRendererCommon {
    * Enable a module
    */
   enableModule(moduleId: string): void {
-    const module = this.modules.get(moduleId)
+    const module = this.modules[moduleId]
     if (!module) {
       console.warn(`Module ${moduleId} not found`)
       return
@@ -216,7 +217,7 @@ export class WorldRendererThree extends WorldRendererCommon {
    * Disable a module
    */
   disableModule(moduleId: string): void {
-    const module = this.modules.get(moduleId)
+    const module = this.modules[moduleId]
     if (!module) {
       console.warn(`Module ${moduleId} not found`)
       return
@@ -241,32 +242,74 @@ export class WorldRendererThree extends WorldRendererCommon {
     }
   }
 
+  /**
+   * Toggle a module on/off, or force a specific state
+   */
+  toggleModule(moduleId: string, forceState?: boolean): boolean {
+    const module = this.modules[moduleId]
+    if (!module) {
+      console.warn(`Module ${moduleId} not found`)
+      return false
+    }
+
+    const targetState = forceState !== undefined ? forceState : !module.enabled
+
+    if (targetState === module.enabled) return module.enabled
+
+    if (!targetState && module.manifest.cannotBeDisabled) {
+      console.warn(`Module ${moduleId} cannot be disabled`)
+      return true
+    }
+
+    module.enabled = targetState
+
+    if (targetState) {
+      module.controller.enable()
+      // Register render callback if provided
+      if (module.controller.render && !this.onRender.includes(module.controller.render)) {
+        this.onRender.push(module.controller.render)
+      }
+    } else {
+      module.controller.disable()
+      // Unregister render callback if provided
+      if (module.controller.render) {
+        const index = this.onRender.indexOf(module.controller.render)
+        if (index > -1) {
+          this.onRender.splice(index, 1)
+        }
+      }
+    }
+
+    return targetState
+  }
+
   /**
    * Dispose all modules
    */
   private disposeModules(): void {
-    for (const module of this.modules.values()) {
+    for (const module of Object.values(this.modules)) {
       module.controller.dispose()
     }
-    this.modules.clear()
+    this.modules = {}
   }
 
   /**
    * Initialize all registered modules
    */
   private initializeModules(): void {
-    for (const [id, module] of this.modules.entries()) {
-      if (module.manifest.enabledDefault) {
-        this.enableModule(id)
-      }
-    }
+    // Use updateModulesFromConfig to handle initial state correctly (respects force states and auto-enable)
+    this.updateModulesFromConfig()
   }
 
   /**
    * Get a module controller by ID
    */
   getModule<T = any>(moduleId: string): T | undefined {
-    return this.modules.get(moduleId)?.controller as T | undefined
+    return this.modules[moduleId]?.controller as T | undefined
+  }
+
+  protected override anyModuleRequiresHeightmap(): boolean {
+    return Object.values(this.modules).some(m => m.enabled && m.manifest.requiresHeightmap)
   }
 
   get cameraObject() {
@@ -366,6 +409,61 @@ export class WorldRendererThree extends WorldRendererCommon {
     this.onReactiveConfigUpdated('defaultSkybox', (value) => {
       this.skyboxRenderer.updateDefaultSkybox(value)
     })
+
+    // Watch for config changes that affect modules
+    this.onReactiveConfigUpdated('*' as any, () => {
+      this.updateModulesFromConfig()
+    })
+
+    // Initial update
+    this.updateModulesFromConfig()
+  }
+
+  /**
+   * Update module states based on config (force states and auto-enable checks)
+   */
+  private updateModulesFromConfig(): void {
+    const { moduleStates } = this.worldRendererConfig
+
+    for (const [moduleId, module] of Object.entries(this.modules)) {
+      const forceState = moduleStates[moduleId]
+
+      // Check force states first
+      if (forceState === 'enabled') {
+        if (!module.enabled) {
+          this.toggleModule(moduleId, true)
+        }
+        continue
+      }
+
+      if (forceState === 'disabled') {
+        if (module.enabled && !module.manifest.cannotBeDisabled) {
+          this.toggleModule(moduleId, false)
+        }
+        continue
+      }
+
+      // Auto mode: use autoEnableCheck if available, otherwise use enabledDefault
+      if (forceState === 'auto' || forceState === undefined) {
+        if (module.controller.autoEnableCheck) {
+          const shouldEnable = module.controller.autoEnableCheck()
+
+          if (shouldEnable && !module.enabled) {
+            this.toggleModule(moduleId, true)
+          } else if (!shouldEnable && module.enabled && !module.manifest.cannotBeDisabled) {
+            this.toggleModule(moduleId, false)
+          }
+        } else {
+          // No autoEnableCheck: use enabledDefault
+          const shouldEnable = module.manifest.enabledDefault ?? false
+          if (shouldEnable && !module.enabled) {
+            this.toggleModule(moduleId, true)
+          } else if (!shouldEnable && module.enabled && !module.manifest.cannotBeDisabled) {
+            this.toggleModule(moduleId, false)
+          }
+        }
+      }
+    }
   }
 
   changeHandSwingingState(isAnimationPlaying: boolean, isLeft = false) {
@@ -486,7 +584,7 @@ export class WorldRendererThree extends WorldRendererCommon {
         text += `TE: ${formatBigNumber(this.renderer.info.memory.textures)} `
         text += `F: ${formatBigNumber(this.tilesRendered)} `
         text += `B: ${formatBigNumber(this.blocksRendered)} `
-        text += `MEM: ${this.getEstimatedMemoryUsage().readable}`
+        text += `MEM: ${this.worldBlockGeometry.getEstimatedMemoryUsage().readable}`
         pane.updateText(text)
         this.backendInfoReport = text
       }
@@ -1144,11 +1242,4 @@ export class WorldRendererThree extends WorldRendererCommon {
   reloadWorld() {
     this.entities.reloadEntities()
   }
-
-  /**
-   * Get estimated memory usage in a human-readable format
-   */
-  getEstimatedMemoryUsage(): { bytes: number; readable: string } {
-    return this.worldBlockGeometry.getEstimatedMemoryUsage()
-  }
 }

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

@@ -466,187 +466,187 @@ export function renderWasmOutputToGeometry(
     if (!cachedModel) continue
 
     if (false) {
-    // For now, use first model variant (can be extended later)
-    const modelVariant = cachedModel.modelVariants[0]
-    if (!modelVariant) continue
+      // For now, use first model variant (can be extended later)
+      const modelVariant = cachedModel!.modelVariants[0]
+      if (!modelVariant) continue
 
-    const { model, globalMatrix, globalShift, elements } = modelVariant
+      const { model, globalMatrix, globalShift, elements } = modelVariant
 
-    // Get biome for tint calculation if world is provided
-    let biome: string | undefined
-    if (world) {
-      const blockObj = world.getBlock(new Vec3(bx, by, bz))
-      biome = blockObj?.biome?.name
-    }
+      // Get biome for tint calculation if world is provided
+      let biome: string | undefined
+      if (world) {
+        const blockObj = world!.getBlock(new Vec3(bx, by, bz))
+        biome = blockObj?.biome?.name
+      }
 
-    // Process faces in the same order as TypeScript (iterate through model's faces)
-    // TypeScript uses: for (const face in element.faces)
-    // We need to match this order to get the same vertex ordering
+      // Process faces in the same order as TypeScript (iterate through model's faces)
+      // TypeScript uses: for (const face in element.faces)
+      // We need to match this order to get the same vertex ordering
 
-    // Find the element that contains faces (use cached element data)
-    const faceElements = elements.filter(elemData => elemData.element.faces && Object.keys(elemData.element.faces).length > 0)
+      // Find the element that contains faces (use cached element data)
+      const faceElements = elements.filter(elemData => elemData.element.faces && Object.keys(elemData.element.faces).length > 0)
 
-    if (faceElements.length === 0) continue
+      if (faceElements.length === 0) continue
 
-    // Map face names to their index in WASM output
-    const faceNameToIndex: Record<string, number> = {
-      'up': 0,
-      'down': 1,
-      'east': 2,
-      'west': 3,
-      'south': 4,
-      'north': 5
-    }
+      // Map face names to their index in WASM output
+      const faceNameToIndex: Record<string, number> = {
+        'up': 0,
+        'down': 1,
+        'east': 2,
+        'west': 3,
+        'south': 4,
+        'north': 5
+      }
 
-    // WASM processes faces in fixed order: [up, down, east, west, south, north]
-    // Build a mapping from WASM face order to data index
-    const wasmFaceOrder = ['up', 'down', 'east', 'west', 'south', 'north']
-    const wasmFaceToDataIndex: Record<string, number> = {}
-    let dataIndex = 0
-    for (const faceName of wasmFaceOrder) {
-      const faceIdx = faceNameToIndex[faceName]
-      if ((block.visible_faces & (1 << faceIdx)) !== 0) {
-        wasmFaceToDataIndex[faceName] = dataIndex++
+      // WASM processes faces in fixed order: [up, down, east, west, south, north]
+      // Build a mapping from WASM face order to data index
+      const wasmFaceOrder = ['up', 'down', 'east', 'west', 'south', 'north']
+      const wasmFaceToDataIndex: Record<string, number> = {}
+      let dataIndex = 0
+      for (const faceName of wasmFaceOrder) {
+        const faceIdx = faceNameToIndex[faceName]
+        if ((block.visible_faces & (1 << faceIdx)) !== 0) {
+          wasmFaceToDataIndex[faceName] = dataIndex++
+        }
       }
-    }
 
-    // Process faces in the order they appear in the model (matching TS)
-    for (const elemData of faceElements) {
-      const element = elemData.element
-      const localMatrix = elemData.localMatrix
-      const localShift = elemData.localShift
+      // Process faces in the order they appear in the model (matching TS)
+      for (const elemData of faceElements) {
+        const element = elemData.element
+        const localMatrix = elemData.localMatrix
+        const localShift = elemData.localShift
 
-      // eslint-disable-next-line guard-for-in
-      for (const faceName in element.faces) {
-      const faceIdx = faceNameToIndex[faceName]
-      if (faceIdx === undefined) continue
+        // eslint-disable-next-line guard-for-in
+        for (const faceName in element.faces) {
+          const faceIdx = faceNameToIndex[faceName]
+          if (faceIdx === undefined) continue
 
-      // Check if this face is visible in WASM output
-      if ((block.visible_faces & (1 << faceIdx)) === 0) {
-        continue
-      }
+          // Check if this face is visible in WASM output
+          if ((block.visible_faces & (1 << faceIdx)) === 0) {
+            continue
+          }
 
-      const matchingEFace = element.faces[faceName]
-      const { dir, corners, mask1, mask2 } = elemFaces[faceName]
+          const matchingEFace = element.faces[faceName]
+          const { dir, corners, mask1, mask2 } = elemFaces[faceName]
 
-      // Get the correct data index for this face based on WASM's processing order
-      const faceDataIndex = wasmFaceToDataIndex[faceName]
-      if (faceDataIndex === undefined) continue
+          // Get the correct data index for this face based on WASM's processing order
+          const faceDataIndex = wasmFaceToDataIndex[faceName]
+          if (faceDataIndex === undefined) continue
 
-      const aoValues = block.ao_data[faceDataIndex]
-      const lightValues = block.light_data[faceDataIndex]
+          const aoValues = block.ao_data[faceDataIndex]
+          const lightValues = block.light_data[faceDataIndex]
 
-      log(`[WASM]   Face ${faceIdx} (${faceName}): dir=[${dir.join(',')}], ao=[${aoValues.join(',')}], light=[${lightValues.map(l => l.toFixed(3)).join(',')}]`)
+          log(`[WASM]   Face ${faceIdx} (${faceName}): dir=[${dir.join(',')}], ao=[${aoValues.join(',')}], light=[${lightValues.map(l => l.toFixed(3)).join(',')}]`)
 
-      const texture = matchingEFace.texture as any
-      const u = texture.u || 0
-      const v = texture.v || 0
-      const su = texture.su || 1
-      const sv = texture.sv || 1
+          const texture = matchingEFace.texture as any
+          const u = texture.u || 0
+          const v = texture.v || 0
+          const su = texture.su || 1
+          const sv = texture.sv || 1
 
-      // UV rotation (matching reference implementation)
-      let r = matchingEFace.rotation || 0
-      if (faceName === 'down') {
-        r += 180
-      }
-      const uvcs = Math.cos(r * Math.PI / 180)
-      const uvsn = -Math.sin(r * Math.PI / 180)
-
-      // Get tint (use cached model data and world if available)
-      const tint = getTint(matchingEFace, cachedModel.blockName, cachedModel.blockProps, biome, world)
-
-      const minx = element.from[0]
-      const miny = element.from[1]
-      const minz = element.from[2]
-      const maxx = element.to[0]
-      const maxy = element.to[1]
-      const maxz = element.to[2]
-
-      // Calculate transformed direction
-      const transformedDir = matmul3(globalMatrix, dir)
-
-      // Add 4 vertices for this face
-      const baseIndex = currentIndex
-      for (let cornerIdx = 0; cornerIdx < 4; cornerIdx++) {
-        const pos = corners[cornerIdx]
-
-        // Calculate vertex position (matching reference)
-        let vertex = [
-          (pos[0] ? maxx : minx),
-          (pos[1] ? maxy : miny),
-          (pos[2] ? maxz : minz)
-        ]
-
-        // Apply element rotation
-        vertex = vecadd3(matmul3(localMatrix, vertex), localShift)
-        // Apply model rotation
-        vertex = vecadd3(matmul3(globalMatrix, vertex), globalShift)
-        // Convert to block coordinates (0-1)
-        vertex = vertex.map(v => v / 16)
-
-        // World position (relative to section)
-        const worldPos = [
-          vertex[0] + (bx & 15) - 8,
-          vertex[1] + (by & 15) - 8,
-          vertex[2] + (bz & 15) - 8
-        ]
-
-        log(`[WASM]     Corner ${cornerIdx}: corner=[${pos.join(',')}], vertex=[${vertex.map(v => v.toFixed(3)).join(',')}], worldPos=[${worldPos.map(v => v.toFixed(3)).join(',')}]`)
-
-        positions.push(...worldPos)
-
-        // Normal (transformed direction)
-        normals.push(transformedDir[0], transformedDir[1], transformedDir[2])
-
-        // Color (with AO and light from WASM) - matching TS formula exactly
-        const ao = aoValues[cornerIdx]
-
-        // TS calculation:
-        // baseLight = world.getLight(neighborPos, ...) / 15  (0-1 range)
-        // cornerLightResult = baseLight * 15  (0-15 range, or interpolated if smooth lighting)
-        // light = (ao + 1) / 4 * (cornerLightResult / 15)
-        // finalColor = baseLight * tint * light
-
-        // WASM provides lightValues in 0-1 range (already divided by 15)
-        // But WASM light calculation seems to return 0.0, so we need to handle that
-        // In the test case, TypeScript gets baseLight = 1.0 (full brightness)
-        // So we should use 1.0 as the base light value when WASM returns 0
-        const baseLight = lightValues[cornerIdx]
-        const cornerLightResult = baseLight * 15
-
-        const light = (ao + 1) / 4 * (cornerLightResult / 15)
-
-        colors.push(tint[0] * light, tint[1] * light, tint[2] * light)
-
-        // UV calculation (matching reference exactly)
-        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
-        const finalU = baseu * su + u
-        const finalV = basev * sv + v
-        log(`[WASM]       UV: cornerUV=[${pos[3]},${pos[4]}], baseUV=[${baseu.toFixed(6)},${basev.toFixed(6)}], finalUV=[${finalU.toFixed(6)},${finalV.toFixed(6)}], texture=[u=${u},v=${v},su=${su},sv=${sv}], rotation=${r}`)
-        uvs.push(finalU, finalV)
-
-        currentIndex++
-      }
+          // UV rotation (matching reference implementation)
+          let r = matchingEFace.rotation || 0
+          if (faceName === 'down') {
+            r += 180
+          }
+          const uvcs = Math.cos(r * Math.PI / 180)
+          const uvsn = -Math.sin(r * Math.PI / 180)
 
-      // Add indices (2 triangles) - matching TS AO-optimized winding
-      // TS uses: if (doAO && aos[0] + aos[3] >= aos[1] + aos[2]) { optimized } else { standard }
-      let tri1: number[], tri2: number[]
-      if (aoValues[0] + aoValues[3] >= aoValues[1] + aoValues[2]) {
-        // AO-optimized winding
-        tri1 = [baseIndex, baseIndex + 3, baseIndex + 2]
-        tri2 = [baseIndex, baseIndex + 1, baseIndex + 3]
-        log(`[WASM]     Indices (AO optimized): tri1=[${tri1.join(',')}], tri2=[${tri2.join(',')}], aos=[${aoValues.join(',')}]`)
-      } else {
-        // Standard winding
-        tri1 = [baseIndex, baseIndex + 1, baseIndex + 2]
-        tri2 = [baseIndex + 2, baseIndex + 1, baseIndex + 3]
-        log(`[WASM]     Indices (standard): tri1=[${tri1.join(',')}], tri2=[${tri2.join(',')}], aos=[${aoValues.join(',')}]`)
-      }
-      indices.push(...tri1, ...tri2)
+          // Get tint (use cached model data and world if available)
+          const tint = getTint(matchingEFace, cachedModel!.blockName, cachedModel!.blockProps, biome, world)
+
+          const minx = element.from[0]
+          const miny = element.from[1]
+          const minz = element.from[2]
+          const maxx = element.to[0]
+          const maxy = element.to[1]
+          const maxz = element.to[2]
+
+          // Calculate transformed direction
+          const transformedDir = matmul3(globalMatrix, dir)
+
+          // Add 4 vertices for this face
+          const baseIndex = currentIndex
+          for (let cornerIdx = 0; cornerIdx < 4; cornerIdx++) {
+            const pos = corners[cornerIdx]
+
+            // Calculate vertex position (matching reference)
+            let vertex = [
+              (pos[0] ? maxx : minx),
+              (pos[1] ? maxy : miny),
+              (pos[2] ? maxz : minz)
+            ]
+
+            // Apply element rotation
+            vertex = vecadd3(matmul3(localMatrix, vertex), localShift)
+            // Apply model rotation
+            vertex = vecadd3(matmul3(globalMatrix, vertex), globalShift)
+            // Convert to block coordinates (0-1)
+            vertex = vertex.map(v => v / 16)
+
+            // World position (relative to section)
+            const worldPos = [
+              vertex[0] + (bx & 15) - 8,
+              vertex[1] + (by & 15) - 8,
+              vertex[2] + (bz & 15) - 8
+            ]
+
+            log(`[WASM]     Corner ${cornerIdx}: corner=[${pos.join(',')}], vertex=[${vertex.map(v => v.toFixed(3)).join(',')}], worldPos=[${worldPos.map(v => v.toFixed(3)).join(',')}]`)
+
+            positions.push(...worldPos)
+
+            // Normal (transformed direction)
+            normals.push(transformedDir[0], transformedDir[1], transformedDir[2])
+
+            // Color (with AO and light from WASM) - matching TS formula exactly
+            const ao = aoValues[cornerIdx]
+
+            // TS calculation:
+            // baseLight = world.getLight(neighborPos, ...) / 15  (0-1 range)
+            // cornerLightResult = baseLight * 15  (0-15 range, or interpolated if smooth lighting)
+            // light = (ao + 1) / 4 * (cornerLightResult / 15)
+            // finalColor = baseLight * tint * light
+
+            // WASM provides lightValues in 0-1 range (already divided by 15)
+            // But WASM light calculation seems to return 0.0, so we need to handle that
+            // In the test case, TypeScript gets baseLight = 1.0 (full brightness)
+            // So we should use 1.0 as the base light value when WASM returns 0
+            const baseLight = lightValues[cornerIdx]
+            const cornerLightResult = baseLight * 15
+
+            const light = (ao + 1) / 4 * (cornerLightResult / 15)
+
+            colors.push(tint[0] * light, tint[1] * light, tint[2] * light)
+
+            // UV calculation (matching reference exactly)
+            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
+            const finalU = baseu * su + u
+            const finalV = basev * sv + v
+            log(`[WASM]       UV: cornerUV=[${pos[3]},${pos[4]}], baseUV=[${baseu.toFixed(6)},${basev.toFixed(6)}], finalUV=[${finalU.toFixed(6)},${finalV.toFixed(6)}], texture=[u=${u},v=${v},su=${su},sv=${sv}], rotation=${r}`)
+            uvs.push(finalU, finalV)
+
+            currentIndex++
+          }
+
+          // Add indices (2 triangles) - matching TS AO-optimized winding
+          // TS uses: if (doAO && aos[0] + aos[3] >= aos[1] + aos[2]) { optimized } else { standard }
+          let tri1: number[], tri2: number[]
+          if (aoValues[0] + aoValues[3] >= aoValues[1] + aoValues[2]) {
+            // AO-optimized winding
+            tri1 = [baseIndex, baseIndex + 3, baseIndex + 2]
+            tri2 = [baseIndex, baseIndex + 1, baseIndex + 3]
+            log(`[WASM]     Indices (AO optimized): tri1=[${tri1.join(',')}], tri2=[${tri2.join(',')}], aos=[${aoValues.join(',')}]`)
+          } else {
+            // Standard winding
+            tri1 = [baseIndex, baseIndex + 1, baseIndex + 2]
+            tri2 = [baseIndex + 2, baseIndex + 1, baseIndex + 3]
+            log(`[WASM]     Indices (standard): tri1=[${tri1.join(',')}], tri2=[${tri2.join(',')}], aos=[${aoValues.join(',')}]`)
+          }
+          indices.push(...tri1, ...tri2)
+        }
       }
     }
-    }
 
     const models = cachedModel.models
     if (!models || models.length == 0) continue

package/src/worldView/worldView.ts

@@ -363,7 +363,7 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
 
       // Unload chunks that are no longer in view
       const chunksToUnload: Vec3[] = []
-      const viewDistanceWithBuffer = this.viewDistance + this.keepChunksDistance
+      const viewDistanceWithBuffer = force ? this.viewDistance : this.viewDistance + this.keepChunksDistance
 
       for (const coords of Object.keys(this.loadedChunks)) {
         const [x, z] = coords.split(',').map(Number)

package/wasm/wasm_mesher.d.ts

@@ -7,9 +7,9 @@
  * 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;
 

package/wasm/wasm_mesher.js

@@ -227,6 +227,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 +242,14 @@ 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) {
+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) {
     _assertNum(section_x);
     _assertNum(section_y);
     _assertNum(section_z);
     _assertNum(section_height);
     _assertNum(world_min_y);
     _assertNum(world_max_y);
+    _assertNum(section_data_start_y);
     const ptr0 = passArray16ToWasm0(block_states, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray8ToWasm0(block_light, wasm.__wbindgen_malloc);
@@ -269,7 +271,7 @@ export function generate_geometry(section_x, section_y, section_z, section_heigh
     _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;
 }
 
@@ -296,13 +298,14 @@ 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) {
+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) {
     _assertNum(section_x);
     _assertNum(section_y);
     _assertNum(section_z);
     _assertNum(section_height);
     _assertNum(world_min_y);
     _assertNum(world_max_y);
+    _assertNum(section_data_start_y);
     const ptr0 = passArray32ToWasm0(chunk_xs, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray32ToWasm0(chunk_zs, wasm.__wbindgen_malloc);
@@ -328,7 +331,7 @@ export function generate_geometry_multi(section_x, section_y, section_z, section
     _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;
 }