address comments

modules/aggregation-layers/src/common/aggregation-layer.ts

@@ -86,12 +86,12 @@ export default abstract class AggregationLayer<
     aggregator.update();
   }
 
-  draw({moduleParameters}) {
+  draw({shaderModuleProps}) {
     // GPU aggregation needs `moduleSettings` for projection/filter uniforms which are only accessible at draw time
     // GPUAggregator's Buffers are pre-allocated during `update()` and passed down to the sublayer attributes in renderLayers()
     // Although the Buffers have been bound to the sublayer's Model, their content are not populated yet
     // GPUAggregator.preDraw() is called in the draw cycle here right before Buffers are used by sublayer.draw()
-    this.state.aggregator.preDraw({moduleSettings: moduleParameters});
+    this.state.aggregator.preDraw({moduleSettings: shaderModuleProps});
   }
 
   // override CompositeLayer._getAttributeManager to create AttributeManager instance

modules/aggregation-layers/src/contour-layer/contour-layer.ts

@@ -286,8 +286,8 @@ export default class GridLayer<DataT = any, ExtraPropsT extends {} = {}> extends
 
   override draw(opts) {
     // Replaces render time viewport with our own
-    if (opts.moduleParameters.project) {
-      opts.moduleParameters.project.viewport = this.state.aggregatorViewport;
+    if (opts.shaderModuleProps.project) {
+      opts.shaderModuleProps.project.viewport = this.state.aggregatorViewport;
     }
     super.draw(opts);
   }

modules/aggregation-layers/src/grid-layer/grid-layer.ts

@@ -489,8 +489,8 @@ export default class GridLayer<DataT = any, ExtraPropsT extends {} = {}> extends
 
   override draw(opts) {
     // Replaces render time viewport with our own
-    if (opts.moduleParameters.project) {
-      opts.moduleParameters.project.viewport = this.state.aggregatorViewport;
+    if (opts.shaderModuleProps.project) {
+      opts.shaderModuleProps.project.viewport = this.state.aggregatorViewport;
     }
     super.draw(opts);
   }

modules/aggregation-layers/src/heatmap-layer/aggregation-layer.ts

@@ -68,7 +68,7 @@ export default abstract class AggregationLayer<
   getModuleSettings() {
     // For regular layer draw this happens during draw cycle (_drawLayersInViewport) not during update cycle
     // For aggregation layers this is called during updateState to update aggregation data
-    // NOTE: it is similar to LayerPass._getModuleParameters() but doesn't inlcude `effects` it is not needed for aggregation
+    // NOTE: it is similar to LayerPass._getShaderModuleProps() but doesn't inlcude `effects` it is not needed for aggregation
     const {viewport, mousePosition, device} = this.context;
     const moduleSettings = Object.assign(Object.create(this.props), {
       viewport,

modules/aggregation-layers/src/hexagon-layer/hexagon-layer.ts

@@ -488,8 +488,8 @@ export default class HexagonLayer<
 
   override draw(opts) {
     // Replaces render time viewport with our own
-    if (opts.moduleParameters.project) {
-      opts.moduleParameters.project.viewport = this.state.aggregatorViewport;
+    if (opts.shaderModuleProps.project) {
+      opts.shaderModuleProps.project.viewport = this.state.aggregatorViewport;
     }
     super.draw(opts);
   }

modules/carto/src/layers/post-process-utils.ts

@@ -68,8 +68,8 @@ export function RTTModifier(BaseLayer) {
     static layerName = `RTT-${BaseLayer.layerName}`;
 
     draw(this: RTTLayer, opts: any) {
-      const {moduleParameters} = opts;
-      const {picking} = moduleParameters;
+      const {shaderModuleProps} = opts;
+      const {picking} = shaderModuleProps;
       const postProcessLayer = getPostProcessLayer(this);
 
       if (!picking.isActive) {
@@ -134,9 +134,9 @@ export function PostProcessModifier<T extends Constructor<DrawableCompositeLayer
 
     _resizeBuffers(this: PostProcessLayer, opts: any) {
       // TODO we could likely render to a smaller buffer for better perf
-      const {moduleParameters} = opts;
+      const {shaderModuleProps} = opts;
       const {viewport} = this.context;
-      const {devicePixelRatio} = moduleParameters.project;
+      const {devicePixelRatio} = shaderModuleProps.project;
       const width = devicePixelRatio * viewport.width;
       const height = devicePixelRatio * viewport.height;
       this.internalState.renderBuffers.forEach((fbo: Framebuffer) => fbo.resize({width, height}));

modules/core/src/effects/lighting/lighting-effect.ts

@@ -11,9 +11,10 @@ import {Matrix4, Vector3} from '@math.gl/core';
 import ShadowPass from '../../passes/shadow-pass';
 import shadow from '../../shaderlib/shadow/shadow';
 
+import type {LightingProps} from '@luma.gl/shadertools';
+import type {ShadowModuleProps} from '../../shaderlib/shadow/shadow';
 import type Layer from '../../lib/layer';
 import type {Effect, EffectContext, PreRenderOptions} from '../../lib/effect';
-import type Viewport from '../../viewports/viewport';
 
 const DEFAULT_AMBIENT_LIGHT_PROPS = {
   color: [255, 255, 255] as [number, number, number],
@@ -117,7 +118,7 @@ export default class LightingEffect implements Effect {
         viewports,
         onViewportActive,
         views,
-        moduleParameters: {
+        shaderModuleProps: {
           shadow: {
             shadowLightId: i,
             dummyShadowMap: this.dummyShadowMap,
@@ -128,26 +129,20 @@ export default class LightingEffect implements Effect {
     }
   }
 
-  getModuleParameters(layer: Layer) {
-    const shadowProps: {
-      viewport?: Viewport;
-      shadowMaps?: Texture[];
-      dummyShadowMap?: Texture | null;
-      shadowColor?: [number, number, number, number];
-      shadowMatrices?: Matrix4[];
-    } = this.shadow
-      ? {
-          viewport: layer.context.viewport,
+  getShaderModuleProps(layer: Layer, otherShaderModuleProps: Record<string, any>) {
+    const shadowProps = this.shadow
+      ? ({
+          project: otherShaderModuleProps.project,
           shadowMaps: this.shadowPasses.map(shadowPass => shadowPass.getShadowMap()),
-          dummyShadowMap: this.dummyShadowMap,
+          dummyShadowMap: this.dummyShadowMap!,
           shadowColor: this.shadowColor,
           shadowMatrices: this.shadowMatrices
-        }
+        } satisfies ShadowModuleProps)
       : {};
 
     // when not rendering to screen, turn off lighting by adding empty light source object
     // lights shader module relies on the `lightSources` to turn on/off lighting
-    const lightingProps = {
+    const lightingProps: LightingProps = {
       enabled: true,
       ambientLight: this.ambientLight,
       directionalLights: this.directionalLights.map(directionalLight =>

modules/core/src/index.ts

@@ -125,7 +125,7 @@ export type {PickingInfo, GetPickingInfoParams} from './lib/picking/pick-info';
 export type {ConstructorOf as _ConstructorOf} from './types/types';
 export type {BinaryAttribute} from './lib/attribute/attribute';
 export type {Effect, EffectContext, PreRenderOptions, PostRenderOptions} from './lib/effect';
-export type {PickingUniforms, ProjectUniforms} from './shaderlib/index';
+export type {PickingUniforms, ProjectProps, ProjectUniforms} from './shaderlib/index';
 export type {DefaultProps} from './lifecycle/prop-types';
 export type {LayersPassRenderOptions} from './passes/layers-pass';
 export type {Widget, WidgetPlacement} from './lib/widget-manager';

modules/core/src/lib/effect.ts

@@ -32,7 +32,7 @@ export interface Effect {
   /** Called after layers are rendered to screen */
   postRender?(opts: PostRenderOptions): Framebuffer | null;
   /** Module settings passed to models */
-  getModuleParameters?(layer: Layer): any;
+  getShaderModuleProps?(layer: Layer, otherShaderModuleProps: Record<string, any>): any;
 
   // / Lifecycle methods
   /** Called when this effect is added */

modules/core/src/lib/layer.ts

@@ -321,15 +321,6 @@ export default abstract class Layer<PropsT extends {} = {}> extends Component<
     return (state && (state.models || (state.model && [state.model]))) || [];
   }
 
-  // TODO deprecate in favour of setShaderModuleProps
-  /** Update shader module parameters */
-  setModuleParameters(moduleParameters: any): void {
-    for (const model of this.getModels()) {
-      // HACK as fp64 is not yet ported to UBO
-      model.uniforms = {ONE: 1};
-    }
-  }
-
   /** Update shader input parameters */
   setShaderModuleProps(...props: Parameters<Model['shaderInputs']['setProps']>): void {
     for (const model of this.getModels()) {
@@ -1035,12 +1026,12 @@ export default abstract class Layer<PropsT extends {} = {}> extends Component<
   // Calculates uniforms
   _drawLayer({
     renderPass,
-    moduleParameters = null,
+    shaderModuleProps = null,
     uniforms = {},
     parameters = {}
   }: {
     renderPass: RenderPass;
-    moduleParameters: any;
+    shaderModuleProps: any;
     uniforms: any;
     parameters: any;
   }): void {
@@ -1055,9 +1046,8 @@ export default abstract class Layer<PropsT extends {} = {}> extends Component<
 
     try {
       // TODO/ib - hack move to luma Model.draw
-      if (moduleParameters) {
-        this.setModuleParameters({});
-        this.setShaderModuleProps(moduleParameters);
+      if (shaderModuleProps) {
+        this.setShaderModuleProps(shaderModuleProps);
       }
 
       // Apply polygon offset to avoid z-fighting
@@ -1076,7 +1066,7 @@ export default abstract class Layer<PropsT extends {} = {}> extends Component<
       // Call subclass lifecycle method
       if (context.device instanceof WebGLDevice) {
         context.device.withParametersWebGL(parameters, () => {
-          const opts = {renderPass, moduleParameters, uniforms, parameters, context};
+          const opts = {renderPass, shaderModuleProps, uniforms, parameters, context};
 
           // extensions
           for (const extension of this.props.extensions) {
@@ -1086,7 +1076,7 @@ export default abstract class Layer<PropsT extends {} = {}> extends Component<
           this.draw(opts);
         });
       } else {
-        const opts = {renderPass, moduleParameters, uniforms, parameters, context};
+        const opts = {renderPass, shaderModuleProps, uniforms, parameters, context};
 
         // extensions
         for (const extension of this.props.extensions) {

modules/core/src/passes/layers-pass.ts

@@ -33,15 +33,15 @@ export type LayersPassRenderOptions = {
   colorMask?: number;
   scissorRect?: number[];
   layerFilter?: ((context: FilterContext) => boolean) | null;
-  moduleParameters?: any;
+  shaderModuleProps?: any;
   /** Stores returned results from Effect.preRender, for use downstream in the render pipeline */
   preRenderStats?: Record<string, any>;
 };
 
 type DrawLayerParameters = {
   shouldDrawLayer: boolean;
   layerRenderIndex?: number;
-  moduleParameters?: any;
+  shaderModuleProps?: any;
   layerParameters?: any;
 };
 
@@ -102,7 +102,7 @@ export default class LayersPass extends Pass {
   private _drawLayers(renderPass: RenderPass, options: LayersPassRenderOptions) {
     const {
       target,
-      moduleParameters,
+      shaderModuleProps,
       viewports,
       views,
       onViewportActive,
@@ -131,7 +131,7 @@ export default class LayersPass extends Pass {
           renderPass,
           {
             target,
-            moduleParameters,
+            shaderModuleProps,
             viewport: subViewport,
             view,
             pass: options.pass,
@@ -157,7 +157,7 @@ export default class LayersPass extends Pass {
       layerFilter,
       cullRect,
       effects,
-      moduleParameters
+      shaderModuleProps
     }: LayersPassRenderOptions,
     /** Internal flag, true if only used to determine whether each layer should be drawn */
     evaluateShouldDrawOnly: boolean = false
@@ -192,11 +192,11 @@ export default class LayersPass extends Pass {
         // It can be the same as another layer
         layerParam.layerRenderIndex = indexResolver(layer, shouldDrawLayer);
 
-        layerParam.moduleParameters = this._getModuleParameters(
+        layerParam.shaderModuleProps = this._getShaderModuleProps(
           layer,
           effects,
           pass,
-          moduleParameters
+          shaderModuleProps
         );
         layerParam.layerParameters = {
           ...layer.context.deck?.props.parameters,
@@ -214,11 +214,11 @@ export default class LayersPass extends Pass {
   /* eslint-disable max-depth, max-statements */
   private _drawLayersInViewport(
     renderPass: RenderPass,
-    {layers, moduleParameters: globalModuleParameters, pass, target, viewport, view},
+    {layers, shaderModuleProps: globalModuleParameters, pass, target, viewport, view},
     drawLayerParams
   ): RenderStats {
     const glViewport = getGLViewport(this.device, {
-      moduleParameters: globalModuleParameters,
+      shaderModuleProps: globalModuleParameters,
       target,
       viewport
     });
@@ -248,7 +248,7 @@ export default class LayersPass extends Pass {
     // render layers in normal colors
     for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {
       const layer = layers[layerIndex] as Layer;
-      const {shouldDrawLayer, layerRenderIndex, moduleParameters, layerParameters} =
+      const {shouldDrawLayer, layerRenderIndex, shaderModuleProps, layerParameters} =
         drawLayerParams[layerIndex];
 
       // Calculate stats
@@ -265,11 +265,8 @@ export default class LayersPass extends Pass {
         this._lastRenderIndex = Math.max(this._lastRenderIndex, layerRenderIndex);
 
         // overwrite layer.context.viewport with the sub viewport
-        for (const moduleName in moduleParameters) {
-          const moduleProps = moduleParameters[moduleName];
-          if (moduleProps && typeof moduleProps === 'object' && 'viewport' in moduleProps) {
-            moduleProps.viewport = viewport;
-          }
+        if (shaderModuleProps.project) {
+          shaderModuleProps.project.viewport = viewport;
         }
 
         // TODO v9 - we are sending renderPass both as a parameter and through the context.
@@ -280,7 +277,7 @@ export default class LayersPass extends Pass {
         try {
           layer._drawLayer({
             renderPass,
-            moduleParameters,
+            shaderModuleProps,
             uniforms: {layerIndex: layerRenderIndex},
             parameters: layerParameters
           });
@@ -299,7 +296,11 @@ export default class LayersPass extends Pass {
     return true;
   }
 
-  protected getModuleParameters(layer: Layer, effects?: Effect[]): any {
+  protected getShaderModuleProps(
+    layer: Layer,
+    effects: Effect[] | undefined,
+    otherShaderModuleProps: Record<string, any>
+  ): any {
     return null;
   }
 
@@ -348,7 +349,7 @@ export default class LayersPass extends Pass {
     return true;
   }
 
-  private _getModuleParameters(
+  private _getShaderModuleProps(
     layer: Layer,
     effects: Effect[] | undefined,
     pass: string,
@@ -358,7 +359,7 @@ export default class LayersPass extends Pass {
     const devicePixelRatio = this.device.canvasContext.cssToDeviceRatio();
     const layerProps = layer.internalState?.propsInTransition || layer.props;
 
-    const moduleParameters = {
+    const shaderModuleProps = {
       layer: layerProps,
       picking: {
         isActive: false
@@ -375,13 +376,16 @@ export default class LayersPass extends Pass {
 
     if (effects) {
       for (const effect of effects) {
-        mergeModuleParameters(moduleParameters, effect.getModuleParameters?.(layer));
+        mergeModuleParameters(
+          shaderModuleProps,
+          effect.getShaderModuleProps?.(layer, shaderModuleProps)
+        );
       }
     }
 
     return mergeModuleParameters(
-      moduleParameters,
-      this.getModuleParameters(layer, effects),
+      shaderModuleProps,
+      this.getShaderModuleProps(layer, effects, shaderModuleProps),
       overrides
     );
   }
@@ -439,17 +443,17 @@ export function layerIndexResolver(
 function getGLViewport(
   device: Device,
   {
-    moduleParameters,
+    shaderModuleProps,
     target,
     viewport
   }: {
-    moduleParameters: any;
+    shaderModuleProps: any;
     target?: Framebuffer;
     viewport: Viewport;
   }
 ): [number, number, number, number] {
   const pixelRatio =
-    moduleParameters?.project?.devicePixelRatio ??
+    shaderModuleProps?.project?.devicePixelRatio ??
     // @ts-expect-error TODO - assuming WebGL context
     device.canvasContext.cssToDeviceRatio();