minecraft-renderer 0.1.74 → 0.1.75

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.74",
+  "version": "0.1.75",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",

package/src/three/chunkMeshManager.ts

@@ -1,5 +1,4 @@
 //@ts-nocheck
-import PrismarineChatLoader from 'prismarine-chat'
 import * as THREE from 'three'
 import * as nbt from 'prismarine-nbt'
 import { Vec3 } from 'vec3'
@@ -20,13 +19,12 @@ import {
   sectionAabbIntersectsRay,
   type ShaderSectionRaycastEntry,
 } from './sectionRaycastAabb'
-import { chunkPos } from '../lib/simpleUtils'
-import { renderSign } from '../sign-renderer'
 import { getMesh } from './entity/EntityMesh'
 import type { WorldRendererThree } from './worldRendererThree'
 import { armorModel } from './entity/armorModels'
 import { disposeObject } from './threeJsUtils'
 import { getBannerTexture, createBannerMesh, releaseBannerTexture } from './bannerRenderer'
+import { getSignTexture, releaseSignTexture, disposeAllSignTextures } from './signTextureCache'
 import { BlockEntityLightRegistry } from '../lib/blockEntityLightRegistry'
 
 export interface ChunkMeshPool {
@@ -1348,8 +1346,12 @@ export class ChunkMeshManager {
         sectionObject.shaderMesh = undefined
       }
       delete sectionObject.deferredShaderCubes
-      // Dispose signs and heads containers
+      // Release shared sign textures (refcount) before disposing meshes
       if (sectionObject.signsContainer) {
+        for (const child of sectionObject.signsContainer.children) {
+          const sign = child as THREE.Group & { signTexture?: THREE.Texture }
+          if (sign.signTexture) releaseSignTexture(sign.signTexture)
+        }
         this.disposeContainer(sectionObject.signsContainer, false)
       }
       if (sectionObject.headsContainer) {
@@ -1473,16 +1475,6 @@ export class ChunkMeshManager {
     }
   }
 
-  /**
-   * Forward to {@link SignHeadsRenderer.cleanChunkTextures} so callers in
-   * `WorldRendererThree` (which historically owned the sign-texture cache)
-   * can invalidate cached sign textures when a section is marked dirty,
-   * without reaching into the manager's private members.
-   */
-  cleanSignChunkTextures (x: number, z: number) {
-    this.signHeadsRenderer.cleanChunkTextures(x, z)
-  }
-
   /**
    * Get mesh for section if it exists
    */
@@ -1923,21 +1915,12 @@ export class ChunkMeshManager {
 }
 
 
-type SignTextureCacheEntry = { tex: THREE.Texture, signature: string }
-
 class SignHeadsRenderer {
-  chunkTextures = new Map<string, { [pos: string]: SignTextureCacheEntry }>()
-
   constructor (public worldRendererThree: WorldRendererThree) {
   }
 
   dispose () {
-    for (const [, textures] of this.chunkTextures) {
-      for (const key of Object.keys(textures)) {
-        textures[key]!.tex.dispose()
-      }
-    }
-    this.chunkTextures.clear()
+    disposeAllSignTextures()
   }
 
   renderHead (position: Vec3, rotation: number, isWall: boolean, blockEntity) {
@@ -1981,18 +1964,10 @@ class SignHeadsRenderer {
   }
 
   renderSign (position: Vec3, rotation: number, isWall: boolean, isHanging: boolean, blockEntity) {
-    const tex = this.getSignTexture(position, blockEntity, isHanging)
+    const tex = getSignTexture(this.worldRendererThree, blockEntity, isHanging)
 
     if (!tex) return
 
-    // todo implement
-    // const key = JSON.stringify({ position, rotation, isWall })
-    // if (this.signsCache.has(key)) {
-    //   console.log('cached', key)
-    // } else {
-    //   this.signsCache.set(key, tex)
-    // }
-
     const mesh = new THREE.Mesh(new THREE.PlaneGeometry(1, 1), new THREE.MeshBasicMaterial({ map: tex, transparent: true }))
     mesh.renderOrder = 999
 
@@ -2008,13 +1983,14 @@ class SignHeadsRenderer {
       mesh.position.set(0, 0, thickness / 2 + 0.0001)
     }
 
-    const group = new THREE.Group()
+    const group = new THREE.Group() as THREE.Group & { signTexture?: THREE.Texture }
     group.rotation.set(
       0,
       -THREE.MathUtils.degToRad(rotation * (isWall ? 90 : 45 / 2)),
       0
     )
     group.add(mesh)
+    group.signTexture = tex
     const height = (isHanging ? 10 : 8) / 16
     const heightOffset = (isHanging ? 0 : isWall ? 4.333 : 9.333) / 16
     const textPosition = height / 2 + heightOffset
@@ -2022,47 +1998,4 @@ class SignHeadsRenderer {
     group.position.set(position.x + 0.5, position.y + textPosition, position.z + 0.5)
     return group
   }
-
-  getSignTexture (position: Vec3, blockEntity, isHanging, backSide = false) {
-    const chunk = chunkPos(position)
-    let textures = this.chunkTextures.get(`${chunk[0]},${chunk[1]}`)
-    if (!textures) {
-      textures = {}
-      this.chunkTextures.set(`${chunk[0]},${chunk[1]}`, textures)
-    }
-    const texturekey = `${position.x},${position.y},${position.z}`
-    const signature = JSON.stringify(blockEntity) + '|' + isHanging + '|' + backSide
-    const cached = textures[texturekey]
-    if (cached && cached.signature === signature) return cached.tex
-
-    if (cached?.tex) cached.tex.dispose()
-
-    const PrismarineChat = PrismarineChatLoader(this.worldRendererThree.version)
-    const canvas = renderSign(blockEntity, isHanging, PrismarineChat)
-    if (!canvas) return
-    const tex = new THREE.Texture(canvas)
-    tex.magFilter = THREE.NearestFilter
-    tex.minFilter = THREE.NearestFilter
-    tex.needsUpdate = true
-    textures[texturekey] = { tex, signature }
-    return tex
-  }
-
-  /**
-   * Dispose all cached sign textures for the chunk containing world coords
-   * (x, z). Called from `WorldRendererThree.cleanChunkTextures` so that
-   * re-meshes triggered by `setSectionDirty` (e.g. a player edits a sign)
-   * pick up fresh block-entity NBT instead of returning the stale cached
-   * texture from {@link SignHeadsRenderer.getSignTexture}.
-   */
-  cleanChunkTextures (x: number, z: number) {
-    const key = `${Math.floor(x / 16)},${Math.floor(z / 16)}`
-    const textures = this.chunkTextures.get(key)
-    if (!textures) return
-    const disposedKeys = Object.keys(textures)
-    for (const k of disposedKeys) {
-      textures[k]!.tex.dispose()
-      delete textures[k]
-    }
-  }
 }

package/src/three/signTextureCache.ts

@@ -0,0 +1,64 @@
+//@ts-nocheck
+import * as THREE from 'three'
+import PrismarineChatLoader from 'prismarine-chat'
+import { renderSign } from '../sign-renderer'
+import type { WorldRendererThree } from './worldRendererThree'
+
+const signTextureCache = new Map<string, { texture: THREE.Texture, refCount: number }>()
+
+// Build the key ONLY from fields that change rendered pixels, so two signs
+// with identical visible text share a texture even if other NBT differs.
+function createSignCacheKey (blockEntity: any, isHanging: boolean, backSide: boolean): string {
+  let lines: string[]
+  let color: string
+  if (blockEntity && 'front_text' in blockEntity) { // 1.20+
+    lines = blockEntity.front_text?.messages ?? []
+    color = blockEntity.front_text?.color || 'black'
+  } else { // legacy
+    lines = [blockEntity?.Text1, blockEntity?.Text2, blockEntity?.Text3, blockEntity?.Text4]
+    color = blockEntity?.Color || 'black'
+  }
+  // \0 separator: cannot appear in JSON text components, so no key collisions
+  return `${isHanging ? 1 : 0}|${backSide ? 1 : 0}|${color}|${lines.join('\0')}`
+}
+
+export function getSignTexture (
+  worldRenderer: WorldRendererThree,
+  blockEntity: any,
+  isHanging: boolean,
+  backSide = false
+): THREE.Texture | undefined {
+  const cacheKey = createSignCacheKey(blockEntity, isHanging, backSide)
+  const cached = signTextureCache.get(cacheKey)
+  if (cached) {
+    cached.refCount++
+    return cached.texture
+  }
+  const PrismarineChat = PrismarineChatLoader(worldRenderer.version)
+  const canvas = renderSign(blockEntity, isHanging, PrismarineChat)
+  if (!canvas) return undefined
+  const tex = new THREE.Texture(canvas)
+  tex.magFilter = THREE.NearestFilter
+  tex.minFilter = THREE.NearestFilter
+  tex.needsUpdate = true
+  signTextureCache.set(cacheKey, { texture: tex, refCount: 1 })
+  return tex
+}
+
+export function releaseSignTexture (texture: THREE.Texture): void {
+  for (const [key, cached] of signTextureCache.entries()) {
+    if (cached.texture === texture) {
+      cached.refCount--
+      if (cached.refCount <= 0) {
+        cached.texture.dispose()
+        signTextureCache.delete(key)
+      }
+      return
+    }
+  }
+}
+
+export function disposeAllSignTextures (): void {
+  for (const [, cached] of signTextureCache) cached.texture.dispose()
+  signTextureCache.clear()
+}

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

@@ -1,11 +1,6 @@
 //@ts-nocheck
 import { test, expect, vi, beforeEach } from 'vitest'
 import * as THREE from 'three'
-import { Vec3 } from 'vec3'
-
-vi.mock('../entity/EntityMesh', () => ({
-  getMesh: vi.fn(),
-}))
 
 const renderSignMock = vi.fn()
 vi.mock('../../sign-renderer', () => ({
@@ -16,25 +11,11 @@ vi.mock('prismarine-chat', () => ({
   default: () => () => ({}),
 }))
 
-import { ChunkMeshManager } from '../chunkMeshManager'
+import { getSignTexture, releaseSignTexture, disposeAllSignTextures } from '../signTextureCache'
 import type { WorldRendererThree } from '../worldRendererThree'
 
-function createManager (): ChunkMeshManager {
-  const scene = new THREE.Scene()
-  const material = new THREE.MeshBasicMaterial()
-  const worldRenderer = {
-    version: '1.20',
-    shaderCubeBlocksEnabled: () => false,
-    getModule: () => undefined,
-    sceneOrigin: {
-      track: () => {},
-      removeAndUntrack: () => {},
-      removeAndUntrackAll: () => {},
-    },
-    blockEntities: {},
-    worldRendererConfig: {},
-  } as unknown as WorldRendererThree
-  return new ChunkMeshManager(worldRenderer, scene, material, 256, 1)
+function createWorldRenderer (): WorldRendererThree {
+  return { version: '1.20' } as WorldRendererThree
 }
 
 function stubCanvas () {
@@ -44,40 +25,80 @@ function stubCanvas () {
 beforeEach(() => {
   renderSignMock.mockReset()
   renderSignMock.mockImplementation(() => stubCanvas())
+  disposeAllSignTextures()
 })
 
-test('getSignTexture: same blockEntity returns cached texture without re-render', () => {
-  const manager = createManager()
-  const signHeadsRenderer = (manager as unknown as { signHeadsRenderer: { getSignTexture: Function } }).signHeadsRenderer
-  const pos = new Vec3(10, 64, 10)
+test('getSignTexture: same content at different positions shares one texture', () => {
+  const wr = createWorldRenderer()
   const blockEntity = { Text1: '{"text":"Hello"}' }
 
-  const tex1 = signHeadsRenderer.getSignTexture(pos, blockEntity, false)
-  const tex2 = signHeadsRenderer.getSignTexture(pos, blockEntity, false)
+  const tex1 = getSignTexture(wr, blockEntity, false)
+  const tex2 = getSignTexture(wr, { ...blockEntity }, false)
 
   expect(tex1).toBeDefined()
   expect(tex2).toBe(tex1)
   expect(renderSignMock).toHaveBeenCalledTimes(1)
+})
+
+test('getSignTexture: different text yields different textures', () => {
+  const wr = createWorldRenderer()
 
-  manager.dispose()
+  const tex1 = getSignTexture(wr, { Text1: '{"text":"Hello"}' }, false)!
+  const tex2 = getSignTexture(wr, { Text1: '{"text":"World"}' }, false)!
+
+  expect(tex2).not.toBe(tex1)
+  expect(renderSignMock).toHaveBeenCalledTimes(2)
 })
 
-test('getSignTexture: changed blockEntity disposes old texture and renders anew', () => {
-  const manager = createManager()
-  const signHeadsRenderer = (manager as unknown as { signHeadsRenderer: { getSignTexture: Function } }).signHeadsRenderer
-  const pos = new Vec3(10, 64, 10)
+test('releaseSignTexture: partial release keeps texture in cache', () => {
+  const wr = createWorldRenderer()
   const blockEntity = { Text1: '{"text":"Hello"}' }
 
-  const tex1 = signHeadsRenderer.getSignTexture(pos, blockEntity, false)!
+  const tex1 = getSignTexture(wr, blockEntity, false)!
+  const tex2 = getSignTexture(wr, blockEntity, false)!
+  expect(tex1).toBe(tex2)
+
   const disposeSpy = vi.spyOn(tex1, 'dispose')
+  releaseSignTexture(tex1)
+
+  expect(disposeSpy).not.toHaveBeenCalled()
+  expect(getSignTexture(wr, blockEntity, false)).toBe(tex1)
+  expect(renderSignMock).toHaveBeenCalledTimes(1)
+})
 
-  const changed = { Text1: '{"text":"World"}' }
-  const tex2 = signHeadsRenderer.getSignTexture(pos, changed, false)
+test('releaseSignTexture: dispose at zero refcount removes cache entry', () => {
+  const wr = createWorldRenderer()
+  const blockEntity = { Text1: '{"text":"Hello"}' }
 
-  expect(tex2).toBeDefined()
-  expect(tex2).not.toBe(tex1)
+  const tex = getSignTexture(wr, blockEntity, false)!
+  const disposeSpy = vi.spyOn(tex, 'dispose')
+
+  releaseSignTexture(tex)
   expect(disposeSpy).toHaveBeenCalledTimes(1)
+
+  const tex2 = getSignTexture(wr, blockEntity, false)!
+  expect(tex2).not.toBe(tex)
   expect(renderSignMock).toHaveBeenCalledTimes(2)
+})
+
+test('getSignTexture: key ignores irrelevant NBT fields', () => {
+  const wr = createWorldRenderer()
+  const base = { Text1: '{"text":"Hello"}', Color: 'black' }
 
-  manager.dispose()
+  const tex1 = getSignTexture(wr, base, false)!
+  const tex2 = getSignTexture(wr, { ...base, GlowingText: 1, is_waxed: 1 }, false)!
+
+  expect(tex2).toBe(tex1)
+  expect(renderSignMock).toHaveBeenCalledTimes(1)
+})
+
+test('getSignTexture: isHanging is part of cache key', () => {
+  const wr = createWorldRenderer()
+  const blockEntity = { Text1: '{"text":"Hello"}' }
+
+  const standing = getSignTexture(wr, blockEntity, false)!
+  const hanging = getSignTexture(wr, blockEntity, true)!
+
+  expect(hanging).not.toBe(standing)
+  expect(renderSignMock).toHaveBeenCalledTimes(2)
 })

package/src/three/worldRendererThree.ts

@@ -2,12 +2,10 @@
 import * as THREE from 'three'
 import { Vec3 } from 'vec3'
 import nbt from 'prismarine-nbt'
-import PrismarineChatLoader from 'prismarine-chat'
 import * as tweenJs from '@tweenjs/tween.js'
 import { Biome } from 'minecraft-data'
-import { renderSign } from '../sign-renderer'
 import { DisplayWorldOptions, GraphicsInitOptions } from '../graphicsBackend/types'
-import { chunkPos, sectionPos } from '../lib/simpleUtils'
+import { sectionPos } from '../lib/simpleUtils'
 import { WorldRendererCommon } from '../lib/worldrendererCommon'
 import { calculateSkyLightSimple } from '../lib/skyLight'
 import { addNewStat, MC_RENDERER_DEBUG_OVERLAY_CLASS } from '../lib/ui/newStats'
@@ -55,8 +53,6 @@ export class WorldRendererThree extends WorldRendererCommon {
   get sectionObjects() {
     return this.chunkMeshManager.sectionObjects
   }
-  chunkTextures = new Map<string, { [pos: string]: THREE.Texture }>()
-  signsCache = new Map<string, any>()
   cameraSectionPos: Vec3 = new Vec3(0, 0, 0)
   holdingBlock: IHoldingBlock
   holdingBlockLeft: IHoldingBlock
@@ -929,28 +925,6 @@ export class WorldRendererThree extends WorldRendererCommon {
   }
 
 
-  getSignTexture(position: Vec3, blockEntity, isHanging, backSide = false) {
-    const chunk = chunkPos(position)
-    let textures = this.chunkTextures.get(`${chunk[0]},${chunk[1]}`)
-    if (!textures) {
-      textures = {}
-      this.chunkTextures.set(`${chunk[0]},${chunk[1]}`, textures)
-    }
-    const texturekey = `${position.x},${position.y},${position.z}`
-    // todo investigate bug and remove this so don't need to clean in section dirty
-    if (textures[texturekey]) return textures[texturekey]
-
-    const PrismarineChat = PrismarineChatLoader(this.version)
-    const canvas = renderSign(blockEntity, isHanging, PrismarineChat)
-    if (!canvas) return
-    const tex = new THREE.Texture(canvas)
-    tex.magFilter = THREE.NearestFilter
-    tex.minFilter = THREE.NearestFilter
-    tex.needsUpdate = true
-    textures[texturekey] = tex
-    return tex
-  }
-
   getCameraPosition(target?: THREE.Vector3): THREE.Vector3 {
     return (target ?? this._tmpCameraPos).set(this.cameraWorldPos.x, this.cameraWorldPos.y, this.cameraWorldPos.z)
   }
@@ -1443,49 +1417,6 @@ export class WorldRendererThree extends WorldRendererCommon {
     }
   }
 
-  renderSign(position: Vec3, rotation: number, isWall: boolean, isHanging: boolean, blockEntity) {
-    const tex = this.getSignTexture(position, blockEntity, isHanging)
-
-    if (!tex) return
-
-    // todo implement
-    // const key = JSON.stringify({ position, rotation, isWall })
-    // if (this.signsCache.has(key)) {
-    //   console.log('cached', key)
-    // } else {
-    //   this.signsCache.set(key, tex)
-    // }
-
-    const mesh = new THREE.Mesh(new THREE.PlaneGeometry(1, 1), new THREE.MeshBasicMaterial({ map: tex, transparent: true }))
-    mesh.renderOrder = 999
-
-    const lineHeight = 7 / 16
-    const scaleFactor = isHanging ? 1.3 : 1
-    mesh.scale.set(1 * scaleFactor, lineHeight * scaleFactor, 1 * scaleFactor)
-
-    const thickness = (isHanging ? 2 : 1.5) / 16
-    const wallSpacing = 0.25 / 16
-    if (isWall && !isHanging) {
-      mesh.position.set(0, 0, -0.5 + thickness + wallSpacing + 0.0001)
-    } else {
-      mesh.position.set(0, 0, thickness / 2 + 0.0001)
-    }
-
-    const group = new THREE.Group()
-    group.rotation.set(
-      0,
-      -THREE.MathUtils.degToRad(rotation * (isWall ? 90 : 45 / 2)),
-      0
-    )
-    group.add(mesh)
-    const height = (isHanging ? 10 : 8) / 16
-    const heightOffset = (isHanging ? 0 : isWall ? 4.333 : 9.333) / 16
-    const textPosition = height / 2 + heightOffset
-    this.sceneOrigin.track(group)
-    group.position.set(position.x + 0.5, position.y + textPosition, position.z + 0.5)
-    return group
-  }
-
   lightUpdate(chunkX: number, chunkZ: number) {
     // set all sections in the chunk dirty
     for (let y = this.worldSizeParams.minY; y < this.worldSizeParams.worldHeight; y += 16) {
@@ -1535,19 +1466,6 @@ export class WorldRendererThree extends WorldRendererCommon {
     }))
   }
 
-  cleanChunkTextures(x, z) {
-    const textures = this.chunkTextures.get(`${Math.floor(x / 16)},${Math.floor(z / 16)}`) ?? {}
-    for (const key of Object.keys(textures)) {
-      textures[key].dispose()
-      delete textures[key]
-    }
-    // Sign / head textures moved to ChunkMeshManager.signHeadsRenderer in PR
-    // #16; without invalidating that cache here, sign edits (and any other
-    // block-entity NBT change picked up via setSectionDirty) would re-render
-    // with the stale cached canvas until a full world reset.
-    this.chunkMeshManager.cleanSignChunkTextures(x, z)
-  }
-
   readdChunks() {
     for (const key of Object.keys(this.sectionObjects)) {
       this.scene.remove(this.sectionObjects[key])
@@ -1569,7 +1487,6 @@ export class WorldRendererThree extends WorldRendererCommon {
   removeColumn(x, z) {
     super.removeColumn(x, z)
 
-    this.cleanChunkTextures(x, z)
     this.clearPendingSectionUpdatesForChunk(x, z)
     const sectionHeight = this.getSectionHeight()
     const worldMinY = this.worldMinYRender