@deck.gl/extensions 9.0.35 → 9.1.0-beta.1

package/src/fill-style/shader-module.ts

@@ -1,32 +1,43 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import type {ShaderModule} from '@luma.gl/shadertools';
 import {project, fp64LowPart} from '@deck.gl/core';
-import type {Viewport, ProjectUniforms} from '@deck.gl/core';
+import type {ProjectProps, ProjectUniforms} from '@deck.gl/core';
 
 import type {Texture} from '@luma.gl/core';
-import {glsl} from '../utils/syntax-tags';
+
+const uniformBlock = /* glsl */ `\
+uniform fillUniforms {
+  vec2 patternTextureSize;
+  bool patternEnabled;
+  bool patternMask;
+  vec2 uvCoordinateOrigin;
+  vec2 uvCoordinateOrigin64Low;
+} fill;
+`;
 
 /*
  * fill pattern shader module
  */
-const patternVs = glsl`
+const patternVs = /* glsl */ `
 in vec4 fillPatternFrames;
 in float fillPatternScales;
 in vec2 fillPatternOffsets;
 
-uniform bool fill_patternEnabled;
-uniform vec2 fill_patternTextureSize;
-
 out vec2 fill_uv;
 out vec4 fill_patternBounds;
 out vec4 fill_patternPlacement;
 `;
 
-const patternFs = glsl`
-uniform bool fill_patternEnabled;
-uniform bool fill_patternMask;
+const vs = `
+${uniformBlock}
+${patternVs}
+`;
+
+const patternFs = /* glsl */ `
 uniform sampler2D fill_patternTexture;
-uniform vec2 fill_uvCoordinateOrigin;
-uniform vec2 fill_uvCoordinateOrigin64Low;
 
 in vec4 fill_patternBounds;
 in vec4 fill_patternPlacement;
@@ -35,86 +46,107 @@ in vec2 fill_uv;
 const float FILL_UV_SCALE = 512.0 / 40000000.0;
 `;
 
+const fs = `
+${uniformBlock}
+${patternFs}
+`;
+
 const inject = {
-  'vs:DECKGL_FILTER_GL_POSITION': glsl`
+  'vs:DECKGL_FILTER_GL_POSITION': /* glsl */ `
     fill_uv = geometry.position.xy;
   `,
 
-  'vs:DECKGL_FILTER_COLOR': glsl`
-    if (fill_patternEnabled) {
-      fill_patternBounds = fillPatternFrames / vec4(fill_patternTextureSize, fill_patternTextureSize);
+  'vs:DECKGL_FILTER_COLOR': /* glsl */ `
+    if (fill.patternEnabled) {
+      fill_patternBounds = fillPatternFrames / vec4(fill.patternTextureSize, fill.patternTextureSize);
       fill_patternPlacement.xy = fillPatternOffsets;
       fill_patternPlacement.zw = fillPatternScales * fillPatternFrames.zw;
     }
   `,
 
-  'fs:DECKGL_FILTER_COLOR': glsl`
-    if (fill_patternEnabled) {
+  'fs:DECKGL_FILTER_COLOR': /* glsl */ `
+    if (fill.patternEnabled) {
       vec2 scale = FILL_UV_SCALE * fill_patternPlacement.zw;
-      vec2 patternUV = mod(mod(fill_uvCoordinateOrigin, scale) + fill_uvCoordinateOrigin64Low + fill_uv, scale) / scale;
+      vec2 patternUV = mod(mod(fill.uvCoordinateOrigin, scale) + fill.uvCoordinateOrigin64Low + fill_uv, scale) / scale;
       patternUV = mod(fill_patternPlacement.xy + patternUV, 1.0);
 
       vec2 texCoords = fill_patternBounds.xy + fill_patternBounds.zw * patternUV;
 
       vec4 patternColor = texture(fill_patternTexture, texCoords);
       color.a *= patternColor.a;
-      if (!fill_patternMask) {
+      if (!fill.patternMask) {
         color.rgb = patternColor.rgb;
       }
     }
   `
 };
 
-type FillStyleModuleSettings =
-  | {
-      viewport: Viewport;
-      fillPatternEnabled?: boolean;
-      fillPatternMask?: boolean;
-    }
-  | {
-      fillPatternTexture: Texture;
-    };
+export type FillStyleModuleProps = {
+  project: ProjectProps;
+  fillPatternEnabled?: boolean;
+  fillPatternMask?: boolean;
+  fillPatternTexture: Texture;
+};
+
+type FillStyleModuleUniforms = {
+  patternTextureSize?: [number, number];
+  patternEnabled?: boolean;
+  patternMask?: boolean;
+  uvCoordinateOrigin?: [number, number];
+  uvCoordinateOrigin64Low?: [number, number];
+};
+
+type FillStyleModuleBindings = {
+  fill_patternTexture?: Texture;
+};
 
 /* eslint-disable camelcase */
 function getPatternUniforms(
-  opts: FillStyleModuleSettings | {},
-  uniforms: Record<string, any>
-): Record<string, any> {
+  opts?: FillStyleModuleProps | {}
+): FillStyleModuleBindings & FillStyleModuleUniforms {
   if (!opts) {
     return {};
   }
+  const uniforms: FillStyleModuleBindings & FillStyleModuleUniforms = {};
   if ('fillPatternTexture' in opts) {
     const {fillPatternTexture} = opts;
-    return {
-      fill_patternTexture: fillPatternTexture,
-      fill_patternTextureSize: [fillPatternTexture.width, fillPatternTexture.height]
-    };
+    uniforms.fill_patternTexture = fillPatternTexture;
+    uniforms.patternTextureSize = [fillPatternTexture.width, fillPatternTexture.height];
   }
-  if ('viewport' in opts) {
+  if ('project' in opts) {
     const {fillPatternMask = true, fillPatternEnabled = true} = opts;
-    const {project_uCommonOrigin: coordinateOriginCommon} = uniforms as ProjectUniforms;
+    const projectUniforms = project.getUniforms(opts.project) as ProjectUniforms;
+    const {commonOrigin: coordinateOriginCommon} = projectUniforms;
 
-    const coordinateOriginCommon64Low = [
+    const coordinateOriginCommon64Low: [number, number] = [
       fp64LowPart(coordinateOriginCommon[0]),
       fp64LowPart(coordinateOriginCommon[1])
     ];
 
-    return {
-      fill_uvCoordinateOrigin: coordinateOriginCommon.slice(0, 2),
-      fill_uvCoordinateOrigin64Low: coordinateOriginCommon64Low,
-      fill_patternMask: fillPatternMask,
-      fill_patternEnabled: fillPatternEnabled
-    };
+    uniforms.uvCoordinateOrigin = coordinateOriginCommon.slice(0, 2) as [number, number];
+    uniforms.uvCoordinateOrigin64Low = coordinateOriginCommon64Low;
+    uniforms.patternMask = fillPatternMask;
+    uniforms.patternEnabled = fillPatternEnabled;
   }
-  return {};
+  return uniforms;
 }
 
-export const patternShaders: ShaderModule<FillStyleModuleSettings> = {
-  name: 'fill-pattern',
-  vs: patternVs,
-  fs: patternFs,
+export const patternShaders = {
+  name: 'fill',
+  vs,
+  fs,
   inject,
   dependencies: [project],
-  // @ts-expect-error stricter luma gl types
-  getUniforms: getPatternUniforms
-};
+  getUniforms: getPatternUniforms,
+  uniformTypes: {
+    patternTextureSize: 'vec2<f32>',
+    patternEnabled: 'i32',
+    patternMask: 'i32',
+    uvCoordinateOrigin: 'vec2<f32>',
+    uvCoordinateOrigin64Low: 'vec2<f32>'
+  }
+} as const satisfies ShaderModule<
+  FillStyleModuleProps,
+  FillStyleModuleUniforms,
+  FillStyleModuleBindings
+>;

package/src/fp64/fp64-extension.ts

@@ -1,22 +1,6 @@
-// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 
 import {LayerExtension, COORDINATE_SYSTEM} from '@deck.gl/core';
 import project64 from './project64';
@@ -40,4 +24,9 @@ export default class Fp64Extension extends LayerExtension {
       modules: [project64]
     };
   }
+
+  draw(this: Layer, params: any, extension: this): void {
+    const {viewport} = params.context;
+    this.setShaderModuleProps({project64: {viewport}});
+  }
 }

package/src/fp64/project64.glsl.ts

@@ -1,28 +1,16 @@
-// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 
 export default `\
 
 const vec2 WORLD_SCALE_FP64 = vec2(81.4873275756836, 0.0000032873668232014097);
 
-uniform vec2 project_uViewProjectionMatrixFP64[16];
+uniform project64Uniforms {
+  vec2 scale;
+  mat4 viewProjectionMatrix;
+  mat4 viewProjectionMatrix64Low;
+} project64;
 
 // longitude: lnglat_fp64.xy; latitude: lnglat_fp64.zw
 void mercatorProject_fp64(vec4 lnglat_fp64, out vec2 out_val[2]) {
@@ -56,7 +44,16 @@ void project_position_fp64(vec2 position, vec2 position64xyLow, out vec2 out_val
 
 vec4 project_common_position_to_clipspace_fp64(vec2 vertex_pos_modelspace[4]) {
   vec2 vertex_pos_clipspace[4];
-  mat4_vec4_mul_fp64(project_uViewProjectionMatrixFP64, vertex_pos_modelspace,
+  vec2 viewProjectionMatrixFP64[16];
+  for (int i = 0; i < 4; i++) {
+    for (int j = 0; j < 4; j++) {
+      viewProjectionMatrixFP64[4 * i + j] = vec2(
+        project64.viewProjectionMatrix[j][i],
+        project64.viewProjectionMatrix64Low[j][i]
+      );
+    }   
+  }
+  mat4_vec4_mul_fp64(viewProjectionMatrixFP64, vertex_pos_modelspace,
     vertex_pos_clipspace);
   return vec4(
     vertex_pos_clipspace[0].x,

package/src/fp64/project64.ts

@@ -1,22 +1,6 @@
-// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 
 /* eslint-disable camelcase */
 import {fp64} from '@luma.gl/shadertools';
@@ -27,7 +11,7 @@ import {project, _memoize as memoize} from '@deck.gl/core';
 import type {Viewport} from '@deck.gl/core';
 import project64Shader from './project64.glsl';
 
-type Project64ModuleSettings = {
+type Project64ModuleProps = {
   viewport: Viewport;
 };
 
@@ -35,15 +19,21 @@ export default {
   name: 'project64',
   dependencies: [project, fp64],
   vs: project64Shader,
-  getUniforms
-} as ShaderModule<Project64ModuleSettings>;
+  getUniforms,
+  uniformTypes: {
+    scale: 'vec2<f32>',
+    // Cannot pass as vec2[16], so instead split into 2 mat4x4
+    viewProjectionMatrix: 'mat4x4<f32>',
+    viewProjectionMatrix64Low: 'mat4x4<f32>'
+  }
+} as ShaderModule<Project64ModuleProps>;
 
 // TODO - this module should calculate the 64 bit uniforms
 // It is currently done by project to minimize duplicated work
 
 const getMemoizedUniforms = memoize(calculateUniforms);
 
-function getUniforms(opts?: Project64ModuleSettings | {}): Record<string, any> {
+function getUniforms(opts?: Project64ModuleProps | {}): Record<string, any> {
   if (opts && 'viewport' in opts) {
     const {viewProjectionMatrix, scale} = opts.viewport;
     // We only need to update fp64 uniforms if fp32 projection is being updated
@@ -60,11 +50,20 @@ function calculateUniforms({
   scale: number;
 }) {
   const glViewProjectionMatrixFP64 = fp64ifyMatrix4(viewProjectionMatrix);
-  const scaleFP64 = fp64ify(scale);
-
+  const viewProjectionMatrix64High = new Float32Array(16);
+  const viewProjectionMatrix64Low = new Float32Array(16);
+  for (let i = 0; i < 4; i++) {
+    for (let j = 0; j < 4; j++) {
+      // Match order used in project.viewProjectionMatrix
+      const from = 4 * i + j;
+      const to = 4 * j + i;
+      viewProjectionMatrix64High[to] = glViewProjectionMatrixFP64[2 * from];
+      viewProjectionMatrix64Low[to] = glViewProjectionMatrixFP64[2 * from + 1];
+    }
+  }
   return {
-    project_uViewProjectionMatrixFP64: glViewProjectionMatrixFP64,
-    project64_uViewProjectionMatrix: glViewProjectionMatrixFP64,
-    project64_uScale: scaleFP64
+    scale: fp64ify(scale),
+    viewProjectionMatrix: [...viewProjectionMatrix64High],
+    viewProjectionMatrix64Low: [...viewProjectionMatrix64Low]
   };
 }

package/src/index.ts

@@ -1,3 +1,7 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 export {default as BrushingExtension} from './brushing/brushing-extension';
 export {default as DataFilterExtension} from './data-filter/data-filter-extension';
 export {default as Fp64Extension} from './fp64/fp64-extension';
@@ -29,3 +33,4 @@ export type {ClipExtensionProps} from './clip/clip-extension';
 export type {CollisionFilterExtensionProps} from './collision-filter/collision-filter-extension';
 export type {MaskExtensionProps} from './mask/mask-extension';
 export type {TerrainExtensionProps} from './terrain/terrain-extension';
+export type {TerrainModuleProps} from './terrain/shader-module';

package/src/mask/mask-effect.ts

@@ -1,3 +1,7 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {
   Layer,
   Viewport,
@@ -186,8 +190,10 @@ export default class MaskEffect implements Effect {
           viewports: maskViewport ? [maskViewport] : [],
           onViewportActive,
           views,
-          moduleParameters: {
-            devicePixelRatio: 1
+          shaderModuleProps: {
+            project: {
+              devicePixelRatio: 1
+            }
           }
         });
 
@@ -257,13 +263,17 @@ export default class MaskEffect implements Effect {
     return channelMap;
   }
 
-  getModuleParameters(): {
-    maskMap: Texture;
-    maskChannels: Record<string, Mask> | null;
+  getShaderModuleProps(): {
+    mask: {
+      maskMap: Texture;
+      maskChannels: Record<string, Mask> | null;
+    };
   } {
     return {
-      maskMap: this.masks ? this.maskMap! : this.dummyMaskMap!,
-      maskChannels: this.masks
+      mask: {
+        maskMap: this.masks ? this.maskMap! : this.dummyMaskMap!,
+        maskChannels: this.masks
+      }
     };
   }
 

package/src/mask/mask-extension.ts

@@ -1,5 +1,9 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {COORDINATE_SYSTEM, Layer, LayerExtension, log} from '@deck.gl/core';
-import mask from './shader-module';
+import mask, {MaskProps} from './shader-module';
 import MaskEffect from './mask-effect';
 
 const defaultProps = {
@@ -49,17 +53,18 @@ export default class MaskExtension extends LayerExtension {
   }
 
   /* eslint-disable camelcase */
-  draw(this: Layer<Required<MaskExtensionProps>>, {uniforms, context, moduleParameters}: any) {
-    uniforms.mask_maskByInstance = this.state.maskByInstance;
+  draw(this: Layer<Required<MaskExtensionProps>>, {context, shaderModuleProps}: any) {
+    const maskProps = {} as MaskProps;
+    maskProps.maskByInstance = Boolean(this.state.maskByInstance);
     const {maskId, maskInverted} = this.props;
-    const {maskChannels} = moduleParameters;
+    const {maskChannels} = shaderModuleProps.mask || {};
     const {viewport} = context;
     if (maskChannels && maskChannels[maskId]) {
       const {index, bounds, coordinateOrigin: fromCoordinateOrigin} = maskChannels[maskId];
       let {coordinateSystem: fromCoordinateSystem} = maskChannels[maskId];
-      uniforms.mask_enabled = true;
-      uniforms.mask_channel = index;
-      uniforms.mask_inverted = maskInverted;
+      maskProps.enabled = true;
+      maskProps.channel = index;
+      maskProps.inverted = maskInverted;
 
       if (fromCoordinateSystem === COORDINATE_SYSTEM.DEFAULT) {
         fromCoordinateSystem = viewport.isGeospatial
@@ -69,12 +74,14 @@ export default class MaskExtension extends LayerExtension {
       const opts = {modelMatrix: null, fromCoordinateOrigin, fromCoordinateSystem};
       const bl = this.projectPosition([bounds[0], bounds[1], 0], opts);
       const tr = this.projectPosition([bounds[2], bounds[3], 0], opts);
-      uniforms.mask_bounds = [bl[0], bl[1], tr[0], tr[1]];
+      maskProps.bounds = [bl[0], bl[1], tr[0], tr[1]];
     } else {
       if (maskId) {
         log.warn(`Could not find a mask layer with id: ${maskId}`)();
       }
-      uniforms.mask_enabled = false;
+      maskProps.enabled = false;
     }
+
+    this.setShaderModuleProps({mask: maskProps});
   }
 }

package/src/mask/mask-pass.ts

@@ -1,3 +1,7 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import type {Device, Framebuffer, RenderPipelineParameters, Texture} from '@luma.gl/core';
 import {Layer, _LayersPass as LayersPass, LayersPassRenderOptions, Viewport} from '@deck.gl/core';
 

package/src/mask/shader-module.ts

@@ -1,38 +1,52 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import type {ShaderModule} from '@luma.gl/shadertools';
 import {project} from '@deck.gl/core';
 import type {Texture} from '@luma.gl/core';
-import {glsl} from '../utils/syntax-tags';
 
-const vs = glsl`
-uniform vec4 mask_bounds;
-uniform bool mask_maskByInstance;
+const uniformBlock = /* glsl */ `\
+uniform maskUniforms {
+  vec4 bounds;
+  highp int channel;
+  bool enabled;
+  bool inverted;
+  bool maskByInstance;
+} mask;
+`;
+
+const vertex = /* glsl */ `
 vec2 mask_getCoords(vec4 position) {
-  return (position.xy - mask_bounds.xy) / (mask_bounds.zw - mask_bounds.xy);
+  return (position.xy - mask.bounds.xy) / (mask.bounds.zw - mask.bounds.xy);
 }
 `;
 
-const fs = glsl`
+const vs = `
+${uniformBlock}
+${vertex}
+`;
+
+const fragment = /* glsl */ `
 uniform sampler2D mask_texture;
-uniform int mask_channel;
-uniform bool mask_enabled;
-uniform bool mask_inverted;
+
 bool mask_isInBounds(vec2 texCoords) {
-  if (!mask_enabled) {
+  if (!mask.enabled) {
     return true;
   }
   vec4 maskColor = texture(mask_texture, texCoords);
   float maskValue = 1.0;
-  if (mask_channel == 0) {
+  if (mask.channel == 0) {
     maskValue = maskColor.r;
-  } else if (mask_channel == 1) {
+  } else if (mask.channel == 1) {
     maskValue = maskColor.g;
-  } else if (mask_channel == 2) {
+  } else if (mask.channel == 2) {
     maskValue = maskColor.b;
-  } else if (mask_channel == 3) {
+  } else if (mask.channel == 3) {
     maskValue = maskColor.a;
   }
 
-  if (mask_inverted) {
+  if (mask.inverted) {
     return maskValue >= 0.5;
   } else {
     return maskValue < 0.5;
@@ -40,47 +54,62 @@ bool mask_isInBounds(vec2 texCoords) {
 }
 `;
 
+const fs = `
+${uniformBlock}
+${fragment}
+`;
+
 const inject = {
-  'vs:#decl': glsl`
+  'vs:#decl': /* glsl */ `
 out vec2 mask_texCoords;
 `,
-  'vs:#main-end': glsl`
+  'vs:#main-end': /* glsl */ `
    vec4 mask_common_position;
-   if (mask_maskByInstance) {
+   if (mask.maskByInstance) {
      mask_common_position = project_position(vec4(geometry.worldPosition, 1.0));
    } else {
      mask_common_position = geometry.position;
    }
    mask_texCoords = mask_getCoords(mask_common_position);
 `,
-  'fs:#decl': glsl`
+  'fs:#decl': /* glsl */ `
 in vec2 mask_texCoords;
 `,
-  'fs:#main-start': glsl`
-  if (mask_enabled) {
+  'fs:#main-start': /* glsl */ `
+  if (mask.enabled) {
     bool mask = mask_isInBounds(mask_texCoords);
 
     // Debug: show extent of render target
     // fragColor = vec4(mask_texCoords, 0.0, 1.0);
-    fragColor = texture(mask_texture, mask_texCoords);
+    // fragColor = texture(mask_texture, mask_texCoords);
 
     if (!mask) discard;
   }
 `
 };
 
-type MaskModuleSettings = {
+type MaskBindingProps = {
   maskMap?: Texture;
 };
 
+type MaskUniformProps = {
+  bounds: [number, number, number, number];
+  channel: number;
+  enabled: boolean;
+  inverted: boolean;
+  maskByInstance: boolean;
+};
+
+export type MaskProps = MaskBindingProps & MaskUniformProps;
+
 /* eslint-disable camelcase */
-const getMaskUniforms = (opts?: MaskModuleSettings | {}): Record<string, any> => {
+const getMaskUniforms = (opts?: MaskProps | {}): Record<string, any> => {
   if (opts && 'maskMap' in opts) {
     return {
       mask_texture: opts.maskMap
     };
   }
-  return {};
+  return opts || {};
 };
 
 export default {
@@ -89,5 +118,12 @@ export default {
   vs,
   fs,
   inject,
-  getUniforms: getMaskUniforms
-} as ShaderModule<MaskModuleSettings>;
+  getUniforms: getMaskUniforms,
+  uniformTypes: {
+    bounds: 'vec4<f32>',
+    channel: 'i32',
+    enabled: 'i32',
+    inverted: 'i32',
+    maskByInstance: 'i32'
+  }
+} as const satisfies ShaderModule<MaskProps>;