minecraft-renderer 0.1.78 → 0.1.79

package/src/three/legacyMultiDraw.ts

@@ -0,0 +1,99 @@
+//@ts-nocheck
+import { MAX_OPAQUE_SPANS } from './globalLegacyBuffer'
+
+export type LegacyMultiDrawTier = 'A' | 'B' | 'C'
+
+export type LegacyDrawSpan = { indexStart: number, indexCount: number }
+
+export type LegacyMultiDrawCaps = {
+  tier: LegacyMultiDrawTier
+  ext: MultiDrawElementsExt | null
+}
+
+type MultiDrawElementsExt = {
+  multiDrawElementsWEBGL: (
+    mode: number,
+    counts: Int32Array,
+    countsOffset: number,
+    type: number,
+    offsets: Int32Array,
+    offsetsOffset: number,
+    drawCount: number,
+  ) => void
+}
+
+export type LegacyMultiDrawScratch = {
+  counts: Int32Array
+  offsets: Int32Array
+}
+
+export function createLegacyMultiDrawScratch (): LegacyMultiDrawScratch {
+  return {
+    counts: new Int32Array(MAX_OPAQUE_SPANS),
+    offsets: new Int32Array(MAX_OPAQUE_SPANS),
+  }
+}
+
+/** Grow scratch arrays when blend (uncapped) span count exceeds opaque cap. */
+function ensureScratchCapacity (scratch: LegacyMultiDrawScratch, minLength: number): void {
+  if (scratch.counts.length >= minLength) return
+  let newLen = scratch.counts.length
+  while (newLen < minLength) newLen *= 2
+  scratch.counts = new Int32Array(newLen)
+  scratch.offsets = new Int32Array(newLen)
+}
+
+export function detectLegacyMultiDrawCaps (gl: WebGL2RenderingContext): LegacyMultiDrawCaps {
+  const ext = gl.getExtension('WEBGL_multi_draw')
+  if (ext) {
+    return { tier: 'A', ext: ext as MultiDrawElementsExt }
+  }
+  return { tier: 'B', ext: null }
+}
+
+let tierLogged = false
+
+export function logLegacyMultiDrawTierOnce (tier: LegacyMultiDrawTier, debug: boolean): void {
+  if (tierLogged || !debug) return
+  tierLogged = true
+  console.info('[globalLegacyBuffer] legacy multi_draw tier', tier)
+}
+
+/**
+ * Issue indexed legacy draws for visible spans. Tier B/C loop drawElements.
+ */
+export function drawLegacySpans (
+  gl: WebGL2RenderingContext,
+  caps: LegacyMultiDrawCaps,
+  spans: readonly LegacyDrawSpan[],
+  scratch: LegacyMultiDrawScratch,
+): void {
+  const drawCount = spans.length
+  if (drawCount === 0) return
+
+  ensureScratchCapacity(scratch, drawCount)
+
+  const mode = gl.TRIANGLES
+  const type = gl.UNSIGNED_INT
+
+  for (let i = 0; i < drawCount; i++) {
+    const span = spans[i]!
+    scratch.counts[i] = span.indexCount
+    scratch.offsets[i] = span.indexStart * 4
+  }
+
+  if (caps.tier === 'A' && caps.ext) {
+    caps.ext.multiDrawElementsWEBGL(
+      mode,
+      scratch.counts, 0,
+      type,
+      scratch.offsets, 0,
+      drawCount,
+    )
+    return
+  }
+
+  for (let i = 0; i < drawCount; i++) {
+    gl.drawElements(mode, scratch.counts[i]!, type, scratch.offsets[i]!)
+  }
+}

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

@@ -9,6 +9,7 @@ vi.mock('../entity/EntityMesh', () => ({
 import { ChunkMeshManager } from '../chunkMeshManager'
 import type { WorldRendererThree } from '../worldRendererThree'
 import type { MesherGeometryOutput } from '../../mesher-shared/shared'
+import { renderWasmOutputToGeometry } from '../../wasm-mesher/bridge/render-from-wasm'
 
 function makeQuadArrays () {
   const positions = new Float32Array([
@@ -123,6 +124,64 @@ function makeInvalidBlendGeometry (): MesherGeometryOutput {
 
 type ManagerOptions = {
   revealDefer?: boolean
+  shaderCubes?: boolean
+  finishedChunks?: Record<string, boolean>
+}
+
+function makeShaderCubeOnlyGeometry (): MesherGeometryOutput {
+  const block = {
+    position: [0, 0, 0] as [number, number, number],
+    block_state_id: 1,
+    visible_faces: (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5),
+    ao_data: Array.from({ length: 6 }, () => [3, 3, 3, 3]),
+    light_data: Array.from({ length: 6 }, () => [1, 1, 1, 1]),
+    light_combined: Array.from({ length: 6 }, () => [255, 255, 255, 255]),
+  }
+  const out = renderWasmOutputToGeometry(
+    { blocks: [block], block_count: 1, block_iterations: 0 },
+    '1.16.5',
+    '0,0,0',
+    { x: 8, y: 8, z: 8 },
+    undefined,
+    { shaderCubes: true },
+  )
+  return {
+    sectionYNumber: 0,
+    chunkKey: '0,0',
+    sectionStartY: 0,
+    sectionEndY: 16,
+    sectionStartX: 0,
+    sectionEndX: 16,
+    sectionStartZ: 0,
+    sectionEndZ: 16,
+    sx: 8,
+    sy: 8,
+    sz: 8,
+    positions: new Float32Array(0),
+    normals: new Float32Array(0),
+    colors: new Float32Array(0),
+    skyLights: new Float32Array(0),
+    blockLights: new Float32Array(0),
+    uvs: new Float32Array(0),
+    indices: new Uint32Array(0),
+    indicesCount: 0,
+    using32Array: true,
+    tiles: {},
+    heads: {},
+    signs: {},
+    banners: {},
+    hadErrors: false,
+    blocksCount: 1,
+    shaderCubes: out.shaderCubes,
+  }
+}
+
+function makeCullCamera (): THREE.PerspectiveCamera {
+  const camera = new THREE.PerspectiveCamera(60, 1, 0.1, 1000)
+  camera.position.set(8, 8, 20)
+  camera.lookAt(8, 8, 8)
+  camera.updateMatrixWorld()
+  return camera
 }
 
 function createManager (opts: ManagerOptions = {}): ChunkMeshManager {
@@ -134,7 +193,7 @@ function createManager (opts: ManagerOptions = {}): ChunkMeshManager {
     }
     : undefined
   const worldRenderer = {
-    shaderCubeBlocksEnabled: () => false,
+    shaderCubeBlocksEnabled: () => opts.shaderCubes ?? false,
     getModule: (name: string) => (name === 'futuristicReveal' ? revealModule : undefined),
     sceneOrigin: {
       track: () => {},
@@ -142,7 +201,9 @@ function createManager (opts: ManagerOptions = {}): ChunkMeshManager {
       removeAndUntrackAll: () => {},
     },
     blockEntities: {},
-    worldRendererConfig: {},
+    worldRendererConfig: opts.shaderCubes ? { wasmMesher: true } : {},
+    displayOptions: { inWorldRenderingConfig: {} },
+    finishedChunks: opts.finishedChunks ?? (opts.shaderCubes ? { '0,0': true } : {}),
   } as unknown as WorldRendererThree
   return new ChunkMeshManager(worldRenderer, scene, material, 256, 1)
 }
@@ -187,11 +248,11 @@ test('ChunkMeshManager: hidden section excluded from draw spans', () => {
   camera.updateMatrixWorld()
 
   manager.updateSectionCullAndSort(camera, 8, 8, 20)
-  expect(manager.globalLegacyBlendBuffer?.mesh.geometry.groups.length).toBe(0)
+  expect(manager.globalLegacyBlendBuffer?.getVisibleIndexSpans().length).toBe(0)
 
   section.visible = true
   manager.updateSectionCullAndSort(camera, 8, 8, 20)
-  expect(manager.globalLegacyBlendBuffer?.mesh.geometry.groups.length).toBeGreaterThan(0)
+  expect(manager.globalLegacyBlendBuffer?.getVisibleIndexSpans().length).toBeGreaterThan(0)
 
   manager.cleanupSection(key)
   manager.dispose()
@@ -284,3 +345,50 @@ test('ChunkMeshManager: mixed opaque and blend route to separate global buffers'
 
   manager.dispose()
 })
+
+test('ChunkMeshManager: hidden cube section excluded from draw spans', () => {
+  const manager = createManager({ shaderCubes: true })
+  const key = '0,0,0'
+  manager.updateSection(key, makeShaderCubeOnlyGeometry())
+  const section = manager.sectionObjects[key]!
+  expect(manager.globalBlockBuffer?.hasSection(key)).toBe(true)
+
+  const camera = makeCullCamera()
+  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  expect(manager.globalBlockBuffer?.getVisibleSpans().length).toBeGreaterThan(0)
+
+  section.visible = false
+  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  expect(manager.globalBlockBuffer?.getVisibleSpans().length).toBe(0)
+
+  section.visible = true
+  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  expect(manager.globalBlockBuffer?.getVisibleSpans().length).toBeGreaterThan(0)
+
+  manager.cleanupSection(key)
+  manager.dispose()
+})
+
+test('ChunkMeshManager: finishChunkDisplay reveals cube spans and marks cull dirty', () => {
+  const manager = createManager({ shaderCubes: true, finishedChunks: {} })
+  const key = '0,0,0'
+  manager.updateSection(key, makeShaderCubeOnlyGeometry())
+  expect(manager.sectionObjects[key]?.visible).toBe(false)
+  expect(manager.globalBlockBuffer?.hasSection(key)).toBe(true)
+
+  const camera = makeCullCamera()
+  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  expect(manager.globalBlockBuffer?.getVisibleSpans().length).toBe(0)
+
+  const markCullDirtySpy = vi.spyOn(manager, 'markCullDirty')
+  manager.finishChunkDisplay('0,0')
+  expect(manager.sectionObjects[key]?.visible).toBe(true)
+  expect(markCullDirtySpy).toHaveBeenCalled()
+
+  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  expect(manager.globalBlockBuffer?.getVisibleSpans().length).toBeGreaterThan(0)
+
+  markCullDirtySpy.mockRestore()
+  manager.cleanupSection(key)
+  manager.dispose()
+})

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

@@ -39,6 +39,8 @@ function makeQuadGeometry (): {
 
 type BufferInternals = {
   pendingRanges: Array<{ start: number, end: number }>
+  pendingMove: { key: string, oldStart: number, newStart: number, count: number } | null
+  growCapacity: (minQuads: number) => void
 }
 
 function getInternals (buffer: GlobalLegacyBuffer): BufferInternals {
@@ -49,6 +51,20 @@ function drainUploads (buffer: GlobalLegacyBuffer): void {
   while (getInternals(buffer).pendingRanges.length) buffer.uploadDirtyRange()
 }
 
+function finishCurrentMove (buffer: GlobalLegacyBuffer): void {
+  drainUploads(buffer)
+  buffer.compactStep()
+}
+
+function readSectionIndices (buffer: GlobalLegacyBuffer, key: string): number[] {
+  const slot = buffer.getSectionSlot(key)
+  if (!slot) throw new Error(`missing section ${key}`)
+  const indexAttr = buffer.mesh.geometry.index!.array as Uint32Array
+  const base = slot.start * 6
+  const len = slot.count * 6
+  return Array.from(indexAttr.slice(base, base + len))
+}
+
 test('GlobalLegacyBuffer: slot reuse and a_origin fill', () => {
   const scene = new THREE.Scene()
   const mat = createGlobalLegacyBlockMaterial()
@@ -193,9 +209,9 @@ test('GlobalLegacyBuffer: updateDrawSpans opaque merges nearby spans', () => {
   buffer.addSection('b', geo, 16, 0, 0)
   buffer.updateDrawSpans([{ key: 'a', distSq: 1 }, { key: 'b', distSq: 4 }], 'opaque')
 
-  const groups = buffer.mesh.geometry.groups
-  expect(groups.length).toBe(1)
-  expect(groups[0]!.count).toBe(12)
+  const spans = buffer.getVisibleIndexSpans()
+  expect(spans.length).toBe(1)
+  expect(spans[0]!.indexCount).toBe(12)
 
   buffer.dispose()
   mat.dispose()
@@ -212,10 +228,10 @@ test('GlobalLegacyBuffer: updateDrawSpans opaque full draw when most quads visib
   buffer.addSection('c', geo, 32, 0, 0)
   buffer.updateDrawSpans([{ key: 'a', distSq: 1 }, { key: 'b', distSq: 2 }, { key: 'c', distSq: 3 }], 'opaque')
 
-  const groups = buffer.mesh.geometry.groups
-  expect(groups.length).toBe(1)
-  expect(groups[0]!.start).toBe(0)
-  expect(groups[0]!.count).toBe(18)
+  const spans = buffer.getVisibleIndexSpans()
+  expect(spans.length).toBe(1)
+  expect(spans[0]!.indexStart).toBe(0)
+  expect(spans[0]!.indexCount).toBe(18)
 
   buffer.dispose()
   mat.dispose()
@@ -234,10 +250,10 @@ test('GlobalLegacyBuffer: updateDrawSpans sortedBlend orders back-to-front', ()
     { key: 'far', distSq: 100 },
   ], 'sortedBlend')
 
-  const groups = buffer.mesh.geometry.groups
-  expect(groups.length).toBe(2)
-  expect(groups[0]!.start).toBe(6)
-  expect(groups[1]!.start).toBe(0)
+  const spans = buffer.getVisibleIndexSpans()
+  expect(spans.length).toBe(2)
+  expect(spans[0]!.indexStart).toBe(6)
+  expect(spans[1]!.indexStart).toBe(0)
 
   buffer.dispose()
   mat.dispose()
@@ -252,14 +268,13 @@ test('GlobalLegacyBuffer: updateDrawSpans skips missing keys', () => {
   buffer.addSection('a', geo, 0, 0, 0)
   buffer.updateDrawSpans([{ key: 'missing', distSq: 1 }], 'opaque')
 
-  expect(buffer.mesh.geometry.groups.length).toBe(0)
-  expect(buffer.mesh.geometry.drawRange.count).toBe(0)
+  expect(buffer.getVisibleIndexSpans().length).toBe(0)
 
   buffer.dispose()
   mat.dispose()
 })
 
-test('GlobalLegacyBuffer: reset clears groups', () => {
+test('GlobalLegacyBuffer: reset clears visible spans', () => {
   const scene = new THREE.Scene()
   const mat = createGlobalLegacyBlockMaterial()
   const buffer = new GlobalLegacyBuffer(mat, scene)
@@ -267,10 +282,10 @@ test('GlobalLegacyBuffer: reset clears groups', () => {
 
   buffer.addSection('a', geo, 0, 0, 0)
   buffer.updateDrawSpans([{ key: 'a', distSq: 1 }], 'opaque')
-  expect(buffer.mesh.geometry.groups.length).toBeGreaterThan(0)
+  expect(buffer.getVisibleIndexSpans().length).toBeGreaterThan(0)
 
   buffer.reset()
-  expect(buffer.mesh.geometry.groups.length).toBe(0)
+  expect(buffer.getVisibleIndexSpans().length).toBe(0)
 
   buffer.dispose()
   mat.dispose()
@@ -318,12 +333,12 @@ test('GlobalLegacyBuffer: updateDrawSpans opaque caps at MAX_OPAQUE_SPANS with f
 
   buffer.updateDrawSpans(visible, 'opaque')
 
-  const groups = buffer.mesh.geometry.groups
-  expect(groups.length).toBe(MAX_OPAQUE_SPANS)
+  const spans = buffer.getVisibleIndexSpans()
+  expect(spans.length).toBe(MAX_OPAQUE_SPANS)
 
   const covered = new Set<number>()
-  for (const group of groups) {
-    for (let idx = group.start; idx < group.start + group.count; idx++) {
+  for (const span of spans) {
+    for (let idx = span.indexStart; idx < span.indexStart + span.indexCount; idx++) {
       covered.add(idx)
     }
   }
@@ -358,3 +373,131 @@ test('GlobalLegacyBuffer: addSection rejects non-quad geometry', () => {
   buffer.dispose()
   mat.dispose()
 })
+
+test('GlobalLegacyBuffer: compaction lowers watermark after interior-hole churn', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+  const geo = makeQuadGeometry()
+
+  buffer.addSection('a', geo, 0, 0, 0)
+  buffer.addSection('b', geo, 16, 0, 0)
+  buffer.addSection('c', geo, 32, 0, 0)
+  expect(buffer.getHighWatermark()).toBe(3)
+
+  buffer.removeSection('b')
+  drainUploads(buffer)
+  expect(buffer.getHighWatermark()).toBe(3)
+
+  buffer.compactStep()
+  finishCurrentMove(buffer)
+
+  expect(buffer.getHighWatermark()).toBe(2)
+  expect(buffer.getSectionSlot('c')).toEqual({ start: 1, count: 1 })
+  const slotC = buffer.getSectionSlot('c')!
+  const indices = readSectionIndices(buffer, 'c')
+  expect(indices[0]).toBe(slotC.start * 4)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: grow during in-flight move preserves section data', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene, { initialCapacityQuads: 4, growthIncrementQuads: 8 })
+  const geo = makeQuadGeometry()
+
+  buffer.addSection('a', geo, 0, 0, 0)
+  buffer.addSection('b', geo, 16, 0, 0)
+  buffer.addSection('c', geo, 32, 0, 0)
+  buffer.removeSection('b')
+  drainUploads(buffer)
+
+  buffer.compactStep()
+  expect(buffer.getPendingMove()).not.toBeNull()
+  expect(buffer.hasSection('c')).toBe(true)
+
+  getInternals(buffer).growCapacity(16)
+
+  expect(buffer.getPendingMove()).toBeNull()
+  expect(buffer.hasSection('c')).toBe(true)
+  const slotC = buffer.getSectionSlot('c')!
+  const indices = readSectionIndices(buffer, 'c')
+  expect(indices[0]).toBe(slotC.start * 4)
+  expect(buffer.getCapacityQuads()).toBeGreaterThanOrEqual(16)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: finalize move bumps layoutVersion and updates draw spans', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+  const geo = makeQuadGeometry()
+
+  buffer.addSection('a', geo, 0, 0, 0)
+  buffer.addSection('b', geo, 16, 0, 0)
+  buffer.addSection('c', geo, 32, 0, 0)
+  buffer.removeSection('b')
+  drainUploads(buffer)
+
+  buffer.compactStep()
+  expect(buffer.getPendingMove()).not.toBeNull()
+  const versionAfterMove = buffer.getLayoutVersion()
+
+  const visible = [{ key: 'c', distSq: 1 }]
+  buffer.updateDrawSpans(visible, 'opaque')
+  expect(buffer.getVisibleIndexSpans()[0]!.indexStart).toBe(2 * 6)
+
+  drainUploads(buffer)
+  buffer.compactStep()
+  expect(buffer.getPendingMove()).toBeNull()
+  expect(buffer.getLayoutVersion()).toBe(versionAfterMove + 1)
+
+  buffer.updateDrawSpans(visible, 'opaque')
+  expect(buffer.getVisibleIndexSpans()[0]!.indexStart).toBe(1 * 6)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: sortedBlend accepts more than MAX_OPAQUE_SPANS sections', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const sectionCount = MAX_OPAQUE_SPANS + 6
+  const buffer = new GlobalLegacyBuffer(mat, scene, {
+    initialCapacityQuads: sectionCount + 4,
+    growthIncrementQuads: 64,
+  })
+  const geo = makeQuadGeometry()
+  const visible: Array<{ key: string, distSq: number }> = []
+
+  for (let i = 0; i < sectionCount; i++) {
+    const key = `s${i}`
+    buffer.addSection(key, geo, i * 16, 0, 0)
+    visible.push({ key, distSq: sectionCount - i })
+  }
+
+  buffer.updateDrawSpans(visible, 'sortedBlend')
+  expect(buffer.getVisibleIndexSpans().length).toBe(sectionCount)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: suppressThreeDraw uses minimal non-zero draw range', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+  const geo = makeQuadGeometry()
+
+  buffer.addSection('a', geo, 0, 0, 0)
+  buffer.suppressThreeDraw()
+  expect(buffer.mesh.geometry.drawRange.start).toBe(0)
+  expect(buffer.mesh.geometry.drawRange.count).toBe(3)
+
+  buffer.dispose()
+  mat.dispose()
+})

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

@@ -0,0 +1,109 @@
+//@ts-nocheck
+import { expect, test, vi } from 'vitest'
+import {
+  createLegacyMultiDrawScratch,
+  detectLegacyMultiDrawCaps,
+  drawLegacySpans,
+} from '../legacyMultiDraw'
+
+function makeMockGl (opts?: { multiDraw?: boolean }): WebGL2RenderingContext {
+  const multiDrawElementsWEBGL = vi.fn()
+  const drawElements = vi.fn()
+  return {
+    TRIANGLES: 0x0004,
+    UNSIGNED_INT: 0x1405,
+    getExtension: (name: string) => {
+      if (opts?.multiDraw && name === 'WEBGL_multi_draw') {
+        return { multiDrawElementsWEBGL }
+      }
+      return null
+    },
+    drawElements,
+  } as unknown as WebGL2RenderingContext
+}
+
+test('detectLegacyMultiDrawCaps: tier A when WEBGL_multi_draw is available', () => {
+  const gl = makeMockGl({ multiDraw: true })
+  const caps = detectLegacyMultiDrawCaps(gl)
+  expect(caps.tier).toBe('A')
+  expect(caps.ext).not.toBeNull()
+})
+
+test('detectLegacyMultiDrawCaps: tier B when extension is missing', () => {
+  const gl = makeMockGl()
+  const caps = detectLegacyMultiDrawCaps(gl)
+  expect(caps.tier).toBe('B')
+  expect(caps.ext).toBeNull()
+})
+
+test('drawLegacySpans: tier A uses multiDrawElementsWEBGL with byte offsets', () => {
+  const gl = makeMockGl({ multiDraw: true })
+  const caps = detectLegacyMultiDrawCaps(gl)
+  const scratch = createLegacyMultiDrawScratch()
+  const spans = [
+    { indexStart: 12, indexCount: 6 },
+    { indexStart: 30, indexCount: 12 },
+  ]
+
+  drawLegacySpans(gl, caps, spans, scratch)
+
+  expect(scratch.counts[0]).toBe(6)
+  expect(scratch.counts[1]).toBe(12)
+  expect(scratch.offsets[0]).toBe(48)
+  expect(scratch.offsets[1]).toBe(120)
+
+  const ext = caps.ext as { multiDrawElementsWEBGL: ReturnType<typeof vi.fn> }
+  expect(ext.multiDrawElementsWEBGL).toHaveBeenCalledTimes(1)
+  expect(ext.multiDrawElementsWEBGL).toHaveBeenCalledWith(
+    gl.TRIANGLES,
+    scratch.counts, 0,
+    gl.UNSIGNED_INT,
+    scratch.offsets, 0,
+    2,
+  )
+})
+
+test('drawLegacySpans: tier B loops drawElements per span', () => {
+  const gl = makeMockGl()
+  const caps = detectLegacyMultiDrawCaps(gl)
+  const scratch = createLegacyMultiDrawScratch()
+  const spans = [{ indexStart: 4, indexCount: 6 }]
+
+  drawLegacySpans(gl, caps, spans, scratch)
+
+  expect((gl as unknown as { drawElements: ReturnType<typeof vi.fn> }).drawElements).toHaveBeenCalledWith(
+    gl.TRIANGLES,
+    6,
+    gl.UNSIGNED_INT,
+    16,
+  )
+})
+
+test('drawLegacySpans: grows scratch past MAX_OPAQUE_SPANS for uncapped blend sets', () => {
+  const gl = makeMockGl({ multiDraw: true })
+  const caps = detectLegacyMultiDrawCaps(gl)
+  const scratch = createLegacyMultiDrawScratch()
+  expect(scratch.counts.length).toBe(64)
+
+  const spanCount = 70
+  const spans = Array.from({ length: spanCount }, (_, i) => ({
+    indexStart: i * 6,
+    indexCount: 6,
+  }))
+
+  drawLegacySpans(gl, caps, spans, scratch)
+
+  expect(scratch.counts.length).toBeGreaterThanOrEqual(spanCount)
+  expect(scratch.offsets.length).toBeGreaterThanOrEqual(spanCount)
+  expect(scratch.counts[69]).toBe(6)
+  expect(scratch.offsets[69]).toBe(69 * 6 * 4)
+
+  const ext = caps.ext as { multiDrawElementsWEBGL: ReturnType<typeof vi.fn> }
+  expect(ext.multiDrawElementsWEBGL).toHaveBeenCalledWith(
+    gl.TRIANGLES,
+    scratch.counts, 0,
+    gl.UNSIGNED_INT,
+    scratch.offsets, 0,
+    spanCount,
+  )
+})