@deck.gl/extensions 8.9.17 → 8.9.18

package/typed/data-filter/shader-module.js

@@ -0,0 +1,152 @@
+/*
+ * data filter shader module
+ */
+const vs = `
+uniform DATAFILTER_TYPE filter_min;
+uniform DATAFILTER_TYPE filter_softMin;
+uniform DATAFILTER_TYPE filter_softMax;
+uniform DATAFILTER_TYPE filter_max;
+uniform bool filter_useSoftMargin;
+uniform bool filter_enabled;
+uniform bool filter_transformSize;
+
+#ifdef NON_INSTANCED_MODEL
+  #define DATAFILTER_ATTRIB filterValues
+  #define DATAFILTER_ATTRIB_64LOW filterValues64Low
+#else
+  #define DATAFILTER_ATTRIB instanceFilterValues
+  #define DATAFILTER_ATTRIB_64LOW instanceFilterValues64Low
+#endif
+
+attribute DATAFILTER_TYPE DATAFILTER_ATTRIB;
+#ifdef DATAFILTER_DOUBLE
+  attribute DATAFILTER_TYPE DATAFILTER_ATTRIB_64LOW;
+
+  uniform DATAFILTER_TYPE filter_min64High;
+  uniform DATAFILTER_TYPE filter_max64High;
+#endif
+
+varying float dataFilter_value;
+
+float dataFilter_reduceValue(float value) {
+  return value;
+}
+float dataFilter_reduceValue(vec2 value) {
+  return min(value.x, value.y);
+}
+float dataFilter_reduceValue(vec3 value) {
+  return min(min(value.x, value.y), value.z);
+}
+float dataFilter_reduceValue(vec4 value) {
+  return min(min(value.x, value.y), min(value.z, value.w));
+}
+void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax) {
+  if (filter_enabled) {
+    if (filter_useSoftMargin) {
+      dataFilter_value = dataFilter_reduceValue(
+        smoothstep(filter_min, filter_softMin, valueFromMin) *
+        (1.0 - smoothstep(filter_softMax, filter_max, valueFromMax))
+      );
+    } else {
+      dataFilter_value = dataFilter_reduceValue(
+        step(filter_min, valueFromMin) * step(valueFromMax, filter_max)
+      );
+    }
+  } else {
+    dataFilter_value = 1.0;
+  }
+}
+`;
+const fs = `
+uniform bool filter_transformColor;
+varying float dataFilter_value;
+`;
+const getUniforms = opts => {
+    if (!opts || !opts.extensions) {
+        return {};
+    }
+    const { filterRange = [-1, 1], filterEnabled = true, filterTransformSize = true, filterTransformColor = true } = opts;
+    const filterSoftRange = opts.filterSoftRange || filterRange;
+    const uniforms = Number.isFinite(filterRange[0])
+        ? {
+            filter_min: filterRange[0],
+            filter_softMin: filterSoftRange[0],
+            filter_softMax: filterSoftRange[1],
+            filter_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])
+        };
+    uniforms.filter_enabled = filterEnabled;
+    uniforms.filter_useSoftMargin = Boolean(opts.filterSoftRange);
+    uniforms.filter_transformSize = filterEnabled && filterTransformSize;
+    uniforms.filter_transformColor = filterEnabled && filterTransformColor;
+    return uniforms;
+};
+const getUniforms64 = opts => {
+    if (!opts || !opts.extensions) {
+        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;
+    }
+    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;
+    }
+    return uniforms;
+};
+const inject = {
+    'vs:#main-start': `
+    #ifdef DATAFILTER_DOUBLE
+      dataFilter_setValue(
+        DATAFILTER_ATTRIB - filter_min64High + DATAFILTER_ATTRIB_64LOW,
+        DATAFILTER_ATTRIB - filter_max64High + DATAFILTER_ATTRIB_64LOW
+      );
+    #else
+      dataFilter_setValue(DATAFILTER_ATTRIB, DATAFILTER_ATTRIB);
+    #endif
+  `,
+    'vs:DECKGL_FILTER_SIZE': `
+    if (filter_transformSize) {
+      size = size * dataFilter_value;
+    }
+  `,
+    'fs:DECKGL_FILTER_COLOR': `
+    if (dataFilter_value == 0.0) discard;
+    if (filter_transformColor) {
+      color.a *= dataFilter_value;
+    }
+  `
+};
+export const shaderModule = {
+    name: 'data-filter',
+    vs,
+    fs,
+    inject,
+    getUniforms
+};
+export const shaderModule64 = {
+    name: 'data-filter-fp64',
+    vs,
+    fs,
+    inject,
+    getUniforms: getUniforms64
+};

package/typed/fill-style/fill-style.js

@@ -0,0 +1,152 @@
+import { LayerExtension } from '@deck.gl/core';
+import { Texture2D } from '@luma.gl/core';
+import GL from '@luma.gl/constants';
+import { patternShaders } from './shaders.glsl';
+const defaultProps = {
+    fillPatternEnabled: true,
+    fillPatternAtlas: null,
+    fillPatternMapping: null,
+    fillPatternMask: true,
+    getFillPattern: { type: 'accessor', value: d => d.pattern },
+    getFillPatternScale: { type: 'accessor', value: 1 },
+    getFillPatternOffset: { type: 'accessor', value: [0, 0] }
+};
+const DEFAULT_TEXTURE_PARAMETERS = {
+    [GL.TEXTURE_MIN_FILTER]: GL.LINEAR,
+    // GL.LINEAR is the default value but explicitly set it here
+    [GL.TEXTURE_MAG_FILTER]: GL.LINEAR,
+    // for texture boundary artifact
+    [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,
+    [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE
+};
+export default class FillStyleExtension extends LayerExtension {
+    constructor({ pattern = false } = {}) {
+        super({ pattern });
+    }
+    isEnabled(layer) {
+        return layer.getAttributeManager() && !layer.state.pathTesselator;
+    }
+    getShaders(extension) {
+        if (!extension.isEnabled(this)) {
+            return null;
+        }
+        return {
+            modules: [extension.opts.pattern && patternShaders].filter(Boolean)
+        };
+    }
+    initializeState(context, extension) {
+        if (!extension.isEnabled(this)) {
+            return;
+        }
+        const attributeManager = this.getAttributeManager();
+        if (extension.opts.pattern) {
+            attributeManager.add({
+                fillPatternFrames: {
+                    size: 4,
+                    accessor: 'getFillPattern',
+                    transform: extension.getPatternFrame.bind(this),
+                    shaderAttributes: {
+                        fillPatternFrames: {
+                            divisor: 0
+                        },
+                        instanceFillPatternFrames: {
+                            divisor: 1
+                        }
+                    }
+                },
+                fillPatternScales: {
+                    size: 1,
+                    accessor: 'getFillPatternScale',
+                    defaultValue: 1,
+                    shaderAttributes: {
+                        fillPatternScales: {
+                            divisor: 0
+                        },
+                        instanceFillPatternScales: {
+                            divisor: 1
+                        }
+                    }
+                },
+                fillPatternOffsets: {
+                    size: 2,
+                    accessor: 'getFillPatternOffset',
+                    shaderAttributes: {
+                        fillPatternOffsets: {
+                            divisor: 0
+                        },
+                        instanceFillPatternOffsets: {
+                            divisor: 1
+                        }
+                    }
+                }
+            });
+        }
+        this.setState({
+            emptyTexture: new Texture2D(this.context.gl, {
+                data: new Uint8Array(4),
+                width: 1,
+                height: 1
+            })
+        });
+    }
+    updateState({ props, oldProps }, extension) {
+        if (!extension.isEnabled(this)) {
+            return;
+        }
+        if (props.fillPatternAtlas && props.fillPatternAtlas !== oldProps.fillPatternAtlas) {
+            extension.loadPatternAtlas.call(this, props);
+        }
+        if (props.fillPatternMapping && props.fillPatternMapping !== oldProps.fillPatternMapping) {
+            extension.loadPatternMapping.call(this, props);
+        }
+    }
+    draw(params, extension) {
+        if (!extension.isEnabled(this)) {
+            return;
+        }
+        const { patternTexture } = this.state;
+        this.setModuleParameters({
+            fillPatternTexture: patternTexture || this.state.emptyTexture
+        });
+    }
+    finalizeState() {
+        const { patternTexture, emptyTexture } = this.state;
+        patternTexture?.delete();
+        emptyTexture?.delete();
+    }
+    async loadPatternAtlas({ fillPatternAtlas, fetch }) {
+        this.state.patternTexture?.delete();
+        this.setState({ patternTexture: null });
+        let image = fillPatternAtlas;
+        if (typeof image === 'string') {
+            image = await fetch(image, { propName: 'fillPatternAtlas', layer: this });
+        }
+        const patternTexture = image instanceof Texture2D
+            ? image
+            : new Texture2D(this.context.gl, {
+                data: image,
+                parameters: DEFAULT_TEXTURE_PARAMETERS
+            });
+        this.setState({ patternTexture });
+    }
+    async loadPatternMapping({ fillPatternMapping, fetch }) {
+        this.setState({ patternMapping: null });
+        let patternMapping = fillPatternMapping;
+        if (typeof patternMapping === 'string') {
+            patternMapping = await fetch(patternMapping, {
+                propName: 'fillPatternMapping',
+                layer: this
+            });
+        }
+        this.setState({ patternMapping });
+        this.getAttributeManager().invalidate('getFillPattern');
+        this.setNeedsUpdate();
+    }
+    getPatternFrame(name) {
+        const { patternMapping } = this.state;
+        const def = patternMapping && patternMapping[name];
+        return def ? [def.x, def.y, def.width, def.height] : [0, 0, 0, 0];
+    }
+}
+FillStyleExtension.extensionName = 'FillStyleExtension';
+FillStyleExtension.defaultProps = defaultProps;

package/typed/fill-style/shaders.glsl.js

@@ -0,0 +1,95 @@
+import { project, COORDINATE_SYSTEM } from '@deck.gl/core';
+/*
+ * fill pattern shader module
+ */
+const patternVs = `
+#ifdef NON_INSTANCED_MODEL
+  #define FILL_PATTERN_FRAME_ATTRIB fillPatternFrames
+  #define FILL_PATTERN_SCALE_ATTRIB fillPatternScales
+  #define FILL_PATTERN_OFFSET_ATTRIB fillPatternOffsets
+#else
+  #define FILL_PATTERN_FRAME_ATTRIB instanceFillPatternFrames
+  #define FILL_PATTERN_SCALE_ATTRIB instanceFillPatternScales
+  #define FILL_PATTERN_OFFSET_ATTRIB instanceFillPatternOffsets
+#endif
+
+attribute vec4 FILL_PATTERN_FRAME_ATTRIB;
+attribute float FILL_PATTERN_SCALE_ATTRIB;
+attribute vec2 FILL_PATTERN_OFFSET_ATTRIB;
+
+uniform bool fill_patternEnabled;
+uniform vec2 fill_patternTextureSize;
+
+varying vec2 fill_uv;
+varying vec4 fill_patternBounds;
+varying vec3 fill_patternPlacement;
+`;
+const patternFs = `
+uniform bool fill_patternEnabled;
+uniform bool fill_patternMask;
+uniform sampler2D fill_patternTexture;
+uniform vec2 fill_uvCoordinateOrigin;
+
+varying vec4 fill_patternBounds;
+varying vec3 fill_patternPlacement;
+varying vec2 fill_uv;
+
+const float FILL_UV_SCALE = 512.0 / 40000000.0;
+`;
+const inject = {
+    'vs:DECKGL_FILTER_GL_POSITION': `
+    fill_uv = geometry.position.xy;
+  `,
+    'vs:DECKGL_FILTER_COLOR': `
+    if (fill_patternEnabled) {
+      fill_patternBounds = FILL_PATTERN_FRAME_ATTRIB / vec4(fill_patternTextureSize, fill_patternTextureSize);
+      fill_patternPlacement.xy = FILL_PATTERN_OFFSET_ATTRIB;
+      fill_patternPlacement.z = FILL_PATTERN_SCALE_ATTRIB * FILL_PATTERN_FRAME_ATTRIB.w;
+    }
+  `,
+    'fs:DECKGL_FILTER_COLOR': `
+    if (fill_patternEnabled) {
+      float scale = FILL_UV_SCALE * fill_patternPlacement.z;
+      vec2 patternUV = mod(mod(fill_uvCoordinateOrigin, scale) + fill_uv, scale) / scale;
+      patternUV = mod(fill_patternPlacement.xy + patternUV, 1.0);
+
+      vec2 texCoords = fill_patternBounds.xy + fill_patternBounds.zw * patternUV;
+
+      vec4 patternColor = texture2D(fill_patternTexture, texCoords);
+      color.a *= patternColor.a;
+      if (!fill_patternMask) {
+        color.rgb = patternColor.rgb;
+      }
+    }
+  `
+};
+function getPatternUniforms(opts = {}, uniforms) {
+    if ('fillPatternTexture' in opts) {
+        const { fillPatternTexture } = opts;
+        return {
+            fill_patternTexture: fillPatternTexture,
+            fill_patternTextureSize: [fillPatternTexture.width, fillPatternTexture.height]
+        };
+    }
+    if (opts.viewport) {
+        const { viewport, fillPatternMask = true, fillPatternEnabled = true } = opts;
+        const { project_uCoordinateOrigin, project_uCoordinateSystem } = uniforms;
+        const coordinateOriginCommon = project_uCoordinateSystem === COORDINATE_SYSTEM.CARTESIAN
+            ? project_uCoordinateOrigin
+            : viewport.projectPosition(project_uCoordinateOrigin);
+        return {
+            fill_uvCoordinateOrigin: coordinateOriginCommon.slice(0, 2),
+            fill_patternMask: fillPatternMask,
+            fill_patternEnabled: fillPatternEnabled
+        };
+    }
+    return {};
+}
+export const patternShaders = {
+    name: 'fill-pattern',
+    vs: patternVs,
+    fs: patternFs,
+    inject,
+    dependencies: [project],
+    getUniforms: getPatternUniforms
+};

package/typed/fp64/fp64.js

@@ -0,0 +1,34 @@
+// 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.
+import { LayerExtension, COORDINATE_SYSTEM } from '@deck.gl/core';
+import project64 from './project64';
+export default class Fp64Extension extends LayerExtension {
+    getShaders(opts) {
+        const { coordinateSystem } = this.props;
+        if (coordinateSystem !== COORDINATE_SYSTEM.LNGLAT &&
+            coordinateSystem !== COORDINATE_SYSTEM.DEFAULT) {
+            throw new Error('fp64: coordinateSystem must be LNGLAT');
+        }
+        return {
+            modules: [project64]
+        };
+    }
+}
+Fp64Extension.extensionName = 'Fp64Extension';

package/typed/fp64/project64.glsl.js

@@ -0,0 +1,100 @@
+// 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.
+export default `\
+
+const vec2 WORLD_SCALE_FP64 = vec2(81.4873275756836, 0.0000032873668232014097);
+
+uniform vec2 project_uViewProjectionMatrixFP64[16];
+
+// longitude: lnglat_fp64.xy; latitude: lnglat_fp64.zw
+void mercatorProject_fp64(vec4 lnglat_fp64, out vec2 out_val[2]) {
+
+#if defined(NVIDIA_FP64_WORKAROUND)
+  out_val[0] = sum_fp64(radians_fp64(lnglat_fp64.xy), PI_FP64 * ONE);
+#else
+  out_val[0] = sum_fp64(radians_fp64(lnglat_fp64.xy), PI_FP64);
+#endif
+  out_val[1] = sum_fp64(PI_FP64,
+    log_fp64(tan_fp64(sum_fp64(PI_4_FP64, radians_fp64(lnglat_fp64.zw) / 2.0))));
+  return;
+}
+
+void project_position_fp64(vec4 position_fp64, out vec2 out_val[2]) {
+  vec2 pos_fp64[2];
+  mercatorProject_fp64(position_fp64, pos_fp64);
+  out_val[0] = mul_fp64(pos_fp64[0], WORLD_SCALE_FP64);
+  out_val[1] = mul_fp64(pos_fp64[1], WORLD_SCALE_FP64);
+
+  return;
+}
+
+void project_position_fp64(vec2 position, vec2 position64xyLow, out vec2 out_val[2]) {
+  vec4 position64xy = vec4(
+    position.x, position64xyLow.x,
+    position.y, position64xyLow.y);
+
+  project_position_fp64(position64xy, 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,
+    vertex_pos_clipspace);
+  return vec4(
+    vertex_pos_clipspace[0].x,
+    vertex_pos_clipspace[1].x,
+    vertex_pos_clipspace[2].x,
+    vertex_pos_clipspace[3].x
+    );
+}
+
+vec4 project_position_to_clipspace(
+  vec3 position, vec3 position64xyLow, vec3 offset, out vec4 commonPosition
+) {
+  // This is the local offset to the instance position
+  vec2 offset64[4];
+  vec4_fp64(vec4(offset, 0.0), offset64);
+
+  float z = project_size(position.z);
+
+  // Apply web mercator projection (depends on coordinate system imn use)
+  vec2 projectedPosition64xy[2];
+  project_position_fp64(position.xy, position64xyLow.xy, projectedPosition64xy);
+
+  vec2 commonPosition64[4];
+  commonPosition64[0] = sum_fp64(offset64[0], projectedPosition64xy[0]);
+  commonPosition64[1] = sum_fp64(offset64[1], projectedPosition64xy[1]);
+  commonPosition64[2] = sum_fp64(offset64[2], vec2(z, 0.0));
+  commonPosition64[3] = vec2(1.0, 0.0);
+
+  commonPosition = vec4(projectedPosition64xy[0].x, projectedPosition64xy[1].x, z, 1.0);
+
+  return project_common_position_to_clipspace_fp64(commonPosition64);
+}
+
+vec4 project_position_to_clipspace(
+  vec3 position, vec3 position64xyLow, vec3 offset
+) {
+  vec4 commonPosition;
+  return project_position_to_clipspace(
+    position, position64xyLow, offset, commonPosition
+  );
+}
+`;

package/typed/fp64/project64.js

@@ -0,0 +1,50 @@
+// 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.
+import { fp64 } from '@luma.gl/shadertools';
+const { fp64ify, fp64ifyMatrix4 } = fp64;
+import { project, _memoize as memoize } from '@deck.gl/core';
+import project64Shader from './project64.glsl';
+export default {
+    name: 'project64',
+    dependencies: [project, fp64],
+    vs: project64Shader,
+    getUniforms
+};
+// TODO - this module should calculate the 64 bit uniforms
+// It is currently done by project to minimize duplicated work
+const DEFAULT_MODULE_OPTIONS = {};
+const getMemoizedUniforms = memoize(calculateUniforms);
+function getUniforms(opts = DEFAULT_MODULE_OPTIONS) {
+    if (opts.viewport) {
+        const { viewProjectionMatrix, scale } = opts.viewport;
+        // We only need to update fp64 uniforms if fp32 projection is being updated
+        return getMemoizedUniforms({ viewProjectionMatrix, scale });
+    }
+    return {};
+}
+function calculateUniforms({ viewProjectionMatrix, scale }) {
+    const glViewProjectionMatrixFP64 = fp64ifyMatrix4(viewProjectionMatrix);
+    const scaleFP64 = fp64ify(scale);
+    return {
+        project_uViewProjectionMatrixFP64: glViewProjectionMatrixFP64,
+        project64_uViewProjectionMatrix: glViewProjectionMatrixFP64,
+        project64_uScale: scaleFP64
+    };
+}

package/typed/index.js

@@ -0,0 +1,9 @@
+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';
+export { default as PathStyleExtension } from './path-style/path-style-extension';
+export { default as FillStyleExtension } from './fill-style/fill-style';
+export { default as ClipExtension } from './clip/clip-extension';
+export { default as MaskExtension } from './mask/mask';
+// Shader module
+export { default as project64 } from './fp64/project64';

package/typed/mask/mask.js

@@ -0,0 +1,48 @@
+import { COORDINATE_SYSTEM, LayerExtension, log } from '@deck.gl/core';
+import mask from './shader-module';
+const defaultProps = {
+    maskId: ''
+};
+export default class MaskExtension extends LayerExtension {
+    getShaders() {
+        // Infer by geometry if 'maskByInstance' prop isn't explictly set
+        let maskByInstance = 'instancePositions' in this.getAttributeManager().attributes;
+        // Users can override by setting the `maskByInstance` prop
+        if ('maskByInstance' in this.props) {
+            maskByInstance = this.props.maskByInstance;
+        }
+        this.state.maskByInstance = maskByInstance;
+        return {
+            modules: [mask]
+        };
+    }
+    draw({ uniforms, context, moduleParameters }) {
+        uniforms.mask_maskByInstance = this.state.maskByInstance;
+        const { maskId } = this.props;
+        const { maskChannels } = moduleParameters;
+        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;
+            if (fromCoordinateSystem === COORDINATE_SYSTEM.DEFAULT) {
+                fromCoordinateSystem = viewport.isGeospatial
+                    ? COORDINATE_SYSTEM.LNGLAT
+                    : COORDINATE_SYSTEM.CARTESIAN;
+            }
+            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]];
+        }
+        else {
+            if (maskId) {
+                log.warn(`Could not find a mask layer with id: ${maskId}`)();
+            }
+            uniforms.mask_enabled = false;
+        }
+    }
+}
+MaskExtension.extensionName = 'MaskExtension';
+MaskExtension.defaultProps = defaultProps;