minecraft-renderer 0.1.99 → 0.1.101

package/package.json

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

package/src/three/cubeMultiDraw.ts

@@ -45,6 +45,17 @@ export function createCubeMultiDrawScratch(): CubeMultiDrawScratch {
   }
 }
 
+/** Grow scratch arrays when culling leaves more disjoint spans than MAX_CUBE_SPANS. */
+function ensureScratchCapacity(scratch: CubeMultiDrawScratch, minLength: number): void {
+  if (scratch.counts.length >= minLength) return
+  let newLen = scratch.counts.length
+  while (newLen < minLength) newLen *= 2
+  scratch.firsts = new Int32Array(newLen)
+  scratch.counts = new Int32Array(newLen)
+  scratch.instanceCounts = new Int32Array(newLen)
+  scratch.baseInstances = new Int32Array(newLen)
+}
+
 export function detectMultiDrawCaps(gl: WebGL2RenderingContext): MultiDrawCaps {
   const tierA = gl.getExtension('WEBGL_multi_draw_instanced_base_vertex_base_instance')
   if (tierA) {
@@ -82,6 +93,7 @@ export function drawCubeSpans(
 
   if (caps.tier === 'A' && caps.ext) {
     const ext = caps.ext as MultiDrawInstancedExt
+    ensureScratchCapacity(scratch, drawCount)
     for (let i = 0; i < drawCount; i++) {
       const span = spans[i]!
       scratch.firsts[i] = 0

package/src/three/tests/cubeMultiDraw.test.ts

@@ -0,0 +1,118 @@
+//@ts-nocheck
+import { expect, test, vi } from 'vitest'
+import { buildVisibleCubeSpans, MAX_CUBE_SPANS } from '../cubeDrawSpans'
+import { createCubeMultiDrawScratch, detectMultiDrawCaps, drawCubeSpans } from '../cubeMultiDraw'
+import { VERTICES_PER_FACE } from '../shaders/cubeBlockShader'
+
+type MultiDrawArgs = [number, Int32Array, number, Int32Array, number, Int32Array, number, Int32Array, number, number]
+
+function makeMockGl(opts?: { tier?: 'A' | 'B' }): WebGL2RenderingContext {
+  const multiDrawArraysInstancedBaseInstanceWEBGL = vi.fn((...args: MultiDrawArgs) => {
+    const [, firsts, , counts, , instanceCounts, , baseInstances, , drawCount] = args
+    // WebGL raises INVALID_OPERATION and draws nothing when an argument array is shorter than drawCount.
+    for (const array of [firsts, counts, instanceCounts, baseInstances]) {
+      if (array.length < drawCount) throw new Error(`argument array of length ${array.length} for drawCount ${drawCount}`)
+    }
+  })
+  const drawArraysInstancedBaseInstanceWEBGL = vi.fn()
+  return {
+    TRIANGLES: 0x0004,
+    getExtension: (name: string) => {
+      if (opts?.tier === 'A' && name === 'WEBGL_multi_draw_instanced_base_vertex_base_instance') {
+        return { multiDrawArraysInstancedBaseInstanceWEBGL }
+      }
+      if (opts?.tier === 'B' && name === 'WEBGL_draw_instanced_base_vertex_base_instance') {
+        return { drawArraysInstancedBaseInstanceWEBGL }
+      }
+      return null
+    }
+  } as unknown as WebGL2RenderingContext
+}
+
+/** Visible slots with a one-instance hole between each, so no two merge into one span. */
+function scatteredSpans(count: number) {
+  const slots = Array.from({ length: count }, (_, i) => ({ start: i * 3, count: 2 }))
+  return buildVisibleCubeSpans(slots, count * 3)
+}
+
+test('drawCubeSpans: tier A submits one instanced draw per span', () => {
+  const gl = makeMockGl({ tier: 'A' })
+  const caps = detectMultiDrawCaps(gl)
+  const scratch = createCubeMultiDrawScratch()
+  const spans = [
+    { start: 4, count: 2 },
+    { start: 10, count: 5 }
+  ]
+
+  drawCubeSpans(gl, caps, spans, scratch)
+
+  expect(Array.from(scratch.firsts.subarray(0, 2))).toEqual([0, 0])
+  expect(Array.from(scratch.counts.subarray(0, 2))).toEqual([VERTICES_PER_FACE, VERTICES_PER_FACE])
+  expect(Array.from(scratch.instanceCounts.subarray(0, 2))).toEqual([2, 5])
+  expect(Array.from(scratch.baseInstances.subarray(0, 2))).toEqual([4, 10])
+
+  const ext = caps.ext as { multiDrawArraysInstancedBaseInstanceWEBGL: ReturnType<typeof vi.fn> }
+  expect(ext.multiDrawArraysInstancedBaseInstanceWEBGL).toHaveBeenCalledTimes(1)
+  expect(ext.multiDrawArraysInstancedBaseInstanceWEBGL).toHaveBeenCalledWith(
+    gl.TRIANGLES,
+    scratch.firsts,
+    0,
+    scratch.counts,
+    0,
+    scratch.instanceCounts,
+    0,
+    scratch.baseInstances,
+    0,
+    2
+  )
+})
+
+test('drawCubeSpans: tier A grows scratch past MAX_CUBE_SPANS for fragmented visible sets', () => {
+  const gl = makeMockGl({ tier: 'A' })
+  const caps = detectMultiDrawCaps(gl)
+  const scratch = createCubeMultiDrawScratch()
+  expect(scratch.counts.length).toBe(MAX_CUBE_SPANS)
+
+  const spans = scatteredSpans(MAX_CUBE_SPANS + 6)
+  expect(spans.length).toBe(MAX_CUBE_SPANS + 6)
+
+  drawCubeSpans(gl, caps, spans, scratch)
+
+  for (const array of [scratch.firsts, scratch.counts, scratch.instanceCounts, scratch.baseInstances]) {
+    expect(array.length).toBeGreaterThanOrEqual(spans.length)
+  }
+  const last = spans.length - 1
+  expect(scratch.instanceCounts[last]).toBe(spans[last]!.count)
+  expect(scratch.baseInstances[last]).toBe(spans[last]!.start)
+  const ext = caps.ext as { multiDrawArraysInstancedBaseInstanceWEBGL: ReturnType<typeof vi.fn> }
+  expect(ext.multiDrawArraysInstancedBaseInstanceWEBGL.mock.calls[0]![9]).toBe(spans.length)
+})
+
+test('drawCubeSpans: tier A keeps grown scratch when the visible set shrinks and grows again', () => {
+  const gl = makeMockGl({ tier: 'A' })
+  const caps = detectMultiDrawCaps(gl)
+  const scratch = createCubeMultiDrawScratch()
+
+  drawCubeSpans(gl, caps, scatteredSpans(MAX_CUBE_SPANS + 1), scratch)
+  const grown = scratch.counts
+  drawCubeSpans(gl, caps, scatteredSpans(3), scratch)
+  expect(scratch.counts).toBe(grown)
+  drawCubeSpans(gl, caps, scatteredSpans(grown.length * 2 + 1), scratch)
+
+  expect(scratch.counts.length).toBeGreaterThanOrEqual(grown.length * 2 + 1)
+  const ext = caps.ext as { multiDrawArraysInstancedBaseInstanceWEBGL: ReturnType<typeof vi.fn> }
+  expect(ext.multiDrawArraysInstancedBaseInstanceWEBGL).toHaveBeenCalledTimes(3)
+})
+
+test('drawCubeSpans: tier B issues one base-instance draw per span', () => {
+  const gl = makeMockGl({ tier: 'B' })
+  const caps = detectMultiDrawCaps(gl)
+  const scratch = createCubeMultiDrawScratch()
+  const spans = scatteredSpans(MAX_CUBE_SPANS + 1)
+
+  drawCubeSpans(gl, caps, spans, scratch)
+
+  const ext = caps.ext as { drawArraysInstancedBaseInstanceWEBGL: ReturnType<typeof vi.fn> }
+  expect(ext.drawArraysInstancedBaseInstanceWEBGL).toHaveBeenCalledTimes(spans.length)
+  expect(ext.drawArraysInstancedBaseInstanceWEBGL).toHaveBeenLastCalledWith(gl.TRIANGLES, 0, VERTICES_PER_FACE, 2, (spans.length - 1) * 3)
+})

package/src/wasm-mesher/bridge/geometryIndices.ts

@@ -0,0 +1,17 @@
+//@ts-nocheck
+export function createGeometryIndexArray(indices: readonly number[]): Uint16Array | Uint32Array {
+  let using32Array = false
+  for (let index = 0; index < indices.length; index++) {
+    if (indices[index] > 65535) {
+      using32Array = true
+      break
+    }
+  }
+  return using32Array ? new Uint32Array(indices) : new Uint16Array(indices)
+}
+
+export function appendGeometryIndices(target: number[], source: readonly number[], vertexOffset: number): void {
+  for (let index = 0; index < source.length; index++) {
+    target.push(source[index] + vertexOffset)
+  }
+}

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

@@ -19,6 +19,7 @@ import { resolveBlockPropertiesForMeshing } from '../../mesher-shared/blockPrope
 import { isSemiTransparentBlockName } from '../../mesher-shared/models'
 import { faceIsCulled } from '../../mesher-shared/faceOcclusion'
 import { buildShaderCubesFromWords, getShaderCubeResources, tryBuildShaderCubeInstances } from './shaderCubeBridge'
+import { appendGeometryIndices } from './geometryIndices'
 import { getSideShading, vertexLightFromAo } from '../../mesher-shared/vertexShading'
 import tintsJson from 'minecraft-data/minecraft-data/data/pc/1.16.2/tints.json'
 
@@ -986,10 +987,8 @@ export function renderWasmOutputToGeometry(
     blendSkyLights = liquidSkyLights.concat(blockBlendSkyLights)
     blendBlockLights = liquidBlockLights.concat(blockBlendBlockLights)
     blendUvs = liquidUvs.concat(blockBlendUvs)
-    blendIndices.push(...liquidIndices)
-    for (const idx of blockBlendIndices) {
-      blendIndices.push(idx + liquidVertexCount)
-    }
+    appendGeometryIndices(blendIndices, liquidIndices, 0)
+    appendGeometryIndices(blendIndices, blockBlendIndices, liquidVertexCount)
   }
 
   const shaderCubes = buildShaderCubesFromWords(shaderWordBuffer)

package/src/wasm-mesher/tests/geometryIndices.test.ts

@@ -0,0 +1,71 @@
+//@ts-nocheck
+import { expect, test } from 'vitest'
+import { appendGeometryIndices, createGeometryIndexArray } from '../bridge/geometryIndices'
+
+function expectSameValues(actual: ArrayLike<number>, expected: ArrayLike<number>): void {
+  expect(actual.length).toBe(expected.length)
+  let firstMismatch = -1
+  for (let index = 0; index < expected.length; index++) {
+    if (actual[index] !== expected[index]) {
+      firstMismatch = index
+      break
+    }
+  }
+  expect(firstMismatch, 'First differing index; -1 means all values match').toBe(-1)
+}
+
+test('creates lossless index buffers without depending on argument count', () => {
+  const cases: Array<{ input: number[]; using32Array: boolean }> = [
+    { input: [], using32Array: false },
+    { input: [0, 65535, 7], using32Array: false },
+    { input: [0, 65536, 7], using32Array: true }
+  ]
+
+  for (const { input, using32Array } of cases) {
+    const inputBefore = input.slice()
+    const result = createGeometryIndexArray(input)
+    expect(result).toBeInstanceOf(using32Array ? Uint32Array : Uint16Array)
+    expect(Array.from(result)).toEqual(inputBefore)
+    expect(input).toEqual(inputBefore)
+  }
+
+  const source = new Array<number>(1_000_000).fill(65535)
+  source[0] = 0
+  source[500_000] = 123
+  const sourceBeforeSmall = source.slice()
+  const smallValues = createGeometryIndexArray(source)
+  expect(smallValues).toBeInstanceOf(Uint16Array)
+  expectSameValues(smallValues, sourceBeforeSmall)
+  expectSameValues(source, sourceBeforeSmall)
+
+  source[source.length - 1] = 65536
+  const sourceBeforeLarge = source.slice()
+  const largeValue = createGeometryIndexArray(source)
+  expect(largeValue).toBeInstanceOf(Uint32Array)
+  expectSameValues(largeValue, sourceBeforeLarge)
+  expectSameValues(source, sourceBeforeLarge)
+})
+
+test('appends large liquid indices before rebased block indices', () => {
+  const liquidIndices = new Array<number>(1_000_000).fill(0)
+  liquidIndices[0] = 2
+  liquidIndices[liquidIndices.length - 1] = 1
+  const blockBlendIndices = [0, 2, 1]
+  const liquidVertexCount = 3
+  const blendIndices: number[] = []
+  const liquidIndicesBefore = liquidIndices.slice()
+  const blockBlendIndicesBefore = blockBlendIndices.slice()
+
+  appendGeometryIndices(blendIndices, liquidIndices, 0)
+  appendGeometryIndices(blendIndices, blockBlendIndices, liquidVertexCount)
+
+  expect(blendIndices.length).toBe(liquidIndicesBefore.length + blockBlendIndicesBefore.length)
+  expectSameValues(blendIndices.slice(0, liquidIndicesBefore.length), liquidIndicesBefore)
+  expect(blendIndices.slice(liquidIndicesBefore.length)).toEqual([3, 5, 4])
+  expect(blockBlendIndices).toEqual(blockBlendIndicesBefore)
+  expectSameValues(liquidIndices, liquidIndicesBefore)
+
+  const snapshot = blendIndices.slice()
+  appendGeometryIndices(blendIndices, [], liquidVertexCount)
+  expectSameValues(blendIndices, snapshot)
+})

package/src/wasm-mesher/worker/mesherWasm.ts

@@ -2,6 +2,7 @@
 import { Vec3 } from 'vec3'
 import { convertChunkToWasm, getBlockMeta, type ChunkConversionResult } from '../bridge/convertChunk'
 import { extractColumnHeightmap, splitColumnWasmOutputToSections } from '../bridge/render-from-wasm'
+import { createGeometryIndexArray } from '../bridge/geometryIndices'
 import { setBlockStatesData as setMesherData } from '../../mesher-shared/models'
 import { defaultMesherConfig, type MesherGeometryOutput, SECTION_HEIGHT } from '../../mesher-shared/shared'
 import { SHADER_CUBES_FORMAT_VERSION } from '../../mesher-shared/shaderCubeFormat'
@@ -1493,8 +1494,8 @@ function processColumnTick() {
         const hasLegacyMesh = hasOpaqueMesh || hasBlendMesh
         const hasShaderCubes = (exported?.shaderCubes?.count ?? 0) > 0
         if (exported && (hasLegacyMesh || hasShaderCubes)) {
-          const maxIndex = exported.geometry.indices.length > 0 ? Math.max(...exported.geometry.indices) : 0
-          const using32Array = maxIndex > 65535
+          const indices = createGeometryIndexArray(exported.geometry.indices)
+          const using32Array = indices instanceof Uint32Array
           geometry = {
             sectionYNumber: (sy - (config?.worldMinY || 0)) >> 4,
             chunkKey: worldColumnKey(sx, sz),
@@ -1513,7 +1514,7 @@ function processColumnTick() {
             skyLights: new Float32Array(exported.geometry.skyLights),
             blockLights: new Float32Array(exported.geometry.blockLights),
             uvs: new Float32Array(exported.geometry.uvs),
-            indices: using32Array ? new Uint32Array(exported.geometry.indices) : new Uint16Array(exported.geometry.indices),
+            indices,
             indicesCount: exported.geometry.indices.length,
             using32Array,
             tiles: {},
@@ -1537,7 +1538,6 @@ function processColumnTick() {
             }
           }
           if (exported.blendGeometry && hasBlendMesh) {
-            const blendMax = Math.max(...exported.blendGeometry.indices)
             geometry.blend = {
               positions: new Float32Array(exported.blendGeometry.positions),
               normals: new Float32Array(exported.blendGeometry.normals),
@@ -1545,7 +1545,7 @@ function processColumnTick() {
               skyLights: new Float32Array(exported.blendGeometry.skyLights),
               blockLights: new Float32Array(exported.blendGeometry.blockLights),
               uvs: new Float32Array(exported.blendGeometry.uvs),
-              indices: blendMax > 65535 ? new Uint32Array(exported.blendGeometry.indices) : new Uint16Array(exported.blendGeometry.indices)
+              indices: createGeometryIndexArray(exported.blendGeometry.indices)
             }
           }
           transferable = [