minecraft-renderer 0.1.87 → 0.1.89

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

@@ -22,8 +22,30 @@ function makeQuadGeometry(): {
   }
 }
 
+/** Two quads along +Z: quad 0 centered at z=0, quad 1 centered at z=8. */
+function makeTwoQuadGeometry(): {
+  positions: Float32Array
+  colors: Float32Array
+  skyLights: Float32Array
+  blockLights: Float32Array
+  uvs: Float32Array
+  indices: Uint32Array
+} {
+  return {
+    positions: new Float32Array([-1, 0, -1, 1, 0, -1, 1, 0, 1, -1, 0, 1, -1, 0, 7, 1, 0, 7, 1, 0, 9, -1, 0, 9]),
+    colors: new Float32Array(24).fill(1),
+    skyLights: new Float32Array(8).fill(1),
+    blockLights: new Float32Array(8).fill(0),
+    uvs: new Float32Array(16).fill(0),
+    indices: new Uint32Array([0, 1, 2, 0, 2, 3, 4, 6, 5, 4, 5, 6])
+  }
+}
+
 type BufferInternals = {
   pendingRanges: Array<{ start: number; end: number }>
+  indexPendingRanges: Array<{ start: number; end: number }>
+  quadCentroids: Float32Array
+  quadIndexTemplate: Uint8Array
   pendingMove: { key: string; oldStart: number; newStart: number; count: number } | null
   growCapacity: (minQuads: number) => void
 }
@@ -36,6 +58,10 @@ function drainUploads(buffer: GlobalLegacyBuffer): void {
   while (getInternals(buffer).pendingRanges.length) buffer.uploadDirtyRange()
 }
 
+function drainIndexUploads(buffer: GlobalLegacyBuffer): void {
+  while (buffer.hasPendingIndexUploads()) buffer.uploadDirtyIndexRange()
+}
+
 function finishCurrentMove(buffer: GlobalLegacyBuffer): void {
   drainUploads(buffer)
   buffer.compactStep()
@@ -675,6 +701,21 @@ test('GlobalLegacyBuffer: carveSpansAroundPendingRanges splits merged span', ()
   ])
 })
 
+test('GlobalLegacyBuffer: carved merged adjacent sections stay within union of input ranges', () => {
+  const sectionRanges = [
+    { start: 100, count: 10 },
+    { start: 110, count: 10 }
+  ]
+  const merged = [{ start: 100, count: 20 }]
+  const carved = carveSpansAroundPendingRanges(merged, [{ start: 105, end: 114 }])
+  for (const span of carved) {
+    for (let q = span.start; q < span.start + span.count; q++) {
+      const inUnion = sectionRanges.some(r => q >= r.start && q < r.start + r.count)
+      expect(inUnion, `quad ${q} not in union of section ranges`).toBe(true)
+    }
+  }
+})
+
 test('GlobalLegacyBuffer: uploadEpoch increments when dirty range drains', () => {
   const scene = new THREE.Scene()
   const mat = createGlobalLegacyBlockMaterial()
@@ -760,3 +801,94 @@ test('GlobalLegacyBuffer: suppressThreeDraw uses minimal non-zero draw range', (
   buffer.dispose()
   mat.dispose()
 })
+
+test('GlobalLegacyBuffer: reorderSectionBlendIndices sorts quads back-to-front', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+  const geo = makeTwoQuadGeometry()
+
+  buffer.addSection('blend', geo, 0, 0, 0)
+  drainUploads(buffer)
+
+  const layoutBefore = buffer.getLayoutVersion()
+  const slot = buffer.getSectionSlot('blend')!
+  const vertBase0 = slot.start * 4
+  const vertBase1 = (slot.start + 1) * 4
+
+  expect(buffer.reorderSectionBlendIndices('blend', 0, 0, -20)).toBe(true)
+  expect(buffer.getLayoutVersion()).toBe(layoutBefore)
+
+  let indices = readSectionIndices(buffer, 'blend')
+  expect(indices.slice(0, 6)).toEqual([vertBase1, vertBase1 + 2, vertBase1 + 1, vertBase1, vertBase1 + 1, vertBase1 + 2])
+  expect(indices.slice(6, 12)).toEqual([vertBase0, vertBase0 + 1, vertBase0 + 2, vertBase0, vertBase0 + 2, vertBase0 + 3])
+
+  expect(buffer.reorderSectionBlendIndices('blend', 0, 0, 20)).toBe(true)
+  indices = readSectionIndices(buffer, 'blend')
+  expect(indices.slice(0, 6)).toEqual([vertBase0, vertBase0 + 1, vertBase0 + 2, vertBase0, vertBase0 + 2, vertBase0 + 3])
+  expect(indices.slice(6, 12)).toEqual([vertBase1, vertBase1 + 2, vertBase1 + 1, vertBase1, vertBase1 + 1, vertBase1 + 2])
+
+  expect(getInternals(buffer).indexPendingRanges.length).toBeGreaterThan(0)
+  drainIndexUploads(buffer)
+  expect(buffer.hasPendingIndexUploads()).toBe(false)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: sortBlend pre-sorts indices on addSection before upload', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene, { sortBlend: true })
+  const geo = makeTwoQuadGeometry()
+
+  buffer.setCameraOrigin(0, 0, -20)
+  buffer.addSection('blend', geo, 0, 0, 0)
+
+  const slot = buffer.getSectionSlot('blend')!
+  const vertBase0 = slot.start * 4
+  const vertBase1 = (slot.start + 1) * 4
+  const indices = readSectionIndices(buffer, 'blend')
+
+  expect(indices.slice(0, 6)).toEqual([vertBase1, vertBase1 + 2, vertBase1 + 1, vertBase1, vertBase1 + 1, vertBase1 + 2])
+  expect(indices.slice(6, 12)).toEqual([vertBase0, vertBase0 + 1, vertBase0 + 2, vertBase0, vertBase0 + 2, vertBase0 + 3])
+  expect(getInternals(buffer).indexPendingRanges.length).toBe(0)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: blend reorder metadata survives compaction', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+  const geo = makeQuadGeometry()
+  const twoGeo = makeTwoQuadGeometry()
+
+  buffer.addSection('a', geo, 0, 0, 0)
+  buffer.addSection('b', geo, 8, 0, 0)
+  buffer.addSection('blend', twoGeo, 16, 0, 0)
+  expect(buffer.getSectionSlot('blend')).toEqual({ start: 2, count: 2 })
+
+  buffer.removeSection('a')
+  buffer.removeSection('b')
+  drainUploads(buffer)
+  buffer.compactStep()
+  finishCurrentMove(buffer)
+
+  const slot = buffer.getSectionSlot('blend')!
+  expect(slot).toEqual({ start: 0, count: 2 })
+
+  const internals = getInternals(buffer)
+  expect(internals.quadCentroids[slot.start * 3 + 2]).toBeCloseTo(0, 5)
+  expect(internals.quadCentroids[(slot.start + 1) * 3 + 2]).toBeCloseTo(8, 5)
+  expect(Array.from(internals.quadIndexTemplate.slice((slot.start + 1) * 6, (slot.start + 1) * 6 + 6))).toEqual([0, 2, 1, 0, 1, 2])
+
+  expect(buffer.reorderSectionBlendIndices('blend', 0, 0, -20)).toBe(true)
+  const vertBase1 = (slot.start + 1) * 4
+  const indices = readSectionIndices(buffer, 'blend')
+  expect(indices[0]).toBe(vertBase1)
+
+  buffer.dispose()
+  mat.dispose()
+})

package/src/three/worldRendererThree.ts

@@ -1327,11 +1327,13 @@ export class WorldRendererThree extends WorldRendererCommon {
       globalLegacyBuffer.suppressThreeDraw()
     }
     const globalLegacyBlendBuffer = this.chunkMeshManager.globalLegacyBlendBuffer
+    let didBlendAllAttrUpload = false
     if (globalLegacyBlendBuffer) {
       globalLegacyBlendBuffer.setDebugOverlay(this.displayOptions.inWorldRenderingConfig.enableDebugOverlay)
       globalLegacyBlendBuffer.compactStep()
       if (globalLegacyBlendBuffer.hasPendingUploads()) {
         globalLegacyBlendBuffer.uploadDirtyRange()
+        didBlendAllAttrUpload = true
       }
       globalLegacyBlendBuffer.suppressThreeDraw()
     }
@@ -1342,6 +1344,10 @@ export class WorldRendererThree extends WorldRendererCommon {
       this.chunkMeshManager.updateSectionCullAndSort(cam, this.cameraWorldPos.x, this.cameraWorldPos.y, this.cameraWorldPos.z)
       this.chunkMeshManager.clearCullDirty()
     }
+    this.chunkMeshManager.sortVisibleBlendSections(camX, camY, camZ)
+    if (!didBlendAllAttrUpload && globalLegacyBlendBuffer?.hasPendingIndexUploads()) {
+      globalLegacyBlendBuffer.uploadDirtyIndexRange()
+    }
     this.renderer.render(this.scene, cam)
 
     if (

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

@@ -279,6 +279,32 @@ test('culling regression: glass/leaves cluster — see-through blocks not over-c
   assertMesherParity(world, 20)
 })
 
+test('culling regression: cactus on grass — ground top face not culled (issue #73)', () => {
+  const world = buildWorld([
+    { x: 0, y: 0, z: 0, name: 'grass_block' },
+    { x: 0, y: 1, z: 0, name: 'cactus' }
+  ])
+  // Pre-fix: grass top culled by cactus cosmetic cap → 14 quads. Post-fix: grass top drawn → 15.
+  assertMesherParity(world, 15)
+})
+
+test('culling regression: cactus stacked on cactus — no over-cull holes', () => {
+  const world = buildWorld([
+    { x: 0, y: 0, z: 0, name: 'cactus' },
+    { x: 0, y: 1, z: 0, name: 'cactus' }
+  ])
+  assertMesherParity(world, 12)
+})
+
+test('culling regression: cactus beside solid block — side faces still drawn', () => {
+  const world = buildWorld([
+    { x: 0, y: 0, z: 0, name: 'dirt' },
+    { x: 1, y: 0, z: 0, name: 'cactus' }
+  ])
+  expect(countQuadsFromLegacy(world)).toBeGreaterThan(9)
+  expect(countQuadsFromWasm(world, false)).toBeGreaterThan(9)
+})
+
 test('shader cubes: dirt UP face culled under farmland', () => {
   const world = buildWorld([
     { x: 0, y: 0, z: 0, name: 'dirt' },