ugly-game 0.5.13 → 0.5.15

package/dist/assets/gpuProps.d.ts

@@ -25,5 +25,5 @@ export declare class GpuPropsRenderer {
     setInstances(instances: PropInstance[]): void;
     /** Occluder pass: draw all instanced props' depth into the shared shadow map from the sun's ortho view. */
     shadowPass(pass: GPURenderPassEncoder, lightVP: Float32Array): void;
-    frame(enc: GPUCommandEncoder, colorView: GPUTextureView, depthView: GPUTextureView, camVP: Float32Array, sunDir: [number, number, number], sunCol: [number, number, number], amb: [number, number, number], camPos: [number, number, number], fog: [number, number, number], fogDensity: number): void;
+    frame(enc: GPUCommandEncoder, colorView: GPUTextureView, depthView: GPUTextureView, camVP: Float32Array, sunDir: [number, number, number], sunCol: [number, number, number], amb: [number, number, number], camPos: [number, number, number], fog: [number, number, number], fogDensity: number, up?: [number, number, number]): void;
 }

package/dist/assets/gpuProps.js

@@ -4,7 +4,7 @@
 // terrain. Runs in a load pass after the terrain so props depth-test against the surface.
 // ─────────────────────────────────────────────────────────────────────────────
 const SHADER = /* wgsl */ `
-struct U { mvp: mat4x4<f32>, sun: vec4<f32>, sunCol: vec4<f32>, amb: vec4<f32>, cam: vec4<f32>, fog: vec4<f32> };
+struct U { mvp: mat4x4<f32>, sun: vec4<f32>, sunCol: vec4<f32>, amb: vec4<f32>, cam: vec4<f32>, fog: vec4<f32>, up: vec4<f32> };
 @group(0) @binding(0) var<uniform> u: U;
 @group(0) @binding(1) var<storage,read> models: array<mat4x4<f32>>;
 struct VO { @builtin(position) pos: vec4<f32>, @location(0) world: vec3<f32>, @location(1) n: vec3<f32>, @location(2) c: vec3<f32> };
@@ -13,9 +13,20 @@ struct VO { @builtin(position) pos: vec4<f32>, @location(0) world: vec3<f32>, @l
   let world = (m * vec4(p, 1.0)).xyz;
   var o: VO; o.pos = u.mvp * vec4(world, 1.0); o.world = world; o.n = (m * vec4(nrm, 0.0)).xyz; o.c = col; return o;
 }
+// same fixed directional FILL as the terrain cubes (gpuShadow.fixedFill) so plants/rocks read the same 3D shape,
+// day or night, under one shared light. up.w > 0.5 signals a valid local-up was supplied (else fall back to flat).
+fn fixedFill(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 L = normalize(up * 0.82 + t * 0.57);
+  return max(dot(N, L), 0.0);
+}
 @fragment fn fs(i: VO) -> @location(0) vec4<f32> {
-  let d = clamp(dot(normalize(i.n), -normalize(u.sun.xyz)), 0.0, 1.0);
-  let lit = i.c * (u.amb.xyz + d * u.sunCol.xyz);
+  let N = normalize(i.n);
+  let ff = select(1.0, 0.5 + 0.85 * fixedFill(N, u.up.xyz), u.up.w > 0.5);   // fixed fill (fall back to flat amb if no up)
+  let d = clamp(dot(N, -normalize(u.sun.xyz)), 0.0, 1.0);
+  let lit = i.c * (u.amb.xyz * ff + d * u.sunCol.xyz);
   let dist = length(i.world - u.cam.xyz);
   let f = clamp(1.0 - exp(-dist * u.fog.w), 0.0, 1.0);
   return vec4(mix(lit, u.fog.xyz, f), 1.0);
@@ -59,7 +70,7 @@ export class GpuPropsRenderer {
             primitive: { topology: 'triangle-list', cullMode: 'none' },
             depthStencil: { format: 'depth32float', depthWriteEnabled: true, depthCompare: 'less' },
         });
-        this.uBuf = device.createBuffer({ size: 96 + 16 * 5, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+        this.uBuf = device.createBuffer({ size: 96 + 16 * 6, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
         this.lightBuf = device.createBuffer({ size: 64, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
     }
     setModels(meshes) {
@@ -120,14 +131,16 @@ export class GpuPropsRenderer {
             pass.drawIndexed(mdl.idxCount, this.counts[m]);
         }
     }
-    frame(enc, colorView, depthView, camVP, sunDir, sunCol, amb, camPos, fog, fogDensity) {
-        const u = new Float32Array(24 + 20);
+    frame(enc, colorView, depthView, camVP, sunDir, sunCol, amb, camPos, fog, fogDensity, up) {
+        const u = new Float32Array(24 + 24);
         u.set(camVP, 0);
         u.set([sunDir[0], sunDir[1], sunDir[2], 0], 16);
         u.set([sunCol[0], sunCol[1], sunCol[2], 0], 20);
         u.set([amb[0], amb[1], amb[2], 0], 24);
         u.set([camPos[0], camPos[1], camPos[2], 0], 28);
         u.set([fog[0], fog[1], fog[2], fogDensity], 32);
+        if (up)
+            u.set([up[0], up[1], up[2], 1], 36); // up.w=1 → enable the fixed directional fill (matches the terrain)
         this.device.queue.writeBuffer(this.uBuf, 0, u);
         const rp = enc.beginRenderPass({ colorAttachments: [{ view: colorView, loadOp: 'load', storeOp: 'store' }], depthStencilAttachment: { view: depthView, depthLoadOp: 'load', depthStoreOp: 'store' } });
         rp.setPipeline(this.pipe);

package/dist/gpuShadow.js

@@ -240,6 +240,17 @@ 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));
 }
+// ONE fixed, subtle directional FILL light in the local gravity frame — always on, independent of the sun, so
+// terrain + props keep their 3D shape even in darkness (the sun stays the primary, shadow-casting key light). The
+// fill comes from up + a fixed horizontal tangent (~35 deg off vertical), so a cube's three visible faces all get
+// distinct brightness and corners/terrace risers read at a glance. Cubes and props (gpuProps) share this formula.
+fn fixedFill(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 L = normalize(up * 0.82 + t * 0.57);       // fixed key-fill direction
+  return max(dot(N, L), 0.0);                     // 0 (facing away) .. 1 (facing the fill)
+}
 @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);
@@ -270,12 +281,12 @@ 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);
-  // HEMISPHERE FACE-SHADING: brighten faces pointing toward the local up (sky), darken side/down faces — so every
-  // block's orientation reads at a glance (edges/corners legible) WITHOUT a per-block grid. Modulates the ambient
-  // sky term (not the direct sun), so sunlit faces keep full key light while shaded areas still show 3D form.
-  let hemi = dot(N, cam.up.xyz) * 0.5 + 0.5;      // 0 = down-facing, 0.5 = side, 1 = up-facing
-  let amb = cam.sun.w * mix(0.55, 1.15, hemi);
-  let lit = base * (amb + cam.sunCol.xyz * ndl * sh) * ao;
+  // LIGHTING = fixed directional FILL (always on, reads 3D shape in the dark) + the sun KEY (primary, shadowed).
+  // cam.sun.w is the fill/ambient brightness knob; the fill's directional term (0.5..1.35) keeps every face's
+  // orientation legible day or night, while the sun adds bright, shadow-casting key light on top during the day.
+  let fill = cam.sun.w * (0.5 + 0.85 * fixedFill(N, cam.up.xyz));
+  let key = cam.sunCol.xyz * ndl * sh;                  // direct sun (shadowed) — primary light
+  let lit = base * (fill + key) * ao;
   return vec4(pow(clamp(lit, vec3(0.0), vec3(1.0)), vec3(0.4545)), 1.0);  // gamma
 }
 `;

package/package.json

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