minecraft-renderer 0.1.79 → 0.1.80

package/src/three/cinimaticScript.ts

@@ -12,7 +12,7 @@ export interface CinimaticPoint {
   pitch: number
   duration: number // Time to reach this point from the previous one
   easing?: 'linear' | 'easeIn' | 'easeOut' | 'easeInOut' | 'smoothstep' | 'bounce'
-  lookAt?: { x: number, y: number, z: number } // Optional: override rotation to look at this point
+  lookAt?: { x: number; y: number; z: number } // Optional: override rotation to look at this point
   fov?: number // Optional: change field of view
 }
 
@@ -41,8 +41,8 @@ export class CinimaticScriptRunner {
     private readonly worldRenderer: WorldRendererThree,
     private readonly updateCamera: (pos: Vec3, yaw: number, pitch: number) => void,
     private readonly updateFov: (fov: number) => void,
-    private readonly getInitialState: () => { position: Vec3, yaw: number, pitch: number, fov: number }
-  ) { }
+    private readonly getInitialState: () => { position: Vec3; yaw: number; pitch: number; fov: number }
+  ) {}
 
   startScript(script: CinimaticScript): boolean {
     if (this.isRunning) {
@@ -116,7 +116,7 @@ export class CinimaticScriptRunner {
       { pos: playerPos.offset(-20, 10, -20), lookAt: playerPos, duration: 3000 },
       { pos: playerPos.offset(20, 15, -20), lookAt: playerPos, duration: 3000 },
       { pos: playerPos.offset(20, 20, 20), lookAt: playerPos, duration: 3000 },
-      { pos: playerPos.offset(-20, 25, 20), lookAt: playerPos, duration: 3000 },
+      { pos: playerPos.offset(-20, 25, 20), lookAt: playerPos, duration: 3000 }
     ])
 
     const scripts = [circular, spiral, buildingTour]
@@ -212,7 +212,7 @@ export class CinimaticScriptRunner {
     })
   }
 
-  private wrapRotation(target: { yaw: number, pitch: number }): { yaw: number, pitch: number } {
+  private wrapRotation(target: { yaw: number; pitch: number }): { yaw: number; pitch: number } {
     // Handle yaw wrapping to take shortest path
     let targetYaw = target.yaw
     const yawDiff = targetYaw - this.currentRotation.yaw
@@ -231,13 +231,20 @@ export class CinimaticScriptRunner {
 
   private getEasingFunction(easing: string): (t: number) => number {
     switch (easing) {
-      case 'linear': return tweenJs.Easing.Linear.None
-      case 'easeIn': return tweenJs.Easing.Quadratic.In
-      case 'easeOut': return tweenJs.Easing.Quadratic.Out
-      case 'easeInOut': return tweenJs.Easing.Quadratic.InOut
-      case 'smoothstep': return tweenJs.Easing.Cubic.InOut
-      case 'bounce': return tweenJs.Easing.Bounce.Out
-      default: return tweenJs.Easing.Quadratic.InOut
+      case 'linear':
+        return tweenJs.Easing.Linear.None
+      case 'easeIn':
+        return tweenJs.Easing.Quadratic.In
+      case 'easeOut':
+        return tweenJs.Easing.Quadratic.Out
+      case 'easeInOut':
+        return tweenJs.Easing.Quadratic.InOut
+      case 'smoothstep':
+        return tweenJs.Easing.Cubic.InOut
+      case 'bounce':
+        return tweenJs.Easing.Bounce.Out
+      default:
+        return tweenJs.Easing.Quadratic.InOut
     }
   }
 
@@ -285,7 +292,9 @@ export class CinimaticScriptRunner {
       const y = center.y + height
 
       points.push({
-        x, y, z,
+        x,
+        y,
+        z,
         yaw: angle + Math.PI / 2, // Look tangent to circle
         pitch: -0.2, // Look slightly down
         duration: duration / numPoints,
@@ -315,7 +324,9 @@ export class CinimaticScriptRunner {
       const y = THREE.MathUtils.lerp(start.y, end.y, t)
 
       points.push({
-        x, y, z,
+        x,
+        y,
+        z,
         yaw: angle + Math.PI / 2,
         pitch: -0.3 * t, // Gradually look more down
         duration: duration / numPoints,
@@ -330,7 +341,7 @@ export class CinimaticScriptRunner {
     }
   }
 
-  static createBuildingTour(waypoints: Array<{ pos: Vec3, lookAt?: Vec3, duration?: number }>): CinimaticScript {
+  static createBuildingTour(waypoints: Array<{ pos: Vec3; lookAt?: Vec3; duration?: number }>): CinimaticScript {
     const points: CinimaticPoint[] = waypoints.map((wp, i) => ({
       x: wp.pos.x,
       y: wp.pos.y,

package/src/three/cubeDrawSpans.ts

@@ -1,26 +1,26 @@
 //@ts-nocheck
 import {
+  assertDrawSpansWithinLiveRanges,
+  carveSpansAroundPendingRanges,
   FULL_DRAW_VISIBLE_FRACTION,
   MAX_OPAQUE_SPANS,
-  SPAN_GAP_TOLERANCE_QUADS,
+  type DirtyRange
 } from './globalLegacyBuffer'
 
-export const MAX_CUBE_SPANS = MAX_OPAQUE_SPANS
-export const SPAN_GAP_TOLERANCE_FACES = SPAN_GAP_TOLERANCE_QUADS
-export { FULL_DRAW_VISIBLE_FRACTION }
+export { FULL_DRAW_VISIBLE_FRACTION, MAX_OPAQUE_SPANS as MAX_CUBE_SPANS }
 
-export type CubeDrawSpan = { start: number, count: number }
+export type CubeDrawSpan = { start: number; count: number }
 
-export type VisibleCubeSlot = { start: number, count: number }
+export type VisibleCubeSlot = { start: number; count: number }
 
-function mergeCubeSpans (spans: CubeDrawSpan[]): void {
+/** Merge only physically adjacent face ranges (gap === 0). Never bridge interior holes. */
+function mergeCubeSpans(spans: CubeDrawSpan[]): void {
   if (spans.length < 2) return
   let i = 0
   while (i < spans.length - 1) {
     const cur = spans[i]!
     const next = spans[i + 1]!
-    const gap = next.start - (cur.start + cur.count)
-    if (gap <= SPAN_GAP_TOLERANCE_FACES) {
+    if (cur.start + cur.count === next.start) {
       cur.count = next.start + next.count - cur.start
       spans.splice(i + 1, 1)
     } else {
@@ -29,31 +29,16 @@ function mergeCubeSpans (spans: CubeDrawSpan[]): void {
   }
 }
 
-function capCubeSpans (spans: CubeDrawSpan[]): void {
-  while (spans.length > MAX_CUBE_SPANS) {
-    let bestIdx = 0
-    let bestGap = Infinity
-    for (let i = 0; i < spans.length - 1; i++) {
-      const gap = spans[i + 1]!.start - (spans[i]!.start + spans[i]!.count)
-      if (gap < bestGap) {
-        bestGap = gap
-        bestIdx = i
-      }
-    }
-    const cur = spans[bestIdx]!
-    const next = spans[bestIdx + 1]!
-    cur.count = next.start + next.count - cur.start
-    spans.splice(bestIdx + 1, 1)
-  }
-}
-
 /**
- * Merge/cap visible face-instance ranges for WEBGL_multi_draw (option B).
+ * Merge visible face-instance ranges for WEBGL_multi_draw (option B).
  * Instance indices — no *6 scaling on span values.
  */
-export function buildVisibleCubeSpans (
+export function buildVisibleCubeSpans(
   visibleSlots: VisibleCubeSlot[],
   highWatermark: number,
+  canFullDraw = true,
+  _isRangeUploaded?: (start: number, end: number) => boolean,
+  pendingRanges: ReadonlyArray<DirtyRange> = []
 ): CubeDrawSpan[] {
   if (visibleSlots.length === 0 || highWatermark === 0) return []
 
@@ -62,13 +47,18 @@ export function buildVisibleCubeSpans (
     visibleFaceCount += slot.count
   }
 
-  if (visibleFaceCount >= highWatermark * FULL_DRAW_VISIBLE_FRACTION) {
-    return [{ start: 0, count: highWatermark }]
+  let spans: CubeDrawSpan[]
+  const usedFullDraw = canFullDraw && visibleFaceCount >= highWatermark * FULL_DRAW_VISIBLE_FRACTION
+  if (usedFullDraw) {
+    spans = [{ start: 0, count: highWatermark }]
+  } else {
+    spans = visibleSlots.map(s => ({ start: s.start, count: s.count }))
+    spans.sort((a, b) => a.start - b.start)
+    const liveDrawRanges = spans.map(s => ({ ...s }))
+    mergeCubeSpans(spans)
+    spans = carveSpansAroundPendingRanges(spans, pendingRanges)
+    assertDrawSpansWithinLiveRanges(spans, liveDrawRanges, 'globalBlockBuffer')
+    return spans
   }
-
-  const spans = visibleSlots.map(s => ({ start: s.start, count: s.count }))
-  spans.sort((a, b) => a.start - b.start)
-  mergeCubeSpans(spans)
-  capCubeSpans(spans)
-  return spans
+  return carveSpansAroundPendingRanges(spans, pendingRanges)
 }

package/src/three/cubeMultiDraw.ts

@@ -21,18 +21,12 @@ type MultiDrawInstancedExt = {
     instanceCountsOffset: number,
     baseInstances: Int32Array,
     baseInstancesOffset: number,
-    drawCount: number,
+    drawCount: number
   ) => void
 }
 
 type DrawInstancedBaseExt = {
-  drawArraysInstancedBaseInstanceWEBGL: (
-    mode: number,
-    first: number,
-    count: number,
-    instanceCount: number,
-    baseInstance: number,
-  ) => void
+  drawArraysInstancedBaseInstanceWEBGL: (mode: number, first: number, count: number, instanceCount: number, baseInstance: number) => void
 }
 
 export type CubeMultiDrawScratch = {
@@ -42,16 +36,16 @@ export type CubeMultiDrawScratch = {
   baseInstances: Int32Array
 }
 
-export function createCubeMultiDrawScratch (): CubeMultiDrawScratch {
+export function createCubeMultiDrawScratch(): CubeMultiDrawScratch {
   return {
     firsts: new Int32Array(MAX_CUBE_SPANS),
     counts: new Int32Array(MAX_CUBE_SPANS),
     instanceCounts: new Int32Array(MAX_CUBE_SPANS),
-    baseInstances: new Int32Array(MAX_CUBE_SPANS),
+    baseInstances: new Int32Array(MAX_CUBE_SPANS)
   }
 }
 
-export function detectMultiDrawCaps (gl: WebGL2RenderingContext): MultiDrawCaps {
+export function detectMultiDrawCaps(gl: WebGL2RenderingContext): MultiDrawCaps {
   const tierA = gl.getExtension('WEBGL_multi_draw_instanced_base_vertex_base_instance')
   if (tierA) {
     return { tier: 'A', ext: tierA as MultiDrawInstancedExt }
@@ -65,7 +59,7 @@ export function detectMultiDrawCaps (gl: WebGL2RenderingContext): MultiDrawCaps
 
 let tierLogged = false
 
-export function logMultiDrawTierOnce (tier: MultiDrawTier, debug: boolean): void {
+export function logMultiDrawTierOnce(tier: MultiDrawTier, debug: boolean): void {
   if (tierLogged || !debug) return
   tierLogged = true
   console.info('[globalBlockBuffer] cube multi_draw tier', tier)
@@ -74,12 +68,12 @@ export function logMultiDrawTierOnce (tier: MultiDrawTier, debug: boolean): void
 /**
  * Issue instanced cube draws for visible spans. Tier C delegates to buffer-owned VAO path.
  */
-export function drawCubeSpans (
+export function drawCubeSpans(
   gl: WebGL2RenderingContext,
   caps: MultiDrawCaps,
   spans: readonly CubeDrawSpan[],
   scratch: CubeMultiDrawScratch,
-  tierCDraw?: (gl: WebGL2RenderingContext, spans: readonly CubeDrawSpan[]) => void,
+  tierCDraw?: (gl: WebGL2RenderingContext, spans: readonly CubeDrawSpan[]) => void
 ): void {
   const drawCount = spans.length
   if (drawCount === 0) return
@@ -95,14 +89,7 @@ export function drawCubeSpans (
       scratch.instanceCounts[i] = span.count
       scratch.baseInstances[i] = span.start
     }
-    ext.multiDrawArraysInstancedBaseInstanceWEBGL(
-      mode,
-      scratch.firsts, 0,
-      scratch.counts, 0,
-      scratch.instanceCounts, 0,
-      scratch.baseInstances, 0,
-      drawCount,
-    )
+    ext.multiDrawArraysInstancedBaseInstanceWEBGL(mode, scratch.firsts, 0, scratch.counts, 0, scratch.instanceCounts, 0, scratch.baseInstances, 0, drawCount)
     return
   }
 

package/src/three/documentRenderer.ts

@@ -52,8 +52,7 @@ export interface ThreeRendererMainData {
   canvas: OffscreenCanvas
 }
 
-export const isWebWorker = typeof (globalThis as any).WorkerGlobalScope !== 'undefined' &&
-  globalThis instanceof (globalThis as any).WorkerGlobalScope
+export const isWebWorker = typeof (globalThis as any).WorkerGlobalScope !== 'undefined' && globalThis instanceof (globalThis as any).WorkerGlobalScope
 
 // ============================================================================
 // TopRightStats - Performance stats display
@@ -66,13 +65,15 @@ class TopRightStats {
   private total = 0
   private readonly denseMode: boolean
 
-  constructor(private readonly canvas: HTMLCanvasElement, initialStatsVisible = 0) {
+  constructor(
+    private readonly canvas: HTMLCanvasElement,
+    initialStatsVisible = 0
+  ) {
     this.stats = new Stats()
     this.stats2 = new Stats()
     this.statsGl = new StatsGl({ minimal: true })
     this.stats2.showPanel(2)
-    this.denseMode = typeof process !== 'undefined' && process.env?.NODE_ENV === 'production' ||
-      (typeof window !== 'undefined' && window.innerHeight < 500)
+    this.denseMode = (typeof process !== 'undefined' && process.env?.NODE_ENV === 'production') || (typeof window !== 'undefined' && window.innerHeight < 500)
 
     this.initStats()
     this.setVisibility(initialStatsVisible)
@@ -176,10 +177,10 @@ export class DocumentRenderer {
   disconnected = false
 
   // Render hooks
-  preRender = () => { }
-  render = (sizeChanged: boolean) => { }
-  postRender = () => { }
-  sizeChanged = () => { }
+  preRender = () => {}
+  render = (sizeChanged: boolean) => {}
+  postRender = () => {}
+  sizeChanged = () => {}
 
   droppedFpsPercentage = 0
   config: GraphicsBackendConfig
@@ -210,9 +211,7 @@ export class DocumentRenderer {
         powerPreference: gpuPreferenceToWebGLPowerPreference(gpuPreference)
       })
     } catch (err: any) {
-      initOptions.callbacks.displayCriticalError(
-        new Error(`Failed to create WebGL context, not possible to render (restart browser): ${err.message}`)
-      )
+      initOptions.callbacks.displayCriticalError(new Error(`Failed to create WebGL context, not possible to render (restart browser): ${err.message}`))
       throw err
     }
 
@@ -333,13 +332,12 @@ export class DocumentRenderer {
       if (this.config.timeoutRendering) {
         const targetFps = this.config.fpsLimit ? Math.min(this.config.fpsLimit, 60) : 60
         const timeoutMs = 1000 / targetFps
-          ; (this as any).timeoutId = setTimeout(animate, timeoutMs)
+        ;(this as any).timeoutId = setTimeout(animate, timeoutMs)
       } else {
         this.animationFrameId = requestAnimationFrame(animate)
       }
 
-      if (this.paused ||
-        (this.renderer.xr.isPresenting && !this.inWorldRenderingConfig?.vrPageGameRendering)) {
+      if (this.paused || (this.renderer.xr.isPresenting && !this.inWorldRenderingConfig?.vrPageGameRendering)) {
         return
       }
 
@@ -364,8 +362,7 @@ export class DocumentRenderer {
         this.pendingResize = false
       }
 
-      if (this.previousCanvasWidth !== this.currentWidth ||
-        this.previousCanvasHeight !== this.currentHeight) {
+      if (this.previousCanvasWidth !== this.currentWidth || this.previousCanvasHeight !== this.currentHeight) {
         this.previousCanvasWidth = this.currentWidth
         this.previousCanvasHeight = this.currentHeight
         this.sizeUpdated()
@@ -449,7 +446,7 @@ export const addCanvasForWorker = (): {
   const canvas = addCanvasToPage()
   const transferred = canvas.transferControlToOffscreen()
   let removed = false
-  let onSizeChanged = (w: number, h: number) => { }
+  let onSizeChanged = (w: number, h: number) => {}
   let oldSize = { width: 0, height: 0 }
 
   const checkSize = () => {