minecraft-renderer 0.1.105 → 0.1.106

package/package.json

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

package/src/mesher-legacy/test/tests.test.ts

@@ -20,61 +20,41 @@ const addPositions = [
   // [[0, 0, -1], 'stone'],
 ] as const
 
-test('Known blocks are not rendered', () => {
-  const { mesherWorld, getGeometry, pos, mcData } = setup(lastVersion, addPositions as any)
+/** Meshes the default state of every block of the version and returns the blocks that gave no geometry / errored */
+function meshAllBlocks(version: string) {
+  const { mesherWorld, getGeometry, pos, mcData } = setup(version, addPositions as any)
   const ignoreAsExpected = new Set([...INVISIBLE_BLOCKS, 'water', 'lava'])
 
-  let time = 0
-  let times = 0
-  const missingBlocks = {} /*  as {[number, number]} */
-  const erroredBlocks = {} /*  as {[number, number]} */
+  const missingBlocks: string[] = []
+  const erroredBlocks: string[] = []
   for (const block of mcData.blocksArray) {
     if (ignoreAsExpected.has(block.name)) continue
-    // if (block.maxStateId! - block.minStateId! > 100) continue
-    // for (let i = block.minStateId!; i <= block.maxStateId!; i++) {
-    for (let i = block.defaultState; i <= block.defaultState; i++) {
-      // if (block.transparent) continue
-      mesherWorld.setBlockStateId(pos, i)
-      const start = performance.now()
-      const { centerFaces, totalTiles, centerTileNeighbors, attr } = getGeometry()
-      time += performance.now() - start
-      times++
-      if (centerFaces === 0) {
-        const objAdd = attr.hadErrors ? erroredBlocks : missingBlocks
-        if (objAdd[block.name]) continue
-        objAdd[block.name] = true
-        // invalidBlocks[block.name] = [i - block.defaultState!, centerTileNeighbors]
-        // console.log('INVALID', block.name, centerTileNeighbors, i - block.minStateId)
-      }
-    }
+    mesherWorld.setBlockStateId(pos, block.defaultState)
+    const { centerFaces, attr } = getGeometry()
+    if (centerFaces === 0) (attr.hadErrors ? erroredBlocks : missingBlocks).push(block.name)
   }
-  console.log('Checking blocks of version', lastVersion)
-  console.log('Average time', time / times)
-  // should be fixed, but to avoid regressions & for visibility
-  // TODO resolve creaking_heart issue (1.21.3)
-  // TODO 26.x: copper chests / copper golem statues (block entity models) and golden_dandelion have no block model yet
-  expect(missingBlocks).toMatchInlineSnapshot(`
-    {
-      "copper_chest": true,
-      "copper_golem_statue": true,
-      "exposed_copper_chest": true,
-      "exposed_copper_golem_statue": true,
-      "golden_dandelion": true,
-      "oxidized_copper_chest": true,
-      "oxidized_copper_golem_statue": true,
-      "potted_golden_dandelion": true,
-      "structure_void": true,
-      "waxed_copper_chest": true,
-      "waxed_copper_golem_statue": true,
-      "waxed_exposed_copper_chest": true,
-      "waxed_exposed_copper_golem_statue": true,
-      "waxed_oxidized_copper_chest": true,
-      "waxed_oxidized_copper_golem_statue": true,
-      "waxed_weathered_copper_chest": true,
-      "waxed_weathered_copper_golem_statue": true,
-      "weathered_copper_chest": true,
-      "weathered_copper_golem_statue": true,
-    }
-  `)
-  expect(erroredBlocks).toMatchInlineSnapshot('{}')
+  return { missingBlocks, erroredBlocks }
+}
+
+// These tests only guard against making the renderer worse. Blocks that a new minecraft-data / mc-assets version adds
+// without a model must not fail them (versions are updated automatically), so the newest version is only checked for errors.
+
+// TODO resolve creaking_heart issue (1.21.3)
+const KNOWN_MISSING_BLOCKS = ['structure_void']
+// pinned: the data of a released version doesn't grow new blocks, so what renders here must keep rendering
+const pinnedVersion = '1.21.8'
+
+test(`Blocks of ${pinnedVersion} that rendered keep rendering`, () => {
+  const { missingBlocks, erroredBlocks } = meshAllBlocks(pinnedVersion)
+  // fixing a block (it renders now) is fine, only blocks that stopped rendering fail
+  expect(missingBlocks.filter(name => !KNOWN_MISSING_BLOCKS.includes(name))).toEqual([])
+  expect(erroredBlocks).toEqual([])
+})
+
+test('Newest version: no block fails to mesh', () => {
+  const { missingBlocks, erroredBlocks } = meshAllBlocks(lastVersion)
+  console.log('Checked blocks of version', lastVersion)
+  // visibility only, e.g. new block entities that need a custom model in mc-assets
+  if (missingBlocks.length > 0) console.warn(`Blocks of ${lastVersion} that render nothing:`, missingBlocks.join(', '))
+  expect(erroredBlocks).toEqual([])
 })

package/src/mesher-shared/modelsGeometryCommon.test.ts

@@ -0,0 +1,50 @@
+//@ts-nocheck
+import { describe, expect, it } from 'vitest'
+import { buildElementRotation, buildRotationMatrix, buildXyzRotationMatrix, matmul3 } from './modelsGeometryCommon'
+
+const origin: [number, number, number] = [8, 8, 8]
+const close = (a: number[], b: number[]) => a.forEach((v, i) => expect(v).toBeCloseTo(b[i], 9))
+
+describe('buildElementRotation', () => {
+  it('keeps the axis/angle form working', () => {
+    const { localMatrix } = buildElementRotation({ origin, axis: 'y', angle: 90 })
+    close(matmul3(localMatrix, [1, 0, 0]), [0, 0, -1])
+    close(matmul3(localMatrix, [0, 0, 1]), [1, 0, 0])
+  })
+
+  it.each(['x', 'y', 'z'] as const)('x/y/z form about a single axis (%s) equals the axis/angle form', axis => {
+    const viaAxis = buildElementRotation({ origin: [2, 5, 11], axis, angle: 37 })
+    const viaXyz = buildElementRotation({ origin: [2, 5, 11], [axis]: 37 })
+    viaAxis.localMatrix.forEach((row, i) => close(viaXyz.localMatrix[i], row))
+    close(viaXyz.localShift, viaAxis.localShift)
+  })
+
+  it('applies a combined x/y/z rotation as rotationZYX: z first, then y, then x', () => {
+    const rotation = { x: -40.06672, y: 3.06532, z: -2.57258 }
+    const vector = [0.3, -1.2, 0.8]
+    const stepwise = matmul3(
+      buildRotationMatrix('x', rotation.x),
+      matmul3(buildRotationMatrix('y', rotation.y), matmul3(buildRotationMatrix('z', rotation.z), vector))
+    )
+    close(matmul3(buildXyzRotationMatrix(rotation), vector), stepwise)
+    // order matters (guards against x, y, z being swapped)
+    const reversed = matmul3(
+      buildRotationMatrix('z', rotation.z),
+      matmul3(buildRotationMatrix('y', rotation.y), matmul3(buildRotationMatrix('x', rotation.x), vector))
+    )
+    expect(Math.abs(reversed[0] - stepwise[0]) + Math.abs(reversed[1] - stepwise[1])).toBeGreaterThan(1e-3)
+  })
+
+  it('rotates around the element origin (the origin stays in place)', () => {
+    const rotationOrigin: [number, number, number] = [2.53162, 8.56801, 5.10154]
+    const { localMatrix, localShift } = buildElementRotation({ origin: rotationOrigin, x: -40, y: 3, z: -2.5 })
+    const moved = matmul3(localMatrix, rotationOrigin).map((v, i) => v + localShift[i])
+    close(moved, rotationOrigin)
+  })
+
+  it('treats a rotation without any angle as no rotation', () => {
+    const { localMatrix, localShift } = buildElementRotation({ origin })
+    localMatrix.forEach((row, i) => close(row, [0, 1, 2].map(j => (i === j ? 1 : 0))))
+    close(localShift, [0, 0, 0])
+  })
+})

package/src/mesher-shared/modelsGeometryCommon.ts

@@ -88,11 +88,27 @@ export function matmulmat3(a, b) {
   return te
 }
 
+/** Plain row-major product a * b (not the transposed convention of matmulmat3) */
+function mulMat3(a: number[][], b: number[][]) {
+  return a.map((row, i) => row.map((_, j) => row[0] * b[0][j] + row[1] * b[1][j] + row[2] * b[2][j]))
+}
+
+/**
+ * 26.x element rotation: degrees about each axis, `{ origin, x, y, z }` instead of `{ origin, axis, angle }`.
+ * Applied like vanilla's `rotationZYX(z, y, x)`: a vector is rotated about z first, then y, then x.
+ */
+export function buildXyzRotationMatrix({ x = 0, y = 0, z = 0 }: { x?: number; y?: number; z?: number }) {
+  return mulMat3(buildRotationMatrix('x', x), mulMat3(buildRotationMatrix('y', y), buildRotationMatrix('z', z)))
+}
+
 export function buildElementRotation(rotation) {
-  let localMatrix = buildRotationMatrix(rotation.axis, rotation.angle)
+  // elements without an axis use the 26.x x/y/z form (a missing x/y/z is 0, so no rotation at all is the identity)
+  const isAxisAngle = rotation.axis !== undefined
+  let localMatrix = isAxisAngle ? buildRotationMatrix(rotation.axis, rotation.angle) : buildXyzRotationMatrix(rotation)
   let localShift = vecsub3(rotation.origin, matmul3(localMatrix, rotation.origin))
 
-  if (rotation.rescale) {
+  // rescale is only defined for a single axis rotation
+  if (rotation.rescale && isAxisAngle) {
     const FIT_TO_BLOCK_SCALE_MULTIPLIER = 2 - Math.sqrt(2)
     const angleRad = (rotation.angle * Math.PI) / 180
     const scale = Math.abs(Math.sin(angleRad)) * FIT_TO_BLOCK_SCALE_MULTIPLIER

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

@@ -19,6 +19,7 @@ import { GlobalBlockBuffer } from '../../three/globalBlockBuffer'
 import { buildVisibleCubeSpans } from '../../three/cubeDrawSpans'
 import { createCubeBlockMaterial, computeSectionOriginRel, setCubeShadingTheme } from '../../three/shaders/cubeBlockShader'
 import * as THREE from 'three'
+import blocksAtlasesJson from 'mc-assets/dist/blocksAtlases.json'
 import { renderWasmOutputToGeometry } from '../bridge/render-from-wasm'
 
 const VERSION = '1.16.5'
@@ -29,8 +30,8 @@ function requireShaderCubeResources() {
   if (!resources) throw new Error('shader cube resources unavailable in test')
   return resources
 }
-/** mc-assets blocksAtlases.json → stone */
-const STONE_ATLAS_TILE_INDEX = 552
+/** mc-assets blocksAtlases.json → stone (looked up, tile positions change whenever the atlas gets new textures) */
+const STONE_ATLAS_TILE_INDEX = blocksAtlasesJson.latest.textures.stone.tileIndex
 
 beforeEach(() => {
   resetShaderCubeResources()