ugly-game 0.5.12 → 0.5.14

package/dist/gpuShadow.d.ts

@@ -107,7 +107,7 @@ export declare class GpuShadowRenderer {
         depth: GPUTextureView;
         w: number;
         h: number;
-    }, tint?: [number, number, number, number], extraShadow?: (sp: GPURenderPassEncoder, lightVP: Float32Array) => void): void;
+    }, tint?: [number, number, number, number], extraShadow?: (sp: GPURenderPassEncoder, lightVP: Float32Array) => void, up?: [number, number, number]): void;
     /** Read back the last frame's GPU cull result (camera-visible, light-visible). Does its OWN copy+submit so it's
      *  safe to call from a live render loop (no per-frame readback cost, no race with the ongoing frames). IR/tests. */
     readCullStats(): Promise<{

package/dist/gpuShadow.js

@@ -51,6 +51,7 @@ struct Cam {
   sunCol: vec4<f32>,   // xyz = sun colour, w = shadow map size (texels)
   tint: vec4<f32>,     // rgb = per-planet tint · w = tint strength (0 = none)
   atlas: vec4<f32>,    // x = useAtlas (1/0)
+  up: vec4<f32>,       // xyz = local gravity up (for hemisphere face-shading readability); w unused
 };
 struct Inst { pos: vec4<f32>, scl: vec4<f32>, rot: vec4<f32>, aux: vec4<f32> };  // pos.w = hue (<0 ⇒ ground) · scl.w = emissive/alpha · rot = quaternion · aux.x = atlas tile (<0 ⇒ hue) · aux.y = up-face code
 @group(0) @binding(0) var<uniform> cam: Cam;
@@ -239,6 +240,18 @@ fn blockShade(fx: f32, fz: f32) -> f32 {
   let t = clamp(edge / 0.17, 0.0, 1.0);
   return 0.6 + 0.4 * (t * t * (3.0 - 2.0 * t));
 }
+// Minecraft-style FIXED per-face directional shade (independent of the sun) — the reliable readability cue for
+// voxel terrain: top brightest, bottom darkest, and the TWO horizontal axes get DISTINCT brightness so any cube's
+// three visible faces all differ - corners, steps and terrace risers read at a glance at ANY sun angle. up is
+// the local gravity up; t is a stable horizontal tangent used only to break the side-face symmetry.
+fn faceDirShade(N: vec3<f32>, up: vec3<f32>) -> f32 {
+  var t = cross(up, vec3(0.0, 0.0, 1.0));
+  if (dot(t, t) < 0.01) { t = cross(up, vec3(1.0, 0.0, 0.0)); }
+  t = normalize(t);
+  let nu = dot(N, up);           // +1 up-facing, 0 side, -1 down-facing
+  let nt = dot(N, t);            // splits the two horizontal side-axes apart
+  return clamp(0.68 + 0.32 * nu + 0.14 * nt, 0.36, 1.0);
+}
 @fragment fn fs(i: VOut) -> @location(0) vec4<f32> {
   if (i.emis > 0.5) {                                  // self-glowing effect cube: full-bright, unlit
     let g = mix(hsv(i.hue), vec3(1.0), 0.4);
@@ -269,7 +282,13 @@ fn blockShade(fx: f32, fz: f32) -> f32 {
   // per-block edge AO makes each voxel visible on FLAT-hue cubes, but reads as a hard GRID over textures — so the
   // atlas path drops it entirely (the texture already supplies surface detail).
   let ao = select(blockShade(fx, fz), 1.0, cam.atlas.x > 0.5 && i.tile >= 0.0);
-  let lit = base * (cam.sun.w + cam.sunCol.xyz * ndl * sh) * ao;
+  // FACE-DIRECTIONAL SHADING (Minecraft-style, sun-independent) makes the 3D shape read at any time of day. It
+  // tints the ambient FILL heavily AND is applied at partial strength to the whole lit result — so even a face in
+  // full key light still shows its orientation, and terrace risers stay clearly darker than the tops above them.
+  let dir = faceDirShade(N, cam.up.xyz);
+  let fill = cam.sun.w * mix(0.5, 1.25, dir);           // ambient sky term, strongly tinted by face orientation
+  let key = cam.sunCol.xyz * ndl * sh;                  // direct sun (shadowed)
+  let lit = base * (fill + key) * ao * (0.72 + 0.28 * dir);   // 0.72..1.0 fixed face-light keeps corners legible under full sun
   return vec4(pow(clamp(lit, vec3(0.0), vec3(1.0)), vec3(0.4545)), 1.0);  // gamma
 }
 `;
@@ -304,7 +323,7 @@ export class GpuShadowRenderer {
     mainBGL;
     shadowSampler;
     count = 0;
-    cam = new Float32Array(48); // 2×mat4 + sun + sunCol + tint + atlas
+    cam = new Float32Array(52); // 2×mat4 + sun + sunCol + tint + atlas + up
     atlasView;
     atlasSampler;
     tileRectBuf;
@@ -585,7 +604,7 @@ export class GpuShadowRenderer {
     /** camVP/lightVP: column-major Float32Array(16). sunDir: travel direction. Pass `occlusion` (the depth target +
      *  its size) to enable Hi-Z occlusion culling on the camera pass — the renderer rebuilds a coarse Hi-Z from that
      *  depth each frame and the NEXT frame's cull uses it (hole-free: the first frame + any resize skip occlusion). */
-    frame(enc, colorView, sceneDepth, camVP, lightVP, sunDir, sunCol, ambient, load = false, occlusion, tint = [1, 1, 1, 0], extraShadow) {
+    frame(enc, colorView, sceneDepth, camVP, lightVP, sunDir, sunCol, ambient, load = false, occlusion, tint = [1, 1, 1, 0], extraShadow, up = [0, 1, 0]) {
         this.cam.set(camVP, 0);
         this.cam.set(lightVP, 16);
         this.cam[32] = sunDir[0];
@@ -601,6 +620,9 @@ export class GpuShadowRenderer {
         this.cam[42] = tint[2];
         this.cam[43] = tint[3];
         this.cam[44] = this.useAtlas;
+        this.cam[48] = up[0];
+        this.cam[49] = up[1];
+        this.cam[50] = up[2];
         this.device.queue.writeBuffer(this.camBuf, 0, this.cam);
         if (occlusion)
             this.ensureHiZ(occlusion.w, occlusion.h);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ugly-game",
-  "version": "0.5.12",
+  "version": "0.5.14",
   "type": "module",
   "exports": {
     ".": {