minecraft-renderer 0.1.71 → 0.1.73

package/src/three/graphicsBackendOffThread.ts

@@ -9,6 +9,7 @@ import type { MenuBackgroundOptions } from './menuBackground/types'
 import { MENU_BACKGROUND_MC_VERSION } from './menuBackground/shared'
 import { createGraphicsBackendBase, type ThreeJsBackendMethods } from './graphicsBackendBase'
 import { addCanvasForWorker } from './documentRenderer'
+import type { WorldView } from '../worldView'
 
 function initThreeWorker(onGotMessage: (data: any) => void) {
   // Node environment needs an absolute path, but browser needs the url of the file
@@ -31,7 +32,12 @@ function initThreeWorker(onGotMessage: (data: any) => void) {
 }
 
 export const createGraphicsBackendOffThread: GraphicsBackendLoader = async (initOptions) => {
-  const worker = initThreeWorker(() => { })
+  const workerSideChannel = {
+    onMessage: (_data: unknown) => {},
+  }
+  const worker = initThreeWorker((data) => {
+    workerSideChannel.onMessage(data)
+  })
   type WorkerType = ReturnType<ReturnType<typeof createGraphicsBackendBase>['workerProxy']>
 
   const proxy = useWorkerProxy<WorkerType>(worker)
@@ -79,6 +85,15 @@ export const createGraphicsBackendOffThread: GraphicsBackendLoader = async (init
       }
     },
     async startWorld(options) {
+      const worldView = options.worldView as unknown as WorldView
+      workerSideChannel.onMessage = (data: any) => {
+        if (data?.type === 'reloadLoadedChunks') {
+          void worldView.reloadLoadedChunks().catch((err) => {
+            console.error('[Renderer] Failed to reload chunks after mesher reconfigure:', err)
+          })
+        }
+      }
+
       const workerThreeSendData = {
         ...dynamicMcDataFiles,
         items: 'itemsArray',

package/src/three/itemMesh.ts

@@ -257,7 +257,7 @@ export interface ItemMeshResult {
  * Extracts item texture region to a canvas
  */
 export function extractItemTextureToCanvas (
-  sourceTexture: THREE.Texture,
+  sourceTexture: THREE.Texture<HTMLImageElement | ImageBitmap>,
   textureInfo: ItemTextureInfo
 ): ItemTextureCanvas {
   const { u, v, sizeX, sizeY } = textureInfo
@@ -333,7 +333,10 @@ export function createItemMesh (
   if (use3D) {
     // Try to create 3D mesh
     try {
-      const canvas = extractItemTextureToCanvas(sourceTexture, textureInfo)
+      const canvas = extractItemTextureToCanvas(
+        sourceTexture as THREE.Texture<HTMLImageElement | ImageBitmap>,
+        textureInfo
+      )
       const { geometry } = create3DItemMesh(canvas, { depth })
 
       // Create texture from canvas for the 3D mesh

package/src/three/legacySectionCull.ts

@@ -0,0 +1,85 @@
+//@ts-nocheck
+import * as THREE from 'three'
+import type { RenderOrigin } from './shaders/legacyBlockShader'
+
+/** Half-extent of a section mesh AABB in section-local space. */
+export const LEGACY_SECTION_HALF_EXTENT = 8
+
+/** Small pad on camera-relative section AABBs for frustum tests. */
+const CULL_BOX_EPSILON = 0.01
+
+/**
+ * Set a legacy section mesh world translation once at build time.
+ * Position proxy is not used — camera-relative math lives in the shader.
+ */
+export function setupLegacySectionMatrix (
+  mesh: THREE.Mesh,
+  sx: number,
+  sy: number,
+  sz: number,
+  renderOrigin: RenderOrigin,
+): void {
+  mesh.matrix.makeTranslation(sx - renderOrigin.x, sy - renderOrigin.y, sz - renderOrigin.z)
+  mesh.matrixWorldNeedsUpdate = true
+  mesh.frustumCulled = false
+}
+
+export function sectionIntersectsFrustum (
+  sectionWorldX: number,
+  sectionWorldY: number,
+  sectionWorldZ: number,
+  cameraWorldX: number,
+  cameraWorldY: number,
+  cameraWorldZ: number,
+  frustum: THREE.Frustum,
+  box: THREE.Box3,
+  boxMin: THREE.Vector3,
+  boxMax: THREE.Vector3,
+): { visible: boolean, distSq: number } {
+  const dx = sectionWorldX - cameraWorldX
+  const dy = sectionWorldY - cameraWorldY
+  const dz = sectionWorldZ - cameraWorldZ
+
+  const half = LEGACY_SECTION_HALF_EXTENT + CULL_BOX_EPSILON
+  boxMin.set(dx - half, dy - half, dz - half)
+  boxMax.set(dx + half, dy + half, dz + half)
+  box.set(boxMin, boxMax)
+
+  return {
+    visible: frustum.intersectsBox(box),
+    distSq: dx * dx + dy * dy + dz * dz,
+  }
+}
+
+/**
+ * Per-frame frustum cull + back-to-front renderOrder for one legacy section.
+ * Used for pooled per-section meshes (reveal defer + invariant fallback).
+ */
+export function updateLegacySectionCullState (
+  mesh: THREE.Mesh,
+  sectionWorldX: number,
+  sectionWorldY: number,
+  sectionWorldZ: number,
+  cameraWorldX: number,
+  cameraWorldY: number,
+  cameraWorldZ: number,
+  frustum: THREE.Frustum,
+  box: THREE.Box3,
+  boxMin: THREE.Vector3,
+  boxMax: THREE.Vector3,
+): void {
+  const { visible, distSq } = sectionIntersectsFrustum(
+    sectionWorldX,
+    sectionWorldY,
+    sectionWorldZ,
+    cameraWorldX,
+    cameraWorldY,
+    cameraWorldZ,
+    frustum,
+    box,
+    boxMin,
+    boxMax,
+  )
+  mesh.visible = visible
+  mesh.renderOrder = -distSq
+}