minecraft-renderer 0.1.90 → 0.1.92

package/src/three/chunkMeshManager.ts

@@ -35,6 +35,7 @@ import { disposeObject } from './threeJsUtils'
 import { getBannerTexture, createBannerMesh, releaseBannerTexture } from './bannerRenderer'
 import { getSignTexture, releaseSignTexture, disposeAllSignTextures } from './signTextureCache'
 import { BlockEntityLightRegistry } from '../lib/blockEntityLightRegistry'
+import { SectionOcclusionCull, hsvToRgb } from './occlusion/sectionOcclusionCull'
 
 export interface ChunkMeshPool {
   mesh: THREE.Mesh
@@ -72,6 +73,8 @@ export interface SectionObject extends THREE.Group {
   worldX?: number
   worldY?: number
   worldZ?: number
+  /** Packed VisibilitySet from mesher (section occlusion graph). */
+  visibilitySet?: number
   foutain?: boolean
   /**
    * True while the section is held invisible by the "Batch Chunks Display"
@@ -170,6 +173,9 @@ export class ChunkMeshManager {
   globalLegacyBlendBuffer: GlobalLegacyBuffer | null = null
   /** Tight world AABBs for shader-cube frustum culling (section centers). */
   private readonly shaderSectionRaycastBoxes = new Map<string, ShaderSectionRaycastEntry>()
+  private readonly sectionOcclusionCull = new SectionOcclusionCull()
+  private _lastOcclusionVisibleKeys = ''
+  private _lastSmartCullEnabled: boolean | undefined
 
   // Performance tracking
   private hits = 0
@@ -399,7 +405,13 @@ export class ChunkMeshManager {
     }
   }
 
-  private updatePooledLegacyCullState(cameraWorldX: number, cameraWorldY: number, cameraWorldZ: number): void {
+  private updatePooledLegacyCullState(
+    cameraWorldX: number,
+    cameraWorldY: number,
+    cameraWorldZ: number,
+    smartCull: boolean,
+    occlusionVisible: ReadonlySet<string>
+  ): void {
     for (const poolEntry of this.activeSections.values()) {
       const sectionKey = poolEntry.sectionKey
       if (!sectionKey) continue
@@ -419,16 +431,44 @@ export class ChunkMeshManager {
         this._legacyCullBoxMin,
         this._legacyCullBoxMax
       )
+      if (smartCull && !occlusionVisible.has(sectionKey)) {
+        poolEntry.mesh.visible = false
+      }
     }
   }
 
+  isSectionOcclusionVisible(sectionKey: string): boolean {
+    return this.sectionOcclusionCull.isSectionVisible(sectionKey)
+  }
+
+  /** Invalidate occlusion graph and mark cull dirty when smart-cull enablement changes. */
+  notifySmartCullChanged(smartCull: boolean): void {
+    if (this._lastSmartCullEnabled === smartCull) return
+    this._lastSmartCullEnabled = smartCull
+    this.sectionOcclusionCull.invalidate()
+    this.markCullDirty()
+  }
+
   /**
    * Shared section visibility + span groups for global legacy and cube buffers.
    */
-  updateSectionCullAndSort(camera: THREE.Camera, cameraWorldX: number, cameraWorldY: number, cameraWorldZ: number): void {
+  updateSectionCullAndSort(camera: THREE.Camera, cameraWorldX: number, cameraWorldY: number, cameraWorldZ: number, smartCull: boolean): void {
     this._legacyCullProjScreen.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse)
     this._legacyCullFrustum.setFromProjectionMatrix(this._legacyCullProjScreen)
 
+    const sectionHeight = this.worldRenderer.getSectionHeight?.() ?? 16
+    const worldSizeParams = this.worldRenderer.worldSizeParams ?? { minY: 0, worldHeight: 256 }
+    const occlusionVisible = this.sectionOcclusionCull.update({
+      smartCull,
+      cameraWorldX,
+      cameraWorldY,
+      cameraWorldZ,
+      viewDistance: this.worldRenderer.viewDistance,
+      sectionHeight,
+      worldMinY: worldSizeParams.minY,
+      worldMaxY: worldSizeParams.minY + worldSizeParams.worldHeight
+    })
+
     const visible = this._visibleSectionSpans
     visible.length = 0
 
@@ -452,6 +492,14 @@ export class ChunkMeshManager {
       }
     }
 
+    if (smartCull) {
+      for (let i = visible.length - 1; i >= 0; i--) {
+        if (!occlusionVisible.has(visible[i]!.key)) {
+          visible.splice(i, 1)
+        }
+      }
+    }
+
     const opaqueBuf = this.globalLegacyBuffer
     const blendBuf = this.globalLegacyBlendBuffer
     const gb = this.globalBlockBuffer
@@ -493,6 +541,9 @@ export class ChunkMeshManager {
         if (!inFrustum) {
           return
         }
+        if (smartCull && !occlusionVisible.has(key)) {
+          return
+        }
         cubeVisibleKeys.push(key)
         const drawStart = gb.getSectionDrawStart(key)
         const drawCount = gb.getSectionDrawCount(key)
@@ -503,10 +554,13 @@ export class ChunkMeshManager {
     }
     cubeVisibleKeys.sort()
 
+    const occlusionFp = smartCull ? [...occlusionVisible].sort().join(',') : 'off'
     const fingerprint = [
       opaqueKeys.join(','),
       blendKeys.join(','),
       cubeVisibleKeys.join(','),
+      occlusionFp,
+      smartCull ? '1' : '0',
       opaqueBuf?.getLayoutVersion() ?? 0,
       blendBuf?.getLayoutVersion() ?? 0,
       gb?.getLayoutVersion() ?? 0,
@@ -516,10 +570,12 @@ export class ChunkMeshManager {
     ].join('|')
 
     if (fingerprint === this._lastCullFingerprint && !this.hasPendingBufferWork()) {
-      this.updatePooledLegacyCullState(cameraWorldX, cameraWorldY, cameraWorldZ)
+      this.updatePooledLegacyCullState(cameraWorldX, cameraWorldY, cameraWorldZ, smartCull, occlusionVisible)
+      this._lastOcclusionVisibleKeys = occlusionFp
       return
     }
     this._lastCullFingerprint = fingerprint
+    this._lastOcclusionVisibleKeys = occlusionFp
 
     opaqueBuf?.updateDrawSpans(visible, 'opaque')
     blendBuf?.updateDrawSpans(visible, 'sortedBlend')
@@ -536,7 +592,7 @@ export class ChunkMeshManager {
     }
 
     this.lastBufferStateKey = this.bufferStateKey()
-    this.updatePooledLegacyCullState(cameraWorldX, cameraWorldY, cameraWorldZ)
+    this.updatePooledLegacyCullState(cameraWorldX, cameraWorldY, cameraWorldZ, smartCull, occlusionVisible)
   }
 
   private static readonly BLEND_RESORT_DISTANCE = 1.0
@@ -999,6 +1055,8 @@ export class ChunkMeshManager {
     sectionObject.worldX = geometryData.sx
     sectionObject.worldY = geometryData.sy
     sectionObject.worldZ = geometryData.sz
+    sectionObject.visibilitySet = geometryData.visibilitySet
+    this.sectionOcclusionCull.registerSection(sectionKey, geometryData.visibilitySet, geometryData.sx, geometryData.sy, geometryData.sz)
     // Stamp the section key so modules (e.g. sciFiWorldReveal) can resolve
     // mesh -> section without falling back to sceneOrigin world-position math.
     ;(sectionObject as any).sectionKey = sectionKey
@@ -1313,6 +1371,7 @@ export class ChunkMeshManager {
         this.globalLegacyBlendBuffer?.removeSection(sectionKey)
         this.maybeUnregisterLegacyCullSection(sectionKey)
         this.unregisterShaderSectionRaycastBox(sectionKey)
+        this.sectionOcclusionCull.unregisterSection(sectionKey)
       }
       this.markCullDirty()
       delete sectionObject.deferredLegacyOpaque
@@ -1450,6 +1509,38 @@ export class ChunkMeshManager {
     }
   }
 
+  /**
+   * Debug overlay: tint section borders by occlusion BFS step (Java ChunkCullingDebugRenderer paths mode).
+   */
+  updateCaveCullingDebug(enabled: boolean, smartCull: boolean): void {
+    if (!enabled) {
+      for (const sectionKey of Object.keys(this.sectionObjects)) {
+        const sectionObject = this.sectionObjects[sectionKey]
+        if (sectionObject?.boxHelper && !this.worldRenderer.displayOptions?.inWorldRenderingConfig?.showChunkBorders) {
+          sectionObject.boxHelper.visible = false
+        }
+      }
+      return
+    }
+
+    for (const [sectionKey, sectionObject] of Object.entries(this.sectionObjects)) {
+      if (!sectionObject) continue
+      if (!sectionObject.boxHelper) {
+        this.updateBoxHelper(sectionKey, true)
+      }
+      const helper = sectionObject.boxHelper
+      if (!helper) continue
+      helper.visible = true
+      const color = !smartCull
+        ? 0x00_ff_00
+        : this.sectionOcclusionCull.isSectionVisible(sectionKey)
+          ? hsvToRgb(this.sectionOcclusionCull.getStep(sectionKey) ?? 0)
+          : 0xff_00_00
+      const mat = helper.material as THREE.LineBasicMaterial
+      mat.color.setHex(color)
+    }
+  }
+
   /**
    * Get mesh for section if it exists
    */
@@ -1516,6 +1607,14 @@ export class ChunkMeshManager {
     }
   }
 
+  getDrawnStats(): { cubeFaces: number; legacyOpaqueQuads: number; legacyBlendQuads: number } {
+    return {
+      cubeFaces: this.globalBlockBuffer?.getVisibleFaceCount() ?? 0,
+      legacyOpaqueQuads: this.globalLegacyBuffer?.getVisibleQuadCount() ?? 0,
+      legacyBlendQuads: this.globalLegacyBlendBuffer?.getVisibleQuadCount() ?? 0
+    }
+  }
+
   getStats() {
     const freeCount = this.meshPool.filter(entry => !entry.inUse).length
     const hitRate = this.hits + this.misses > 0 ? ((this.hits / (this.hits + this.misses)) * 100).toFixed(1) : '0'

package/src/three/entities.ts

@@ -457,7 +457,10 @@ export class Entities {
         const dz = entity.position.z - botPos.z
         const distanceSquared = dx * dx + dy * dy + dz * dz
 
-        entity.visible = !!(distanceSquared < VISIBLE_DISTANCE || this.worldRenderer.shouldObjectVisible(entity))
+        const sectionKey = this.worldRenderer.entitySectionKey(entity.position.x, entity.position.y, entity.position.z)
+        const occlusionVisible = this.worldRenderer.isSectionOcclusionVisible(sectionKey)
+
+        entity.visible = !!((distanceSquared < VISIBLE_DISTANCE || this.worldRenderer.shouldObjectVisible(entity)) && occlusionVisible)
 
         this.maybeRenderPlayerSkin(entityIdRaw)
       }

package/src/three/globalBlockBuffer.ts

@@ -147,6 +147,12 @@ export class GlobalBlockBuffer {
     return this.visibleSpans
   }
 
+  getVisibleFaceCount(): number {
+    let faces = 0
+    for (const s of this.visibleSpans) faces += s.count
+    return faces
+  }
+
   forEachSectionSlot(cb: (key: string, slot: { start: number; count: number }) => void): void {
     for (const [key, slot] of this.sectionSlots) {
       cb(key, slot)

package/src/three/globalLegacyBuffer.ts

@@ -216,6 +216,12 @@ export class GlobalLegacyBuffer {
     return this.visibleIndexSpans
   }
 
+  getVisibleQuadCount(): number {
+    let indices = 0
+    for (const s of this.visibleIndexSpans) indices += s.indexCount
+    return indices / INDICES_PER_QUAD
+  }
+
   private syncDefaultDrawGroups(): void {
     const geometry = this.mesh.geometry
     geometry.clearGroups()

package/src/three/occlusion/sectionOcclusionCull.ts

@@ -0,0 +1,90 @@
+//@ts-nocheck
+import { SectionOcclusionGraph, type OcclusionSectionRecord, type OcclusionUpdateParams } from './sectionOcclusionGraph'
+import { VISIBILITY_SET_ALL_TRUE } from '../../mesher-shared/visibilitySet'
+
+export type { OcclusionSectionRecord, OcclusionUpdateParams }
+
+export class SectionOcclusionCull {
+  private readonly graph = new SectionOcclusionGraph()
+  private readonly registered = new Set<string>()
+  private lastVisible = new Set<string>()
+
+  registerSection(key: string, visibilitySet: number | undefined, worldX: number, worldY: number, worldZ: number): void {
+    this.registered.add(key)
+    this.graph.registerSection(key, {
+      visibilitySet: visibilitySet ?? VISIBILITY_SET_ALL_TRUE,
+      worldX,
+      worldY,
+      worldZ
+    })
+  }
+
+  unregisterSection(key: string): void {
+    this.registered.delete(key)
+    this.graph.unregisterSection(key)
+  }
+
+  invalidate(): void {
+    this.graph.invalidate()
+  }
+
+  update(params: OcclusionUpdateParams): Set<string> {
+    this.lastVisible = this.graph.update(params)
+    return this.lastVisible
+  }
+
+  isSectionVisible(key: string): boolean {
+    if (!this.registered.has(key)) return true
+    return this.lastVisible.has(key)
+  }
+
+  hasRegisteredSection(key: string): boolean {
+    return this.registered.has(key)
+  }
+
+  getVisibleKeys(): ReadonlySet<string> {
+    return this.lastVisible
+  }
+
+  getStep(key: string): number | undefined {
+    return this.graph.getStep(key)
+  }
+
+  getGraph(): SectionOcclusionGraph {
+    return this.graph
+  }
+}
+
+export function hsvToRgb(step: number): number {
+  const hue = (step % 50) / 50
+  const h = hue * 6
+  const c = 0.9
+  const x = c * (1 - Math.abs((h % 2) - 1))
+  let r = 0
+  let g = 0
+  let b = 0
+  if (h < 1) {
+    r = c
+    g = x
+  } else if (h < 2) {
+    r = x
+    g = c
+  } else if (h < 3) {
+    g = c
+    b = x
+  } else if (h < 4) {
+    g = x
+    b = c
+  } else if (h < 5) {
+    r = x
+    b = c
+  } else {
+    r = c
+    b = x
+  }
+  const m = 0.1
+  const ri = Math.round((r + m) * 255)
+  const gi = Math.round((g + m) * 255)
+  const bi = Math.round((b + m) * 255)
+  return (ri << 16) | (gi << 8) | bi
+}

package/src/three/occlusion/sectionOcclusionGraph.ts

@@ -0,0 +1,272 @@
+//@ts-nocheck
+/**
+ * Sync port of Minecraft SectionOcclusionGraph BFS (v1 — no Octree/async/advanced ray-march).
+ * @see extracted_minecraft_data/client/net/minecraft/client/renderer/SectionOcclusionGraph.java
+ */
+
+import { Vec3 } from 'vec3'
+import { Direction, DIRECTIONS, VISIBILITY_SET_ALL_TRUE, oppositeDirection, visibilityBetweenPacked } from '../../mesher-shared/visibilitySet'
+
+export type OcclusionSectionRecord = {
+  visibilitySet: number
+  worldX: number
+  worldY: number
+  worldZ: number
+}
+
+export type OcclusionUpdateParams = {
+  smartCull: boolean
+  cameraWorldX: number
+  cameraWorldY: number
+  cameraWorldZ: number
+  viewDistance: number
+  sectionHeight: number
+  worldMinY: number
+  worldMaxY: number
+}
+
+export class OcclusionNode {
+  readonly sectionKey: string
+  private sourceDirections = 0
+  directions = 0
+  readonly step: number
+
+  constructor(sectionKey: string, sourceDir: Direction | null, step: number) {
+    this.sectionKey = sectionKey
+    this.step = step
+    if (sourceDir != null) {
+      this.addSourceDirection(sourceDir)
+    }
+  }
+
+  setDirections(fromParent: number, exitDir: Direction): void {
+    this.directions = (fromParent | this.directions | (1 << exitDir)) >>> 0
+  }
+
+  hasDirection(dir: Direction): boolean {
+    return (this.directions & (1 << dir)) !== 0
+  }
+
+  addSourceDirection(dir: Direction): void {
+    this.sourceDirections = (this.sourceDirections | (1 << dir)) >>> 0
+  }
+
+  hasSourceDirection(index: number): boolean {
+    return (this.sourceDirections & (1 << index)) !== 0
+  }
+
+  hasSourceDirections(): boolean {
+    return this.sourceDirections !== 0
+  }
+}
+
+function sectionKeyFromWorld(worldX: number, worldY: number, worldZ: number): string {
+  return `${worldX},${worldY},${worldZ}`
+}
+
+function parseSectionKey(key: string): { x: number; y: number; z: number } {
+  const [x, y, z] = key.split(',').map(Number)
+  return { x: x!, y: y!, z: z! }
+}
+
+function getNeighborKey(key: string, dir: Direction, sectionHeight: number): string {
+  const { x, y, z } = parseSectionKey(key)
+  switch (dir) {
+    case Direction.DOWN:
+      return sectionKeyFromWorld(x, y - sectionHeight, z)
+    case Direction.UP:
+      return sectionKeyFromWorld(x, y + sectionHeight, z)
+    case Direction.NORTH:
+      return sectionKeyFromWorld(x, y, z - 16)
+    case Direction.SOUTH:
+      return sectionKeyFromWorld(x, y, z + 16)
+    case Direction.WEST:
+      return sectionKeyFromWorld(x - 16, y, z)
+    case Direction.EAST:
+      return sectionKeyFromWorld(x + 16, y, z)
+    default:
+      return key
+  }
+}
+
+function isInViewDistance(cameraKey: string, sectionKey: string, viewDistance: number, sectionHeight: number): boolean {
+  const cam = parseSectionKey(cameraKey)
+  const sec = parseSectionKey(sectionKey)
+  const camChunkX = Math.floor(cam.x / 16)
+  const camChunkZ = Math.floor(cam.z / 16)
+  const secChunkX = Math.floor(sec.x / 16)
+  const secChunkZ = Math.floor(sec.z / 16)
+  if (Math.abs(secChunkX - camChunkX) > viewDistance || Math.abs(secChunkZ - camChunkZ) > viewDistance) {
+    return false
+  }
+  const camSecY = Math.floor(cam.y / sectionHeight)
+  const secSecY = Math.floor(sec.y / sectionHeight)
+  return Math.abs(secSecY - camSecY) <= viewDistance
+}
+
+export class SectionOcclusionGraph {
+  private readonly sections = new Map<string, OcclusionSectionRecord>()
+  private readonly nodeByKey = new Map<string, OcclusionNode>()
+  private visibleKeys = new Set<string>()
+  private stepByKey = new Map<string, number>()
+  private needsFullUpdate = true
+  private lastCameraKey = ''
+
+  registerSection(key: string, record: OcclusionSectionRecord): void {
+    // v1: every register/unregister triggers a synchronous full BFS on next update (no partial graph).
+    this.sections.set(key, record)
+    this.needsFullUpdate = true
+  }
+
+  unregisterSection(key: string): void {
+    if (this.sections.delete(key)) {
+      this.needsFullUpdate = true
+    }
+    this.nodeByKey.delete(key)
+    this.visibleKeys.delete(key)
+    this.stepByKey.delete(key)
+  }
+
+  invalidate(): void {
+    this.needsFullUpdate = true
+  }
+
+  getVisibleKeys(): ReadonlySet<string> {
+    return this.visibleKeys
+  }
+
+  getStep(key: string): number | undefined {
+    return this.stepByKey.get(key)
+  }
+
+  isVisible(key: string): boolean {
+    return this.visibleKeys.has(key)
+  }
+
+  update(params: OcclusionUpdateParams): Set<string> {
+    const cameraKey = sectionKeyFromWorld(
+      Math.floor(params.cameraWorldX / 16) * 16,
+      Math.floor(params.cameraWorldY / params.sectionHeight) * params.sectionHeight,
+      Math.floor(params.cameraWorldZ / 16) * 16
+    )
+
+    if (cameraKey !== this.lastCameraKey) {
+      this.needsFullUpdate = true
+      this.lastCameraKey = cameraKey
+    }
+
+    if (!params.smartCull) {
+      this.visibleKeys = new Set(this.sections.keys())
+      this.stepByKey.clear()
+      for (const key of this.visibleKeys) {
+        this.stepByKey.set(key, 0)
+      }
+      return this.visibleKeys
+    }
+
+    if (this.needsFullUpdate) {
+      this.runFullUpdate(cameraKey, params)
+      this.needsFullUpdate = false
+    }
+
+    return this.visibleKeys
+  }
+
+  private runFullUpdate(cameraKey: string, params: OcclusionUpdateParams): void {
+    this.nodeByKey.clear()
+    this.visibleKeys = new Set()
+    this.stepByKey.clear()
+
+    const queue: OcclusionNode[] = []
+    this.initializeQueueForFullUpdate(cameraKey, queue, params)
+
+    while (queue.length > 0) {
+      const node = queue.shift()!
+      const sectionKey = node.sectionKey
+      if (!this.sections.has(sectionKey)) continue
+
+      this.visibleKeys.add(sectionKey)
+      this.stepByKey.set(sectionKey, node.step)
+
+      const visibilitySet = this.sections.get(sectionKey)?.visibilitySet ?? VISIBILITY_SET_ALL_TRUE
+
+      for (const exitDir of DIRECTIONS) {
+        const neighborSectionKey = getNeighborKey(sectionKey, exitDir, params.sectionHeight)
+        if (!this.sections.has(neighborSectionKey)) continue
+        if (!isInViewDistance(cameraKey, neighborSectionKey, params.viewDistance, params.sectionHeight)) continue
+
+        if (node.hasDirection(oppositeDirection(exitDir))) continue
+
+        if (node.hasSourceDirections()) {
+          let canSee = false
+          for (let i = 0; i < DIRECTIONS.length; i++) {
+            if (node.hasSourceDirection(i) && visibilityBetweenPacked(visibilitySet, oppositeDirection(DIRECTIONS[i]!), exitDir)) {
+              canSee = true
+              break
+            }
+          }
+          if (!canSee) continue
+        }
+
+        const existing = this.nodeByKey.get(neighborSectionKey)
+        if (existing) {
+          existing.addSourceDirection(exitDir)
+        } else {
+          const next = new OcclusionNode(neighborSectionKey, exitDir, node.step + 1)
+          next.setDirections(node.directions, exitDir)
+          this.nodeByKey.set(neighborSectionKey, next)
+          queue.push(next)
+        }
+      }
+    }
+  }
+
+  /** @see SectionOcclusionGraph.initializeQueueForFullUpdate */
+  private initializeQueueForFullUpdate(cameraKey: string, queue: OcclusionNode[], params: OcclusionUpdateParams): void {
+    if (this.sections.has(cameraKey)) {
+      const node = new OcclusionNode(cameraKey, null, 0)
+      this.nodeByKey.set(cameraKey, node)
+      queue.push(node)
+      return
+    }
+
+    const cam = parseSectionKey(cameraKey)
+    const camSecY = Math.floor(cam.y / params.sectionHeight)
+    const minSecY = Math.floor(params.worldMinY / params.sectionHeight)
+    const maxSecY = Math.floor((params.worldMaxY - 1) / params.sectionHeight)
+    const belowMin = camSecY < minSecY
+    const surfaceSecY = belowMin ? minSecY : maxSecY
+    const surfaceY = surfaceSecY * params.sectionHeight
+
+    const camChunkX = Math.floor(cam.x / 16)
+    const camChunkZ = Math.floor(cam.z / 16)
+    const seeds: Array<{ node: OcclusionNode; distSq: number }> = []
+
+    for (let dx = -params.viewDistance; dx <= params.viewDistance; dx++) {
+      for (let dz = -params.viewDistance; dz <= params.viewDistance; dz++) {
+        const key = sectionKeyFromWorld((camChunkX + dx) * 16, surfaceY, (camChunkZ + dz) * 16)
+        if (!this.sections.has(key)) continue
+        if (!isInViewDistance(cameraKey, key, params.viewDistance, params.sectionHeight)) continue
+
+        const entryDir = belowMin ? Direction.UP : Direction.DOWN
+        const node = new OcclusionNode(key, entryDir, 0)
+        node.setDirections(0, entryDir)
+        if (dx > 0) node.setDirections(node.directions, Direction.EAST)
+        else if (dx < 0) node.setDirections(node.directions, Direction.WEST)
+        if (dz > 0) node.setDirections(node.directions, Direction.SOUTH)
+        else if (dz < 0) node.setDirections(node.directions, Direction.NORTH)
+
+        const center = new Vec3(cam.x + 8, cam.y + 8, cam.z + 8)
+        const sec = parseSectionKey(key)
+        const distSq = center.distanceTo(new Vec3(sec.x + 8, sec.y + 8, sec.z + 8))
+        seeds.push({ node, distSq })
+      }
+    }
+
+    seeds.sort((a, b) => a.distSq - b.distSq)
+    for (const seed of seeds) {
+      this.nodeByKey.set(seed.node.sectionKey, seed.node)
+      queue.push(seed.node)
+    }
+  }
+}

package/src/three/positionalAudioAttenuation.ts

@@ -0,0 +1,35 @@
+//@ts-nocheck
+export const DEFAULT_ATTENUATION_DISTANCE = 16
+
+export function computeEffectiveVolume(soundEntryVolume: number, packetVolume: number): number {
+  return soundEntryVolume * Math.max(packetVolume, 0)
+}
+
+export function computeIndividualGain(effectiveVolume: number): number {
+  return Math.min(Math.max(effectiveVolume, 0), 1)
+}
+
+export function computePositionalAudioParams(effectiveVolume: number, attenuationDistance: number): { individualGain: number; maxDistance: number } {
+  return {
+    individualGain: computeIndividualGain(effectiveVolume),
+    maxDistance: Math.max(effectiveVolume, 1) * attenuationDistance
+  }
+}
+
+export function applyVanillaLinearPanner(panner: PannerNode, maxDistance: number): void {
+  panner.distanceModel = 'linear'
+  panner.refDistance = 0
+  panner.rolloffFactor = 1
+  panner.maxDistance = maxDistance
+}
+
+export function setPannerPositionImmediate(panner: PannerNode, audioContext: AudioContext, x: number, y: number, z: number): void {
+  const t = audioContext.currentTime
+  if (panner.positionX) {
+    panner.positionX.setValueAtTime(x, t)
+    panner.positionY.setValueAtTime(y, t)
+    panner.positionZ.setValueAtTime(z, t)
+  } else {
+    panner.setPosition(x, y, z)
+  }
+}