minecraft-renderer 0.1.98 → 0.1.100

package/package.json

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

package/src/three/entities.ts

@@ -240,12 +240,18 @@ function getUsernameTexture(
   const iconSize = fontSize * 0.85
   const iconAreaWidth = voiceState ? iconSize + padding * 2.5 : 0
 
-  const canvas = createCanvas(iconAreaWidth + textWidth, height)
+  // The nametag sprite is anchored (and thus centered above the player) at the
+  // midpoint of this canvas. Mirroring the icon's width as a second, unpainted
+  // margin on the right moves that midpoint to align with the *text's* own
+  // center instead of the icon+text bounding box's center — otherwise the
+  // icon's extra width on the left alone drags the whole sprite's anchor left,
+  // which visually reads as the text drifting right of the player.
+  const canvas = createCanvas(iconAreaWidth * 2 + textWidth, height)
   const ctx = canvas.getContext('2d')
   if (!ctx) throw new Error('Could not get 2d context')
 
   ctx.fillStyle = nameTagBackgroundColor
-  ctx.fillRect(0, 0, canvas.width, canvas.height)
+  ctx.fillRect(0, 0, iconAreaWidth + textWidth, canvas.height)
   if (voiceState) {
     drawVoiceStateIcon(ctx, voiceState, iconAreaWidth / 2, canvas.height / 2, iconSize)
   }

package/src/wasm-mesher/bridge/geometryIndices.ts

@@ -0,0 +1,17 @@
+//@ts-nocheck
+export function createGeometryIndexArray(indices: readonly number[]): Uint16Array | Uint32Array {
+  let using32Array = false
+  for (let index = 0; index < indices.length; index++) {
+    if (indices[index] > 65535) {
+      using32Array = true
+      break
+    }
+  }
+  return using32Array ? new Uint32Array(indices) : new Uint16Array(indices)
+}
+
+export function appendGeometryIndices(target: number[], source: readonly number[], vertexOffset: number): void {
+  for (let index = 0; index < source.length; index++) {
+    target.push(source[index] + vertexOffset)
+  }
+}

package/src/wasm-mesher/bridge/render-from-wasm.ts

@@ -19,6 +19,7 @@ import { resolveBlockPropertiesForMeshing } from '../../mesher-shared/blockPrope
 import { isSemiTransparentBlockName } from '../../mesher-shared/models'
 import { faceIsCulled } from '../../mesher-shared/faceOcclusion'
 import { buildShaderCubesFromWords, getShaderCubeResources, tryBuildShaderCubeInstances } from './shaderCubeBridge'
+import { appendGeometryIndices } from './geometryIndices'
 import { getSideShading, vertexLightFromAo } from '../../mesher-shared/vertexShading'
 import tintsJson from 'minecraft-data/minecraft-data/data/pc/1.16.2/tints.json'
 
@@ -986,10 +987,8 @@ export function renderWasmOutputToGeometry(
     blendSkyLights = liquidSkyLights.concat(blockBlendSkyLights)
     blendBlockLights = liquidBlockLights.concat(blockBlendBlockLights)
     blendUvs = liquidUvs.concat(blockBlendUvs)
-    blendIndices.push(...liquidIndices)
-    for (const idx of blockBlendIndices) {
-      blendIndices.push(idx + liquidVertexCount)
-    }
+    appendGeometryIndices(blendIndices, liquidIndices, 0)
+    appendGeometryIndices(blendIndices, blockBlendIndices, liquidVertexCount)
   }
 
   const shaderCubes = buildShaderCubesFromWords(shaderWordBuffer)

package/src/wasm-mesher/tests/geometryIndices.test.ts

@@ -0,0 +1,71 @@
+//@ts-nocheck
+import { expect, test } from 'vitest'
+import { appendGeometryIndices, createGeometryIndexArray } from '../bridge/geometryIndices'
+
+function expectSameValues(actual: ArrayLike<number>, expected: ArrayLike<number>): void {
+  expect(actual.length).toBe(expected.length)
+  let firstMismatch = -1
+  for (let index = 0; index < expected.length; index++) {
+    if (actual[index] !== expected[index]) {
+      firstMismatch = index
+      break
+    }
+  }
+  expect(firstMismatch, 'First differing index; -1 means all values match').toBe(-1)
+}
+
+test('creates lossless index buffers without depending on argument count', () => {
+  const cases: Array<{ input: number[]; using32Array: boolean }> = [
+    { input: [], using32Array: false },
+    { input: [0, 65535, 7], using32Array: false },
+    { input: [0, 65536, 7], using32Array: true }
+  ]
+
+  for (const { input, using32Array } of cases) {
+    const inputBefore = input.slice()
+    const result = createGeometryIndexArray(input)
+    expect(result).toBeInstanceOf(using32Array ? Uint32Array : Uint16Array)
+    expect(Array.from(result)).toEqual(inputBefore)
+    expect(input).toEqual(inputBefore)
+  }
+
+  const source = new Array<number>(1_000_000).fill(65535)
+  source[0] = 0
+  source[500_000] = 123
+  const sourceBeforeSmall = source.slice()
+  const smallValues = createGeometryIndexArray(source)
+  expect(smallValues).toBeInstanceOf(Uint16Array)
+  expectSameValues(smallValues, sourceBeforeSmall)
+  expectSameValues(source, sourceBeforeSmall)
+
+  source[source.length - 1] = 65536
+  const sourceBeforeLarge = source.slice()
+  const largeValue = createGeometryIndexArray(source)
+  expect(largeValue).toBeInstanceOf(Uint32Array)
+  expectSameValues(largeValue, sourceBeforeLarge)
+  expectSameValues(source, sourceBeforeLarge)
+})
+
+test('appends large liquid indices before rebased block indices', () => {
+  const liquidIndices = new Array<number>(1_000_000).fill(0)
+  liquidIndices[0] = 2
+  liquidIndices[liquidIndices.length - 1] = 1
+  const blockBlendIndices = [0, 2, 1]
+  const liquidVertexCount = 3
+  const blendIndices: number[] = []
+  const liquidIndicesBefore = liquidIndices.slice()
+  const blockBlendIndicesBefore = blockBlendIndices.slice()
+
+  appendGeometryIndices(blendIndices, liquidIndices, 0)
+  appendGeometryIndices(blendIndices, blockBlendIndices, liquidVertexCount)
+
+  expect(blendIndices.length).toBe(liquidIndicesBefore.length + blockBlendIndicesBefore.length)
+  expectSameValues(blendIndices.slice(0, liquidIndicesBefore.length), liquidIndicesBefore)
+  expect(blendIndices.slice(liquidIndicesBefore.length)).toEqual([3, 5, 4])
+  expect(blockBlendIndices).toEqual(blockBlendIndicesBefore)
+  expectSameValues(liquidIndices, liquidIndicesBefore)
+
+  const snapshot = blendIndices.slice()
+  appendGeometryIndices(blendIndices, [], liquidVertexCount)
+  expectSameValues(blendIndices, snapshot)
+})

package/src/wasm-mesher/worker/mesherWasm.ts

@@ -2,6 +2,7 @@
 import { Vec3 } from 'vec3'
 import { convertChunkToWasm, getBlockMeta, type ChunkConversionResult } from '../bridge/convertChunk'
 import { extractColumnHeightmap, splitColumnWasmOutputToSections } from '../bridge/render-from-wasm'
+import { createGeometryIndexArray } from '../bridge/geometryIndices'
 import { setBlockStatesData as setMesherData } from '../../mesher-shared/models'
 import { defaultMesherConfig, type MesherGeometryOutput, SECTION_HEIGHT } from '../../mesher-shared/shared'
 import { SHADER_CUBES_FORMAT_VERSION } from '../../mesher-shared/shaderCubeFormat'
@@ -1493,8 +1494,8 @@ function processColumnTick() {
         const hasLegacyMesh = hasOpaqueMesh || hasBlendMesh
         const hasShaderCubes = (exported?.shaderCubes?.count ?? 0) > 0
         if (exported && (hasLegacyMesh || hasShaderCubes)) {
-          const maxIndex = exported.geometry.indices.length > 0 ? Math.max(...exported.geometry.indices) : 0
-          const using32Array = maxIndex > 65535
+          const indices = createGeometryIndexArray(exported.geometry.indices)
+          const using32Array = indices instanceof Uint32Array
           geometry = {
             sectionYNumber: (sy - (config?.worldMinY || 0)) >> 4,
             chunkKey: worldColumnKey(sx, sz),
@@ -1513,7 +1514,7 @@ function processColumnTick() {
             skyLights: new Float32Array(exported.geometry.skyLights),
             blockLights: new Float32Array(exported.geometry.blockLights),
             uvs: new Float32Array(exported.geometry.uvs),
-            indices: using32Array ? new Uint32Array(exported.geometry.indices) : new Uint16Array(exported.geometry.indices),
+            indices,
             indicesCount: exported.geometry.indices.length,
             using32Array,
             tiles: {},
@@ -1537,7 +1538,6 @@ function processColumnTick() {
             }
           }
           if (exported.blendGeometry && hasBlendMesh) {
-            const blendMax = Math.max(...exported.blendGeometry.indices)
             geometry.blend = {
               positions: new Float32Array(exported.blendGeometry.positions),
               normals: new Float32Array(exported.blendGeometry.normals),
@@ -1545,7 +1545,7 @@ function processColumnTick() {
               skyLights: new Float32Array(exported.blendGeometry.skyLights),
               blockLights: new Float32Array(exported.blendGeometry.blockLights),
               uvs: new Float32Array(exported.blendGeometry.uvs),
-              indices: blendMax > 65535 ? new Uint32Array(exported.blendGeometry.indices) : new Uint16Array(exported.blendGeometry.indices)
+              indices: createGeometryIndexArray(exported.blendGeometry.indices)
             }
           }
           transferable = [