shadow and light effect - restore uniform shadow during the nighttime

Signed-off-by: Ihor Dykhta <dikhta.igor@gmail.com>

Author: igorDykhta

src/deckgl-augmentations.d.ts

@@ -45,6 +45,8 @@ declare module '@deck.gl/core' {
   export type RGBAColor = [number, number, number, number];
   export type RGBColor = [number, number, number];
 
+  export const shadow: any;
+
   export class DeckRenderer {
     device: any;
     renderBuffers: any[];

src/effects/src/custom-deck-lighting-effect.ts

@@ -3,40 +3,116 @@
 
 // @ts-nocheck
 
-import {LightingEffect} from '@deck.gl/core';
+import {LightingEffect, shadow} from '@deck.gl/core';
+
+/**
+ * Insert text before a target string in shader source.
+ */
+function insertBefore(source: string, target: string, textToInsert: string): string {
+  const at = source.indexOf(target);
+  if (at < 0) return source;
+  return source.slice(0, at) + textToInsert + source.slice(at);
+}
+
+/**
+ * Create a patched shadow module that adds `outputUniformShadow` to the
+ * shadow UBO. When true, `shadow_getShadowWeight` returns 1.0 (full
+ * uniform shadow) instead of sampling the shadow map. Used for nighttime
+ * rendering to avoid partial shadows from below.
+ */
+function createCustomShadowModule() {
+  if (!shadow) return null;
+
+  const mod = {...shadow};
+
+  // Add outputUniformShadow to the UBO block (present in both vs and fs)
+  const uboField = '  bool outputUniformShadow;\n';
+  mod.vs = insertBefore(mod.vs, '} shadow;', uboField);
+  mod.fs = insertBefore(mod.fs, '} shadow;', uboField);
+
+  // Early return in shadow_getShadowWeight when outputUniformShadow is set
+  mod.fs = insertBefore(
+    mod.fs,
+    'vec4 rgbaDepth = texture(shadowMap, position.xy);',
+    'if (shadow.outputUniformShadow) return 1.0;\n  '
+  );
+
+  mod.uniformTypes = {
+    ...shadow.uniformTypes,
+    outputUniformShadow: 'f32'
+  };
+
+  // Wrap getUniforms to include outputUniformShadow in the UBO
+  const originalGetUniforms = shadow.getUniforms;
+  mod.getUniforms = (opts = {}, context = {}) => {
+    const u = originalGetUniforms(opts, context);
+    if (opts.outputUniformShadow !== undefined) {
+      u.outputUniformShadow = opts.outputUniformShadow;
+    } else {
+      u.outputUniformShadow = false;
+    }
+    return u;
+  };
+
+  return mod;
+}
+
+const CustomShadowModule = createCustomShadowModule();
 
 /**
  * Custom LightingEffect for kepler.gl.
  *
- * This is a thin wrapper around deck.gl's LightingEffect. The original
- * deck.gl 8 version patched the shadow shader module with custom GLSL,
- * but that approach doesn't work with deck.gl 9's UBO-based shadow module.
- *
- * We override getShaderModuleProps to always include dummyShadowMap in
- * the shadow props, even when shadows are disabled. This prevents "Bad
- * texture binding" errors: the shadow module's createShadowUniforms needs
- * a valid texture for shadow_uShadowMap0/1 bindings, and without
- * dummyShadowMap it would set them to undefined.
+ * Extends deck.gl's LightingEffect with:
+ * - A patched shadow module with `outputUniformShadow` for uniform shadow
+ *   during nighttime (avoids partial shadows from below).
+ * - getShaderModuleProps override that always provides dummyShadowMap
+ *   to prevent "Bad texture binding" errors when shadows are disabled.
  */
 class CustomDeckLightingEffect extends LightingEffect {
-  useOutputUniformShadow: boolean;
+  outputUniformShadow: boolean;
 
   constructor(props) {
     super(props);
-    this.useOutputUniformShadow = false;
+    this.outputUniformShadow = false;
+  }
+
+  setup(context) {
+    this.context = context;
+    const {device, deck} = context;
+    if (this.shadow && !this.dummyShadowMap) {
+      this._createShadowPasses(device);
+      deck._addDefaultShaderModule(CustomShadowModule || shadow);
+      this.dummyShadowMap = device.createTexture({width: 1, height: 1});
+    }
+  }
+
+  cleanup(context) {
+    for (const shadowPass of this.shadowPasses) {
+      shadowPass.delete();
+    }
+    this.shadowPasses.length = 0;
+    if (this.dummyShadowMap) {
+      this.dummyShadowMap.destroy();
+      this.dummyShadowMap = null;
+      context.deck._removeDefaultShaderModule(CustomShadowModule || shadow);
+    }
   }
 
   getShaderModuleProps(layer, otherShaderModuleProps) {
     const props = super.getShaderModuleProps(layer, otherShaderModuleProps);
 
-    // When shadow is disabled, the parent returns shadow: {} without
-    // dummyShadowMap. The shadow module's getUniforms then sets
-    // shadow_uShadowMap0/1 to undefined, causing texture binding errors.
-    // Always provide the dummy texture so bindings remain valid.
+    // Always provide dummyShadowMap so texture bindings are never undefined.
+    // Prevents "Bad texture binding" errors in composite layer sublayers
+    // when shadows are disabled.
     if (props.shadow && !props.shadow.dummyShadowMap && this.dummyShadowMap) {
       props.shadow.dummyShadowMap = this.dummyShadowMap;
     }
 
+    // Pass outputUniformShadow through to the custom shadow module
+    if (props.shadow) {
+      props.shadow.outputUniformShadow = this.outputUniformShadow;
+    }
+
     return props;
   }
 }

src/utils/src/effect-utils.ts

@@ -98,6 +98,7 @@ function disableLightingEffect(effect: Effect) {
   const deckEffect = effect.deckEffect;
   if (!deckEffect) return;
   deckEffect.shadow = false;
+  deckEffect.outputUniformShadow = false;
   for (const light of deckEffect.directionalLights || []) {
     light.shadow = false;
   }