@driftengine/core 4.1.3 → 4.1.5

package/dist/render/pointShadowImage.d.ts

@@ -111,6 +111,18 @@ export declare class PointShadowImage {
     private pendingRange;
     private pendingNear;
     private pendingSourceRadius;
+    /**
+     * Where this image was rendered from, which is what a sampler has to shoot its ray from.
+     *
+     * **Not the light's position**, and the difference is the whole point: `matchesSource` lets a
+     * light drift up to the caller's rebake tolerance from here before the image is re-rendered,
+     * so for any light that wanders these two are apart on nearly every frame. A shader that
+     * builds its direction and its distance from the live light asks this picture a question the
+     * picture cannot answer. See `ResolvedPointShadows.origins`.
+     */
+    get originX(): number;
+    get originY(): number;
+    get originZ(): number;
     /** Whether this map holds an image worth sampling. False until a bake completes. */
     get hasBaked(): boolean;
     /** How present the image is, 0 to 1. The shader mixes the occlusion in by it. */
@@ -222,6 +234,10 @@ export interface PointShadowSource {
     readonly far: number;
     readonly near: number;
     readonly sourceRadius: number;
+    /** Where the image was rendered from. See `PointShadowImage.originX`. */
+    readonly originX: number;
+    readonly originY: number;
+    readonly originZ: number;
     /** Whether this map holds an image worth sampling. */
     readonly hasBaked: boolean;
     /** How present the image is, 0 to 1. */
@@ -253,6 +269,28 @@ export interface ResolvedPointShadows {
     readonly far: Float32Array;
     readonly near: Float32Array;
     readonly sourceRadius: Float32Array;
+    /**
+     * The projection each bound map was rendered under: origin in `xyz`, far plane in `w`, four
+     * floats a light. The origin is **not** the light's position.
+     *
+     * A light is allowed to drift `pointShadowRebakeDistance` from its image before the image is
+     * re-rendered — that tolerance is what stops a flame re-baking six faces of the static world
+     * every frame — so for anything that flickers these two are apart on nearly every frame. The
+     * shader builds both its sample direction and the distance it compares from this point, so the
+     * ray it shoots is the ray the picture was drawn along and the drift costs nothing.
+     *
+     * **It used to build them from the live light**, and the drift went straight into the
+     * comparison: `dist` moved one for one with it against a bias of a few centimetres, and the
+     * single-tap blocker search moved across the occluder's silhouette, swapping `occluderDistance`
+     * between the caster and nothing. Reported on a brazier at night as a hard square under the
+     * fire, flashing in time with the flame while the camera stood still.
+     *
+     * **The far plane rides in `w` rather than in an array of its own**, because a default-block
+     * `float[N]` spends a whole uniform vector per element: declared separately the origin cost
+     * sixteen rows on each of the two sets, which the budget ladder answers on a 256-vector
+     * device by halving `MAX_LIGHTS`. See `uPointShadowProjection` in the preamble.
+     */
+    readonly projections: Float32Array;
     /** How present each bound map is, so a re-baked one arrives rather than appears. */
     readonly presence: Float32Array;
     /** The live pair, by the same light index: a light owns at most one of the two. */
@@ -260,6 +298,8 @@ export interface ResolvedPointShadows {
     readonly liveFar: Float32Array;
     readonly liveNear: Float32Array;
     readonly liveSourceRadius: Float32Array;
+    /** The live pair's own, by the same rule and for the same reason. */
+    readonly liveProjections: Float32Array;
     readonly liveWeights: Float32Array;
 }
 export declare function createResolvedPointShadows(lights: number): ResolvedPointShadows;

package/dist/render/pointShadowImage.js

@@ -160,6 +160,24 @@ export class PointShadowImage {
     pendingRange = 0;
     pendingNear = 0;
     pendingSourceRadius = 0;
+    /**
+     * Where this image was rendered from, which is what a sampler has to shoot its ray from.
+     *
+     * **Not the light's position**, and the difference is the whole point: `matchesSource` lets a
+     * light drift up to the caller's rebake tolerance from here before the image is re-rendered,
+     * so for any light that wanders these two are apart on nearly every frame. A shader that
+     * builds its direction and its distance from the live light asks this picture a question the
+     * picture cannot answer. See `ResolvedPointShadows.origins`.
+     */
+    get originX() {
+        return this.x;
+    }
+    get originY() {
+        return this.y;
+    }
+    get originZ() {
+        return this.z;
+    }
     /** Whether this map holds an image worth sampling. False until a bake completes. */
     get hasBaked() {
         return this.baked;
@@ -329,11 +347,13 @@ export function createResolvedPointShadows(lights) {
         far: new Float32Array(lights),
         near: new Float32Array(lights),
         sourceRadius: new Float32Array(lights),
+        projections: new Float32Array(lights * 4),
         presence: new Float32Array(lights),
         liveLayers: new Int32Array(lights).fill(-1),
         liveFar: new Float32Array(lights),
         liveNear: new Float32Array(lights),
         liveSourceRadius: new Float32Array(lights),
+        liveProjections: new Float32Array(lights * 4),
         liveWeights: new Float32Array(lights),
     };
 }

package/dist/render/pointShadowMap.d.ts

@@ -46,6 +46,10 @@ export declare class PointShadowMap {
     get far(): number;
     get near(): number;
     get sourceRadius(): number;
+    /** Where the image was rendered from, not where the light is now. See the image. */
+    get originX(): number;
+    get originY(): number;
+    get originZ(): number;
     /** Whether this map holds an image worth sampling. False until a bake completes. */
     get hasBaked(): boolean;
     /** How present the image is, 0 to 1. The shader mixes the occlusion in by it. */

package/dist/render/pointShadowMap.js

@@ -54,6 +54,16 @@ export class PointShadowMap {
     get sourceRadius() {
         return this.image.sourceRadius;
     }
+    /** Where the image was rendered from, not where the light is now. See the image. */
+    get originX() {
+        return this.image.originX;
+    }
+    get originY() {
+        return this.image.originY;
+    }
+    get originZ() {
+        return this.image.originZ;
+    }
     /** Whether this map holds an image worth sampling. False until a bake completes. */
     get hasBaked() {
         return this.image.hasBaked;

package/dist/render/pointShadowSystem.js

@@ -272,6 +272,10 @@ export class PointShadowSystem {
         out.far.fill(1);
         out.near.fill(0.01);
         out.sourceRadius.fill(0);
+        /* Origin zero, far plane one: the same neutral the separate `far` array is filled with. */
+        out.projections.fill(0);
+        for (let k = 0; k < MAX_POINT_LIGHTS; k++)
+            out.projections[k * 4 + 3] = 1;
         out.presence.fill(0);
         for (let k = 0; k < MAX_POINT_LIGHTS; k++) {
             const map = this.mapForShaderSlot(k);
@@ -299,6 +303,11 @@ export class PointShadowSystem {
             out.far[light] = map.far;
             out.near[light] = map.near;
             out.sourceRadius[light] = map.sourceRadius;
+            /* Where the image was rendered from, not where the light is now. See `projections`. */
+            out.projections[light * 4] = map.originX;
+            out.projections[light * 4 + 1] = map.originY;
+            out.projections[light * 4 + 2] = map.originZ;
+            out.projections[light * 4 + 3] = map.far;
             out.presence[light] = map.presence;
             out.layers[light] = map.layer;
         }

package/dist/render/renderQuality.d.ts

@@ -154,10 +154,33 @@ export interface RenderQuality {
      * sampled lights flickering at once accounted for 174 of the frame's 296 draw
      * calls, and for the game being unplayable exactly where lamps cluster.
      *
-     * The default clears a flame's own wander with room to spare, because drift is
-     * measured from the baked origin and a wander can be caught at either extreme
-     * of its travel. A light that really moves still re-bakes; it just does so once
-     * per this much movement instead of once per frame.
+     * **It was 0.4 until 4.1.5, chosen to clear a flame's whole wander with room to spare** — so
+     * a flame never re-baked at all, and its shadow of the static world stood still while the live
+     * map under the same light, which is re-rendered every frame because it holds the movers, swung
+     * with the flame. One light, two shadows, visibly disagreeing about where it was. Reported as
+     * the runner's shadow following the fire and the brazier's not.
+     *
+     * **A millimetre instead, which is as near to "whenever it moved" as makes sense**, so a shadow
+     * travels with its light rather than freezing between re-bakes. A centimetre was tried first and
+     * left a visible vibration: a light wandering on a curve moves less than that in a frame near
+     * the turning points of its travel, so the shadow ran smoothly through the fast part and stepped
+     * through the slow part. What the tolerance is still for is not re-baking on arithmetic noise.
+     *
+     * A light that does not move never goes stale at any positive value, so the whole cost falls on
+     * the lights that need it, and it is bounded rather than proportional: one such light takes a
+     * whole cube in a frame and the rest dribble under the ordinary face budget.
+     *
+     * **What makes that affordable is not this number.** The 174-of-296 draw calls this paragraph
+     * used to cite was measured before `pointShadowFacesPerFrame` capped the whole static bake, and
+     * before `planPointShadowBakes` learned to put a chronically stale map behind every cold and
+     * settling one. A flame now spends leftover budget and can never hold another light's first
+     * image hostage. One such light also finishes its cube inside a single frame rather than
+     * dribbling it over three, which is what makes the motion smooth instead of stepped; see
+     * `pointShadowBudget.ts`.
+     *
+     * **What would make it wrong** is a caster set heavy enough that six passes over it does not
+     * fit the frame, where a stepped shadow is the better trade and this should go back up.
+     * `gpuTiming` is how to tell which, and it is a number rather than an opinion.
      */
     readonly pointShadowRebakeDistance: number;
     /**

package/dist/render/renderQuality.js

@@ -58,7 +58,7 @@ export const DEFAULT_RENDER_QUALITY = Object.freeze({
     directionalShadowDepthLayers: 2,
     directionalShadowMaxDistance: 6,
     directionalShadowMaxSlope: 3,
-    pointShadowRebakeDistance: 0.4,
+    pointShadowRebakeDistance: 0.001,
     pointShadowFacesPerFrame: 2,
     /*
      * Twelve, which is `LIVE_POINT_SHADOW_MAPS` cubemaps of six faces: exactly what the live