minecraft-renderer 0.1.107 → 0.1.108

package/src/three/worldRendererThree.ts

@@ -40,6 +40,9 @@ import { FireworksManager } from './fireworks'
 import { SceneOrigin } from './sceneOrigin'
 import { downloadWorldGeometry } from './worldGeometryExport'
 import { ChunkMeshManager } from './chunkMeshManager'
+import { selectReadySectionFlushes } from '../lighting/versioning/pendingSectionFlush'
+import { isClientLightTraceEnabled, recordClientLightTrace } from '../lighting/debug/clientLightTrace'
+import { EntityLightController } from '../lighting/entity/entityLightController'
 import { raycastVoxelSolid } from './thirdPersonVoxelRaycast'
 import type { RendererModuleManifest, RegisteredModule, RendererModuleController } from './rendererModuleSystem'
 import { BUILTIN_MODULES } from './modules/index'
@@ -89,6 +92,7 @@ export class WorldRendererThree extends WorldRendererCommon {
   ambientLight = new THREE.AmbientLight(0xcc_cc_cc, WorldRendererThree.LEGACY_TO_PHYSICAL_LIGHT)
   directionalLight = new THREE.DirectionalLight(0xff_ff_ff, 0.5 * WorldRendererThree.LEGACY_TO_PHYSICAL_LIGHT)
   entities = new Entities(this, (globalThis as any).mcData)
+  entityLightController?: EntityLightController
   performanceMonitor!: PerformanceMonitor
   cameraGroupVr?: THREE.Object3D
   material = new THREE.MeshBasicMaterial({ vertexColors: true, transparent: true, alphaTest: 0.1 })
@@ -204,6 +208,14 @@ export class WorldRendererThree extends WorldRendererCommon {
 
     // Initialize chunk mesh manager
     this.chunkMeshManager = new ChunkMeshManager(this, this.scene, this.material, this.worldSizeParams.worldHeight, this.viewDistance)
+    this.entityLightController = new EntityLightController({
+      getLight: (x, y, z) => this.rendererLightCache.getLight(x, y, z),
+      getSkyLevel: () => this.chunkMeshManager.getSkyLevel(),
+      getLightmapParams: () => this.chunkMeshManager.getLightmapParams(),
+      getColumnRevision: (cx, cz) => this.rendererLightCache.getColumnRevision(cx, cz),
+      getGlobalRevision: () => this.rendererLightCache.getGlobalRevision(),
+      lightingEnabled: () => this.worldRendererConfig.enableLighting !== false
+    })
     this.onRenderDistanceChanged = viewDistance => {
       this.chunkMeshManager.updateViewDistance(viewDistance)
     }
@@ -563,6 +575,9 @@ export class WorldRendererThree extends WorldRendererCommon {
       this.cursorBlock.setHighlightCursorBlock(value ? new Vec3(value.x, value.y, value.z) : null, value?.shapes)
     })
     this.onReactivePlayerStateUpdated('diggingBlock', value => {
+      if (value && (value.stage == null || value.stage === 0) && isClientLightTraceEnabled()) {
+        recordClientLightTrace({ phase: 'inputClick', sectionKey: `${value.x},${value.y},${value.z}` })
+      }
       this.cursorBlock.updateBreakAnimation(value ? { x: value.x, y: value.y, z: value.z } : undefined, value?.stage ?? null, value?.mergedShape)
     })
     this.onReactivePlayerStateUpdated('perspective', value => {
@@ -594,6 +609,13 @@ export class WorldRendererThree extends WorldRendererCommon {
     this.onReactiveConfigUpdated('futuristicReveal', () => {
       this.updateModulesFromConfig()
     })
+    this.onReactiveConfigUpdated(
+      'enableLighting',
+      () => {
+        this.rerenderAllChunks()
+      },
+      false
+    )
     this.onReactiveDebugUpdated('disableEntities', () => {
       this.entities.syncSceneAttachment()
     })
@@ -830,6 +852,10 @@ export class WorldRendererThree extends WorldRendererCommon {
         if (camCollisionBytes > 0) {
           text += `CAM: ${formatCompact(camCollisionBytes)}b `
         }
+        const entityLightBytes = this.rendererLightCache.getAllocatedBytes()
+        if (entityLightBytes > 0) {
+          text += `ELIGHT: ${formatCompact(entityLightBytes)}b `
+        }
         const pf = formatPerformanceFactorsDebug(this.reactiveState.world.instabilityFactors)
         if (pf) text += `PF: ${pf} `
         // entities can be seen in F3
@@ -884,45 +910,37 @@ export class WorldRendererThree extends WorldRendererCommon {
     if (this.pendingSectionUpdates.size === 0) return
 
     const now = performance.now()
-    const sectionHeight = this.getSectionHeight()
-    const ready: string[] = []
-
-    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]) {
-            neighborBusy = true
-            break
+    // Face-adjacent buffered sections are installed as one group: a lone
+    // install would show the neighbour's faces still culled against the old
+    // block state, i.e. a see-through hole (sky flash) on dig/place.
+    const ready = selectReadySectionFlushes({
+      pendingKeys: this.pendingSectionUpdates.keys(),
+      startedAt: key => this.pendingSectionBufferStartTimes.get(key),
+      now,
+      maxBufferMs: WorldRendererThree.MAX_SECTION_UPDATE_BUFFER_MS,
+      sectionHeight: this.getSectionHeight(),
+      isOutstanding: key => this.sectionsWaiting.has(key) && !this.pendingSectionUpdates.has(key),
+      ...(this.lightCoordinator.isSessionLive()
+        ? {
+            isTopologyOutstanding: (key: string) => this.lightCoordinator.pendingTopologyBySection.has(key) && !this.pendingSectionUpdates.has(key)
           }
-        }
-        if (neighborBusy) continue
-      }
-
-      ready.push(key)
-    }
+        : {}),
+      hasSectionObject: key => !!this.sectionObjects[key]
+    })
 
     if (ready.length === 0) return
 
-    for (const key of ready) {
+    for (const { key, reason } of ready) {
       const update = this.pendingSectionUpdates.get(key)!
       this.pendingSectionUpdates.delete(key)
       this.pendingSectionBufferStartTimes.delete(key)
+      if (isClientLightTraceEnabled()) {
+        recordClientLightTrace({
+          phase: 'flush',
+          sectionKey: key,
+          flushReason: reason
+        })
+      }
 
       const chunkCoords = update.key.split(',')
       const chunkKey = `${chunkCoords[0]},${chunkCoords[2]}`
@@ -932,6 +950,14 @@ export class WorldRendererThree extends WorldRendererCommon {
         continue
       }
 
+      const decision = this.lightCoordinator.evaluateOwnerGeometry(update)
+      if (!decision.accepted || update.geometry?.hadErrors) {
+        this.lightCoordinator.noteRejectedOwnerGeometry(update.key, undefined, { expectLaterFinished: false })
+        continue
+      }
+      this.lightCoordinator.acknowledgeAcceptedTopology(update)
+      if (decision.keepCovering) this.lightCoordinator.maybeDispatchCoveringRemesh(update.key)
+
       if (!this.chunkMeshManager.sectionHasRenderableContent(update.geometry)) {
         this.chunkMeshManager.releaseSection(update.key)
         continue
@@ -966,6 +992,14 @@ export class WorldRendererThree extends WorldRendererCommon {
         return
       }
 
+      const decision = this.lightCoordinator.evaluateOwnerGeometry(data)
+      if (!decision.accepted || data.geometry?.hadErrors) {
+        this.lightCoordinator.noteRejectedOwnerGeometry(data.key, undefined, { expectLaterFinished: true })
+        return
+      }
+      this.lightCoordinator.acknowledgeAcceptedTopology(data)
+      if (decision.keepCovering) this.lightCoordinator.maybeDispatchCoveringRemesh(data.key)
+
       if (this.sectionObjects[data.key]) {
         this.pendingSectionUpdates.set(data.key, data)
         // Per-section deadline: only set if we don't already have one, so
@@ -973,6 +1007,13 @@ export class WorldRendererThree extends WorldRendererCommon {
         if (!this.pendingSectionBufferStartTimes.has(data.key)) {
           this.pendingSectionBufferStartTimes.set(data.key, performance.now())
         }
+        if (isClientLightTraceEnabled()) {
+          recordClientLightTrace({
+            phase: 'pending',
+            sectionKey: data.key,
+            queueDepth: this.pendingSectionUpdates.size
+          })
+        }
         return
       }
 
@@ -1552,8 +1593,8 @@ export class WorldRendererThree extends WorldRendererCommon {
     }
   }
 
-  removeColumn(x, z) {
-    super.removeColumn(x, z)
+  removeColumn(x, z, opts?: { preserveClientLight?: boolean }) {
+    super.removeColumn(x, z, opts)
 
     this.clearPendingSectionUpdatesForChunk(x, z)
     const sectionHeight = this.getSectionHeight()

package/src/wasm-mesher/bridge/render-from-wasm.ts

@@ -3,6 +3,7 @@
 // This file takes WASM output and generates full Three.js buffer geometry
 
 import * as THREE from 'three'
+import { isClientLightProbeBlock } from '../../lighting/debug/clientLightProbe'
 import worldBlockProviderModule, { WorldBlockProvider } from 'mc-assets/dist/worldBlockProvider'
 import blocksAtlasesJson from 'mc-assets/dist/blocksAtlases.json'
 import blockStatesModels from 'mc-assets/dist/blockStatesModels.json'
@@ -692,7 +693,26 @@ export function renderWasmOutputToGeometry(
           },
           shaderWordBuffer
         )
-        if (emitted) continue
+        if (emitted) {
+          if (isClientLightProbeBlock(bx, by, bz)) {
+            console.log('[lightProbe:shaderCube]', {
+              time: Date.now(),
+              position: [bx, by, bz],
+              blockStateId,
+              name: prismBlock.name,
+              useModelLighting: false,
+              wasmSky: block.sky_light_data?.map(values => [...values]),
+              visibleFaces: block.visible_faces,
+              jsNeighborSky: Object.fromEntries(
+                Object.entries(elemFaces).map(([face, info]) => [
+                  face,
+                  world?.getChannelLightNorm(new Vec3(bx, by, bz).offset(info.dir[0], info.dir[1], info.dir[2])).sky
+                ])
+              )
+            })
+          }
+          continue
+        }
       }
     }
 
@@ -842,6 +862,20 @@ export function renderWasmOutputToGeometry(
           const tint = getTint(matchingEFace, cachedModel.blockName, cachedModel.blockProps, biome, world)
 
           const useModelLighting = (!cachedModel.isCube || globalMatrix != null) && world
+          if (isClientLightProbeBlock(bx, by, bz)) {
+            console.log('[lightProbe:face]', {
+              time: Date.now(),
+              position: [bx, by, bz],
+              faceName,
+              blockStateId,
+              name: prismBlock.name,
+              isCube: cachedModel.isCube,
+              rotated: globalMatrix != null,
+              useModelLighting: Boolean(useModelLighting),
+              wasmSky: skyValuesRaw ? [...skyValuesRaw] : null,
+              jsNeighborSky: world?.getChannelLightNorm(new Vec3(bx, by, bz).offset(...transformedDirI)).sky
+            })
+          }
           const baseChannels = useModelLighting
             ? world.getChannelLightNorm(new Vec3(bx, by, bz).offset(transformedDirI[0], transformedDirI[1], transformedDirI[2]))
             : null
@@ -921,6 +955,17 @@ export function renderWasmOutputToGeometry(
             tgtCol.push(tintAo[0], tintAo[1], tintAo[2])
             tgtSky.push(skyLightNorm)
             tgtBlock.push(blockLightNorm)
+            if (isClientLightProbeBlock(bx, by, bz)) {
+              console.log('[lightProbe:vertex]', {
+                time: Date.now(),
+                position: [bx, by, bz],
+                faceName,
+                cornerIdx,
+                useModelLighting: Boolean(useModelLighting),
+                skyLightNorm,
+                blockLightNorm
+              })
+            }
 
             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

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

@@ -2,6 +2,21 @@
 /* tslint:disable */
 /* eslint-disable */
 
+export class JsLightEngine {
+  free(): void;
+  [Symbol.dispose](): void;
+  pushEvent(event: any): void;
+  getSkyLight(x: number, y: number, z: number): number;
+  getBlockLight(x: number, y: number, z: number): number;
+  setLightTables(emission: Uint8Array, opacity: Uint8Array): void;
+  setOcclusionTable(occupancy: Uint8Array): void;
+  setSkyLightEnabled(enabled: boolean): void;
+  pollCompletedPublication(): any;
+  step(budget_ms: number): boolean;
+  constructor(world_min_y: number, world_height: number);
+  readonly fallbackRelights: number;
+}
+
 /**
  * Compute wireframe edge positions from a triangle mesh.
  *
@@ -210,11 +225,11 @@ export function parseMapChunkV18Plus(raw_packet: Uint8Array, num_sections: numbe
  * `raw_packet` includes the leading packet-id varint (we skip it).
  * `num_sections` should match the column the light is for (16 in 1.17).
  *
- * Returns `{ x, z, skyLight: Uint8Array(num_sections * 4096),
- *            blockLight: Uint8Array(num_sections * 4096), bytesRead }`.
- * Layout matches the existing 1.18+ light arrays
- * (`x + z*16 + y_abs*256`); the JS-side worker reorders into per-section
- * stack via the same path used for 1.18+ raw map_chunk parsing.
+ * Returns `{ x, z, trustEdges, skyLight, blockLight, skyLightMask,
+ *            emptySkyLightMask, blockLightMask, emptyBlockLightMask,
+ *            skyBelow?, skyAbove?, blockBelow?, blockAbove?, bytesRead }`.
+ * World arrays are `num_sections * 4096` (`x + z*16 + y_abs*256`).
+ * Omitted sections are left 0 and are not authoritative — use the masks.
  */
 export function parseUpdateLightV17(raw_packet: Uint8Array, num_sections: number): any;
 
@@ -227,6 +242,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly __wbg_jslightengine_free: (a: number, b: number) => void;
   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 generateGeometryFromDump118: (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, h1: number, i1: number, j1: number, k1: number) => any;
@@ -236,6 +252,16 @@ export interface InitOutput {
   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 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 jslightengine_fallbackRelights: (a: number) => number;
+  readonly jslightengine_getBlockLight: (a: number, b: number, c: number, d: number) => number;
+  readonly jslightengine_getSkyLight: (a: number, b: number, c: number, d: number) => number;
+  readonly jslightengine_js_new: (a: number, b: number) => number;
+  readonly jslightengine_pollCompletedPublication: (a: number) => any;
+  readonly jslightengine_pushEvent: (a: number, b: any) => void;
+  readonly jslightengine_setLightTables: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly jslightengine_setOcclusionTable: (a: number, b: number, c: number) => void;
+  readonly jslightengine_setSkyLightEnabled: (a: number, b: number) => void;
+  readonly jslightengine_step: (a: number, b: number) => number;
   readonly parseChunkDump118: (a: number, b: number, c: number, d: number, e: number) => any;
   readonly parseChunkDump118FullColumn: (a: number, b: number, c: number, d: number, e: number) => any;
   readonly parseChunkDump118FullColumnAll: (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) => any;

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

@@ -86,6 +86,11 @@ function getArrayU16FromWasm0(ptr, len) {
     return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
 }
 
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -153,6 +158,10 @@ function handleError(f, args) {
     }
 }
 
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
 function passArray16ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 2, 2) >>> 0;
     getUint16ArrayMemory0().set(arg, ptr / 2);
@@ -247,6 +256,107 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
+const JsLightEngineFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jslightengine_free(ptr >>> 0, 1));
+
+export class JsLightEngine {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsLightEngineFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jslightengine_free(ptr, 0);
+    }
+    /**
+     * @param {any} event
+     */
+    pushEvent(event) {
+        wasm.jslightengine_pushEvent(this.__wbg_ptr, event);
+    }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number}
+     */
+    getSkyLight(x, y, z) {
+        const ret = wasm.jslightengine_getSkyLight(this.__wbg_ptr, x, y, z);
+        return ret;
+    }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number}
+     */
+    getBlockLight(x, y, z) {
+        const ret = wasm.jslightengine_getBlockLight(this.__wbg_ptr, x, y, z);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} emission
+     * @param {Uint8Array} opacity
+     */
+    setLightTables(emission, opacity) {
+        const ptr0 = passArray8ToWasm0(emission, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(opacity, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.jslightengine_setLightTables(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * @returns {number}
+     */
+    get fallbackRelights() {
+        const ret = wasm.jslightengine_fallbackRelights(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {Uint8Array} occupancy
+     */
+    setOcclusionTable(occupancy) {
+        const ptr0 = passArray8ToWasm0(occupancy, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jslightengine_setOcclusionTable(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {boolean} enabled
+     */
+    setSkyLightEnabled(enabled) {
+        wasm.jslightengine_setSkyLightEnabled(this.__wbg_ptr, enabled);
+    }
+    /**
+     * @returns {any}
+     */
+    pollCompletedPublication() {
+        const ret = wasm.jslightengine_pollCompletedPublication(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} budget_ms
+     * @returns {boolean}
+     */
+    step(budget_ms) {
+        const ret = wasm.jslightengine_step(this.__wbg_ptr, budget_ms);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} world_min_y
+     * @param {number} world_height
+     */
+    constructor(world_min_y, world_height) {
+        const ret = wasm.jslightengine_js_new(world_min_y, world_height);
+        this.__wbg_ptr = ret >>> 0;
+        JsLightEngineFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) JsLightEngine.prototype[Symbol.dispose] = JsLightEngine.prototype.free;
+
 /**
  * Compute wireframe edge positions from a triangle mesh.
  *
@@ -879,11 +989,11 @@ export function parseMapChunkV18Plus(raw_packet, num_sections, max_bits_per_bloc
  * `raw_packet` includes the leading packet-id varint (we skip it).
  * `num_sections` should match the column the light is for (16 in 1.17).
  *
- * Returns `{ x, z, skyLight: Uint8Array(num_sections * 4096),
- *            blockLight: Uint8Array(num_sections * 4096), bytesRead }`.
- * Layout matches the existing 1.18+ light arrays
- * (`x + z*16 + y_abs*256`); the JS-side worker reorders into per-section
- * stack via the same path used for 1.18+ raw map_chunk parsing.
+ * Returns `{ x, z, trustEdges, skyLight, blockLight, skyLightMask,
+ *            emptySkyLightMask, blockLightMask, emptyBlockLightMask,
+ *            skyBelow?, skyAbove?, blockBelow?, blockAbove?, bytesRead }`.
+ * World arrays are `num_sections * 4096` (`x + z*16 + y_abs*256`).
+ * Omitted sections are left 0 and are not authoritative — use the masks.
  * @param {Uint8Array} raw_packet
  * @param {number} num_sections
  * @returns {any}
@@ -948,6 +1058,11 @@ function __wbg_get_imports() {
         const ret = Error(getStringFromWasm0(arg0, arg1));
         return ret;
     };
+    imports.wbg.__wbg___wbindgen_boolean_get_dea25b33882b895b = function(arg0) {
+        const v = arg0;
+        const ret = typeof(v) === 'boolean' ? v : undefined;
+        return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+    };
     imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
         const ret = debugString(arg1);
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -955,6 +1070,28 @@ function __wbg_get_imports() {
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
+    imports.wbg.__wbg___wbindgen_is_null_dfda7d66506c95b5 = function(arg0) {
+        const ret = arg0 === null;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_number_get_9619185a74197f95 = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'number' ? obj : undefined;
+        getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    };
+    imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
     imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
@@ -962,6 +1099,10 @@ function __wbg_get_imports() {
         const ret = arg0[arg1 >>> 0];
         return ret;
     };
+    imports.wbg.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_instanceof_Int32Array_b6281022039fba32 = function(arg0) {
         let result;
         try {
@@ -990,6 +1131,10 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
+    imports.wbg.__wbg_length_89c3414ed7f0594d = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
     imports.wbg.__wbg_length_ab53989976907f11 = function(arg0) {
         const ret = arg0.length;
         return ret;
@@ -1002,10 +1147,26 @@ function __wbg_get_imports() {
         const ret = new Array();
         return ret;
     };
+    imports.wbg.__wbg_new_6421f6084cc5bc5a = function(arg0) {
+        const ret = new Uint8Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_9f7fd5c3a6ba7298 = function(arg0) {
+        const ret = new Uint16Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_from_slice_e6bd3cfb5a35313d = function(arg0, arg1) {
+        const ret = new Int32Array(getArrayI32FromWasm0(arg0, arg1));
+        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_202b3db94ba5fc86 = function(arg0) {
+        const ret = new Uint32Array(arg0 >>> 0);
+        return ret;
+    };
     imports.wbg.__wbg_new_with_length_aa5eaf41d35235e5 = function(arg0) {
         const ret = new Uint8Array(arg0 >>> 0);
         return ret;
@@ -1014,12 +1175,23 @@ function __wbg_get_imports() {
         const ret = new Uint16Array(arg0 >>> 0);
         return ret;
     };
+    imports.wbg.__wbg_now_69d776cd24f5215b = function() {
+        const ret = Date.now();
+        return ret;
+    };
+    imports.wbg.__wbg_prototypesetcall_b0bea5f39077cfd3 = function(arg0, arg1, arg2) {
+        Uint16Array.prototype.set.call(getArrayU16FromWasm0(arg0, arg1), arg2);
+    };
     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_push_7d9be8f38fc13975 = function(arg0, arg1) {
+        const ret = arg0.push(arg1);
+        return ret;
+    };
     imports.wbg.__wbg_set_169e13b608078b7b = function(arg0, arg1, arg2) {
         arg0.set(getArrayU8FromWasm0(arg1, arg2));
     };
@@ -1036,6 +1208,9 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_set_bb0c6a7fe60d81b5 = function(arg0, arg1, arg2) {
         arg0.set(getArrayU16FromWasm0(arg1, arg2));
     };
+    imports.wbg.__wbg_set_e7cd108182596b7f = function(arg0, arg1, arg2) {
+        arg0.set(getArrayU32FromWasm0(arg1, arg2));
+    };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);

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

@@ -2,6 +2,7 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_jslightengine_free: (a: number, b: number) => void;
 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 generateGeometryFromDump118: (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, h1: number, i1: number, j1: number, k1: number) => any;
@@ -11,6 +12,16 @@ export const generateGeometryFromParsedV16V17: (a: number, b: number, c: number,
 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 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;
 export const 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;
+export const jslightengine_fallbackRelights: (a: number) => number;
+export const jslightengine_getBlockLight: (a: number, b: number, c: number, d: number) => number;
+export const jslightengine_getSkyLight: (a: number, b: number, c: number, d: number) => number;
+export const jslightengine_js_new: (a: number, b: number) => number;
+export const jslightengine_pollCompletedPublication: (a: number) => any;
+export const jslightengine_pushEvent: (a: number, b: any) => void;
+export const jslightengine_setLightTables: (a: number, b: number, c: number, d: number, e: number) => void;
+export const jslightengine_setOcclusionTable: (a: number, b: number, c: number) => void;
+export const jslightengine_setSkyLightEnabled: (a: number, b: number) => void;
+export const jslightengine_step: (a: number, b: number) => number;
 export const parseChunkDump118: (a: number, b: number, c: number, d: number, e: number) => any;
 export const parseChunkDump118FullColumn: (a: number, b: number, c: number, d: number, e: number) => any;
 export const parseChunkDump118FullColumnAll: (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) => any;