@deck.gl/carto 9.0.10 → 9.0.12

package/dist/index.d.ts

@@ -1,16 +1,18 @@
 import { default as H3TileLayer } from "./layers/h3-tile-layer.js";
 import { default as _PointLabelLayer } from "./layers/point-label-layer.js";
 import { default as QuadbinTileLayer } from "./layers/quadbin-tile-layer.js";
+import { default as QuadbinHeatmapTileLayer } from "./layers/quadbin-heatmap-tile-layer.js";
 import { default as RasterTileLayer } from "./layers/raster-tile-layer.js";
 import { default as VectorTileLayer } from "./layers/vector-tile-layer.js";
 declare const CARTO_LAYERS: {
     H3TileLayer: typeof H3TileLayer;
     _PointLabelLayer: typeof _PointLabelLayer;
     QuadbinTileLayer: typeof QuadbinTileLayer;
+    QuadbinHeatmapTileLayer: typeof QuadbinHeatmapTileLayer;
     RasterTileLayer: typeof RasterTileLayer;
     VectorTileLayer: typeof VectorTileLayer;
 };
-export { CARTO_LAYERS, H3TileLayer, _PointLabelLayer, QuadbinTileLayer, RasterTileLayer, VectorTileLayer };
+export { CARTO_LAYERS, H3TileLayer, _PointLabelLayer, QuadbinTileLayer, QuadbinHeatmapTileLayer, RasterTileLayer, VectorTileLayer };
 export { default as BASEMAP } from "./basemap.js";
 export { default as colorBins } from "./style/color-bins-style.js";
 export { default as colorCategories } from "./style/color-categories-style.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,IAAI,WAAW,EAAC,kCAA+B;AAC9D,OAAO,EAAC,OAAO,IAAI,gBAAgB,EAAC,sCAAmC;AACvE,OAAO,EAAC,OAAO,IAAI,gBAAgB,EAAC,uCAAoC;AACxE,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,sCAAmC;AACtE,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,sCAAmC;AACtE,QAAA,MAAM,YAAY;;;;;;CAMjB,CAAC;AACF,OAAO,EACL,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,eAAe,EAChB,CAAC;AAEF,OAAO,EAAC,OAAO,IAAI,OAAO,EAAC,qBAAkB;AAC7C,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,oCAAiC;AAC9D,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,0CAAuC;AAC1E,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,0CAAuC;AAC1E,OAAO,EAAC,aAAa,EAAE,QAAQ,EAAE,KAAK,EAAC,uBAAoB;AAC3D,YAAY,EACV,eAAe,EACf,eAAe,EACf,MAAM,EACN,OAAO,EACP,WAAW,EACX,eAAe,EACf,YAAY,EACb,uBAAoB;AAErB,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,aAAa,EACb,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EAChB,2BAAwB;AAEzB,QAAA,MAAM,aAAa;;;;;;;;;;;;;CAalB,CAAC;AAEF,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,aAAa,EACb,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,aAAa,EACb,eAAe,EAChB,CAAC;AAEF,YAAY,EACV,aAAa,EACb,UAAU,EACV,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,0BAA0B,EAC1B,0BAA0B,EAC1B,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,mBAAmB,EACnB,yBAAyB,EACzB,yBAAyB,EACzB,2BAA2B,EAC3B,wBAAwB,EACxB,wBAAwB,EACxB,0BAA0B,EAC3B,2BAAwB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,IAAI,WAAW,EAAC,kCAA+B;AAC9D,OAAO,EAAC,OAAO,IAAI,gBAAgB,EAAC,sCAAmC;AACvE,OAAO,EAAC,OAAO,IAAI,gBAAgB,EAAC,uCAAoC;AACxE,OAAO,EAAC,OAAO,IAAI,uBAAuB,EAAC,+CAA4C;AACvF,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,sCAAmC;AACtE,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,sCAAmC;AACtE,QAAA,MAAM,YAAY;;;;;;;CAOjB,CAAC;AACF,OAAO,EACL,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,uBAAuB,EACvB,eAAe,EACf,eAAe,EAChB,CAAC;AAEF,OAAO,EAAC,OAAO,IAAI,OAAO,EAAC,qBAAkB;AAC7C,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,oCAAiC;AAC9D,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,0CAAuC;AAC1E,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,0CAAuC;AAC1E,OAAO,EAAC,aAAa,EAAE,QAAQ,EAAE,KAAK,EAAC,uBAAoB;AAC3D,YAAY,EACV,eAAe,EACf,eAAe,EACf,MAAM,EACN,OAAO,EACP,WAAW,EACX,eAAe,EACf,YAAY,EACb,uBAAoB;AAErB,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,aAAa,EACb,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EAChB,2BAAwB;AAEzB,QAAA,MAAM,aAAa;;;;;;;;;;;;;CAalB,CAAC;AAEF,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,aAAa,EACb,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,aAAa,EACb,eAAe,EAChB,CAAC;AAEF,YAAY,EACV,aAAa,EACb,UAAU,EACV,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,0BAA0B,EAC1B,0BAA0B,EAC1B,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,mBAAmB,EACnB,yBAAyB,EACzB,yBAAyB,EACzB,2BAA2B,EAC3B,wBAAwB,EACxB,wBAAwB,EACxB,0BAA0B,EAC3B,2BAAwB"}

package/dist/index.js

@@ -1,16 +1,18 @@
 import { default as H3TileLayer } from "./layers/h3-tile-layer.js";
 import { default as _PointLabelLayer } from "./layers/point-label-layer.js";
 import { default as QuadbinTileLayer } from "./layers/quadbin-tile-layer.js";
+import { default as QuadbinHeatmapTileLayer } from "./layers/quadbin-heatmap-tile-layer.js";
 import { default as RasterTileLayer } from "./layers/raster-tile-layer.js";
 import { default as VectorTileLayer } from "./layers/vector-tile-layer.js";
 const CARTO_LAYERS = {
     H3TileLayer,
     _PointLabelLayer,
     QuadbinTileLayer,
+    QuadbinHeatmapTileLayer,
     RasterTileLayer,
     VectorTileLayer
 };
-export { CARTO_LAYERS, H3TileLayer, _PointLabelLayer, QuadbinTileLayer, RasterTileLayer, VectorTileLayer };
+export { CARTO_LAYERS, H3TileLayer, _PointLabelLayer, QuadbinTileLayer, QuadbinHeatmapTileLayer, RasterTileLayer, VectorTileLayer };
 export { default as BASEMAP } from "./basemap.js";
 export { default as colorBins } from "./style/color-bins-style.js";
 export { default as colorCategories } from "./style/color-categories-style.js";

package/dist/layers/heatmap.d.ts

@@ -0,0 +1,36 @@
+import type { ShaderPass } from '@luma.gl/shadertools';
+import { Color } from '@deck.gl/core';
+export type HeatmapProps = {
+    /**
+     * Radius of the circle in pixels, to which the weight of an object is distributed.
+     *
+     * @default 30
+     */
+    radiusPixels?: number;
+    /**
+     * Controls how weight values are mapped to the `colorRange`, as an array of two numbers [`minValue`, `maxValue`].
+     *
+     * @default [0, 1]
+     */
+    colorDomain?: [number, number];
+    /**
+     * Specified as an array of colors [color1, color2, ...].
+     *
+     * @default `6-class YlOrRd` - [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6)
+     */
+    colorRange: Color[];
+    opacity: number;
+};
+export type HeatmapUniforms = {
+    radiusPixels?: number;
+    colorDomain?: [number, number];
+    color1?: [number, number, number];
+    color2?: [number, number, number];
+    color3?: [number, number, number];
+    color4?: [number, number, number];
+    color5?: [number, number, number];
+    color6?: [number, number, number];
+    opacity?: number;
+};
+export declare const heatmap: ShaderPass<HeatmapProps, HeatmapUniforms>;
+//# sourceMappingURL=heatmap.d.ts.map

package/dist/layers/heatmap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heatmap.d.ts","sourceRoot":"","sources":["../../src/layers/heatmap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AAErD,OAAO,EAAC,KAAK,EAAC,MAAM,eAAe,CAAC;AAgHpC,MAAM,MAAM,YAAY,GAAG;IACzB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B;;;;OAIG;IACH,UAAU,EAAE,KAAK,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,UAAU,CAAC,YAAY,EAAE,eAAe,CA+C7D,CAAC"}

package/dist/layers/heatmap.js

@@ -0,0 +1,128 @@
+import { random } from '@luma.gl/shadertools';
+const glsl = (s) => `${s}`;
+/**
+ * @filter       Heatmap
+ * @param radiusPixels Blur radius in pixels, controls smoothness of heatmap
+ * @param colorDomain Domain to apply to values prior to applying color scale
+ * @param color1-6 Colors to use in color scale
+ */
+const fs = `\
+uniform heatmapUniforms {
+float radiusPixels;
+vec2 colorDomain;
+vec3 color1;
+vec3 color2;
+vec3 color3;
+vec3 color4;
+vec3 color5;
+vec3 color6;
+float opacity;
+} heatmap;
+const float SUPPORT = 8.0;
+const vec4 STOPS = vec4(0.2, 0.4, 0.6, 0.8);
+vec3 colorGradient(float value) {
+vec3 c1;
+vec3 c2;
+vec2 range;
+if (value < STOPS.x) {
+range = vec2(0.0, STOPS.x);
+c1 = heatmap.color1; c2 = heatmap.color2;
+} else if (value < STOPS.y) {
+range = STOPS.xy;
+c1 = heatmap.color2; c2 = heatmap.color3;
+} else if (value < STOPS.z) {
+range = STOPS.yz;
+c1 = heatmap.color3; c2 = heatmap.color4;
+} else if (value < STOPS.w) {
+range = STOPS.zw;
+c1 = heatmap.color4; c2 = heatmap.color5;
+} else if (value < 1.0 ) {
+range = vec2(STOPS.w, 1.0);
+c1 = heatmap.color5; c2 = heatmap.color6;
+} else {
+range = vec2(1.0, 10.0);
+c1 = heatmap.color6; c2 = vec3(255.0);
+}
+float f = (value - range.x) / (range.y - range.x);
+return mix(c1, c2, f) / 255.0;
+}
+const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);
+float unpack(vec3 color) {
+return 255.0 * dot(color, SHIFT);
+}
+vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+float accumulator = 0.0;
+float offset = 0.5 * random(vec3(12.9898, 78.233, 151.7182), 0.0);
+const float sigma = SUPPORT / 3.0;
+const float a = -0.5 / (sigma * sigma);
+const float w0 = 1.0 / (2.0 * 3.141592653589793 * sigma * sigma);
+for (float t = -SUPPORT; t <= SUPPORT; t++) {
+for (float s = -SUPPORT; s <= SUPPORT; s++) {
+vec2 percent = (vec2(s, t) + offset - 0.5) / SUPPORT;
+vec2 delta = percent * heatmap.radiusPixels / texSize;
+vec4 offsetColor = texture(source, texCoord + delta);
+float value = unpack(offsetColor.rgb);
+float weight = w0 * exp(a * (s * s + t * t));
+accumulator += value * weight;
+}
+}
+float f = (accumulator - heatmap.colorDomain[0]) / (heatmap.colorDomain[1] - heatmap.colorDomain[0]);
+vec4 color = vec4(0.0);
+color.rgb = colorGradient(f);
+color.a = smoothstep(0.0, 0.1, f);
+color.a = pow(color.a, 1.0 / 2.2);
+color.a *= heatmap.opacity;
+return color;
+}
+`;
+const defaultColorRange = [
+    [255, 255, 178],
+    [254, 217, 118],
+    [254, 178, 76],
+    [253, 141, 60],
+    [240, 59, 32],
+    [189, 0, 38]
+];
+export const heatmap = {
+    name: 'heatmap',
+    uniformPropTypes: {
+        radiusPixels: { value: 20, min: 0, softMax: 100 },
+        colorDomain: { value: [0, 1] },
+        color1: { value: [0, 0, 0] },
+        color2: { value: [0, 0, 0] },
+        color3: { value: [0, 0, 0] },
+        color4: { value: [0, 0, 0] },
+        color5: { value: [0, 0, 0] },
+        color6: { value: [0, 0, 0] },
+        opacity: { value: 1, min: 0, max: 1 }
+    },
+    uniformTypes: {
+        radiusPixels: 'f32',
+        colorDomain: 'vec2<f32>',
+        color1: 'vec3<f32>',
+        color2: 'vec3<f32>',
+        color3: 'vec3<f32>',
+        color4: 'vec3<f32>',
+        color5: 'vec3<f32>',
+        color6: 'vec3<f32>',
+        opacity: 'f32'
+    },
+    getUniforms: opts => {
+        const { colorRange = defaultColorRange, radiusPixels = 20, colorDomain = [0, 1], opacity = 1 } = opts;
+        const [color1, color2, color3, color4, color5, color6] = colorRange;
+        return {
+            color1,
+            color2,
+            color3,
+            color4,
+            color5,
+            color6,
+            radiusPixels,
+            colorDomain,
+            opacity
+        };
+    },
+    dependencies: [random],
+    fs,
+    passes: [{ sampler: true }]
+};

package/dist/layers/post-process-utils.d.ts

@@ -0,0 +1,27 @@
+import { CompositeLayer, Layer, LayersList } from '@deck.gl/core';
+type Constructor<T> = (new (...args: any[]) => T) & {
+    layerName: string;
+};
+type DrawableCompositeLayer = CompositeLayer & {
+    renderLayers(): Layer<{}> | null | LayersList;
+};
+/**
+ * Modifier that marks a layer for Render-to-Target rendering.
+ * Resulting layer must be used as a sublayer of a layer created
+ * with `PostProcessModifier`
+ */
+export declare function RTTModifier(BaseLayer: any): {
+    new (): {
+        [x: string]: any;
+        draw(this: any, opts: any): void;
+    };
+    [x: string]: any;
+    layerName: string;
+};
+/**
+ * Modifier that returns the a modified Layer, which applies a
+ * postprocess effect to all subLayers created using `RTTModifier`
+ */
+export declare function PostProcessModifier<T extends Constructor<DrawableCompositeLayer>>(BaseLayer: T, effect: any): T;
+export {};
+//# sourceMappingURL=post-process-utils.d.ts.map

package/dist/layers/post-process-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-process-utils.d.ts","sourceRoot":"","sources":["../../src/layers/post-process-utils.ts"],"names":[],"mappings":"AACA,OAAO,EACL,cAAc,EACd,KAAK,EAGL,UAAU,EAGX,MAAM,eAAe,CAAC;AAoBvB,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,GAAG;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,CAAC;AACxE,KAAK,sBAAsB,GAAG,cAAc,GAAG;IAC7C,YAAY,IAAI,KAAK,CAAC,EAAE,CAAC,GAAG,IAAI,GAAG,UAAU,CAAC;CAC/C,CAAC;AAwBF;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,SAAS,KAAA;;;8BAIN,GAAG;;;;EAiBjC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,WAAW,CAAC,sBAAsB,CAAC,EAC/E,SAAS,EAAE,CAAC,EACZ,MAAM,EAAE,GAAG,GACV,CAAC,CAwFH"}

package/dist/layers/post-process-utils.js

@@ -0,0 +1,130 @@
+import { Layer, PostProcessEffect } from '@deck.gl/core';
+const TEXTURE_PROPS = {
+    format: 'rgba8unorm',
+    mipmaps: false,
+    sampler: {
+        minFilter: 'linear',
+        magFilter: 'linear',
+        addressModeU: 'clamp-to-edge',
+        addressModeV: 'clamp-to-edge'
+    }
+};
+function getPostProcessLayer(layer) {
+    while (layer.parent && !layer.applyPostProcess) {
+        layer = layer.parent;
+    }
+    return layer;
+}
+/**
+ * Dummy Layer that draws nothing, just calls back to root Layer
+ */
+class DrawCallbackLayer extends Layer {
+    static { this.layerName = 'DrawCallbackLayer'; }
+    initializeState() {
+        this.id = `draw-callback-${getPostProcessLayer(this).props.id}`;
+    }
+    _drawLayer() {
+        getPostProcessLayer(this).applyPostProcess();
+    }
+}
+/**
+ * Modifier that marks a layer for Render-to-Target rendering.
+ * Resulting layer must be used as a sublayer of a layer created
+ * with `PostProcessModifier`
+ */
+export function RTTModifier(BaseLayer) {
+    return class RTTLayer extends BaseLayer {
+        static { this.layerName = `RTT-${BaseLayer.layerName}`; }
+        draw(opts) {
+            const { moduleParameters } = opts;
+            const { picking } = moduleParameters;
+            const postProcessLayer = getPostProcessLayer(this);
+            if (!picking.isActive) {
+                postProcessLayer.enableRTT(opts);
+            }
+            // Draw actual layer
+            super.draw(opts);
+            if (!picking.isActive) {
+                postProcessLayer.disableRTT();
+            }
+        }
+    };
+}
+/**
+ * Modifier that returns the a modified Layer, which applies a
+ * postprocess effect to all subLayers created using `RTTModifier`
+ */
+export function PostProcessModifier(BaseLayer, effect) {
+    return class PostProcessLayer extends BaseLayer {
+        static { this.layerName = `PostProcess${BaseLayer.layerName}`; }
+        initializeState(context) {
+            super.initializeState(context);
+            this._createTextures();
+            this.internalState.postProcess = new PostProcessEffect(effect, this.props);
+            this.internalState.postProcess.setup(context);
+        }
+        updateState(params) {
+            super.updateState(params);
+            this.internalState.postProcess.setProps(this.props);
+        }
+        renderLayers() {
+            let subLayers = super.renderLayers();
+            if (!subLayers) {
+                return null;
+            }
+            subLayers = Array.isArray(subLayers) ? subLayers : [subLayers];
+            return [...subLayers, new DrawCallbackLayer()];
+        }
+        _createTextures() {
+            const { device } = this.context;
+            this.internalState.renderBuffers = [0, 1].map(i => {
+                return device.createFramebuffer({
+                    id: `layer-fbo-${i}`,
+                    colorAttachments: [device.createTexture(TEXTURE_PROPS)],
+                    depthStencilAttachment: 'depth16unorm'
+                });
+            });
+        }
+        _resizeBuffers(opts) {
+            // TODO we could likely render to a smaller buffer for better perf
+            const { moduleParameters } = opts;
+            const { viewport } = this.context;
+            const width = moduleParameters.devicePixelRatio * viewport.width;
+            const height = moduleParameters.devicePixelRatio * viewport.height;
+            this.internalState.renderBuffers.forEach((fbo) => fbo.resize({ width, height }));
+        }
+        enableRTT(opts) {
+            this._resizeBuffers(opts);
+            this.internalState.originalRenderPass = this.context.renderPass;
+            const [framebuffer] = this.internalState.renderBuffers;
+            // Create new render pass for RTT
+            this.internalState.internalRenderPass = this.context.device.beginRenderPass({
+                framebuffer,
+                parameters: { viewport: [0, 0, framebuffer.width, framebuffer.height] },
+                // Only clear on first render
+                clearColor: this.internalState.renderInProgress ? false : [0, 0, 0, 0]
+            });
+            this.internalState.renderInProgress = true;
+            this.context.renderPass = this.internalState.internalRenderPass;
+        }
+        disableRTT() {
+            // End render pass, and reinstate original
+            this.internalState.internalRenderPass.end();
+            this.context.renderPass = this.internalState.originalRenderPass;
+        }
+        applyPostProcess() {
+            if (!this.internalState.renderInProgress) {
+                return;
+            }
+            // Apply post process effect
+            const [inputBuffer, swapBuffer] = this.internalState.renderBuffers;
+            const { framebuffer: target } = this.context.renderPass.props;
+            this.internalState.postProcess.postRender({
+                inputBuffer,
+                swapBuffer,
+                target
+            });
+            this.internalState.renderInProgress = false;
+        }
+    };
+}

package/dist/layers/quadbin-heatmap-tile-layer.d.ts

@@ -0,0 +1,21 @@
+import { Accessor, CompositeLayer, DefaultProps, Layer } from '@deck.gl/core';
+import { HeatmapProps } from "./heatmap.js";
+import { QuadbinTileLayerProps } from "./quadbin-tile-layer.js";
+/** All properties supported by QuadbinHeatmapTileLayer. */
+export type QuadbinHeatmapTileLayerProps<DataT = unknown> = _QuadbinHeatmapTileLayerProps<DataT> & QuadbinTileLayerProps;
+/** Properties added by QuadbinHeatmapTileLayer. */
+type _QuadbinHeatmapTileLayerProps<DataT> = QuadbinTileLayerProps<DataT> & HeatmapProps & {
+    /**
+     * The weight of each object.
+     *
+     * @default 1
+     */
+    getWeight?: Accessor<DataT, number>;
+};
+declare class QuadbinHeatmapTileLayer<DataT = any, ExtraProps extends {} = {}> extends CompositeLayer<ExtraProps & Required<_QuadbinHeatmapTileLayerProps<DataT>>> {
+    static layerName: string;
+    static defaultProps: DefaultProps<QuadbinHeatmapTileLayerProps<unknown>>;
+    renderLayers(): Layer;
+}
+export default QuadbinHeatmapTileLayer;
+//# sourceMappingURL=quadbin-heatmap-tile-layer.d.ts.map

package/dist/layers/quadbin-heatmap-tile-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quadbin-heatmap-tile-layer.d.ts","sourceRoot":"","sources":["../../src/layers/quadbin-heatmap-tile-layer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,QAAQ,EAAE,cAAc,EAAE,YAAY,EAAE,KAAK,EAAC,MAAM,eAAe,CAAC;AAG5E,OAAO,EAAC,YAAY,EAAU,qBAAkB;AAEhD,OAAyB,EAAC,qBAAqB,EAAC,gCAA6B;AAkD7E,2DAA2D;AAC3D,MAAM,MAAM,4BAA4B,CAAC,KAAK,GAAG,OAAO,IAAI,6BAA6B,CAAC,KAAK,CAAC,GAC9F,qBAAqB,CAAC;AAExB,mDAAmD;AACnD,KAAK,6BAA6B,CAAC,KAAK,IAAI,qBAAqB,CAAC,KAAK,CAAC,GACtE,YAAY,GAAG;IACb;;;;OAIG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CACrC,CAAC;AAEJ,cAAM,uBAAuB,CAAC,KAAK,GAAG,GAAG,EAAE,UAAU,SAAS,EAAE,GAAG,EAAE,CAAE,SAAQ,cAAc,CAC3F,UAAU,GAAG,QAAQ,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC,CAC5D;IACC,MAAM,CAAC,SAAS,SAA6B;IAC7C,MAAM,CAAC,YAAY,sDAAgB;IAEnC,YAAY,IAAI,KAAK;CAyCtB;AAED,eAAe,uBAAuB,CAAC"}

package/dist/layers/quadbin-heatmap-tile-layer.js

@@ -0,0 +1,83 @@
+import { getResolution } from 'quadbin';
+import { CompositeLayer } from '@deck.gl/core';
+import { SolidPolygonLayer } from '@deck.gl/layers';
+import { heatmap } from "./heatmap.js";
+import { RTTModifier, PostProcessModifier } from "./post-process-utils.js";
+import QuadbinTileLayer from "./quadbin-tile-layer.js";
+// Modified polygon layer to draw offscreen and output value expected by heatmap
+class RTTSolidPolygonLayer extends RTTModifier(SolidPolygonLayer) {
+    static { this.layerName = 'RTTSolidPolygonLayer'; }
+    getShaders(type) {
+        const shaders = super.getShaders(type);
+        shaders.inject = {
+            'vs:#decl': 'uniform float cellResolution;',
+            'vs:DECKGL_FILTER_COLOR': `
+  const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);
+  float value = 255.0 * dot(SHIFT, color.rgb);
+
+  // Keep "power" delivered to screen constant when tiles update
+  float relativeZoom = log2(project_uScale) - cellResolution + 3.5; // range 0-1
+  float relativeArea = pow(2.0, -2.0 * relativeZoom); // range 0.25-1
+  value *= relativeArea;
+
+  // Pack float into 3 channels to pass to heatmap shader
+  color = vec4(mod(vec3(value, floor(value / SHIFT.yz)), 256.0), 255.0) / 255.0;
+      `
+        };
+        return shaders;
+    }
+    draw(opts) {
+        const cell0 = this.props.data[0];
+        const cellResolution = Number(getResolution(cell0.id));
+        for (const model of this.state.models) {
+            model.setUniforms({ cellResolution });
+        }
+        super.draw(opts);
+    }
+}
+// Modify QuadbinTileLayer to apply heatmap post process effect
+const PostProcessQuadbinTileLayer = PostProcessModifier(QuadbinTileLayer, heatmap);
+function encodeWeight(w) {
+    return [w % 256, Math.floor(w / 256), Math.floor(w / (256 * 256))];
+}
+const defaultProps = {
+    ...QuadbinTileLayer.defaultProps,
+    getWeight: { type: 'accessor', value: 1 }
+};
+class QuadbinHeatmapTileLayer extends CompositeLayer {
+    static { this.layerName = 'QuadbinHeatmapTileLayer'; }
+    static { this.defaultProps = defaultProps; }
+    renderLayers() {
+        const { getWeight, colorDomain, colorRange, radiusPixels, _subLayerProps } = this.props;
+        // Inject modified polygon layer as sublayer into TileLayer
+        const subLayerProps = {
+            ..._subLayerProps,
+            cell: {
+                ..._subLayerProps?.cell,
+                _subLayerProps: {
+                    ..._subLayerProps?.cell?._subLayerProps,
+                    fill: {
+                        ..._subLayerProps?.cell?._subLayerProps?.fill,
+                        type: RTTSolidPolygonLayer
+                    }
+                }
+            }
+        };
+        const getFillColor = typeof getWeight === 'function'
+            ? (d, info) => encodeWeight(getWeight(d, info))
+            : encodeWeight(getWeight);
+        return new PostProcessQuadbinTileLayer(this.getSubLayerProps({
+            id: 'heatmap',
+            data: this.props.data,
+            getFillColor,
+            colorDomain,
+            colorRange,
+            radiusPixels,
+            _subLayerProps: subLayerProps,
+            updateTriggers: {
+                getPosition: this.props.updateTriggers.getWeight
+            }
+        }));
+    }
+}
+export default QuadbinHeatmapTileLayer;

package/dist/layers/schema/carto-raster-tile-loader.js

@@ -1,7 +1,7 @@
 import { TileReader } from "./carto-raster-tile.js";
 import { parsePbf } from "./tile-loader-utils.js";
 import { getWorkerUrl } from "../../utils.js";
-const VERSION = typeof "9.0.10" !== 'undefined' ? "9.0.10" : 'latest';
+const VERSION = typeof "9.0.12" !== 'undefined' ? "9.0.12" : 'latest';
 const id = 'cartoRasterTile';
 const DEFAULT_OPTIONS = {
     cartoRasterTile: {

package/dist/layers/schema/carto-spatial-tile-loader.js

@@ -2,7 +2,7 @@ import { TileReader } from "./carto-spatial-tile.js";
 import { parsePbf } from "./tile-loader-utils.js";
 import { getWorkerUrl } from "../../utils.js";
 import { binaryToSpatialjson } from "./spatialjson-utils.js";
-const VERSION = typeof "9.0.10" !== 'undefined' ? "9.0.10" : 'latest';
+const VERSION = typeof "9.0.12" !== 'undefined' ? "9.0.12" : 'latest';
 const id = 'cartoSpatialTile';
 const DEFAULT_OPTIONS = {
     cartoSpatialTile: {

package/dist/layers/schema/carto-vector-tile-loader.js

@@ -2,7 +2,7 @@ import earcut from 'earcut';
 import { TileReader } from "./carto-tile.js";
 import { parsePbf } from "./tile-loader-utils.js";
 import { getWorkerUrl } from "../../utils.js";
-const VERSION = typeof "9.0.10" !== 'undefined' ? "9.0.10" : 'latest';
+const VERSION = typeof "9.0.12" !== 'undefined' ? "9.0.12" : 'latest';
 const id = 'cartoVectorTile';
 const DEFAULT_OPTIONS = {
     cartoVectorTile: {