@deck.gl/extensions 8.8.7 → 8.9.0-alpha.2

package/typed/clip/clip.js

@@ -0,0 +1,114 @@
+// 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 } from '@deck.gl/core';
+const defaultProps = {
+    clipBounds: [0, 0, 1, 1]
+};
+const shaderFunction = `
+uniform vec4 clip_bounds;
+
+bool clip_isInBounds(vec2 position) {
+  return position.x >= clip_bounds[0] && position.y >= clip_bounds[1] && position.x < clip_bounds[2] && position.y < clip_bounds[3];
+}
+`;
+/*
+ * The vertex-shader version clips geometries by their anchor position
+ * e.g. ScatterplotLayer - show if the center of a circle is within bounds
+ */
+const shaderModuleVs = {
+    name: 'clip-vs',
+    vs: shaderFunction
+};
+const injectionVs = {
+    'vs:#decl': `
+varying float clip_isVisible;
+`,
+    'vs:DECKGL_FILTER_GL_POSITION': `
+  clip_isVisible = float(clip_isInBounds(geometry.worldPosition.xy));
+`,
+    'fs:#decl': `
+varying float clip_isVisible;
+`,
+    'fs:DECKGL_FILTER_COLOR': `
+  if (clip_isVisible < 0.5) discard;
+`
+};
+/*
+ * The fragment-shader version clips pixels at the bounds
+ * e.g. PolygonLayer - show the part of the polygon that intersect with the bounds
+ */
+const shaderModuleFs = {
+    name: 'clip-fs',
+    fs: shaderFunction
+};
+const injectionFs = {
+    'vs:#decl': `
+varying vec2 clip_commonPosition;
+`,
+    'vs:DECKGL_FILTER_GL_POSITION': `
+  clip_commonPosition = geometry.position.xy;
+`,
+    'fs:#decl': `
+varying vec2 clip_commonPosition;
+`,
+    'fs:DECKGL_FILTER_COLOR': `
+  if (!clip_isInBounds(clip_commonPosition)) discard;
+`
+};
+export default class ClipExtension extends LayerExtension {
+    getShaders() {
+        // If `clipByInstance: true`, the entire object is shown/hidden based on its anchor position (done by vertex shader)
+        // Otherwise, the object is trimmed by the clip bounds (done by fragment shader)
+        // Default behavior: consider a layer instanced if it has attribute `instancePositions`
+        let clipByInstance = 'instancePositions' in this.getAttributeManager().attributes;
+        // Users can override by setting the `clipByInstance` prop
+        if ('clipByInstance' in this.props) {
+            clipByInstance = this.props.clipByInstance;
+        }
+        this.state.clipByInstance = clipByInstance;
+        return clipByInstance
+            ? {
+                modules: [shaderModuleVs],
+                inject: injectionVs
+            }
+            : {
+                modules: [shaderModuleFs],
+                inject: injectionFs
+            };
+    }
+    draw({ uniforms }) {
+        const { clipBounds = defaultProps.clipBounds } = this.props;
+        if (this.state.clipByInstance) {
+            uniforms.clip_bounds = clipBounds;
+        }
+        else {
+            const corner0 = this.projectPosition([clipBounds[0], clipBounds[1], 0]);
+            const corner1 = this.projectPosition([clipBounds[2], clipBounds[3], 0]);
+            uniforms.clip_bounds = [
+                Math.min(corner0[0], corner1[0]),
+                Math.min(corner0[1], corner1[1]),
+                Math.max(corner0[0], corner1[0]),
+                Math.max(corner0[1], corner1[1])
+            ];
+        }
+    }
+}
+ClipExtension.extensionName = 'ClipExtension';
+ClipExtension.defaultProps = defaultProps;

package/typed/data-filter/aggregator.js

@@ -0,0 +1,98 @@
+import { Model, Texture2D, Framebuffer, isWebGL2 } from '@luma.gl/core';
+import GL from '@luma.gl/constants';
+const AGGREGATE_VS = `\
+#define SHADER_NAME data-filter-vertex-shader
+
+#ifdef FLOAT_TARGET
+  attribute float filterIndices;
+  attribute float filterPrevIndices;
+#else
+  attribute vec2 filterIndices;
+  attribute vec2 filterPrevIndices;
+#endif
+
+varying vec4 vColor;
+const float component = 1.0 / 255.0;
+
+void main() {
+  #ifdef FLOAT_TARGET
+    dataFilter_value *= float(filterIndices != filterPrevIndices);
+    gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
+    vColor = vec4(0.0, 0.0, 0.0, 1.0);
+  #else
+    // Float texture is not supported: pack result into 4 channels x 256 px x 64px
+    dataFilter_value *= float(filterIndices.x != filterPrevIndices.x);
+    float col = filterIndices.x;
+    float row = filterIndices.y * 4.0;
+    float channel = floor(row);
+    row = fract(row);
+    vColor = component * vec4(bvec4(channel == 0.0, channel == 1.0, channel == 2.0, channel == 3.0));
+    gl_Position = vec4(col * 2.0 - 1.0, row * 2.0 - 1.0, 0.0, 1.0);
+  #endif
+  gl_PointSize = 1.0;
+}
+`;
+const AGGREGATE_FS = `\
+#define SHADER_NAME data-filter-fragment-shader
+precision highp float;
+
+varying vec4 vColor;
+
+void main() {
+  if (dataFilter_value < 0.5) {
+    discard;
+  }
+  gl_FragColor = vColor;
+}
+`;
+export function supportsFloatTarget(gl) {
+    // https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/WebGL_best_practices#Support_for_float_textures_doesnt_mean_you_can_render_into_them!
+    return (gl.getExtension('EXT_float_blend') &&
+        // WebGL 2
+        (gl.getExtension('EXT_color_buffer_float') ||
+            // WebGL 1
+            gl.getExtension('WEBGL_color_buffer_float')));
+}
+// A 1x1 framebuffer object that encodes the total count of filtered items
+export function getFramebuffer(gl, useFloatTarget) {
+    if (useFloatTarget) {
+        return new Framebuffer(gl, {
+            width: 1,
+            height: 1,
+            attachments: {
+                [GL.COLOR_ATTACHMENT0]: new Texture2D(gl, {
+                    format: isWebGL2(gl) ? GL.RGBA32F : GL.RGBA,
+                    type: GL.FLOAT,
+                    mipmaps: false
+                })
+            }
+        });
+    }
+    return new Framebuffer(gl, {
+        width: 256,
+        height: 64,
+        depth: false
+    });
+}
+// Increments the counter based on dataFilter_value
+export function getModel(gl, shaderOptions, useFloatTarget) {
+    shaderOptions.defines.NON_INSTANCED_MODEL = 1;
+    if (useFloatTarget) {
+        shaderOptions.defines.FLOAT_TARGET = 1;
+    }
+    return new Model(gl, {
+        id: 'data-filter-aggregation-model',
+        vertexCount: 1,
+        isInstanced: false,
+        drawMode: GL.POINTS,
+        vs: AGGREGATE_VS,
+        fs: AGGREGATE_FS,
+        ...shaderOptions
+    });
+}
+export const parameters = {
+    blend: true,
+    blendFunc: [GL.ONE, GL.ONE, GL.ONE, GL.ONE],
+    blendEquation: [GL.FUNC_ADD, GL.FUNC_ADD],
+    depthTest: false
+};

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

@@ -0,0 +1,159 @@
+// 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 } from '@deck.gl/core';
+import { shaderModule, shaderModule64 } from './shader-module';
+import * as aggregator from './aggregator';
+import { readPixelsToArray, clear } from '@luma.gl/core';
+import GL from '@luma.gl/constants';
+const defaultProps = {
+    getFilterValue: { type: 'accessor', value: 0 },
+    onFilteredItemsChange: { type: 'function', value: null, compare: false },
+    filterEnabled: true,
+    filterRange: [-1, 1],
+    filterSoftRange: null,
+    filterTransformSize: true,
+    filterTransformColor: true
+};
+const DATA_TYPE_FROM_SIZE = {
+    1: 'float',
+    2: 'vec2',
+    3: 'vec3',
+    4: 'vec4'
+};
+export default class DataFilterExtension extends LayerExtension {
+    constructor({ filterSize = 1, fp64 = false, countItems = false } = {}) {
+        if (!DATA_TYPE_FROM_SIZE[filterSize]) {
+            throw new Error('filterSize out of range');
+        }
+        super({ filterSize, fp64, countItems });
+    }
+    getShaders(extension) {
+        const { filterSize, fp64 } = extension.opts;
+        return {
+            modules: [fp64 ? shaderModule64 : shaderModule],
+            defines: {
+                DATAFILTER_TYPE: DATA_TYPE_FROM_SIZE[filterSize],
+                DATAFILTER_DOUBLE: Boolean(fp64)
+            }
+        };
+    }
+    initializeState(context, extension) {
+        const attributeManager = this.getAttributeManager();
+        if (attributeManager) {
+            attributeManager.add({
+                filterValues: {
+                    size: extension.opts.filterSize,
+                    type: extension.opts.fp64 ? GL.DOUBLE : GL.FLOAT,
+                    accessor: 'getFilterValue',
+                    shaderAttributes: {
+                        filterValues: {
+                            divisor: 0
+                        },
+                        instanceFilterValues: {
+                            divisor: 1
+                        }
+                    }
+                }
+            });
+        }
+        const { gl } = this.context;
+        if (attributeManager && extension.opts.countItems) {
+            const useFloatTarget = aggregator.supportsFloatTarget(gl);
+            // This attribute is needed for variable-width data, e.g. Path, SolidPolygon, Text
+            // The vertex shader checks if a vertex has the same "index" as the previous vertex
+            // so that we only write one count cross multiple vertices of the same object
+            attributeManager.add({
+                filterIndices: {
+                    size: useFloatTarget ? 1 : 2,
+                    vertexOffset: 1,
+                    type: GL.UNSIGNED_BYTE,
+                    normalized: true,
+                    accessor: (object, { index }) => {
+                        const i = object && object.__source ? object.__source.index : index;
+                        return useFloatTarget ? (i + 1) % 255 : [(i + 1) % 255, Math.floor(i / 255) % 255];
+                    },
+                    shaderAttributes: {
+                        filterPrevIndices: {
+                            vertexOffset: 0
+                        },
+                        filterIndices: {
+                            vertexOffset: 1
+                        }
+                    }
+                }
+            });
+            const filterFBO = aggregator.getFramebuffer(gl, useFloatTarget);
+            const filterModel = aggregator.getModel(gl, extension.getShaders(extension), useFloatTarget);
+            this.setState({ filterFBO, filterModel });
+        }
+    }
+    updateState({ props, oldProps }) {
+        if (this.state.filterModel) {
+            const attributeManager = this.getAttributeManager();
+            const filterNeedsUpdate = attributeManager.attributes.filterValues.needsUpdate() ||
+                props.filterEnabled !== oldProps.filterEnabled ||
+                props.filterRange !== oldProps.filterRange ||
+                props.filterSoftRange !== oldProps.filterSoftRange;
+            if (filterNeedsUpdate) {
+                this.setState({ filterNeedsUpdate });
+            }
+        }
+    }
+    draw(params, extension) {
+        const { filterFBO, filterModel, filterNeedsUpdate } = this.state;
+        const { onFilteredItemsChange } = this.props;
+        if (filterNeedsUpdate && onFilteredItemsChange && filterModel) {
+            const { attributes: { filterValues, filterIndices } } = this.getAttributeManager();
+            filterModel.setVertexCount(this.getNumInstances());
+            const { gl } = this.context;
+            clear(gl, { framebuffer: filterFBO, color: [0, 0, 0, 0] });
+            filterModel
+                .updateModuleSettings(params.moduleParameters)
+                .setAttributes({
+                ...filterValues.getShaderAttributes(),
+                ...(filterIndices && filterIndices.getShaderAttributes())
+            })
+                .draw({
+                framebuffer: filterFBO,
+                parameters: {
+                    ...aggregator.parameters,
+                    viewport: [0, 0, filterFBO.width, filterFBO.height]
+                }
+            });
+            const color = readPixelsToArray(filterFBO);
+            let count = 0;
+            for (let i = 0; i < color.length; i++) {
+                count += color[i];
+            }
+            onFilteredItemsChange({ id: this.id, count });
+            this.state.filterNeedsUpdate = false;
+        }
+    }
+    finalizeState() {
+        const { filterFBO, filterModel } = this.state;
+        if (filterFBO) {
+            filterFBO.color.delete();
+            filterFBO.delete();
+            filterModel.delete();
+        }
+    }
+}
+DataFilterExtension.extensionName = 'DataFilterExtension';
+DataFilterExtension.defaultProps = defaultProps;

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;