@deck.gl/extensions 9.0.40 → 9.1.0-beta.3

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,4 +1,14 @@
-import type {Device, Framebuffer, RenderPipelineParameters, Texture} from '@luma.gl/core';
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {
+  Device,
+  Framebuffer,
+  Parameters,
+  RenderPipelineParameters,
+  Texture
+} from '@luma.gl/core';
 import {Layer, _LayersPass as LayersPass, LayersPassRenderOptions, Viewport} from '@deck.gl/core';
 
 type MaskPassRenderOptions = LayersPassRenderOptions & {
@@ -50,11 +60,15 @@ export default class MaskPass extends LayersPass {
     super.render({...options, clearColor, colorMask, target: this.fbo, pass: 'mask'});
   }
 
-  protected getLayerParameters(layer: Layer<{}>, layerIndex: number, viewport: Viewport) {
+  protected getLayerParameters(
+    layer: Layer<{}>,
+    layerIndex: number,
+    viewport: Viewport
+  ): Parameters {
     return {
       ...layer.props.parameters,
       blend: true,
-      depthTest: false,
+      depthCompare: 'always',
       ...MASK_BLENDING
     };
   }

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>;

package/src/path-style/path-style-extension.ts

@@ -1,29 +1,13 @@
-// 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, _mergeShaders as mergeShaders} from '@deck.gl/core';
 import {vec3} from '@math.gl/core';
 import {dashShaders, offsetShaders} from './shaders.glsl';
 
 import type {Layer, LayerContext, Accessor, UpdateParameters} from '@deck.gl/core';
-import type {Model} from '@luma.gl/engine';
+import type {ShaderModule} from '@luma.gl/shadertools';
 
 const defaultProps = {
   getDashArray: {type: 'accessor', value: [0, 0]},
@@ -32,6 +16,11 @@ const defaultProps = {
   dashGapPickable: false
 };
 
+type PathStyleProps = {
+  dashAlignMode: number;
+  dashGapPickable: boolean;
+};
+
 export type PathStyleExtensionProps<DataT = any> = {
   /**
    * Accessor for the dash array to draw each path with: `[dashSize, gapSize]` relative to the width of the path.
@@ -97,7 +86,7 @@ export default class PathStyleExtension extends LayerExtension<PathStyleExtensio
     }
 
     // Merge shader injection
-    let result = {};
+    let result = {} as {inject: Record<string, string>};
     if (extension.opts.dash) {
       result = mergeShaders(result, dashShaders);
     }
@@ -105,7 +94,18 @@ export default class PathStyleExtension extends LayerExtension<PathStyleExtensio
       result = mergeShaders(result, offsetShaders);
     }
 
-    return result;
+    const {inject} = result;
+    const pathStyle: ShaderModule<PathStyleProps> = {
+      name: 'pathStyle',
+      inject,
+      uniformTypes: {
+        dashAlignMode: 'f32',
+        dashGapPickable: 'i32'
+      }
+    };
+    return {
+      modules: [pathStyle]
+    };
   }
 
   initializeState(this: Layer<PathStyleExtensionProps>, context: LayerContext, extension: this) {
@@ -149,14 +149,13 @@ export default class PathStyleExtension extends LayerExtension<PathStyleExtensio
       return;
     }
 
-    const uniforms: any = {};
-
     if (extension.opts.dash) {
-      uniforms.dashAlignMode = this.props.dashJustified ? 1 : 0;
-      uniforms.dashGapPickable = Boolean(this.props.dashGapPickable);
+      const pathStyleProps: PathStyleProps = {
+        dashAlignMode: this.props.dashJustified ? 1 : 0,
+        dashGapPickable: Boolean(this.props.dashGapPickable)
+      };
+      this.setShaderModuleProps({pathStyle: pathStyleProps});
     }
-
-    (this.state.model as Model)?.setUniforms(uniforms);
   }
 
   getDashOffsets(this: Layer<PathStyleExtensionProps>, path: number[] | number[][]): number[] {

package/src/path-style/shaders.glsl.ts

@@ -1,3 +1,7 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 export const dashShaders = {
   inject: {
     'vs:#decl': `
@@ -13,9 +17,11 @@ vDashOffset = instanceDashOffsets / width.x;
 `,
 
     'fs:#decl': `
-uniform float dashAlignMode;
-uniform float capType;
-uniform bool dashGapPickable;
+uniform pathStyleUniforms {
+  float dashAlignMode;
+  bool dashGapPickable;
+} pathStyle;
+
 in vec2 vDashArray;
 in float vDashOffset;
 `,
@@ -36,7 +42,7 @@ in float vDashOffset;
   float offset;
 
   if (unitLength > 0.0) {
-    if (dashAlignMode == 0.0) {
+    if (pathStyle.dashAlignMode == 0.0) {
       offset = vDashOffset;
     } else {
       unitLength = vPathLength / round(vPathLength / unitLength);
@@ -46,8 +52,8 @@ in float vDashOffset;
     float unitOffset = mod(vPathPosition.y + offset, unitLength);
 
     if (gapLength > 0.0 && unitOffset > solidLength) {
-      if (capType <= 0.5) {
-        if (!(dashGapPickable && bool(picking.isActive))) {
+      if (path.capType <= 0.5) {
+        if (!(pathStyle.dashGapPickable && bool(picking.isActive))) {
           discard;
         }
       } else {
@@ -57,7 +63,7 @@ in float vDashOffset;
           vPathPosition.x
         ));
         if (distToEnd > 1.0) {
-          if (!(dashGapPickable && bool(picking.isActive))) {
+          if (!(pathStyle.dashGapPickable && bool(picking.isActive))) {
             discard;
           }
         }

package/src/terrain/height-map-builder.ts

@@ -1,3 +1,7 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {Device, Framebuffer} from '@luma.gl/core';
 import {joinLayerBounds, getRenderBounds, makeViewport, Bounds} from '../utils/projection-utils';
 import {createRenderTarget} from './utils';