@driftengine/core 4.1.3 → 4.1.5

package/src/render/depthConvention.ts

@@ -104,6 +104,28 @@ export const REVERSED_DEPTH = true;
 /** What a scene depth attachment is cleared to: the far plane. */
 export const DEPTH_CLEAR = REVERSED_DEPTH ? 0 : 1;
 
+/**
+ * The same value for a backend that learned its convention at runtime rather than at compile time.
+ *
+ * **`DEPTH_CLEAR` above says what the engine wants; this says what a context got.** Reversed depth
+ * on WebGL2 needs `EXT_clip_control`, and a context not granted it runs conventional depth while
+ * the constant still reads 0. Clearing to 0 with a `LEQUAL` compare rejects every fragment in the
+ * scene — every one sits at depth >= 0 and only depth <= 0 is admitted — so the frame that reaches
+ * the screen is the colour clear and nothing else.
+ *
+ * Reported from Firefox on Linux, which exposes no `EXT_clip_control`: every consumer drew one flat
+ * colour with its interface still on top, at a healthy sixty frames a second. The depth *compare*
+ * beside it was already chosen at runtime, and that asymmetry is what made this total rather than
+ * subtle — two halves of one convention would still have drawn a picture.
+ *
+ * **Here rather than in the backend** for the 2026-08-13 rule's first clause: the decision is
+ * backend-neutral and only the binding is per-backend. It is also what lets a test hold the clear
+ * and the compare to each other, which a private field on a renderer could not.
+ */
+export function depthClearFor(reversed: boolean): number {
+  return reversed ? 0 : 1;
+}
+
 /** The WebGPU compare for "nearer than what is there". */
 export const DEPTH_COMPARE: GPUCompareFunction = REVERSED_DEPTH ? 'greater' : 'less';
 

package/src/render/livePointShadowSet.ts

@@ -182,6 +182,8 @@ export class LivePointShadowSet<M extends PointShadowSource> {
     out.liveFar.fill(1);
     out.liveNear.fill(0.01);
     out.liveSourceRadius.fill(0);
+    out.liveProjections.fill(0);
+    for (let k = 0; k < out.liveLayers.length; k++) out.liveProjections[k * 4 + 3] = 1;
     /*
      * Zero, then written under the owning light below. The weights used to be a straight copy of
      * this set's own two, because the arrays were addressed by live slot; they are addressed by
@@ -214,6 +216,11 @@ export class LivePointShadowSet<M extends PointShadowSource> {
       out.liveFar[shaderSlot] = map.far;
       out.liveNear[shaderSlot] = map.near;
       out.liveSourceRadius[shaderSlot] = map.sourceRadius;
+      /* Where the image was rendered from, not where the light is now. See `projections`. */
+      out.liveProjections[shaderSlot * 4] = map.originX;
+      out.liveProjections[shaderSlot * 4 + 1] = map.originY;
+      out.liveProjections[shaderSlot * 4 + 2] = map.originZ;
+      out.liveProjections[shaderSlot * 4 + 3] = map.far;
       /*
        * The handover weight *and* the image's own arrival, multiplied.
        *

package/src/render/pointShadowBudget.ts

@@ -244,7 +244,24 @@ export function runPointShadowBakes<M extends StaleCheck, L extends BakeableLigh
       scratch.staleOwner[slot] = lightIndex;
       scratch.staleRun[slot] = 0;
     }
-    const run = stale ? Math.min((scratch.staleRun[slot] ?? 0) + 1, CHRONIC_STALE_FRAMES) : 0;
+    /*
+     * **The run decays rather than resetting, and it climbs past the threshold before it stops.**
+     *
+     * A light that wanders on a curve is not stale on *every* frame — near the turning points of
+     * its travel it moves less in a frame than the rebake tolerance, so a run that reset to zero
+     * lost the tracking allowance there and the map dropped back to two faces a frame. The shadow
+     * then travelled smoothly through the fast part of the wander and stepped through the slow
+     * part, which is not motion and not stillness: it reads as a vibration. Reported that way,
+     * against a brazier, once the tracking allowance was in.
+     *
+     * So the run is hysteresis. It climbs to twice the threshold, which buys a light that has
+     * earned the allowance three quiet frames before it loses it, and decays one frame at a time
+     * so a light that genuinely settles stops re-baking rather than holding a budget for ever.
+     */
+    const previous = scratch.staleRun[slot] ?? 0;
+    const run = stale
+      ? Math.min(previous + 1, CHRONIC_STALE_FRAMES * 2)
+      : Math.max(previous - 1, 0);
     scratch.staleRun[slot] = run;
     scratch.chronic[slot] = run >= CHRONIC_STALE_FRAMES ? 1 : 0;
   }
@@ -259,6 +276,38 @@ export function runPointShadowBakes<M extends StaleCheck, L extends BakeableLigh
 
   let faces = facesPerFrame;
   let urgentSpent = false;
+  /*
+   * **One wandering light finishes its cube in the frame it started it**, the same allowance a
+   * light with no image at all gets, and for a reason that turns out to be the same one: a map
+   * dribbled out at two faces a frame is a map nobody can sample correctly until it lands.
+   *
+   * A cold light cannot be sampled *at all* until its six faces are in, so it takes the whole
+   * cube at once. A chronically stale one can be sampled throughout and is wrong in a quieter
+   * way: `planBake` pins the origin for the whole of a resumed bake, so six faces spread over
+   * three frames means the published origin steps once every third frame. The shader shoots from
+   * that origin, so the shadow it draws steps with it — reported on a brazier as motion that was
+   * "really fast, not smooth, snappy, and unrealistic", which is a 20 Hz sample of a flame that
+   * wanders about once a second.
+   *
+   * Given the cube in one frame the origin moves every frame and the shadow travels instead.
+   *
+   * **Bounded to one light, and it has to be.** Eight braziers each taking six passes is the 48
+   * passes and 89 ms `pointShadowFacesPerFrame` exists to prevent. One is the light being shaded
+   * that most recently went stale, which is the one somebody is standing next to; the rest keep
+   * dribbling under the ordinary budget, and their shadows step rather than travel. That is the
+   * right way round: a shadow you are looking at moves, and a shadow across the square does not
+   * cost the frame.
+   *
+   * It is spent *after* the cold and settling groups, because `planPointShadowBakes` orders the
+   * chronic ones last — so a light arriving in range still gets its first image ahead of a flame
+   * refining one it already has.
+   *
+   * **What would make it wrong** is a caster set heavy enough that six passes over it does not
+   * fit the frame. Measured against a game whose whole static world is about 8,500 triangles in
+   * a handful of draws; a world an order of magnitude heavier wants `pointShadowFacesPerFrame`
+   * raised or this given up, and `gpuTiming` is how to tell which.
+   */
+  let trackingSpent = false;
   for (let i = 0; i < planned && faces > 0; i++) {
     const slot = scratch.order[i] ?? -1;
     /*
@@ -270,10 +319,14 @@ export function runPointShadowBakes<M extends StaleCheck, L extends BakeableLigh
     const map = lightIndex >= 0 ? pool.mapForLight(lightIndex) : undefined;
     if (light === undefined || map === undefined) continue;
 
-    const cold = slot < pool.sampledCount && scratch.ready[slot] === 0;
-    const budget = cold && !urgentSpent ? faceCount : faces;
-    if (cold && !urgentSpent) urgentSpent = true;
-    faces -= bake(map, light, staticCasters, budget);
+    const sampled = slot < pool.sampledCount;
+    const cold = sampled && scratch.ready[slot] === 0;
+    const urgent = cold && !urgentSpent;
+    /* A light being shaded whose map will be stale again next frame however it is served. */
+    const tracking = !cold && sampled && scratch.chronic[slot] === 1 && !trackingSpent;
+    if (urgent) urgentSpent = true;
+    if (tracking) trackingSpent = true;
+    faces -= bake(map, light, staticCasters, urgent || tracking ? faceCount : faces);
   }
 
   /*

package/src/render/pointShadowImage.ts

@@ -202,6 +202,27 @@ export class PointShadowImage {
   private pendingNear = 0;
   private 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(): number {
+    return this.x;
+  }
+
+  get originY(): number {
+    return this.y;
+  }
+
+  get originZ(): number {
+    return this.z;
+  }
+
   /** Whether this map holds an image worth sampling. False until a bake completes. */
   get hasBaked(): boolean {
     return this.baked;
@@ -401,6 +422,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. */
@@ -433,6 +458,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. */
@@ -440,6 +487,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;
 }
 
@@ -460,11 +509,13 @@ export function createResolvedPointShadows(lights: number): ResolvedPointShadows
     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/src/render/pointShadowMap.ts

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

package/src/render/pointShadowSystem.ts

@@ -343,6 +343,9 @@ export class PointShadowSystem<M extends PointShadowSource> {
     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++) {
@@ -369,6 +372,11 @@ export class PointShadowSystem<M extends PointShadowSource> {
       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/src/render/renderQuality.ts

@@ -162,10 +162,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;
   /**
@@ -815,7 +838,7 @@ export const DEFAULT_RENDER_QUALITY: Readonly<RenderQuality> = 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

package/src/render/shaders/flat/main.ts

@@ -793,6 +793,27 @@ export const MAIN_GLSL = `void main() {
      */
     float lightShade = 1.0;
 
+    /*
+     * **The lamps' light twice: once as it arrives, once as their shadows leave it.**
+     *
+     * Every point light's contribution used to go straight into \`lit\`. It is accumulated here
+     * instead, in two sums that differ only by the shadow term, so that after the loop there is
+     * a single number per channel saying how much of the lamps' light survived — and *that* is
+     * the thing the resolve below can average across a pair of pixels without touching albedo,
+     * a highlight, or anything else the frame has in it.
+     *
+     * **The two sums are not an approximation.** \`lampOpen\` multiplied by
+     * \`lampShadowed / lampOpen\` is \`lampShadowed\`, per channel, whatever mixture of lamps
+     * and shadows produced it. With the resolve switched off this is arithmetically the line it
+     * replaces; a lamp that is shadowed and a lamp beside it that is not keep their own shares.
+     *
+     * **What it costs** is two vector adds per light and six floats of live state. **What would
+     * make it wrong** is a term wanting to sit between the lamps and \`lit\` — a per-light
+     * tone map, say — because these two are summed before anything can get between them.
+     */
+    vec3 lampOpen = vec3(0.0);
+    vec3 lampShadowed = vec3(0.0);
+
     /*
      * Which froxel this fragment is in.
      *
@@ -969,7 +990,7 @@ export const MAIN_GLSL = `void main() {
 #if POINT_SHADOWS
       float grazing = 1.0 - ndl;
       float normalOffset = (0.06 + dist * 0.05) * grazing * grazing + 0.02;
-      vec3 shadowFrom = (vWorldPos + n * normalOffset) - lightPos;
+      vec3 receiverPoint = vWorldPos + n * normalOffset;
 
       /*
        * uPointShadowWeight is how present the cubemap is, and it is the difference
@@ -1010,8 +1031,15 @@ export const MAIN_GLSL = `void main() {
           pointShadow(
             uPointShadows,
             float(layer),
-            shadowFrom,
-            uPointShadowFar[shadowRead],
+            /*
+             * **From where the map was baked, not from where the light is.** The two are apart
+             * by up to \`pointShadowRebakeDistance\` for anything that wanders, and both things
+             * this asks the picture move with that gap: the distance it compares against the
+             * stored one, and which texel the single-tap blocker search lands in. See
+             * \`uPointShadowOrigin\`.
+             */
+            receiverPoint - uPointShadowProjection[shadowRead].xyz,
+            uPointShadowProjection[shadowRead].w,
             uPointShadowNear[shadowRead],
             uPointShadowSize[shadowRead]
           ),
@@ -1030,8 +1058,9 @@ export const MAIN_GLSL = `void main() {
         liveOccl = pointShadow(
           uPointShadows,
           float(liveLayer),
-          shadowFrom,
-          uLivePointShadowFar[shadowRead],
+          /* Its own bake origin, for the reason the static layer above gives. */
+          receiverPoint - uLivePointShadowProjection[shadowRead].xyz,
+          uLivePointShadowProjection[shadowRead].w,
           uLivePointShadowNear[shadowRead],
           uLivePointShadowSize[shadowRead]
         );
@@ -1192,7 +1221,13 @@ export const MAIN_GLSL = `void main() {
        *
        * At metal 0 this is one multiply by 1.0 away from the expression it replaces.
        */
-      lit += albedo * lightColor * ndl * shape * shaded * lightWeight * (1.0 - metal);
+      /*
+       * Held back from \`lit\` until the loop is over, so the shadow can be resolved across a
+       * pair of pixels first. See the block below the loop; nothing else about this term moved.
+       */
+      vec3 lampDiffuse = albedo * lightColor * ndl * shape * lightWeight * (1.0 - metal);
+      lampOpen += lampDiffuse;
+      lampShadowed += lampDiffuse * shaded;
 
       /*
        * A lamp reflected in a polished surface, which point lights could not do at all.
@@ -1222,8 +1257,12 @@ export const MAIN_GLSL = `void main() {
           vec3(1.0),
           pow(1.0 - max(dot(toEyeLamp, lampHalfway), 0.0), 5.0) * metal
         );
-        lit += lightColor * sphereLobe(max(dot(n, lampHalfway), 0.0), surfaceRoughness, lightSourceRadius, dist)
-          * lampSpec * shape * shaded * lightWeight;
+        /* Held back with the diffuse half, and shadowed by the same term it always was. */
+        vec3 lampHighlight =
+          lightColor * sphereLobe(max(dot(n, lampHalfway), 0.0), surfaceRoughness, lightSourceRadius, dist)
+          * lampSpec * shape * lightWeight;
+        lampOpen += lampHighlight;
+        lampShadowed += lampHighlight * shaded;
       }
       /*
        * The most any light in range shadows this point, for the emissive term below —
@@ -1371,7 +1410,10 @@ export const MAIN_GLSL = `void main() {
       }
 #endif
 
-      lit += albedo * uAreaLightColor[a] * form * (1.0 - metal) * areaOccl;
+      /* Held back with the point lamps', and shadowed by the same term it always was. */
+      vec3 areaDiffuse = albedo * uAreaLightColor[a] * form * (1.0 - metal);
+      lampOpen += areaDiffuse;
+      lampShadowed += areaDiffuse * areaOccl;
 
       if (vSpecular > 0.0 || metal > 0.0) {
         /*
@@ -1396,11 +1438,63 @@ export const MAIN_GLSL = `void main() {
         if (coverage > 0.0) {
           vec2 areaDfg = envBrdfApprox(max(dot(n, toEyeArea), 0.0), surfaceRoughness);
           vec3 areaSpec = specColor * areaDfg.x + vec3(areaDfg.y);
-          lit += areaSpec * uAreaLightColor[a] * coverage * areaOccl;
+          vec3 areaHighlight = areaSpec * uAreaLightColor[a] * coverage;
+          lampOpen += areaHighlight;
+          lampShadowed += areaHighlight * areaOccl;
         }
       }
     }
 
+    /*
+     * **The other half of the shadow filter: the two pixels of a column pair, folded together.**
+     *
+     * \`pointShadow\` turns its twelve taps by half a golden angle on every other column, so a
+     * pair of neighbouring pixels holds twenty-four places on the disk between them and neither
+     * holds more than twelve. This is where the pair becomes one filter. \`dFdx\` of a value is
+     * the difference across the pair, and half of it, signed by which of the two this pixel is,
+     * is exactly the average of both — so each pixel ends up shaded by all twenty-four taps
+     * while paying for twelve. It is the pairing \`ambientOcclusion.ts\` describes between its
+     * rotation tile and its blur, at the smallest size that needs no second pass.
+     *
+     * **After both lamp loops rather than beside the taps, and that is why this block exists at
+     * all.** A derivative is only defined where every pixel of the quad reaches it, and neither
+     * loop above reaches anything uniformly: the point loop \`continue\`s on falloff and on
+     * facing, and in the clustered arm its trip count is read from a froxel, so two neighbouring
+     * pixels can be shading different lights with a froxel boundary drawn across the screen
+     * where they stop agreeing. A \`dFdx\` in there is the 2026-08-07 rule's own case, and it
+     * would also invite a compiler to flatten the loop. Measured, too: with the turn taken from
+     * a per-fragment hash instead of the column, the same resolve made the penumbra *worse*
+     * than no resolve at all — 3.14 against 3.00 — because the hardware here answers a coarse
+     * derivative and the second row of a quad then borrows the first row's difference. The
+     * column tile is what makes that borrowing correct, so the two halves are one mechanism.
+     *
+     * Both lamp kinds are in the sums, because a rectangle's shadow is filtered by the same
+     * twelve taps and stippled the same way.
+     *
+     * **Clamped, and the clamp is a guard rather than tidying.** A fragment killed by the
+     * cutout or the clip plane above leaves its lane without a value for its neighbour to
+     * difference against, and GLSL ES says nothing about what comes back. What could reach the
+     * frame is a shadow term outside 0..1 on the pixel beside a cutout hole, which the clamp
+     * turns into a pixel that is merely fully lit or fully shadowed. **What would make this
+     * wrong** is a consumer whose cutout edges are most of the frame — dense foliage drawn as
+     * one alpha-tested sheet — where the honest answer is to resolve in a pass of its own,
+     * against a shadow term written to a target.
+     *
+     * The floor under the divisor costs nothing and answers the case where no lamp reached this
+     * pixel at all: both sums are zero there, so the ratio is zero and multiplying it back by
+     * the floor adds nothing.
+     */
+    vec3 lampOpenFloor = max(lampOpen, vec3(1e-6));
+    vec3 lampShade = lampShadowed / lampOpenFloor;
+#if POINT_SHADOWS
+    lampShade = clamp(
+      lampShade - dFdx(lampShade) * (float(int(gl_FragCoord.x) & 1) - 0.5),
+      0.0,
+      1.0
+    );
+#endif
+    lit += lampOpenFloor * lampShade;
+
     /*
      * Self-illuminated geometry, dimmed where a lamp's shadow crosses it.
      *