minecraft-renderer 0.1.107 → 0.1.108

package/src/three/globalBlockBuffer.ts

@@ -12,6 +12,7 @@ import {
 import { VERTICES_PER_FACE, computeSectionOriginRel } from './shaders/cubeBlockShader'
 import { computeCameraRelativeUniforms, type RenderOrigin } from './shaders/legacyBlockShader'
 import { packWord2Empty } from '../wasm-mesher/bridge/shaderCubeBridge'
+import { isClientLightTraceEnabled, recordClientLightTrace, recordClientLightTraceGpuSample } from '../lighting/debug/clientLightTrace'
 
 type WebGLRendererInternals = THREE.WebGLRenderer & {
   properties: {
@@ -162,9 +163,9 @@ export class GlobalBlockBuffer {
   getSectionDrawStart(sectionKey: string): number | undefined {
     const slot = this.sectionSlots.get(sectionKey)
     if (!slot) return undefined
-    if (this.pendingMove?.key === sectionKey) return this.pendingMove.oldStart
     const replace = this.pendingReplace.get(sectionKey)
     if (replace) return replace.oldStart
+    if (this.pendingMove?.key === sectionKey) return this.pendingMove.oldStart
     if (!this.rangeFullyUploaded(slot.start, slot.start + slot.count - 1)) return undefined
     return slot.start
   }
@@ -172,13 +173,37 @@ export class GlobalBlockBuffer {
   getSectionDrawCount(sectionKey: string): number | undefined {
     const slot = this.sectionSlots.get(sectionKey)
     if (!slot) return undefined
-    if (this.pendingMove?.key === sectionKey) return this.pendingMove.count
     const replace = this.pendingReplace.get(sectionKey)
     if (replace) return replace.oldCount
+    if (this.pendingMove?.key === sectionKey) return this.pendingMove.count
     if (!this.rangeFullyUploaded(slot.start, slot.start + slot.count - 1)) return undefined
     return slot.count
   }
 
+  getGpuSlotTrace(sectionKey: string):
+    | {
+        displayedStart?: number
+        displayedCount?: number
+        candidateStart: number
+        candidateCount: number
+        pendingReplace: boolean
+        pendingMove: boolean
+        unuploadedRanges: number
+      }
+    | undefined {
+    const slot = this.sectionSlots.get(sectionKey)
+    if (!slot) return undefined
+    return {
+      displayedStart: this.getSectionDrawStart(sectionKey),
+      displayedCount: this.getSectionDrawCount(sectionKey),
+      candidateStart: slot.start,
+      candidateCount: slot.count,
+      pendingReplace: this.pendingReplace.has(sectionKey),
+      pendingMove: this.pendingMove?.key === sectionKey,
+      unuploadedRanges: this.pendingRanges.length
+    }
+  }
+
   getUploadEpoch(): number {
     return this.uploadEpoch
   }
@@ -282,6 +307,20 @@ export class GlobalBlockBuffer {
     this.markDirty(slot.start, slot.start + faceCount - 1)
     this.mesh.geometry.instanceCount = this.highWatermark
     this.layoutVersion++
+    if (isClientLightTraceEnabled()) {
+      const gpu = this.getGpuSlotTrace(sectionKey)
+      recordClientLightTrace({
+        phase: 'gpuStaged',
+        sectionKey,
+        displayedStart: gpu?.displayedStart,
+        displayedCount: gpu?.displayedCount,
+        candidateStart: gpu?.candidateStart,
+        candidateCount: gpu?.candidateCount,
+        pendingReplace: gpu?.pendingReplace,
+        pendingMove: gpu?.pendingMove,
+        unuploadedRanges: gpu?.unuploadedRanges
+      })
+    }
   }
 
   getLayoutVersion(): number {
@@ -388,6 +427,20 @@ export class GlobalBlockBuffer {
     this.markDirty(newStart, newStart + section.count - 1)
     this.pendingMove = { key: section.key, oldStart, newStart, count: section.count }
     this.layoutVersion++
+    if (isClientLightTraceEnabled()) {
+      const gpu = this.getGpuSlotTrace(section.key)
+      recordClientLightTrace({
+        phase: 'gpuStaged',
+        sectionKey: section.key,
+        displayedStart: gpu?.displayedStart,
+        displayedCount: gpu?.displayedCount,
+        candidateStart: gpu?.candidateStart,
+        candidateCount: gpu?.candidateCount,
+        pendingReplace: gpu?.pendingReplace,
+        pendingMove: true,
+        unuploadedRanges: gpu?.unuploadedRanges
+      })
+    }
   }
 
   uploadDirtyRange(): void {
@@ -411,6 +464,13 @@ export class GlobalBlockBuffer {
       r.start = offset + count
     }
     this.uploadEpoch++
+    if (isClientLightTraceEnabled()) {
+      recordClientLightTraceGpuSample('gpuUploaded', this.highWatermark, () => ({
+        phase: 'gpuUploaded',
+        unuploadedRanges: this.pendingRanges.length,
+        drawableFaces: this.highWatermark
+      }))
+    }
   }
 
   setCameraOrigin(renderOrigin: RenderOrigin, x: number, y: number, z: number): void {
@@ -608,6 +668,9 @@ export class GlobalBlockBuffer {
   private findMovableSection(maxCount: number): { key: string; start: number; count: number } | undefined {
     const sections: Array<{ key: string; start: number; count: number }> = []
     for (const [key, slot] of this.sectionSlots) {
+      if (this.pendingReplace.has(key)) continue
+      if (this.pendingMove?.key === key) continue
+      if (!this.rangeFullyUploaded(slot.start, slot.start + slot.count - 1)) continue
       sections.push({ key, start: slot.start, count: slot.count })
     }
     if (sections.length === 0) return undefined
@@ -684,11 +747,26 @@ export class GlobalBlockBuffer {
     this.mesh.geometry.instanceCount = this.highWatermark
     this.layoutVersion++
     this.uploadEpoch++
+    if (isClientLightTraceEnabled()) {
+      const gpu = this.getGpuSlotTrace(key)
+      recordClientLightTrace({
+        phase: 'gpuCommitted',
+        sectionKey: key,
+        displayedStart: gpu?.displayedStart,
+        displayedCount: gpu?.displayedCount,
+        candidateStart: gpu?.candidateStart,
+        candidateCount: gpu?.candidateCount,
+        pendingReplace: false,
+        pendingMove: gpu?.pendingMove,
+        unuploadedRanges: gpu?.unuploadedRanges
+      })
+    }
   }
 
   private finalizePendingMove(): void {
     const move = this.pendingMove
     if (!move) return
+    const movedKey = move.key
 
     const { oldStart, count } = move
     this.zeroAndFreeSlot(oldStart, count)
@@ -697,6 +775,20 @@ export class GlobalBlockBuffer {
     this.pendingMove = null
     this.layoutVersion++
     this.uploadEpoch++
+    if (isClientLightTraceEnabled()) {
+      const gpu = this.getGpuSlotTrace(movedKey)
+      recordClientLightTrace({
+        phase: 'gpuCommitted',
+        sectionKey: movedKey,
+        displayedStart: gpu?.displayedStart,
+        displayedCount: gpu?.displayedCount,
+        candidateStart: gpu?.candidateStart,
+        candidateCount: gpu?.candidateCount,
+        pendingReplace: gpu?.pendingReplace,
+        pendingMove: false,
+        unuploadedRanges: gpu?.unuploadedRanges
+      })
+    }
   }
 
   private shrinkHighWatermark(): void {

package/src/three/globalLegacyBuffer.ts

@@ -10,6 +10,7 @@ import {
   type LegacyMultiDrawScratch
 } from './legacyMultiDraw'
 import { computeCameraRelativeUniforms, type RenderOrigin } from './shaders/legacyBlockShader'
+import { isClientLightTraceEnabled, recordClientLightTrace, recordClientLightTraceGpuSample } from '../lighting/debug/clientLightTrace'
 
 const VERTS_PER_QUAD = 4
 const INDICES_PER_QUAD = 6
@@ -337,6 +338,20 @@ export class GlobalLegacyBuffer {
     this.markDirty(slot.start, slot.start + quadCount - 1)
     this.syncDefaultDrawGroups()
     this.layoutVersion++
+    if (isClientLightTraceEnabled()) {
+      const gpu = this.getGpuSlotTrace(sectionKey)
+      recordClientLightTrace({
+        phase: 'gpuStaged',
+        sectionKey,
+        displayedStart: gpu?.displayedStart,
+        displayedCount: gpu?.displayedCount,
+        candidateStart: gpu?.candidateStart,
+        candidateCount: gpu?.candidateCount,
+        pendingReplace: gpu?.pendingReplace,
+        pendingMove: gpu?.pendingMove,
+        unuploadedRanges: gpu?.unuploadedRanges
+      })
+    }
     return true
   }
 
@@ -367,9 +382,9 @@ export class GlobalLegacyBuffer {
   getSectionDrawStart(sectionKey: string): number | undefined {
     const slot = this.sectionSlots.get(sectionKey)
     if (!slot) return undefined
-    if (this.pendingMove?.key === sectionKey) return this.pendingMove.oldStart
     const replace = this.pendingReplace.get(sectionKey)
     if (replace) return replace.oldStart
+    if (this.pendingMove?.key === sectionKey) return this.pendingMove.oldStart
     if (!this.rangeFullyUploaded(slot.start, slot.start + slot.count - 1)) return undefined
     return slot.start
   }
@@ -377,13 +392,37 @@ export class GlobalLegacyBuffer {
   getSectionDrawCount(sectionKey: string): number | undefined {
     const slot = this.sectionSlots.get(sectionKey)
     if (!slot) return undefined
-    if (this.pendingMove?.key === sectionKey) return this.pendingMove.count
     const replace = this.pendingReplace.get(sectionKey)
     if (replace) return replace.oldCount
+    if (this.pendingMove?.key === sectionKey) return this.pendingMove.count
     if (!this.rangeFullyUploaded(slot.start, slot.start + slot.count - 1)) return undefined
     return slot.count
   }
 
+  getGpuSlotTrace(sectionKey: string):
+    | {
+        displayedStart?: number
+        displayedCount?: number
+        candidateStart: number
+        candidateCount: number
+        pendingReplace: boolean
+        pendingMove: boolean
+        unuploadedRanges: number
+      }
+    | undefined {
+    const slot = this.sectionSlots.get(sectionKey)
+    if (!slot) return undefined
+    return {
+      displayedStart: this.getSectionDrawStart(sectionKey),
+      displayedCount: this.getSectionDrawCount(sectionKey),
+      candidateStart: slot.start,
+      candidateCount: slot.count,
+      pendingReplace: this.pendingReplace.has(sectionKey),
+      pendingMove: this.pendingMove?.key === sectionKey,
+      unuploadedRanges: this.pendingRanges.length
+    }
+  }
+
   getPendingMove(): PendingMove | null {
     return this.pendingMove
   }
@@ -425,6 +464,20 @@ export class GlobalLegacyBuffer {
     this.markDirty(newStart, newStart + section.count - 1)
     this.pendingMove = { key: section.key, oldStart, newStart, count: section.count }
     this.layoutVersion++
+    if (isClientLightTraceEnabled()) {
+      const gpu = this.getGpuSlotTrace(section.key)
+      recordClientLightTrace({
+        phase: 'gpuStaged',
+        sectionKey: section.key,
+        displayedStart: gpu?.displayedStart,
+        displayedCount: gpu?.displayedCount,
+        candidateStart: gpu?.candidateStart,
+        candidateCount: gpu?.candidateCount,
+        pendingReplace: gpu?.pendingReplace,
+        pendingMove: true,
+        unuploadedRanges: gpu?.unuploadedRanges
+      })
+    }
   }
 
   updateDrawSpans(visible: VisibleSectionSpan[], mode: 'opaque' | 'sortedBlend'): void {
@@ -696,6 +749,13 @@ export class GlobalLegacyBuffer {
       r.start = quadOffset + quadCount
     }
     this.uploadEpoch++
+    if (isClientLightTraceEnabled()) {
+      recordClientLightTraceGpuSample('gpuUploaded', this.highWatermark, () => ({
+        phase: 'gpuUploaded',
+        unuploadedRanges: this.pendingRanges.length,
+        drawableFaces: this.highWatermark
+      }))
+    }
   }
 
   uploadDirtyIndexRange(): void {
@@ -898,6 +958,9 @@ export class GlobalLegacyBuffer {
   private findMovableSection(maxCount: number): { key: string; start: number; count: number } | undefined {
     const sections: Array<{ key: string; start: number; count: number }> = []
     for (const [key, slot] of this.sectionSlots) {
+      if (this.pendingReplace.has(key)) continue
+      if (this.pendingMove?.key === key) continue
+      if (!this.rangeFullyUploaded(slot.start, slot.start + slot.count - 1)) continue
       sections.push({ key, start: slot.start, count: slot.count })
     }
     if (sections.length === 0) return undefined
@@ -1006,11 +1069,26 @@ export class GlobalLegacyBuffer {
     this.syncDefaultDrawGroups()
     this.layoutVersion++
     this.uploadEpoch++
+    if (isClientLightTraceEnabled()) {
+      const gpu = this.getGpuSlotTrace(key)
+      recordClientLightTrace({
+        phase: 'gpuCommitted',
+        sectionKey: key,
+        displayedStart: gpu?.displayedStart,
+        displayedCount: gpu?.displayedCount,
+        candidateStart: gpu?.candidateStart,
+        candidateCount: gpu?.candidateCount,
+        pendingReplace: false,
+        pendingMove: gpu?.pendingMove,
+        unuploadedRanges: gpu?.unuploadedRanges
+      })
+    }
   }
 
   private finalizePendingMove(): void {
     const move = this.pendingMove
     if (!move) return
+    const movedKey = move.key
 
     const { oldStart, count } = move
     this.zeroAndFreeSlot(oldStart, count)
@@ -1019,6 +1097,20 @@ export class GlobalLegacyBuffer {
     this.pendingMove = null
     this.layoutVersion++
     this.uploadEpoch++
+    if (isClientLightTraceEnabled()) {
+      const gpu = this.getGpuSlotTrace(movedKey)
+      recordClientLightTrace({
+        phase: 'gpuCommitted',
+        sectionKey: movedKey,
+        displayedStart: gpu?.displayedStart,
+        displayedCount: gpu?.displayedCount,
+        candidateStart: gpu?.candidateStart,
+        candidateCount: gpu?.candidateCount,
+        pendingReplace: gpu?.pendingReplace,
+        pendingMove: false,
+        unuploadedRanges: gpu?.unuploadedRanges
+      })
+    }
   }
 
   private growCapacity(minQuads: number): void {

package/src/three/graphicsBackendBase.ts

@@ -87,15 +87,8 @@ export const getBackendMethods = (worldRenderer: WorldRendererThree): any => {
     },
     feedChunkPacket(payload: FeedChunkPacketPayload) {
       // Forward parsed/raw map_chunk + update_light packets from the
-      // web-client to all WASM mesher workers. The fan-out below uses
-      // structured clone (one Uint8Array can only be transferred to a
-      // single recipient); useWorkerProxy still gives zero-copy transfer
-      // from main into the off-thread renderer worker for free.
-      const { kind, ...rest } = payload
-      const message = { type: kind, ...rest }
-      for (const worker of worldRenderer.workers) {
-        worker.postMessage(message)
-      }
+      // web-client to WASM mesher workers (and the light owner when flagged).
+      worldRenderer.feedChunkPacket(payload)
     },
     getChunksDebugState() {
       const loadedSectionsChunks: Record<string, true> = {}

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

@@ -215,3 +215,101 @@ test('GlobalBlockBuffer: uploadEpoch increments when dirty range drains', () =>
   buffer.dispose()
   mat.dispose()
 })
+
+function faceWords(faceCount: number): Uint32Array {
+  return new Uint32Array(faceCount * 4)
+}
+
+function drawableCubeFaces(buffer: GlobalBlockBuffer, key: string): number {
+  const start = buffer.getSectionDrawStart(key)
+  const count = buffer.getSectionDrawCount(key)
+  if (start === undefined || count === undefined) return 0
+  const spans = buildVisibleCubeSpans([{ start, count }], buffer.getHighWatermark(), false, undefined, buffer.getPendingDirtyRanges())
+  return spans.reduce((sum, span) => sum + span.count, 0)
+}
+
+test('GlobalBlockBuffer: compaction must not hide pending-replace displayed faces', () => {
+  const scene = new THREE.Scene()
+  const mat = createCubeBlockMaterial()
+  const buffer = new GlobalBlockBuffer(mat, scene)
+
+  buffer.addSection('H', faceWords(20_000), 20_000)
+  buffer.addSection('A', faceWords(8000), 8000)
+  buffer.addSection('B', faceWords(1000), 1000)
+  drainUploads(buffer)
+  const original = buffer.getSectionDrawStart('A')
+
+  buffer.addSection('A', faceWords(8000), 8000)
+  buffer.removeSection('H')
+  buffer.compactStep()
+  buffer.uploadDirtyRange()
+
+  expect(drawableCubeFaces(buffer, 'A')).toBe(8000)
+  expect(buffer.getSectionDrawStart('A')).toBe(original)
+  const move = buffer.getPendingMove()
+  expect(move?.key === 'A').toBe(false)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalBlockBuffer: 27 simultaneous remeshes keep 8000 faces on every frame', () => {
+  const scene = new THREE.Scene()
+  const mat = createCubeBlockMaterial()
+  const buffer = new GlobalBlockBuffer(mat, scene)
+  const n = 27
+  const faces = 8000
+
+  for (let i = 0; i < n; i++) buffer.addSection(String(i), faceWords(faces), faces)
+  drainUploads(buffer)
+  for (let i = 0; i < n; i++) buffer.addSection(String(i), faceWords(faces), faces)
+
+  for (let frame = 1; frame <= 120; frame++) {
+    buffer.compactStep()
+    buffer.uploadDirtyRange()
+    for (let i = 0; i < n; i++) {
+      expect(drawableCubeFaces(buffer, String(i)), `section ${i} on frame ${frame}`).toBe(faces)
+    }
+    if (!buffer.hasPendingUploads() && !buffer.hasPendingReplace() && !buffer.getPendingMove()) break
+  }
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalBlockBuffer: remesh during move keeps original displayed slot', () => {
+  const scene = new THREE.Scene()
+  const mat = createCubeBlockMaterial()
+  const buffer = new GlobalBlockBuffer(mat, scene)
+
+  buffer.addSection('H', faceWords(20_000), 20_000)
+  buffer.addSection('B', faceWords(1000), 1000)
+  buffer.addSection('A', faceWords(8000), 8000)
+  drainUploads(buffer)
+  buffer.removeSection('H')
+  drainUploads(buffer)
+  buffer.compactStep()
+  expect(buffer.getPendingMove()?.key).toBe('A')
+  const displayed = buffer.getSectionDrawStart('A')
+  expect(displayed).toBeDefined()
+
+  buffer.addSection('A', faceWords(8000), 8000)
+  expect(buffer.getSectionDrawStart('A')).toBe(displayed)
+  expect(buffer.getPendingMove()).toBeNull()
+  expect(buffer.hasPendingReplace()).toBe(true)
+  expect(drawableCubeFaces(buffer, 'A')).toBe(8000)
+
+  buffer.compactStep()
+  buffer.uploadDirtyRange()
+  expect(buffer.getSectionDrawStart('A')).toBe(displayed)
+  expect(buffer.getPendingMove()?.key === 'A').toBe(false)
+  expect(drawableCubeFaces(buffer, 'A')).toBe(8000)
+
+  drainUploads(buffer)
+  buffer.compactStep()
+  finishCurrentMove(buffer)
+  expect(drawableCubeFaces(buffer, 'A')).toBe(8000)
+
+  buffer.dispose()
+  mat.dispose()
+})

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

@@ -892,3 +892,111 @@ test('GlobalLegacyBuffer: blend reorder metadata survives compaction', () => {
   buffer.dispose()
   mat.dispose()
 })
+
+function quadGeometry(quadCount: number): ReturnType<typeof makeQuadGeometry> {
+  const indices = new Uint32Array(quadCount * 6)
+  for (let i = 0; i < quadCount; i++) {
+    const v = i * 4
+    indices.set([v, v + 1, v + 2, v, v + 2, v + 3], i * 6)
+  }
+  return {
+    positions: new Float32Array(quadCount * 12),
+    colors: new Float32Array(quadCount * 12),
+    skyLights: new Float32Array(quadCount * 4),
+    blockLights: new Float32Array(quadCount * 4),
+    uvs: new Float32Array(quadCount * 8),
+    indices
+  }
+}
+
+function drawableLegacyIndices(buffer: GlobalLegacyBuffer, key: string): number {
+  buffer.updateDrawSpans([{ key, distSq: 0 }], 'opaque')
+  return buffer.getVisibleIndexSpans().reduce((sum, span) => sum + span.indexCount, 0)
+}
+
+test('GlobalLegacyBuffer: compaction must not hide pending-replace displayed indices', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+
+  buffer.addSection('H', quadGeometry(8000), 0, 0, 0)
+  buffer.addSection('A', quadGeometry(3000), 0, 0, 0)
+  buffer.addSection('B', quadGeometry(500), 0, 0, 0)
+  drainUploads(buffer)
+  const original = buffer.getSectionDrawStart('A')
+
+  buffer.addSection('A', quadGeometry(3000), 0, 0, 0)
+  buffer.removeSection('H')
+  buffer.compactStep()
+  buffer.uploadDirtyRange()
+  buffer.updateDrawSpans([{ key: 'A', distSq: 0 }], 'opaque')
+
+  expect(drawableLegacyIndices(buffer, 'A')).toBe(18_000)
+  expect(buffer.getSectionDrawStart('A')).toBe(original)
+  expect(buffer.getPendingMove()?.key === 'A').toBe(false)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: 27 simultaneous remeshes keep displayed quads on every frame', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+  const n = 27
+  const quads = 1000
+  const expectedIndices = quads * 6
+
+  for (let i = 0; i < n; i++) buffer.addSection(String(i), quadGeometry(quads), 0, 0, 0)
+  drainUploads(buffer)
+  for (let i = 0; i < n; i++) buffer.addSection(String(i), quadGeometry(quads), 0, 0, 0)
+
+  for (let frame = 1; frame <= 160; frame++) {
+    buffer.compactStep()
+    buffer.uploadDirtyRange()
+    for (let i = 0; i < n; i++) {
+      expect(drawableLegacyIndices(buffer, String(i)), `section ${i} on frame ${frame}`).toBe(expectedIndices)
+    }
+    if (!buffer.hasPendingUploads() && !buffer.hasPendingReplace() && !buffer.getPendingMove()) break
+  }
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: remesh during move keeps original displayed slot', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+
+  buffer.addSection('H', quadGeometry(8000), 0, 0, 0)
+  buffer.addSection('B', quadGeometry(500), 0, 0, 0)
+  buffer.addSection('A', quadGeometry(3000), 0, 0, 0)
+  drainUploads(buffer)
+  buffer.removeSection('H')
+  drainUploads(buffer)
+  buffer.compactStep()
+  expect(buffer.getPendingMove()?.key).toBe('A')
+  const displayed = buffer.getSectionDrawStart('A')
+  expect(displayed).toBeDefined()
+
+  buffer.addSection('A', quadGeometry(3000), 0, 0, 0)
+  expect(buffer.getSectionDrawStart('A')).toBe(displayed)
+  expect(buffer.getPendingMove()).toBeNull()
+  expect(buffer.hasPendingReplace()).toBe(true)
+  expect(drawableLegacyIndices(buffer, 'A')).toBe(18_000)
+
+  buffer.compactStep()
+  buffer.uploadDirtyRange()
+  expect(buffer.getSectionDrawStart('A')).toBe(displayed)
+  expect(buffer.getPendingMove()?.key === 'A').toBe(false)
+  expect(drawableLegacyIndices(buffer, 'A')).toBe(18_000)
+
+  drainUploads(buffer)
+  buffer.compactStep()
+  finishCurrentMove(buffer)
+  expect(drawableLegacyIndices(buffer, 'A')).toBe(18_000)
+
+  buffer.dispose()
+  mat.dispose()
+})