reze-engine 0.67.0 → 0.67.1

package/dist/shaders/shadow-api.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 3×3 PCF over one cascade's map, for a point already in that cascade's NDC.
+ *
+ * Shared with the materials, so an effect's shadow and her own shadow soften
+ * alike. The sampler is linear-filtered, which makes each tap a 2×2 bilinear
+ * compare. Unrolled — Safari's Metal backend doesn't unroll nested shadow
+ * loops reliably. The body expects `ndc` in scope and returns.
+ */
+export declare const pcf9: (map: string, ts: string, sampler?: string) => string;
+/** Bindings the real accessor takes, from `binding` upward. */
+export declare const SHADOW_API_BINDINGS = 5;
+/**
+ * `rzShadow(p)`: how much of the sun reaches world point `p` — 1 lit, 0 in a
+ * caster's shadow, soft in between.
+ *
+ * With `on`, declares five bindings from `binding`:
+ *   +0 the light uniform (the sun's direction, and in .w the shadow switch)
+ *   +1 the cascade view-projections, then the caster sphere
+ *   +2 the near cascade's map   +3 the far cascade's map
+ *   +4 the comparison sampler
+ *
+ * It takes a POINT and no normal. The materials' sampleShadow also rejects a
+ * surface facing away from the sun, which is right for skin and wrong for a
+ * blade of grass or a petal: those are thin, lit through, and shaded by their
+ * own N·L. The point is nudged toward the sun instead, which lifts a blade's
+ * root off a stage floor that casts into the same map.
+ */
+export declare function shadowApi(on: boolean, group: number, binding: number): string;
+//# sourceMappingURL=shadow-api.d.ts.map

package/dist/shaders/shadow-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-api.d.ts","sourceRoot":"","sources":["../../src/shaders/shadow-api.ts"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,MAAM,EAAE,IAAI,MAAM,EAAE,gBAAyB,WActE,CAAA;AAED,+DAA+D;AAC/D,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAyD7E"}

package/dist/shaders/shadow-api.js

@@ -0,0 +1,112 @@
+import { SHADOW_CASCADES } from "../shadow-cascades";
+// The sun's shadow, as an effect author sees it.
+//
+// A lawn standing in a character's shadow has to darken where the floor under
+// it does, or the figure floats: the ground catcher draws her shadow, and the
+// blades drawn over it hide it. The map is already there — the materials and
+// the ground read it every frame — so this hands the same lookup to effects.
+//
+// Bound for real in the particle SHADING stage only. That is where geometry an
+// effect draws inside the scene pass is shaded, and the shadow pass has already
+// run by then. Every other module that compiles the author's file gets the
+// stub, which answers 1: lit is what a point with no occlusion information is,
+// the same answer sampleShadow gives outside every cascade.
+/**
+ * 3×3 PCF over one cascade's map, for a point already in that cascade's NDC.
+ *
+ * Shared with the materials, so an effect's shadow and her own shadow soften
+ * alike. The sampler is linear-filtered, which makes each tap a 2×2 bilinear
+ * compare. Unrolled — Safari's Metal backend doesn't unroll nested shadow
+ * loops reliably. The body expects `ndc` in scope and returns.
+ */
+export const pcf9 = (map, ts, sampler = "shadowSampler") => /* wgsl */ `
+  let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
+  let cmpZ = ndc.z - 0.001;
+  let ts = ${ts};
+  let s00 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts, -ts), cmpZ);
+  let s10 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(0.0, -ts), cmpZ);
+  let s20 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts, -ts), cmpZ);
+  let s01 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts, 0.0), cmpZ);
+  let s11 = textureSampleCompareLevel(${map}, ${sampler}, suv, cmpZ);
+  let s21 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts, 0.0), cmpZ);
+  let s02 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts,  ts), cmpZ);
+  let s12 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(0.0,  ts), cmpZ);
+  let s22 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts,  ts), cmpZ);
+  return (s00 + s10 + s20 + s01 + s11 + s21 + s02 + s12 + s22) * (1.0 / 9.0);
+`;
+/** Bindings the real accessor takes, from `binding` upward. */
+export const SHADOW_API_BINDINGS = 5;
+/**
+ * `rzShadow(p)`: how much of the sun reaches world point `p` — 1 lit, 0 in a
+ * caster's shadow, soft in between.
+ *
+ * With `on`, declares five bindings from `binding`:
+ *   +0 the light uniform (the sun's direction, and in .w the shadow switch)
+ *   +1 the cascade view-projections, then the caster sphere
+ *   +2 the near cascade's map   +3 the far cascade's map
+ *   +4 the comparison sampler
+ *
+ * It takes a POINT and no normal. The materials' sampleShadow also rejects a
+ * surface facing away from the sun, which is right for skin and wrong for a
+ * blade of grass or a petal: those are thin, lit through, and shaded by their
+ * own N·L. The point is nudged toward the sun instead, which lifts a blade's
+ * root off a stage floor that casts into the same map.
+ */
+export function shadowApi(on, group, binding) {
+    if (!on) {
+        return /* wgsl */ `
+fn rzShadow(p: vec3f) -> f32 { return 1.0; }
+`;
+    }
+    const n = SHADOW_CASCADES.length;
+    return /* wgsl */ `
+// The first two vec4s of the light uniform: world ambient, then the sun.
+struct _RzShadowSun { ambient: vec4f, direction: vec4f, }
+// The cascades' matrices, inner to outer, then every caster in one sphere
+// (x, y, z, radius): radius 0 = nothing casts, negative = do not test.
+struct _RzShadowBlock { viewProj: array<mat4x4f, ${n}>, casters: vec4f, }
+@group(${group}) @binding(${binding}) var<uniform> _rzShadowSun: _RzShadowSun;
+@group(${group}) @binding(${binding + 1}) var<uniform> _rzShadowVP: _RzShadowBlock;
+@group(${group}) @binding(${binding + 2}) var _rzShadowNear: texture_depth_2d;
+@group(${group}) @binding(${binding + 3}) var _rzShadowFar: texture_depth_2d;
+@group(${group}) @binding(${binding + 4}) var _rzShadowCmp: sampler_comparison;
+
+fn _rzShadowNearTaps(ndc: vec3f) -> f32 {
+${pcf9("_rzShadowNear", `1.0 / ${SHADOW_CASCADES[0].mapSize}.0`, "_rzShadowCmp")}
+}
+
+fn _rzShadowFarTaps(ndc: vec3f) -> f32 {
+${pcf9("_rzShadowFar", `1.0 / ${SHADOW_CASCADES[n - 1].mapSize}.0`, "_rzShadowCmp")}
+}
+
+fn rzShadow(p: vec3f) -> f32 {
+  // The scene's one shadow switch, on the sun — see sampleShadow.
+  let castAmt = _rzShadowSun.direction.w;
+  if (castAmt <= 0.0) { return 1.0; }
+  let toSun = normalize(-_rzShadowSun.direction.xyz);
+  // Can anything cast onto this point at all? The ground's test, for the same
+  // two reasons: most of a lawn is nowhere near her, and a scene with no
+  // models never renders the map, whose untouched zeroes compare as shadowed.
+  let cs = _rzShadowVP.casters;
+  if (cs.w == 0.0) { return 1.0; }
+  if (cs.w > 0.0) {
+    let toCaster = cs.xyz - p;
+    let along = dot(toCaster, toSun);
+    let perp = length(toCaster - toSun * along);
+    if (along <= -cs.w || perp > cs.w) { return 1.0; }
+  }
+  let q = p + toSun * 0.08;
+  let c0 = _rzShadowVP.viewProj[0] * vec4f(q, 1.0);
+  let n0 = c0.xyz / max(c0.w, 1e-6);
+  if (all(abs(n0.xy) < vec2f(0.98)) && n0.z > 0.0 && n0.z < 1.0) {
+    return mix(1.0, _rzShadowNearTaps(n0), castAmt);
+  }
+  let c1 = _rzShadowVP.viewProj[${n - 1}] * vec4f(q, 1.0);
+  let n1 = c1.xyz / max(c1.w, 1e-6);
+  if (all(abs(n1.xy) < vec2f(0.98)) && n1.z > 0.0 && n1.z < 1.0) {
+    return mix(1.0, _rzShadowFarTaps(n1), castAmt);
+  }
+  return 1.0;
+}
+`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reze-engine",
-  "version": "0.67.0",
+  "version": "0.67.1",
   "description": "A lightweight WebGPU engine for real-time 3D MMD/PMX model rendering",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/camera.ts

@@ -74,7 +74,8 @@ export class Camera {
 
   // Camera settings
   angularSensitivity: number = 0.005
-  panSensitivity: number = 0.0002 // Sensitivity for right-click panning
+  panSensitivity: number = 0.0003 // Sensitivity for right-click panning
+  static readonly PAN_REF_RADIUS = 33
   wheelPrecision: number = 0.01
   pinchPrecision: number = 0.05
   minZ: number = 0.05
@@ -335,10 +336,13 @@ export class Camera {
   private panCamera(deltaX: number, deltaY: number) {
     const { right, up } = this.getCameraVectors()
 
-    // Calculate pan distance based on camera distance
-    // The pan amount is proportional to the camera distance (radius) for consistent feel
-    // This makes panning feel natural at all zoom levels
-    const panDistance = this.radius * this.panSensitivity
+    // Pan scales with camera distance, so a drag covers the same share of the
+    // frame at every zoom from PAN_REF_RADIUS out. Closer in it shrinks slower
+    // than the distance (power 0.7): a close-up pans a little faster across the
+    // frame — 1.4x at distance 10, 1.8x at 5 — instead of crawling.
+    const r = this.radius
+    const ref = Camera.PAN_REF_RADIUS
+    const panDistance = (r >= ref ? r : ref * Math.pow(Math.max(r, 0) / ref, 0.7)) * this.panSensitivity
 
     // Horizontal movement: drag right pans left (opposite direction)
     // Vertical movement: drag up pans up (positive up vector)

package/src/engine.ts

@@ -17144,28 +17144,25 @@ export class Engine {
           py += pos.y
           pz += pos.z
         }
-        px += this.cameraTargetOffset.x
-        py += this.cameraTargetOffset.y
-        pz += this.cameraTargetOffset.z
         const tau = this.cameraFollowSmoothing
+        const f = this.cameraFollowPos
         if (tau > 0 && this.cameraFollowSeeded) {
           // Exponential lag toward the bone: the handheld-camera feel. The
           // orbit pivot trails the target and eases in, never snapping.
           const k = 1 - Math.exp(-deltaTime / tau)
-          const f = this.cameraFollowPos
           f.x += (px - f.x) * k
           f.y += (py - f.y) * k
           f.z += (pz - f.z) * k
-          this.camera.target.x = f.x
-          this.camera.target.y = f.y
-          this.camera.target.z = f.z
         } else {
-          this.cameraFollowPos.setXYZ(px, py, pz)
+          f.setXYZ(px, py, pz)
           this.cameraFollowSeeded = true
-          this.camera.target.x = px
-          this.camera.target.y = py
-          this.camera.target.z = pz
         }
+        // The offset goes on AFTER the lag. A pan writes the offset (panSink),
+        // and the lag is for the bone's motion: eased with it, a pan glided
+        // on after the hand let go while an orbit stopped dead.
+        this.camera.target.x = f.x + this.cameraTargetOffset.x
+        this.camera.target.y = f.y + this.cameraTargetOffset.y
+        this.camera.target.z = f.z + this.cameraTargetOffset.z
       }
     }