minecraft-renderer 0.1.77 → 0.1.79

package/src/three/globalLegacyBuffer.ts

@@ -1,5 +1,14 @@
 //@ts-nocheck
 import * as THREE from 'three'
+import {
+  createLegacyMultiDrawScratch,
+  detectLegacyMultiDrawCaps,
+  drawLegacySpans,
+  logLegacyMultiDrawTierOnce,
+  type LegacyDrawSpan,
+  type LegacyMultiDrawCaps,
+  type LegacyMultiDrawScratch,
+} from './legacyMultiDraw'
 import { computeCameraRelativeUniforms, type RenderOrigin } from './shaders/legacyBlockShader'
 
 const VERTS_PER_QUAD = 4
@@ -11,6 +20,9 @@ const FLOATS_PER_LIGHT_VERT = 1
 const DEFAULT_INITIAL_CAPACITY_QUADS = 128_000
 const DEFAULT_GROWTH_INCREMENT_QUADS = 128_000
 const MAX_UPLOAD_QUADS_PER_FRAME = 5_000
+const FRAGMENTATION_THRESHOLD = 0.25
+
+type PendingMove = { key: string, oldStart: number, newStart: number, count: number }
 
 /** CPU bytes per allocated quad slot (all legacy vertex/index attrs). */
 export const LEGACY_BYTES_PER_QUAD =
@@ -44,6 +56,8 @@ export type LegacySectionGeometryData = LegacySectionGeometry & {
   sz: number
 }
 
+export type { LegacyDrawSpan } from './legacyMultiDraw'
+
 /**
  * Single GPU mesh for legacy quads (opaque+cutout or transparent blend).
  * Camera-relative via per-vertex a_origin (relative to render origin) + u_originDelta uniforms.
@@ -67,6 +81,12 @@ export class GlobalLegacyBuffer {
   private pendingRanges: Array<{ start: number, end: number }> = []
   private readonly _spanScratch: Array<{ start: number, count: number }> = []
   private renderOrigin: RenderOrigin = { x: 0, y: 0, z: 0 }
+  private layoutVersion = 0
+  private pendingMove: PendingMove | null = null
+  private visibleIndexSpans: LegacyDrawSpan[] = []
+  private readonly _drawScratch: LegacyMultiDrawScratch = createLegacyMultiDrawScratch()
+  private multiDrawCaps: LegacyMultiDrawCaps | null = null
+  private debugOverlay = false
 
   constructor (
     material: THREE.ShaderMaterial,
@@ -114,6 +134,38 @@ export class GlobalLegacyBuffer {
     this.mesh.position.set(0, 0, 0)
     scene.add(this.mesh)
     this.syncDefaultDrawGroups()
+
+    this.mesh.onAfterRender = (renderer, _scene, _camera, _geometry, material) => {
+      if (this.visibleIndexSpans.length === 0) return
+      const gl = renderer.getContext() as WebGL2RenderingContext
+      if (!this.multiDrawCaps) {
+        this.multiDrawCaps = detectLegacyMultiDrawCaps(gl)
+        logLegacyMultiDrawTierOnce(this.multiDrawCaps.tier, this.debugOverlay)
+      }
+      drawLegacySpans(gl, this.multiDrawCaps, this.visibleIndexSpans, this._drawScratch)
+    }
+  }
+
+  setDebugOverlay (enabled: boolean): void {
+    this.debugOverlay = enabled
+  }
+
+  /**
+   * Suppress three's full-buffer indexed draw; onAfterRender issues visible spans only.
+   * setDrawRange(0,0) skips bindingStates.setup — use a minimal non-zero range so
+   * program/VAO/ELEMENT_ARRAY_BUFFER stay bound while three draws ~nothing.
+   * Draws one triangle from index 0 (usually harmless; if quad 0 is culled, one stray tri).
+   */
+  suppressThreeDraw (): void {
+    this.mesh.geometry.setDrawRange(0, 3)
+  }
+
+  setVisibleIndexSpans (spans: LegacyDrawSpan[]): void {
+    this.visibleIndexSpans = spans
+  }
+
+  getVisibleIndexSpans (): readonly LegacyDrawSpan[] {
+    return this.visibleIndexSpans
   }
 
   private syncDefaultDrawGroups (): void {
@@ -171,14 +223,14 @@ export class GlobalLegacyBuffer {
     this.uvs.set(geo.uvs, dstUvBase)
 
     const originOff = dstFloatBase
-    const rx = this.renderOrigin.x
-    const ry = this.renderOrigin.y
-    const rz = this.renderOrigin.z
+    const ox = sx - this.renderOrigin.x
+    const oy = sy - this.renderOrigin.y
+    const oz = sz - this.renderOrigin.z
     for (let v = 0; v < vertCount; v++) {
       const o = originOff + v * FLOATS_PER_VERT
-      this.aOrigin[o] = sx - rx
-      this.aOrigin[o + 1] = sy - ry
-      this.aOrigin[o + 2] = sz - rz
+      this.aOrigin[o] = ox
+      this.aOrigin[o + 1] = oy
+      this.aOrigin[o + 2] = oz
     }
 
     const dstIndexBase = slot.start * INDICES_PER_QUAD
@@ -190,15 +242,60 @@ export class GlobalLegacyBuffer {
     this.sectionSlots.set(sectionKey, slot)
     this.markDirty(slot.start, slot.start + quadCount - 1)
     this.syncDefaultDrawGroups()
+    this.layoutVersion++
     return true
   }
 
+  getLayoutVersion (): number {
+    return this.layoutVersion
+  }
+
+  getSectionDrawStart (sectionKey: string): number | undefined {
+    const slot = this.sectionSlots.get(sectionKey)
+    if (!slot) return undefined
+    if (this.pendingMove?.key === sectionKey) return this.pendingMove.oldStart
+    return slot.start
+  }
+
+  getPendingMove (): PendingMove | null {
+    return this.pendingMove
+  }
+
+  /** One interior-hole move per frame when fragmentation exceeds threshold; deferred shrink. */
+  compactStep (): void {
+    if (this.pendingMove) {
+      const { newStart, count } = this.pendingMove
+      if (this.rangeFullyUploaded(newStart, newStart + count - 1)) {
+        this.finalizePendingMove()
+      }
+      return
+    }
+
+    if (this.highWatermark === 0) return
+    const interiorFree = this.interiorFreeQuads()
+    if (interiorFree / this.highWatermark <= FRAGMENTATION_THRESHOLD) return
+
+    const section = this.findMovableSection(MAX_UPLOAD_QUADS_PER_FRAME)
+    if (!section) return
+
+    const hole = this.findLowestInteriorHole(section.start, section.count)
+    if (!hole) return
+
+    const reserved = this.reserveFreeSlotAt(hole.index, section.count)
+    const oldStart = section.start
+    const newStart = reserved.start
+
+    this.copySectionRange(oldStart, newStart, section.count)
+    this.sectionSlots.set(section.key, { start: newStart, count: section.count })
+    this.markDirty(newStart, newStart + section.count - 1)
+    this.pendingMove = { key: section.key, oldStart, newStart, count: section.count }
+    this.layoutVersion++
+  }
+
   updateDrawSpans (visible: VisibleSectionSpan[], mode: 'opaque' | 'sortedBlend'): void {
-    const geometry = this.mesh.geometry
-    geometry.clearGroups()
+    this.visibleIndexSpans = []
 
     if (this.highWatermark === 0) {
-      geometry.setDrawRange(0, 0)
       return
     }
 
@@ -207,21 +304,30 @@ export class GlobalLegacyBuffer {
     let visibleQuadCount = 0
 
     for (const entry of visible) {
+      const drawStart = this.getSectionDrawStart(entry.key)
       const slot = this.sectionSlots.get(entry.key)
-      if (!slot) continue
-      spans.push({ start: slot.start, count: slot.count })
+      if (drawStart === undefined || !slot) continue
+      spans.push({ start: drawStart, count: slot.count })
       visibleQuadCount += slot.count
     }
 
     if (spans.length === 0) {
-      geometry.setDrawRange(0, 0)
       return
     }
 
+    const pushIndexSpan = (quadStart: number, quadCount: number): void => {
+      this.visibleIndexSpans.push({
+        indexStart: quadStart * INDICES_PER_QUAD,
+        indexCount: quadCount * INDICES_PER_QUAD,
+      })
+    }
+
     if (mode === 'opaque') {
       if (visibleQuadCount >= this.highWatermark * FULL_DRAW_VISIBLE_FRACTION) {
-        geometry.addGroup(0, this.highWatermark * INDICES_PER_QUAD, 0)
-        geometry.setDrawRange(0, this.highWatermark * INDICES_PER_QUAD)
+        this.visibleIndexSpans.push({
+          indexStart: 0,
+          indexCount: this.highWatermark * INDICES_PER_QUAD,
+        })
         return
       }
 
@@ -230,18 +336,17 @@ export class GlobalLegacyBuffer {
       this.capOpaqueSpans(spans)
 
       for (const span of spans) {
-        geometry.addGroup(span.start * INDICES_PER_QUAD, span.count * INDICES_PER_QUAD, 0)
+        pushIndexSpan(span.start, span.count)
       }
     } else {
       visible.sort((a, b) => b.distSq - a.distSq)
       for (const entry of visible) {
+        const drawStart = this.getSectionDrawStart(entry.key)
         const slot = this.sectionSlots.get(entry.key)
-        if (!slot) continue
-        geometry.addGroup(slot.start * INDICES_PER_QUAD, slot.count * INDICES_PER_QUAD, 0)
+        if (drawStart === undefined || !slot) continue
+        pushIndexSpan(drawStart, slot.count)
       }
     }
-
-    geometry.setDrawRange(0, this.highWatermark * INDICES_PER_QUAD)
   }
 
   private mergeOpaqueSpans (spans: Array<{ start: number, count: number }>): void {
@@ -328,6 +433,18 @@ export class GlobalLegacyBuffer {
     const slot = this.sectionSlots.get(sectionKey)
     if (!slot) return
 
+    if (this.pendingMove?.key === sectionKey) {
+      const { oldStart, count } = this.pendingMove
+      const oldIndexBase = oldStart * INDICES_PER_QUAD
+      const oldIndexLen = count * INDICES_PER_QUAD
+      for (let i = 0; i < oldIndexLen; i++) {
+        this.indices[oldIndexBase + i] = 0
+      }
+      this.markDirty(oldStart, oldStart + count - 1)
+      this.insertFreeSlot({ start: oldStart, count })
+      this.pendingMove = null
+    }
+
     const dstIndexBase = slot.start * INDICES_PER_QUAD
     const indexLen = slot.count * INDICES_PER_QUAD
     for (let i = 0; i < indexLen; i++) {
@@ -339,6 +456,7 @@ export class GlobalLegacyBuffer {
     this.insertFreeSlot(slot)
     this.shrinkHighWatermark()
     this.syncDefaultDrawGroups()
+    this.layoutVersion++
   }
 
   hasPendingUploads (): boolean {
@@ -505,6 +623,8 @@ export class GlobalLegacyBuffer {
     this.freeList.length = 0
     this.highWatermark = 0
     this.pendingRanges.length = 0
+    this.pendingMove = null
+    this.visibleIndexSpans = []
     this.syncDefaultDrawGroups()
   }
 
@@ -585,7 +705,125 @@ export class GlobalLegacyBuffer {
     }
   }
 
+  private interiorFreeQuads (): number {
+    let total = 0
+    for (const slot of this.freeList) {
+      if (slot.start < this.highWatermark) total += slot.count
+    }
+    return total
+  }
+
+  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) {
+      sections.push({ key, start: slot.start, count: slot.count })
+    }
+    if (sections.length === 0) return undefined
+
+    sections.sort((a, b) => {
+      if (b.start !== a.start) return b.start - a.start
+      return (b.start + b.count) - (a.start + a.count)
+    })
+
+    const tailmost = sections[0]!
+    if (tailmost.count <= maxCount && this.findLowestInteriorHole(tailmost.start, tailmost.count)) {
+      return tailmost
+    }
+
+    const candidates = sections
+      .filter(s => s.count <= maxCount)
+      .sort((a, b) => b.count - a.count)
+
+    for (const s of candidates) {
+      if (this.findLowestInteriorHole(s.start, s.count)) return s
+    }
+    return undefined
+  }
+
+  private findLowestInteriorHole (
+    sectionStart: number,
+    count: number,
+  ): { start: number, count: number, index: number } | undefined {
+    for (let i = 0; i < this.freeList.length; i++) {
+      const slot = this.freeList[i]!
+      if (slot.start < sectionStart && slot.count >= count) {
+        return { start: slot.start, count: slot.count, index: i }
+      }
+    }
+    return undefined
+  }
+
+  private reserveFreeSlotAt (index: number, count: number): { start: number, count: number } {
+    const slot = this.freeList[index]!
+    this.freeList.splice(index, 1)
+    if (slot.count === count) return { start: slot.start, count }
+    const used = { start: slot.start, count }
+    this.insertFreeSlot({ start: slot.start + count, count: slot.count - count })
+    return used
+  }
+
+  private copySectionRange (oldStart: number, newStart: number, quadCount: number): void {
+    const oldVertBase = oldStart * VERTS_PER_QUAD
+    const newVertBase = newStart * VERTS_PER_QUAD
+    const vertCount = quadCount * VERTS_PER_QUAD
+    const vertDelta = newVertBase - oldVertBase
+
+    const oldFloatBase = oldVertBase * FLOATS_PER_VERT
+    const newFloatBase = newVertBase * FLOATS_PER_VERT
+    const floatLen = vertCount * FLOATS_PER_VERT
+    this.positions.copyWithin(newFloatBase, oldFloatBase, oldFloatBase + floatLen)
+    this.colors.copyWithin(newFloatBase, oldFloatBase, oldFloatBase + floatLen)
+    this.aOrigin.copyWithin(newFloatBase, oldFloatBase, oldFloatBase + floatLen)
+
+    const oldLightBase = oldVertBase * FLOATS_PER_LIGHT_VERT
+    const newLightBase = newVertBase * FLOATS_PER_LIGHT_VERT
+    const lightLen = vertCount * FLOATS_PER_LIGHT_VERT
+    this.skyLights.copyWithin(newLightBase, oldLightBase, oldLightBase + lightLen)
+    this.blockLights.copyWithin(newLightBase, oldLightBase, oldLightBase + lightLen)
+
+    const oldUvBase = oldVertBase * FLOATS_PER_UV_VERT
+    const newUvBase = newVertBase * FLOATS_PER_UV_VERT
+    const uvLen = vertCount * FLOATS_PER_UV_VERT
+    this.uvs.copyWithin(newUvBase, oldUvBase, oldUvBase + uvLen)
+
+    const oldIndexBase = oldStart * INDICES_PER_QUAD
+    const newIndexBase = newStart * INDICES_PER_QUAD
+    const indexLen = quadCount * INDICES_PER_QUAD
+    for (let i = 0; i < indexLen; i++) {
+      this.indices[newIndexBase + i] = this.indices[oldIndexBase + i]! + vertDelta
+    }
+  }
+
+  private rangeFullyUploaded (start: number, end: number): boolean {
+    for (const r of this.pendingRanges) {
+      if (r.start <= end && r.end >= start) return false
+    }
+    return true
+  }
+
+  private finalizePendingMove (): void {
+    const move = this.pendingMove
+    if (!move) return
+
+    const { oldStart, count } = move
+    const oldIndexBase = oldStart * INDICES_PER_QUAD
+    const oldIndexLen = count * INDICES_PER_QUAD
+    for (let i = 0; i < oldIndexLen; i++) {
+      this.indices[oldIndexBase + i] = 0
+    }
+    this.insertFreeSlot({ start: oldStart, count })
+    this.shrinkHighWatermark()
+    if (oldStart < this.highWatermark) {
+      this.markDirty(oldStart, oldStart + count - 1)
+    }
+    this.syncDefaultDrawGroups()
+    this.pendingMove = null
+    this.layoutVersion++
+  }
+
   private growCapacity (minQuads: number): void {
+    if (this.pendingMove) this.finalizePendingMove()
+
     let newCap = this.capacityQuads
     while (newCap < minQuads) newCap += this.growthIncrementQuads
 

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/shaders/cubeBlockShader.ts

@@ -199,6 +199,8 @@ uniform float u_skyLevel;
 uniform float u_lightCurve;
 uniform float u_minBrightness;
 uniform float u_lightGamma;
+uniform float u_shadingTheme;  // 0 = vanilla, 1 = high-contrast
+uniform float u_cardinalLight; // 0 = default, 1 = nether
 
 in float v_blockLight;
 in float v_skyLight;
@@ -248,6 +250,24 @@ void applyFog() {
 
 ${APPLY_LIGHTMAP_GLSL}
 
+const vec3 FACE_NORMAL[6] = vec3[6](
+    vec3(0.0, 1.0, 0.0),  // UP
+    vec3(0.0,-1.0, 0.0),  // DOWN
+    vec3(1.0, 0.0, 0.0),  // EAST
+    vec3(-1.0,0.0, 0.0),  // WEST
+    vec3(0.0, 0.0, 1.0),  // SOUTH
+    vec3(0.0, 0.0,-1.0)   // NORTH
+);
+
+float sideShadingFromFaceId(int faceId, float theme, float cardinal) {
+    vec3 n = FACE_NORMAL[faceId];
+    float hc      = 0.8 + 0.5 * max(0.0, 0.66*n.x + 0.66*n.y + 0.33*n.z);
+    float nether  = 0.5 + abs(0.1*n.x + 0.4*n.y + 0.3*n.z);
+    float vanilla = 0.75 + 0.25*n.y + 0.05*(abs(n.z) - 3.0*abs(n.x));
+    float nonHc   = mix(vanilla, nether, cardinal);
+    return mix(nonHc, hc, theme);
+}
+
 void main() {
     // Atlas sample (pixelated, no filtering)
     ivec2 atlasSize = textureSize(u_atlas, 0);
@@ -294,7 +314,9 @@ void main() {
 
     float L = max(v_blockLight, min(v_skyLight, u_skyLevel));
     float Lm = applyLightmap(L);
-    float brightness = Lm * v_ao;
+    float aoFactor = mix(0.8 * v_ao + 0.2, v_ao, u_shadingTheme);
+    float side     = sideShadingFromFaceId(v_faceId, u_shadingTheme, u_cardinalLight);
+    float brightness = Lm * aoFactor * side;
 
     // Opaque full cubes: always alpha 1 (legacy uses cutout material; avoids seeing blocks behind)
     FragColor = vec4(baseColor.rgb * tint * brightness, 1.0);
@@ -317,6 +339,8 @@ export function createCubeBlockMaterial(): THREE.ShaderMaterial {
                 u_tintPalette: { value: null },
                 u_debugMode: { value: 0 },
                 u_skyLevel: { value: 1.0 },
+                u_shadingTheme: { value: 1.0 },
+                u_cardinalLight: { value: 0.0 },
                 u_lightCurve: { value: DEFAULT_LIGHTMAP_PARAMS.curve },
                 u_minBrightness: { value: DEFAULT_LIGHTMAP_PARAMS.minBrightness },
                 u_lightGamma: { value: DEFAULT_LIGHTMAP_PARAMS.gamma },
@@ -344,6 +368,17 @@ export function setCubeSkyLevel (material: THREE.ShaderMaterial, value: number):
     if (u) u.value = value
 }
 
+export function setCubeShadingTheme (
+  material: THREE.ShaderMaterial,
+  theme: 'vanilla' | 'high-contrast',
+  cardinalLight: string,
+): void {
+  const t = material.uniforms.u_shadingTheme
+  if (t) t.value = theme === 'high-contrast' ? 1.0 : 0.0
+  const c = material.uniforms.u_cardinalLight
+  if (c) c.value = cardinalLight === 'nether' ? 1.0 : 0.0
+}
+
 export function setCubeLightmapParams (
     material: THREE.ShaderMaterial,
     params: BlockLightmapParams,