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

package/src/data-filter/shader-module.ts

@@ -1,6 +1,10 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import type {ShaderModule} from '@luma.gl/shadertools';
-import type {DataFilterExtensionProps} from './data-filter-extension';
-import {glsl} from '../utils/syntax-tags';
+import type {DataFilterExtensionOptions, DataFilterExtensionProps} from './data-filter-extension';
+import {UniformFormat} from '@luma.gl/shadertools/dist/types';
 
 /*
  * data filter shader module
@@ -10,7 +14,7 @@ export type Defines = {
   /**
    * Primitive type of parameter used for category filtering. If undefined, category filtering disabled.
    */
-  DATACATEGORY_TYPE?: 'float' | 'vec2' | 'vec3' | 'vec4';
+  DATACATEGORY_TYPE?: 'uint' | 'uvec2' | 'uvec3' | 'uvec4';
   /**
    * Number of category filtering channels. Must match dimension of `DATACATEGORY_TYPE`
    */
@@ -27,27 +31,35 @@ export type Defines = {
   DATAFILTER_DOUBLE?: boolean;
 };
 
-const vs = glsl`
-uniform bool filter_useSoftMargin;
-uniform bool filter_enabled;
-uniform bool filter_transformSize;
-uniform ivec4 filter_categoryBitMask;
-
+const uniformBlock = /* glsl */ `\
+uniform dataFilterUniforms {
+  bool useSoftMargin;
+  bool enabled;
+  bool transformSize;
+  bool transformColor;
 #ifdef DATAFILTER_TYPE
-  uniform DATAFILTER_TYPE filter_min;
-  uniform DATAFILTER_TYPE filter_softMin;
-  uniform DATAFILTER_TYPE filter_softMax;
-  uniform DATAFILTER_TYPE filter_max;
+  DATAFILTER_TYPE min;
+  DATAFILTER_TYPE softMin;
+  DATAFILTER_TYPE softMax;
+  DATAFILTER_TYPE max;
+#ifdef DATAFILTER_DOUBLE
+  DATAFILTER_TYPE min64High;
+  DATAFILTER_TYPE max64High;
+#endif
+#endif
+#ifdef DATACATEGORY_TYPE
+  highp uvec4 categoryBitMask;
+#endif
+} dataFilter;
+`;
 
+const vertex = /* glsl */ `
+#ifdef DATAFILTER_TYPE
   in DATAFILTER_TYPE filterValues;
-  #ifdef DATAFILTER_DOUBLE
-    in DATAFILTER_TYPE filterValues64Low;
-
-    uniform DATAFILTER_TYPE filter_min64High;
-    uniform DATAFILTER_TYPE filter_max64High;
-  #endif
+#ifdef DATAFILTER_DOUBLE
+  in DATAFILTER_TYPE filterValues64Low;
+#endif
 #endif
-
 
 #ifdef DATACATEGORY_TYPE
   in DATACATEGORY_TYPE filterCategoryValues;
@@ -70,23 +82,23 @@ float dataFilter_reduceValue(vec4 value) {
 
 #ifdef DATAFILTER_TYPE
   void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax) {
-    if (filter_useSoftMargin) {
+    if (dataFilter.useSoftMargin) {
       // smoothstep results are undefined if edge0 ≥ edge1
       // Fallback to ignore filterSoftRange if it is truncated by filterRange
       DATAFILTER_TYPE leftInRange = mix(
-        smoothstep(filter_min, filter_softMin, valueFromMin),
-        step(filter_min, valueFromMin),
-        step(filter_softMin, filter_min)
+        smoothstep(dataFilter.min, dataFilter.softMin, valueFromMin),
+        step(dataFilter.min, valueFromMin),
+        step(dataFilter.softMin, dataFilter.min)
       );
       DATAFILTER_TYPE rightInRange = mix(
-        1.0 - smoothstep(filter_softMax, filter_max, valueFromMax),
-        step(valueFromMax, filter_max),
-        step(filter_max, filter_softMax)
+        1.0 - smoothstep(dataFilter.softMax, dataFilter.max, valueFromMax),
+        step(valueFromMax, dataFilter.max),
+        step(dataFilter.max, dataFilter.softMax)
       );
       dataFilter_value = dataFilter_reduceValue(leftInRange * rightInRange);
     } else {
       dataFilter_value = dataFilter_reduceValue(
-        step(filter_min, valueFromMin) * step(valueFromMax, filter_max)
+        step(dataFilter.min, valueFromMin) * step(valueFromMax, dataFilter.max)
       );
     }
   }
@@ -95,42 +107,53 @@ float dataFilter_reduceValue(vec4 value) {
 #ifdef DATACATEGORY_TYPE
   void dataFilter_setCategoryValue(DATACATEGORY_TYPE category) {
     #if DATACATEGORY_CHANNELS == 1 // One 128-bit mask
-    int dataFilter_masks = filter_categoryBitMask[int(category / 32.0)];
+    uint dataFilter_masks = dataFilter.categoryBitMask[category / 32u];
     #elif DATACATEGORY_CHANNELS == 2 // Two 64-bit masks
-    ivec2 dataFilter_masks = ivec2(
-      filter_categoryBitMask[int(category.x / 32.0)],
-      filter_categoryBitMask[int(category.y / 32.0) + 2]
+    uvec2 dataFilter_masks = uvec2(
+      dataFilter.categoryBitMask[category.x / 32u],
+      dataFilter.categoryBitMask[category.y / 32u + 2u]
     );
     #elif DATACATEGORY_CHANNELS == 3 // Three 32-bit masks
-    ivec3 dataFilter_masks = filter_categoryBitMask.xyz;
+    uvec3 dataFilter_masks = dataFilter.categoryBitMask.xyz;
     #else // Four 32-bit masks
-    ivec4 dataFilter_masks = filter_categoryBitMask;
+    uvec4 dataFilter_masks = dataFilter.categoryBitMask;
     #endif
 
     // Shift mask and extract relevant bits
-    DATACATEGORY_TYPE dataFilter_bits = DATACATEGORY_TYPE(dataFilter_masks) / pow(DATACATEGORY_TYPE(2.0), mod(category, 32.0));
-    dataFilter_bits = mod(floor(dataFilter_bits), 2.0);
+    DATACATEGORY_TYPE dataFilter_bits = DATACATEGORY_TYPE(dataFilter_masks) >> (category & 31u);
+    dataFilter_bits &= 1u;
 
     #if DATACATEGORY_CHANNELS == 1
-    if(dataFilter_bits == 0.0) dataFilter_value = 0.0;
+    if(dataFilter_bits == 0u) dataFilter_value = 0.0;
     #else
-    if(any(equal(dataFilter_bits, DATACATEGORY_TYPE(0.0)))) dataFilter_value = 0.0;
+    if(any(equal(dataFilter_bits, DATACATEGORY_TYPE(0u)))) dataFilter_value = 0.0;
     #endif
   }
 #endif
 `;
 
-const fs = glsl`
-uniform bool filter_transformColor;
+const vs = `
+${uniformBlock}
+${vertex}
+`;
+
+const fragment = /* glsl */ `
 in float dataFilter_value;
 `;
 
-type DataFilterModuleSettings = {
+const fs = `
+${uniformBlock}
+${fragment}
+`;
+
+export type CategoryBitMask = Uint32Array;
+export type DataFilterModuleProps = {
   extensions: any[]; // used to detect if layer props are present
+  categoryBitMask?: CategoryBitMask;
 } & DataFilterExtensionProps;
 
 /* eslint-disable camelcase */
-function getUniforms(opts?: DataFilterModuleSettings | {}): Record<string, any> {
+function getUniforms(opts?: DataFilterModuleProps | {}): Record<string, any> {
   if (!opts || !('extensions' in opts)) {
     return {};
   }
@@ -138,69 +161,71 @@ function getUniforms(opts?: DataFilterModuleSettings | {}): Record<string, any>
     filterRange = [-1, 1],
     filterEnabled = true,
     filterTransformSize = true,
-    filterTransformColor = true
+    filterTransformColor = true,
+    categoryBitMask = [0, 0, 0, 0]
   } = opts;
   const filterSoftRange = opts.filterSoftRange || filterRange;
 
   return {
     ...(Number.isFinite(filterRange[0])
       ? {
-          filter_min: filterRange[0],
-          filter_softMin: filterSoftRange[0],
-          filter_softMax: filterSoftRange[1],
-          filter_max: filterRange[1]
+          min: filterRange[0],
+          softMin: filterSoftRange[0],
+          softMax: filterSoftRange[1],
+          max: filterRange[1]
         }
       : {
-          filter_min: filterRange.map(r => r[0]),
-          filter_softMin: filterSoftRange.map(r => r[0]),
-          filter_softMax: filterSoftRange.map(r => r[1]),
-          filter_max: filterRange.map(r => r[1])
+          min: filterRange.map(r => r[0]),
+          softMin: filterSoftRange.map(r => r[0]),
+          softMax: filterSoftRange.map(r => r[1]),
+          max: filterRange.map(r => r[1])
         }),
-    filter_enabled: filterEnabled,
-    filter_useSoftMargin: Boolean(opts.filterSoftRange),
-    filter_transformSize: filterEnabled && filterTransformSize,
-    filter_transformColor: filterEnabled && filterTransformColor
+    enabled: filterEnabled,
+    useSoftMargin: Boolean(opts.filterSoftRange),
+    transformSize: filterEnabled && filterTransformSize,
+    transformColor: filterEnabled && filterTransformColor,
+    categoryBitMask
   };
 }
 
-function getUniforms64(opts?: DataFilterModuleSettings | {}): Record<string, any> {
+function getUniforms64(opts?: DataFilterModuleProps | {}): Record<string, any> {
   if (!opts || !('extensions' in opts)) {
     return {};
   }
   const uniforms = getUniforms(opts);
-  if (Number.isFinite(uniforms.filter_min)) {
-    const min64High = Math.fround(uniforms.filter_min);
-    uniforms.filter_min -= min64High;
-    uniforms.filter_softMin -= min64High;
-    uniforms.filter_min64High = min64High;
-
-    const max64High = Math.fround(uniforms.filter_max);
-    uniforms.filter_max -= max64High;
-    uniforms.filter_softMax -= max64High;
-    uniforms.filter_max64High = max64High;
+  if (Number.isFinite(uniforms.min)) {
+    const min64High = Math.fround(uniforms.min);
+    uniforms.min -= min64High;
+    uniforms.softMin -= min64High;
+    uniforms.min64High = min64High;
+
+    const max64High = Math.fround(uniforms.max);
+    uniforms.max -= max64High;
+    uniforms.softMax -= max64High;
+    uniforms.max64High = max64High;
   } else {
-    const min64High = uniforms.filter_min.map(Math.fround);
-    uniforms.filter_min = uniforms.filter_min.map((x, i) => x - min64High[i]);
-    uniforms.filter_softMin = uniforms.filter_softMin.map((x, i) => x - min64High[i]);
-    uniforms.filter_min64High = min64High;
-
-    const max64High = uniforms.filter_max.map(Math.fround);
-    uniforms.filter_max = uniforms.filter_max.map((x, i) => x - max64High[i]);
-    uniforms.filter_softMax = uniforms.filter_softMax.map((x, i) => x - max64High[i]);
-    uniforms.filter_max64High = max64High;
+    const min64High = uniforms.min.map(Math.fround);
+    uniforms.min = uniforms.min.map((x, i) => x - min64High[i]);
+    uniforms.softMin = uniforms.softMin.map((x, i) => x - min64High[i]);
+    uniforms.min64High = min64High;
+
+    const max64High = uniforms.max.map(Math.fround);
+    uniforms.max = uniforms.max.map((x, i) => x - max64High[i]);
+    uniforms.softMax = uniforms.softMax.map((x, i) => x - max64High[i]);
+    uniforms.max64High = max64High;
   }
   return uniforms;
 }
 
 const inject = {
-  'vs:#main-start': glsl`
+  'vs:#main-start': /* glsl */ `
     dataFilter_value = 1.0;
-    if (filter_enabled) {
+    if (dataFilter.enabled) {
       #ifdef DATAFILTER_TYPE
         #ifdef DATAFILTER_DOUBLE
           dataFilter_setValue(
-            filterValues - filter_min64High + filterValues64Low,
-            filterValues - filter_max64High + filterValues64Low
+            filterValues - dataFilter.min64High + filterValues64Low,
+            filterValues - dataFilter.max64High + filterValues64Low
           );
         #else
           dataFilter_setValue(filterValues, filterValues);
@@ -213,38 +238,73 @@ const inject = {
     }
   `,
 
-  'vs:#main-end': glsl`
+  'vs:#main-end': /* glsl */ `
     if (dataFilter_value == 0.0) {
       gl_Position = vec4(0.);
     }
   `,
 
-  'vs:DECKGL_FILTER_SIZE': glsl`
-    if (filter_transformSize) {
+  'vs:DECKGL_FILTER_SIZE': /* glsl */ `
+    if (dataFilter.transformSize) {
       size = size * dataFilter_value;
     }
   `,
 
-  'fs:DECKGL_FILTER_COLOR': glsl`
+  'fs:DECKGL_FILTER_COLOR': /* glsl */ `
     if (dataFilter_value == 0.0) discard;
-    if (filter_transformColor) {
+    if (dataFilter.transformColor) {
       color.a *= dataFilter_value;
     }
   `
 };
 
-export const shaderModule: ShaderModule<DataFilterModuleSettings> = {
-  name: 'data-filter',
+type UniformTypesFunc = (opts: DataFilterExtensionOptions) => any;
+function uniformTypesFromOptions(opts: DataFilterExtensionOptions): any {
+  const {categorySize, filterSize, fp64} = opts;
+  const uniformTypes: Record<string, UniformFormat> = {
+    useSoftMargin: 'i32',
+    enabled: 'i32',
+    transformSize: 'i32',
+    transformColor: 'i32'
+  };
+
+  if (filterSize) {
+    const uniformFormat: UniformFormat = filterSize === 1 ? 'f32' : `vec${filterSize}<f32>`;
+    uniformTypes.min = uniformFormat;
+    uniformTypes.softMin = uniformFormat;
+    uniformTypes.softMax = uniformFormat;
+    uniformTypes.max = uniformFormat;
+    if (fp64) {
+      uniformTypes.min64High = uniformFormat;
+      uniformTypes.max64High = uniformFormat;
+    }
+  }
+
+  if (categorySize) {
+    uniformTypes.categoryBitMask = 'vec4<i32>';
+  }
+
+  return uniformTypes;
+}
+
+export const dataFilter: ShaderModule<DataFilterModuleProps> & {
+  uniformTypesFromOptions: UniformTypesFunc;
+} = {
+  name: 'dataFilter',
   vs,
   fs,
   inject,
-  getUniforms
+  getUniforms,
+  uniformTypesFromOptions
 };
 
-export const shaderModule64: ShaderModule<DataFilterModuleSettings> = {
-  name: 'data-filter-fp64',
+export const dataFilter64: ShaderModule<DataFilterModuleProps> & {
+  uniformTypesFromOptions: UniformTypesFunc;
+} = {
+  name: 'dataFilter',
   vs,
   fs,
   inject,
-  getUniforms: getUniforms64
+  getUniforms: getUniforms64,
+  uniformTypesFromOptions
 };

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

@@ -1,6 +1,10 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {LayerExtension} from '@deck.gl/core';
 
-import {patternShaders} from './shader-module';
+import {FillStyleModuleProps, patternShaders} from './shader-module';
 
 import type {
   Layer,
@@ -155,10 +159,14 @@ export default class FillStyleExtension extends LayerExtension<FillStyleExtensio
       return;
     }
 
-    const {fillPatternAtlas} = this.props;
-    this.setModuleParameters({
-      fillPatternTexture: fillPatternAtlas || this.state.emptyTexture
-    });
+    const {fillPatternAtlas, fillPatternEnabled, fillPatternMask} = this.props;
+    const fillProps: FillStyleModuleProps = {
+      project: params.shaderModuleProps.project,
+      fillPatternEnabled,
+      fillPatternMask,
+      fillPatternTexture: (fillPatternAtlas || this.state.emptyTexture) as Texture
+    };
+    this.setShaderModuleProps({fill: fillProps});
   }
 
   finalizeState(this: Layer<FillStyleExtensionProps>) {

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}});
+  }
 }