minecraft-renderer 0.1.106 → 0.1.108

package/src/lighting/owner/lightOwnerHost.ts

@@ -0,0 +1,202 @@
+//@ts-nocheck
+import { RendererLightCache } from '../cache/rendererLightCache'
+
+export type LightPublicationSection = {
+  sx: number
+  sy: number
+  sz: number
+  blockLight: Uint8Array
+  skyLight?: Uint8Array
+}
+
+export type LightPublication = {
+  worldGeneration: number
+  publicationVersion: number
+  sections: LightPublicationSection[]
+  /** Flat world-origin triples, independent of the section payload coordinates. */
+  dirtyMeshSections?: Int32Array
+}
+
+export type LightOwnerEvent =
+  | { type: 'ingestBlockSection'; sx: number; sy: number; sz: number; states: Uint16Array }
+  | { type: 'setAvailability'; sx: number; sy: number; sz: number; availability: 'loaded' | 'lightOnly' | 'unloaded' }
+  | {
+      type: 'serverLight'
+      sx: number
+      sy: number
+      sz: number
+      channel: 'block' | 'sky'
+      kind: 'omitted' | 'empty' | 'data'
+      trusted?: boolean
+      data?: Uint8Array
+    }
+  | { type: 'blockChange'; x: number; y: number; z: number; stateId: number }
+  | { type: 'unloadColumn'; sx: number; sz: number }
+
+export type LightEngineBackend = {
+  setLightTables(tables: { emission: Uint8Array; opacity: Uint8Array; occupancy?: Uint8Array }): void
+  setSkyLightEnabled?(enabled: boolean): void
+  pushEvent(event: LightOwnerEvent): void
+  step(budgetMs: number): boolean
+  pollCompletedPublication(): LightPublication | null
+}
+
+export type PublicationGate = {
+  acceptedGeneration: number
+  lastVersion: number
+}
+
+export type ApplyPublicationResult = { applied: boolean; lastVersion: number; acceptedGeneration: number }
+
+/** Engine ABI uses section indices; RendererLightCache keys are world origins. */
+export function sectionIndexToWorldOrigin(sx: number, sy: number, sz: number) {
+  return { sx: sx * 16, sy: sy * 16, sz: sz * 16 }
+}
+
+export function applyLightPublication(
+  cache: RendererLightCache,
+  publication: LightPublication,
+  gate: PublicationGate,
+  coords: 'world' | 'section-index' = 'world'
+): ApplyPublicationResult {
+  if (publication.worldGeneration < gate.acceptedGeneration) {
+    return { applied: false, lastVersion: gate.lastVersion, acceptedGeneration: gate.acceptedGeneration }
+  }
+  if (publication.worldGeneration === gate.acceptedGeneration && publication.publicationVersion <= gate.lastVersion) {
+    return { applied: false, lastVersion: gate.lastVersion, acceptedGeneration: gate.acceptedGeneration }
+  }
+  const sections = publication.sections.map(section => {
+    const origin = coords === 'section-index' ? sectionIndexToWorldOrigin(section.sx, section.sy, section.sz) : section
+    return {
+      sx: origin.sx,
+      sy: origin.sy,
+      sz: origin.sz,
+      blockLight: section.blockLight,
+      skyLight: section.skyLight
+    }
+  })
+  cache.ingestPackedSections(sections)
+  return { applied: true, lastVersion: publication.publicationVersion, acceptedGeneration: publication.worldGeneration }
+}
+
+/** Production spawn stays behind `enableClientLightOwner` (default off). */
+export const CLIENT_LIGHT_OWNER_FLAG = 'enableClientLightOwner' as const
+
+export class LightOwnerHost {
+  private lastVersion = 0
+  private generation: number
+
+  private constructor(
+    private readonly cache: RendererLightCache,
+    private readonly backend: LightEngineBackend,
+    opts: { worldMinY: number; worldHeight: number; generation?: number }
+  ) {
+    this.generation = opts.generation ?? 1
+    this.cache.setWorldBounds(opts.worldMinY, opts.worldHeight)
+  }
+
+  static create(cache: RendererLightCache, backend: LightEngineBackend, opts: { worldMinY: number; worldHeight: number; generation?: number }) {
+    return new LightOwnerHost(cache, backend, opts)
+  }
+
+  static async createInProcess(cache: RendererLightCache, opts: { worldMinY: number; worldHeight: number; generation?: number }) {
+    const backend = await createWasmLightBackend(opts.worldMinY, opts.worldHeight)
+    return new LightOwnerHost(cache, backend, opts)
+  }
+
+  setLightTables(tables: { emission: Uint8Array; opacity: Uint8Array; occupancy?: Uint8Array }) {
+    this.backend.setLightTables(tables)
+  }
+
+  setSkyLightEnabled(enabled: boolean) {
+    this.backend.setSkyLightEnabled?.(enabled)
+  }
+
+  pushEvent(event: LightOwnerEvent) {
+    this.backend.pushEvent(event)
+  }
+
+  async stepUntilIdle(maxSlices = 32, budgetMs = 16): Promise<LightPublication | undefined> {
+    let last: LightPublication | undefined
+    for (let i = 0; i < maxSlices; i++) {
+      const remaining = this.backend.step(budgetMs)
+      const publication = this.backend.pollCompletedPublication()
+      if (publication) {
+        const result = applyLightPublication(this.cache, publication, { acceptedGeneration: this.generation, lastVersion: this.lastVersion }, 'section-index')
+        if (result.applied) {
+          this.lastVersion = result.lastVersion
+          this.generation = result.acceptedGeneration
+          last = publication
+        }
+      }
+      if (!remaining) break
+    }
+    return last
+  }
+}
+
+async function createWasmLightBackend(worldMinY: number, worldHeight: number): Promise<LightEngineBackend> {
+  const { readFileSync } = await import('node:fs')
+  const { dirname, join } = await import('node:path')
+  const { fileURLToPath } = await import('node:url')
+  const wasmModule = await import('../../wasm-mesher/runtime-build/wasm_mesher.js')
+  const wasmDir = dirname(fileURLToPath(import.meta.url))
+  const wasmBytes = readFileSync(join(wasmDir, '../../wasm-mesher/runtime-build/wasm_mesher_bg.wasm'))
+  try {
+    if (typeof wasmModule.initSync === 'function') {
+      wasmModule.initSync(wasmBytes)
+    } else {
+      await wasmModule.default(wasmBytes)
+    }
+  } catch {
+    // wasm already initialized in this vitest worker
+  }
+  const Engine = (wasmModule as { JsLightEngine?: new (minY: number, height: number) => WasmEngine }).JsLightEngine
+  if (!Engine) {
+    throw new Error('JsLightEngine is not exported from wasm_mesher')
+  }
+  const engine = new Engine(worldMinY, worldHeight)
+  return {
+    setLightTables({ emission, opacity, occupancy }) {
+      engine.setLightTables(emission, opacity)
+      if (occupancy && engine.setOcclusionTable) engine.setOcclusionTable(occupancy)
+    },
+    setSkyLightEnabled(enabled) {
+      engine.setSkyLightEnabled?.(enabled)
+    },
+    pushEvent(event) {
+      engine.pushEvent(event)
+    },
+    step(budgetMs) {
+      return engine.step(budgetMs)
+    },
+    pollCompletedPublication() {
+      const raw = engine.pollCompletedPublication()
+      if (!raw) return null
+      return {
+        worldGeneration: raw.worldGeneration,
+        publicationVersion: raw.publicationVersion,
+        sections: raw.sections.map((section: { sx: number; sy: number; sz: number; blockLight: Uint8Array; skyLight?: Uint8Array }) => ({
+          sx: section.sx,
+          sy: section.sy,
+          sz: section.sz,
+          blockLight: section.blockLight,
+          skyLight: section.skyLight
+        }))
+      }
+    }
+  }
+}
+
+type WasmEngine = {
+  setLightTables(emission: Uint8Array, opacity: Uint8Array): void
+  setOcclusionTable?(occupancy: Uint8Array): void
+  setSkyLightEnabled?(enabled: boolean): void
+  pushEvent(event: LightOwnerEvent): void
+  step(budgetMs: number): boolean
+  pollCompletedPublication(): null | {
+    worldGeneration: number
+    publicationVersion: number
+    sections: Array<{ sx: number; sy: number; sz: number; blockLight: Uint8Array; skyLight?: Uint8Array }>
+  }
+}

package/src/lighting/owner/lightOwnerWorker.ts

@@ -0,0 +1,154 @@
+//@ts-nocheck
+/**
+ * Dedicated light-owner worker. Mesh workers stay read-only.
+ * Protocol: init / setLightTables / setSkyLightEnabled / pushEvent /
+ * setUpdateLightV17 / setUpdateLightV16 / step / poll.
+ * Messages arriving before init completes are queued.
+ */
+
+import type { LightOwnerEvent, LightPublication } from './lightOwnerHost'
+import { eventsFromWasmUpdateLight } from './updateLightToOwnerEvents'
+import {
+  CLIENT_LIGHT_TRACE_MESSAGE,
+  armClientLightTrace,
+  enableClientLightTrace,
+  isClientLightTraceArmed,
+  isClientLightTraceEnabled,
+  postClientLightTrace
+} from '../debug/clientLightTrace'
+
+type WasmEngine = {
+  readonly fallbackRelights?: number
+  setLightTables(emission: Uint8Array, opacity: Uint8Array): void
+  setOcclusionTable?(occupancy: Uint8Array): void
+  setSkyLightEnabled?(enabled: boolean): void
+  pushEvent(event: LightOwnerEvent): void
+  step(budgetMs: number): boolean
+  pollCompletedPublication(): LightPublication | null
+}
+
+let engine: WasmEngine | null = null
+let wasm: any = null
+let worldMinY = 0
+const pending: any[] = []
+let localContinue: ReturnType<typeof setTimeout> | null = null
+let stepGeneration = 0
+
+const ctx = self as unknown as DedicatedWorkerGlobalScope
+const postTrace = (message: { type: typeof CLIENT_LIGHT_TRACE_MESSAGE; events?: unknown; event?: unknown }) => {
+  ctx.postMessage(message)
+}
+
+function runOwnerStepSlice(budgetMs: number) {
+  localContinue = null
+  const remaining = engine?.step(budgetMs) ?? false
+  const publication = engine?.pollCompletedPublication() ?? null
+  ctx.postMessage({ type: 'stepped', remaining, publication, stepGeneration, fallbackRelights: engine?.fallbackRelights ?? 0 })
+  if (publication && isClientLightTraceEnabled() && isClientLightTraceArmed()) {
+    postClientLightTrace(postTrace, {
+      phase: 'ownerComplete',
+      lightVersion: publication.publicationVersion,
+      worldGeneration: publication.worldGeneration,
+      queueDepth: remaining ? 1 : 0,
+      fallbackRelights: engine?.fallbackRelights ?? 0
+    })
+  }
+  if (remaining) {
+    localContinue = setTimeout(() => {
+      runOwnerStepSlice(budgetMs)
+    }, 0)
+  }
+}
+
+async function handle(data: any) {
+  if (!data || typeof data !== 'object') return
+  switch (data.type) {
+    case 'init': {
+      wasm = await import('../../wasm-mesher/runtime-build/wasm_mesher.js')
+      await wasm.default('/wasm_mesher_bg.wasm')
+      const Engine = (wasm as unknown as { JsLightEngine: new (minY: number, height: number) => WasmEngine }).JsLightEngine
+      worldMinY = data.worldMinY ?? 0
+      engine = new Engine(worldMinY, data.worldHeight ?? 256)
+      ctx.postMessage({ type: 'ready' })
+      const queued = pending.splice(0, pending.length)
+      for (const message of queued) await handle(message)
+      break
+    }
+    case 'setLightTables': {
+      engine?.setLightTables(data.emission, data.opacity)
+      if (data.occupancy) engine?.setOcclusionTable?.(data.occupancy)
+      ctx.postMessage({ type: 'tablesSet' })
+      break
+    }
+    case 'setSkyLightEnabled': {
+      engine?.setSkyLightEnabled?.(Boolean(data.enabled))
+      break
+    }
+    case 'pushEvent': {
+      engine?.pushEvent(data.event)
+      const event = data.event as LightOwnerEvent | undefined
+      const currentColumn =
+        event && 'x' in event && typeof event.x === 'number'
+          ? `${Math.floor(event.x / 16)},${Math.floor((event as { z: number }).z / 16)}`
+          : event && 'sx' in event && typeof event.sx === 'number'
+            ? `${event.sx},${(event as { sz: number }).sz}`
+            : undefined
+      if (isClientLightTraceEnabled() && isClientLightTraceArmed()) {
+        postClientLightTrace(postTrace, {
+          phase: 'ownerAdmit',
+          currentColumn,
+          queueDepth: pending.length
+        })
+      }
+      break
+    }
+    case 'clientLightTraceConfig': {
+      enableClientLightTrace(Boolean(data.enabled))
+      armClientLightTrace(Boolean(data.armed))
+      break
+    }
+    case 'setUpdateLightV17': {
+      if (!wasm || !engine) break
+      const parsed = wasm.parseUpdateLightV17(data.rawPacket as Uint8Array, data.numSections as number)
+      for (const event of eventsFromWasmUpdateLight(parsed, data.numSections as number, worldMinY)) {
+        engine.pushEvent(event)
+      }
+      break
+    }
+    case 'setUpdateLightV16': {
+      if (!wasm || !engine) break
+      const parsed = wasm.parseUpdateLightV17(data.rawPacket as Uint8Array, 16)
+      for (const event of eventsFromWasmUpdateLight(parsed, 16, worldMinY)) {
+        engine.pushEvent(event)
+      }
+      break
+    }
+    case 'step': {
+      if (typeof data.stepGeneration === 'number') stepGeneration = data.stepGeneration
+      if (localContinue) break
+      runOwnerStepSlice(data.budgetMs ?? 5)
+      break
+    }
+    case 'poll': {
+      const publication = engine?.pollCompletedPublication() ?? null
+      ctx.postMessage({ type: 'publication', publication })
+      break
+    }
+    default:
+      break
+  }
+}
+
+ctx.onmessage = async (message: MessageEvent) => {
+  const data = message.data
+  if (!data || typeof data !== 'object') return
+  try {
+    if (!engine && data.type !== 'init') {
+      pending.push(data)
+      return
+    }
+    await handle(data)
+  } catch (err) {
+    ctx.postMessage({ type: 'error', error: err instanceof Error ? err.message : String(err) })
+  }
+}

package/src/lighting/owner/updateLight1171OwnerPath.test.ts

@@ -0,0 +1,68 @@
+//@ts-nocheck
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it } from 'vitest'
+import { RendererLightCache } from '../cache/rendererLightCache'
+import { applyLightPublication } from './lightOwnerHost'
+import { isLightSectionPresent, mergeUpdateLight, parsedUpdateLightFromWasm, worldSectionMaskBit } from '../../wasm-mesher/worker/mesherWasmLightMerge'
+
+const NUM_SECTIONS = 16
+
+function packedNibble(value: number): Uint8Array {
+  const n = value & 0x0f
+  return new Uint8Array(2048).fill(n | (n << 4))
+}
+
+describe('1.17.1 fixture owner path (scenario б)', () => {
+  it('keeps an omitted neighbor after the captured empty-block packet', async () => {
+    const wasmDir = dirname(fileURLToPath(import.meta.url))
+    const wasmModule = await import('../../wasm-mesher/runtime-build/wasm_mesher.js')
+    const wasmBytes = readFileSync(join(wasmDir, '../../wasm-mesher/runtime-build/wasm_mesher_bg.wasm'))
+    try {
+      wasmModule.initSync(wasmBytes)
+    } catch {
+      // already initialized
+    }
+
+    const fixture = readFileSync(join(wasmDir, '../../../chunk-packet-fixtures/fixtures/map_chunk/1.17.1/5_0.update_light.bin'))
+    const parsed = parsedUpdateLightFromWasm((wasmModule as any).parseUpdateLightV17(fixture, NUM_SECTIONS), NUM_SECTIONS)
+    expect(parsed.x).toBe(7)
+    expect(parsed.z).toBe(0)
+
+    const seed = mergeUpdateLight(undefined, {
+      ...parsed,
+      blockLightMask: new Uint32Array([1 << 7, 0]),
+      emptyBlockLightMask: new Uint32Array(2),
+      blockLight: (() => {
+        const column = new Uint8Array(NUM_SECTIONS * 4096)
+        column.fill(7, 6 * 4096, 7 * 4096)
+        return column
+      })()
+    })
+    expect(isLightSectionPresent(seed.blockPresent, worldSectionMaskBit(6))).toBe(true)
+
+    const merged = mergeUpdateLight(seed, parsed)
+    expect(isLightSectionPresent(merged.blockPresent, worldSectionMaskBit(6))).toBe(true)
+    expect(merged.blockLight[6 * 4096]).toBe(7)
+    expect(isLightSectionPresent(merged.blockPresent, worldSectionMaskBit(0))).toBe(true)
+    expect(merged.blockLight[0]).toBe(0)
+
+    const cache = new RendererLightCache('1.17.1')
+    cache.setWorldBounds(0, 256)
+    applyLightPublication(
+      cache,
+      {
+        worldGeneration: 1,
+        publicationVersion: 1,
+        sections: [
+          { sx: 112, sy: 96, sz: 0, blockLight: packedNibble(7) },
+          { sx: 112, sy: 0, sz: 0, blockLight: packedNibble(0) }
+        ]
+      },
+      { acceptedGeneration: 1, lastVersion: 0 }
+    )
+    expect(cache.getLight(112, 96, 0).block).toBeCloseTo(9 / 15, 5)
+    expect(cache.getLight(112, 0, 0).block).toBeCloseTo(2 / 15, 5)
+  })
+})

package/src/lighting/owner/updateLightToOwnerEvents.ts

@@ -0,0 +1,49 @@
+//@ts-nocheck
+import { maskBitGet, parsedUpdateLightFromWasm, type ParsedUpdateLight } from '../../wasm-mesher/worker/mesherWasmLightMerge'
+import { packUnpackedLightSection } from '../../mesher-shared/lightNibblePack'
+import type { LightOwnerEvent } from './lightOwnerHost'
+
+export function eventsFromParsedUpdateLight(parsed: ParsedUpdateLight, worldMinY: number): LightOwnerEvent[] {
+  const sx = parsed.x
+  const sz = parsed.z
+  const baseSy = Math.floor(worldMinY / 16)
+  const events: LightOwnerEvent[] = []
+  const pushChannel = (channel: 'block' | 'sky', dataMask: Uint32Array, emptyMask: Uint32Array, column: Uint8Array, below?: Uint8Array, above?: Uint8Array) => {
+    const totalBits = parsed.numSections + 2
+    for (let bit = 0; bit < totalBits; bit++) {
+      const hasData = maskBitGet(dataMask, bit)
+      const hasEmpty = maskBitGet(emptyMask, bit)
+      if (!hasData && !hasEmpty) continue
+      const sy = baseSy + bit - 1
+      if (hasEmpty) {
+        events.push({ type: 'serverLight', sx, sy, sz, channel, kind: 'empty', trusted: parsed.trustEdges })
+        continue
+      }
+      let unpacked: Uint8Array | undefined
+      if (bit === 0) unpacked = below
+      else if (bit === parsed.numSections + 1) unpacked = above
+      else unpacked = column.subarray((bit - 1) * 4096, bit * 4096)
+      if (!unpacked || unpacked.length < 4096) {
+        events.push({ type: 'serverLight', sx, sy, sz, channel, kind: 'empty', trusted: parsed.trustEdges })
+        continue
+      }
+      events.push({
+        type: 'serverLight',
+        sx,
+        sy,
+        sz,
+        channel,
+        kind: 'data',
+        trusted: parsed.trustEdges,
+        data: packUnpackedLightSection(unpacked)
+      })
+    }
+  }
+  pushChannel('block', parsed.blockLightMask, parsed.emptyBlockLightMask, parsed.blockLight, parsed.blockBelow, parsed.blockAbove)
+  pushChannel('sky', parsed.skyLightMask, parsed.emptySkyLightMask, parsed.skyLight, parsed.skyBelow, parsed.skyAbove)
+  return events
+}
+
+export function eventsFromWasmUpdateLight(parsedJs: unknown, numSections: number, worldMinY: number): LightOwnerEvent[] {
+  return eventsFromParsedUpdateLight(parsedUpdateLightFromWasm(parsedJs, numSections), worldMinY)
+}