minecraft-renderer 0.1.76 → 0.1.78

package/package.json

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

package/src/lib/createPlayerObject.test.ts

@@ -0,0 +1,46 @@
+//@ts-nocheck
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock('./utils/skins', () => ({
+  stevePngUrl: '',
+  loadSkinImage: vi.fn(),
+}))
+
+import { PlayerObject } from 'skinview3d'
+import { configurePlayerSkinMaterials } from './createPlayerObject'
+
+describe('configurePlayerSkinMaterials', () => {
+  it('configures cutout materials and log-depth bias on arm/leg mats only', () => {
+    const playerObject = new PlayerObject()
+    const skin = playerObject.skin as any
+
+    configurePlayerSkinMaterials(playerObject)
+
+    const allMaterials = [
+      skin.layer1Material,
+      skin.layer1MaterialBiased,
+      skin.layer2Material,
+      skin.layer2MaterialBiased,
+    ]
+    for (const mat of allMaterials) {
+      expect(mat.transparent).toBe(false)
+      expect(mat.alphaTest).toBe(0.1)
+      expect(mat.depthWrite).toBe(true)
+    }
+
+    expect(skin.layer1MaterialBiased.userData.logDepthBiasApplied).toBe(true)
+    expect(skin.layer2MaterialBiased.userData.logDepthBiasApplied).toBe(true)
+    expect(typeof skin.layer1MaterialBiased.onBeforeCompile).toBe('function')
+    expect(typeof skin.layer2MaterialBiased.onBeforeCompile).toBe('function')
+    expect(skin.layer1MaterialBiased.onBeforeCompile).toBe(skin.layer2MaterialBiased.onBeforeCompile)
+
+    expect(skin.layer1Material.userData.logDepthBiasApplied).toBeUndefined()
+    expect(skin.layer2Material.userData.logDepthBiasApplied).toBeUndefined()
+    expect(skin.layer1Material.onBeforeCompile).not.toBe(skin.layer1MaterialBiased.onBeforeCompile)
+    expect(skin.layer2Material.onBeforeCompile).not.toBe(skin.layer2MaterialBiased.onBeforeCompile)
+
+    const firstCompile = skin.layer1MaterialBiased.onBeforeCompile
+    configurePlayerSkinMaterials(playerObject)
+    expect(skin.layer1MaterialBiased.onBeforeCompile).toBe(firstCompile)
+  })
+})

package/src/lib/createPlayerObject.ts

@@ -10,7 +10,30 @@ export type PlayerObjectType = PlayerObject & {
   realUsername: string
 }
 
-/** Starfield + log-depth world: cutout skin mats need alphaTest and depthWrite (not mesh traverse). */
+const LOG_DEPTH_BIAS = -2e-4 // tune visually; negative ≈ polygonOffset “closer”
+
+function patchLogDepthBiasShader (shader: THREE.WebGLProgramParametersWithUniforms): void {
+  shader.uniforms.uLogDepthBias = { value: LOG_DEPTH_BIAS }
+  shader.fragmentShader = shader.fragmentShader.replace(
+    '#include <logdepthbuf_pars_fragment>',
+    `#include <logdepthbuf_pars_fragment>\nuniform float uLogDepthBias;`
+  )
+  shader.fragmentShader = shader.fragmentShader.replace(
+    '#include <logdepthbuf_fragment>',
+    `#if defined( USE_LOGARITHMIC_DEPTH_BUFFER )
+      gl_FragDepth = log2( vFragDepth ) * logDepthBufFC * 0.5 + uLogDepthBias;
+    #endif`
+  )
+}
+
+function applyLogDepthBias (material: THREE.Material): void {
+  if (material.userData.logDepthBiasApplied) return
+  material.userData.logDepthBiasApplied = true
+  material.onBeforeCompile = patchLogDepthBiasShader
+  material.needsUpdate = true
+}
+
+/** Log-depth world: opaque cutout mats (alphaTest + depthWrite, not transparent sort). */
 export function configurePlayerSkinMaterials (playerObject: PlayerObject): void {
   const skin = playerObject.skin as any
   const materials = [
@@ -20,10 +43,12 @@ export function configurePlayerSkinMaterials (playerObject: PlayerObject): void
     skin.layer2MaterialBiased,
   ]
   for (const mat of materials) {
-    mat.transparent = true
+    mat.transparent = false
     mat.alphaTest = 0.1
     mat.depthWrite = true
   }
+  applyLogDepthBias(skin.layer1MaterialBiased)
+  applyLogDepthBias(skin.layer2MaterialBiased)
 }
 
 export function createPlayerObject (options: {

package/src/three/chunkMeshManager.ts

@@ -4,7 +4,7 @@ import * as nbt from 'prismarine-nbt'
 import { Vec3 } from 'vec3'
 import { MesherGeometryOutput } from '../mesher-shared/shared'
 import { getShaderCubeResources, SHADER_CUBES_WORDS_PER_FACE } from '../wasm-mesher/bridge/shaderCubeBridge'
-import { createCubeBlockMaterial, computeSectionOriginRel, setCubeSkyLevel, setCubeLightmapParams, type BlockLightmapParams } from './shaders/cubeBlockShader'
+import { createCubeBlockMaterial, computeSectionOriginRel, setCubeSkyLevel, setCubeShadingTheme, setCubeLightmapParams, type BlockLightmapParams } from './shaders/cubeBlockShader'
 import { computeCameraRelativeUniforms, createGlobalLegacyBlendMaterial, createGlobalLegacyBlockMaterial, createLegacyBlockMaterial, setLegacyCameraOrigin, setLegacySkyLevel, setLegacyLightmapParams, type RenderOrigin } from './shaders/legacyBlockShader'
 import { LEGACY_SECTION_HALF_EXTENT, sectionIntersectsFrustum, setupLegacySectionMatrix, updateLegacySectionCullState } from './legacySectionCull'
 import { createShaderCubeMesh, disposeShaderCubeMesh } from './shaderCubeMesh'
@@ -266,6 +266,11 @@ export class ChunkMeshManager {
     this.blockEntityLightRegistry.setSkyLevel(value)
   }
 
+  setShadingTheme (theme: 'vanilla' | 'high-contrast', cardinalLight: string): void {
+    const cube = this.cubeShaderMaterial ?? (this.isShaderCubesGpuEnabled() ? this.getCubeShaderMaterial() : null)
+    if (cube) setCubeShadingTheme(cube, theme, cardinalLight)
+  }
+
   /** Vanilla-like lightmap curve params (live tuning via window.setBlockLightmap). */
   setBlockLightmapParams (params: BlockLightmapParams): void {
     const cube = this.cubeShaderMaterial ?? (this.isShaderCubesGpuEnabled() ? this.getCubeShaderMaterial() : null)
@@ -531,6 +536,8 @@ export class ChunkMeshManager {
     if (!this.cubeShaderMaterial) {
       this.cubeShaderMaterial = createCubeBlockMaterial()
       this.syncCubeShaderUniforms()
+      const cfg = this.worldRenderer.worldRendererConfig
+      setCubeShadingTheme(this.cubeShaderMaterial, cfg.shadingTheme, cfg.cardinalLight)
     }
     return this.cubeShaderMaterial
   }

package/src/three/shaders/cubeBlockShader.ts

@@ -199,6 +199,8 @@ uniform float u_skyLevel;
 uniform float u_lightCurve;
 uniform float u_minBrightness;
 uniform float u_lightGamma;
+uniform float u_shadingTheme;  // 0 = vanilla, 1 = high-contrast
+uniform float u_cardinalLight; // 0 = default, 1 = nether
 
 in float v_blockLight;
 in float v_skyLight;
@@ -248,6 +250,24 @@ void applyFog() {
 
 ${APPLY_LIGHTMAP_GLSL}
 
+const vec3 FACE_NORMAL[6] = vec3[6](
+    vec3(0.0, 1.0, 0.0),  // UP
+    vec3(0.0,-1.0, 0.0),  // DOWN
+    vec3(1.0, 0.0, 0.0),  // EAST
+    vec3(-1.0,0.0, 0.0),  // WEST
+    vec3(0.0, 0.0, 1.0),  // SOUTH
+    vec3(0.0, 0.0,-1.0)   // NORTH
+);
+
+float sideShadingFromFaceId(int faceId, float theme, float cardinal) {
+    vec3 n = FACE_NORMAL[faceId];
+    float hc      = 0.8 + 0.5 * max(0.0, 0.66*n.x + 0.66*n.y + 0.33*n.z);
+    float nether  = 0.5 + abs(0.1*n.x + 0.4*n.y + 0.3*n.z);
+    float vanilla = 0.75 + 0.25*n.y + 0.05*(abs(n.z) - 3.0*abs(n.x));
+    float nonHc   = mix(vanilla, nether, cardinal);
+    return mix(nonHc, hc, theme);
+}
+
 void main() {
     // Atlas sample (pixelated, no filtering)
     ivec2 atlasSize = textureSize(u_atlas, 0);
@@ -294,7 +314,9 @@ void main() {
 
     float L = max(v_blockLight, min(v_skyLight, u_skyLevel));
     float Lm = applyLightmap(L);
-    float brightness = Lm * v_ao;
+    float aoFactor = mix(0.8 * v_ao + 0.2, v_ao, u_shadingTheme);
+    float side     = sideShadingFromFaceId(v_faceId, u_shadingTheme, u_cardinalLight);
+    float brightness = Lm * aoFactor * side;
 
     // Opaque full cubes: always alpha 1 (legacy uses cutout material; avoids seeing blocks behind)
     FragColor = vec4(baseColor.rgb * tint * brightness, 1.0);
@@ -317,6 +339,8 @@ export function createCubeBlockMaterial(): THREE.ShaderMaterial {
                 u_tintPalette: { value: null },
                 u_debugMode: { value: 0 },
                 u_skyLevel: { value: 1.0 },
+                u_shadingTheme: { value: 1.0 },
+                u_cardinalLight: { value: 0.0 },
                 u_lightCurve: { value: DEFAULT_LIGHTMAP_PARAMS.curve },
                 u_minBrightness: { value: DEFAULT_LIGHTMAP_PARAMS.minBrightness },
                 u_lightGamma: { value: DEFAULT_LIGHTMAP_PARAMS.gamma },
@@ -344,6 +368,17 @@ export function setCubeSkyLevel (material: THREE.ShaderMaterial, value: number):
     if (u) u.value = value
 }
 
+export function setCubeShadingTheme (
+  material: THREE.ShaderMaterial,
+  theme: 'vanilla' | 'high-contrast',
+  cardinalLight: string,
+): void {
+  const t = material.uniforms.u_shadingTheme
+  if (t) t.value = theme === 'high-contrast' ? 1.0 : 0.0
+  const c = material.uniforms.u_cardinalLight
+  if (c) c.value = cardinalLight === 'nether' ? 1.0 : 0.0
+}
+
 export function setCubeLightmapParams (
     material: THREE.ShaderMaterial,
     params: BlockLightmapParams,

package/src/three/worldRendererThree.ts

@@ -549,6 +549,12 @@ export class WorldRendererThree extends WorldRendererCommon {
       this.chunkMeshManager.syncCubeShaderUniforms()
       this.chunkMeshManager.syncLegacyShaderUniforms()
     })
+    const pushShading = () => {
+      const cfg = this.worldRendererConfig
+      this.chunkMeshManager.setShadingTheme(cfg.shadingTheme, cfg.cardinalLight)
+    }
+    this.onReactiveConfigUpdated('shadingTheme', pushShading)
+    this.onReactiveConfigUpdated('cardinalLight', pushShading)
     this.onReactiveConfigUpdated('futuristicReveal', () => {
       this.updateModulesFromConfig()
     })

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

@@ -17,7 +17,7 @@ import {
 } from '../bridge/shaderCubeBridge'
 import { GlobalBlockBuffer } from '../../three/globalBlockBuffer'
 import { buildVisibleCubeSpans } from '../../three/cubeDrawSpans'
-import { createCubeBlockMaterial, computeSectionOriginRel } from '../../three/shaders/cubeBlockShader'
+import { createCubeBlockMaterial, computeSectionOriginRel, setCubeShadingTheme } from '../../three/shaders/cubeBlockShader'
 import * as THREE from 'three'
 import { renderWasmOutputToGeometry } from '../bridge/render-from-wasm'
 
@@ -36,6 +36,17 @@ beforeEach(() => {
   resetShaderCubeResources()
 })
 
+test('setCubeShadingTheme: maps theme and cardinalLight to shader uniforms', () => {
+  const mat = createCubeBlockMaterial()
+  setCubeShadingTheme(mat, 'vanilla', 'default')
+  expect(mat.uniforms.u_shadingTheme.value).toBe(0)
+  expect(mat.uniforms.u_cardinalLight.value).toBe(0)
+  setCubeShadingTheme(mat, 'high-contrast', 'nether')
+  expect(mat.uniforms.u_shadingTheme.value).toBe(1)
+  expect(mat.uniforms.u_cardinalLight.value).toBe(1)
+  mat.dispose()
+})
+
 test('packWord2: AO diagonal flip sets bit 12', () => {
   const words: number[] = []
   const block = {