@deck.gl/aggregation-layers 9.4.0-alpha.2 → 9.4.0-beta.1

package/dist.webgl-only/common/aggregator/gpu-aggregator/webgl-aggregation-transform.js

@@ -0,0 +1,222 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { BufferTransform } from '@luma.gl/engine';
+import { createRenderTarget } from "./utils.js";
+import { TEXTURE_WIDTH } from "./webgl-bin-sorter.js";
+import { aggregatorTransformUniforms } from "./aggregation-transform-uniforms.js";
+const MAX_FLOAT32 = 3e38;
+export class WebGLAggregationTransform {
+    constructor(device, props) {
+        /** Packed from bin ids */
+        this.binBuffer = null;
+        /** Packed values from each channel of each bin
+         * Stride is number of channels * 4 bytes (float32)
+         */
+        this.valueBuffer = null;
+        /** Aggregated [min, max] for each channel */
+        this._domains = null;
+        this.device = device;
+        this.channelCount = props.channelCount;
+        this.transform = createTransform(device, props);
+        this.domainFBO = createRenderTarget(device, 2, 1);
+    }
+    destroy() {
+        this.transform.destroy();
+        this.binBuffer?.destroy();
+        this.valueBuffer?.destroy();
+        this.domainFBO.colorAttachments[0].texture.destroy();
+        this.domainFBO.destroy();
+    }
+    get domains() {
+        if (!this._domains) {
+            // Domain model has run, but result has not been read to CPU
+            const buffer = this.device.readPixelsToArrayWebGL(this.domainFBO).buffer;
+            const domain = new Float32Array(buffer);
+            this._domains = [
+                [-domain[4], domain[0]],
+                [-domain[5], domain[1]],
+                [-domain[6], domain[2]]
+            ].slice(0, this.channelCount);
+        }
+        return this._domains;
+    }
+    setDimensions(binCount, binIdRange) {
+        const { model, transformFeedback } = this.transform;
+        model.setVertexCount(binCount);
+        const aggregatorTransformProps = {
+            binIdRange: [
+                binIdRange[0][0],
+                binIdRange[0][1],
+                binIdRange[1]?.[0] || 0,
+                binIdRange[1]?.[1] || 0
+            ]
+        };
+        model.shaderInputs.setProps({ aggregatorTransform: aggregatorTransformProps });
+        // Only destroy existing buffer if it is not large enough
+        const binBufferByteLength = binCount * binIdRange.length * 4;
+        if (!this.binBuffer || this.binBuffer.byteLength < binBufferByteLength) {
+            this.binBuffer?.destroy();
+            this.binBuffer = this.device.createBuffer({ byteLength: binBufferByteLength });
+            transformFeedback.setBuffer('binIds', this.binBuffer);
+        }
+        const valueBufferByteLength = binCount * this.channelCount * 4;
+        if (!this.valueBuffer || this.valueBuffer.byteLength < valueBufferByteLength) {
+            this.valueBuffer?.destroy();
+            this.valueBuffer = this.device.createBuffer({ byteLength: valueBufferByteLength });
+            transformFeedback.setBuffer('values', this.valueBuffer);
+        }
+    }
+    update(bins, operations) {
+        if (!bins) {
+            return;
+        }
+        const transform = this.transform;
+        const target = this.domainFBO;
+        const isCount = [0, 1, 2].map(i => (operations[i] === 'COUNT' ? 1 : 0));
+        const isMean = [0, 1, 2].map(i => (operations[i] === 'MEAN' ? 1 : 0));
+        const aggregatorTransformProps = {
+            isCount: isCount,
+            isMean: isMean,
+            bins
+        };
+        transform.model.shaderInputs.setProps({ aggregatorTransform: aggregatorTransformProps });
+        transform.run({
+            id: 'gpu-aggregation-domain',
+            framebuffer: target,
+            discard: false,
+            parameters: {
+                viewport: [0, 0, 2, 1]
+            },
+            clearColor: [-MAX_FLOAT32, -MAX_FLOAT32, -MAX_FLOAT32, 0],
+            clearDepth: false,
+            clearStencil: false
+        });
+        // Clear the last read results. This will be lazy-populated if used.
+        this._domains = null;
+    }
+}
+function createTransform(device, props) {
+    const vs = /* glsl */ `\
+#version 300 es
+#define SHADER_NAME gpu-aggregation-domain-vertex
+
+uniform sampler2D bins;
+
+#if NUM_DIMS == 1
+out float binIds;
+#else
+out vec2 binIds;
+#endif
+
+#if NUM_CHANNELS == 1
+flat out float values;
+#elif NUM_CHANNELS == 2
+flat out vec2 values;
+#else
+flat out vec3 values;
+#endif
+
+const float NAN = intBitsToFloat(-1);
+
+void main() {
+  int row = gl_VertexID / SAMPLER_WIDTH;
+  int col = gl_VertexID - row * SAMPLER_WIDTH;
+  vec4 weights = texelFetch(bins, ivec2(col, row), 0);
+  vec3 value3 = mix(
+    mix(weights.rgb, vec3(weights.a), aggregatorTransform.isCount),
+    weights.rgb / max(weights.a, 1.0),
+    aggregatorTransform.isMean
+  );
+  if (weights.a == 0.0) {
+    value3 = vec3(NAN);
+  }
+
+#if NUM_DIMS == 1
+  binIds = float(gl_VertexID + aggregatorTransform.binIdRange.x);
+#else
+  int y = gl_VertexID / (aggregatorTransform.binIdRange.y - aggregatorTransform.binIdRange.x);
+  int x = gl_VertexID - y * (aggregatorTransform.binIdRange.y - aggregatorTransform.binIdRange.x);
+  binIds.y = float(y + aggregatorTransform.binIdRange.z);
+  binIds.x = float(x + aggregatorTransform.binIdRange.x);
+#endif
+
+#if NUM_CHANNELS == 3
+  values = value3;
+#elif NUM_CHANNELS == 2
+  values = value3.xy;
+#else
+  values = value3.x;
+#endif
+
+  gl_Position = vec4(0., 0., 0., 1.);
+  // This model renders into a 2x1 texture to obtain min and max simultaneously.
+  // See comments in fragment shader
+  gl_PointSize = 2.0;
+}
+`;
+    const fs = /* glsl */ `\
+#version 300 es
+#define SHADER_NAME gpu-aggregation-domain-fragment
+
+precision highp float;
+
+#if NUM_CHANNELS == 1
+flat in float values;
+#elif NUM_CHANNELS == 2
+flat in vec2 values;
+#else
+flat in vec3 values;
+#endif
+
+out vec4 fragColor;
+
+void main() {
+  vec3 value3;
+#if NUM_CHANNELS == 3
+  value3 = values;
+#elif NUM_CHANNELS == 2
+  value3.xy = values;
+#else
+  value3.x = values;
+#endif
+  if (isnan(value3.x)) discard;
+  // This shader renders into a 2x1 texture with blending=max
+  // The left pixel yields the max value of each channel
+  // The right pixel yields the min value of each channel
+  if (gl_FragCoord.x < 1.0) {
+    fragColor = vec4(value3, 1.0);
+  } else {
+    fragColor = vec4(-value3, 1.0);
+  }
+}
+`;
+    // Enable intBitsToFloat on Firefox + Nvidia driver: https://github.com/visgl/deck.gl/pull/10069
+    if (device.type === 'webgl') {
+        // @ts-expect-error WebGLDevice method
+        device.getExtension('GL_ARB_shader_bit_encoding');
+    }
+    return new BufferTransform(device, {
+        vs,
+        fs,
+        topology: 'point-list',
+        modules: [aggregatorTransformUniforms],
+        parameters: {
+            blend: true,
+            blendColorSrcFactor: 'one',
+            blendColorDstFactor: 'one',
+            blendColorOperation: 'max',
+            blendAlphaSrcFactor: 'one',
+            blendAlphaDstFactor: 'one',
+            blendAlphaOperation: 'max'
+        },
+        defines: {
+            NUM_DIMS: props.dimensions,
+            NUM_CHANNELS: props.channelCount,
+            SAMPLER_WIDTH: TEXTURE_WIDTH
+        },
+        varyings: ['binIds', 'values'],
+        disableWarnings: true
+    });
+}
+//# sourceMappingURL=webgl-aggregation-transform.js.map

package/dist.webgl-only/common/aggregator/gpu-aggregator/webgl-aggregation-transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-aggregation-transform.js","sourceRoot":"","sources":["../../../../src/common/aggregator/gpu-aggregator/webgl-aggregation-transform.ts"],"names":[],"mappings":"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"}

package/dist.webgl-only/common/aggregator/gpu-aggregator/webgl-aggregator.js

@@ -0,0 +1,203 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { WebGLBinSorter } from "./webgl-bin-sorter.js";
+import { WebGLAggregationTransform } from "./webgl-aggregation-transform.js";
+import { _deepEqual as deepEqual, log } from '@deck.gl/core';
+/** An Aggregator implementation that calculates aggregation on the GPU */
+export class WebGLAggregator {
+    /** Checks if the current device supports GPU aggregation */
+    static isSupported(device) {
+        return (device.features.has('float32-renderable-webgl') &&
+            device.features.has('texture-blend-float-webgl'));
+    }
+    constructor(device, props) {
+        this.binCount = 0;
+        /** Cached outputs */
+        this.binIds = null;
+        this.results = [];
+        this.device = device;
+        this.dimensions = props.dimensions;
+        this.channelCount = props.channelCount;
+        this.props = {
+            ...props,
+            pointCount: 0,
+            binIdRange: [[0, 0]],
+            operations: [],
+            attributes: {},
+            binOptions: {}
+        };
+        this.needsUpdate = new Array(this.channelCount).fill(true);
+        this.binSorter = new WebGLBinSorter(device, props);
+        this.aggregationTransform = new WebGLAggregationTransform(device, props);
+        this.setProps(props);
+    }
+    getBins() {
+        const buffer = this.aggregationTransform.binBuffer;
+        if (!buffer) {
+            return null;
+        }
+        if (this.binIds?.buffer !== buffer) {
+            // deck.gl Attribute.setBinaryValue uses shallow comparison to determine if attribute value has changed
+            // For performance, only create a new binary attribute descriptor when Buffer changes
+            this.binIds = { buffer, type: 'float32', size: this.dimensions };
+        }
+        return this.binIds;
+    }
+    /** Returns an accessor to the output for a given channel. */
+    getResult(channel) {
+        const buffer = this.aggregationTransform.valueBuffer;
+        if (!buffer || channel >= this.channelCount) {
+            return null;
+        }
+        if (this.results[channel]?.buffer !== buffer) {
+            this.results[channel] = {
+                buffer,
+                type: 'float32',
+                size: 1,
+                stride: this.channelCount * 4,
+                offset: channel * 4
+            };
+        }
+        return this.results[channel];
+    }
+    /** Returns the [min, max] of aggregated values for a given channel. */
+    getResultDomain(channel) {
+        return this.aggregationTransform.domains[channel];
+    }
+    /** Returns the information for a given bin. */
+    getBin(index) {
+        if (index < 0 || index >= this.binCount) {
+            return null;
+        }
+        const { binIdRange } = this.props;
+        let id;
+        if (this.dimensions === 1) {
+            id = [index + binIdRange[0][0]];
+        }
+        else {
+            const [[x0, x1], [y0]] = binIdRange;
+            const width = x1 - x0;
+            id = [(index % width) + x0, Math.floor(index / width) + y0];
+        }
+        const pixel = this.binSorter.getBinValues(index);
+        if (!pixel) {
+            return null;
+        }
+        const count = pixel[3];
+        const value = [];
+        for (let channel = 0; channel < this.channelCount; channel++) {
+            const operation = this.props.operations[channel];
+            if (operation === 'COUNT') {
+                value[channel] = count;
+            }
+            else if (count === 0) {
+                value[channel] = NaN;
+            }
+            else {
+                value[channel] = operation === 'MEAN' ? pixel[channel] / count : pixel[channel];
+            }
+        }
+        return { id, value, count };
+    }
+    /** Release GPU resources */
+    destroy() {
+        this.binSorter.destroy();
+        this.aggregationTransform.destroy();
+    }
+    /** Update aggregation props. Normalize prop values and set change flags. */
+    // eslint-disable-next-line complexity, max-statements
+    setProps(props) {
+        const oldProps = this.props;
+        // Update local settings. These will set the flag this._needsUpdate
+        if ('binIdRange' in props && !deepEqual(props.binIdRange, oldProps.binIdRange, 2)) {
+            const binIdRange = props.binIdRange;
+            log.assert(binIdRange.length === this.dimensions);
+            if (this.dimensions === 1) {
+                const [[x0, x1]] = binIdRange;
+                this.binCount = x1 - x0;
+            }
+            else {
+                const [[x0, x1], [y0, y1]] = binIdRange;
+                this.binCount = (x1 - x0) * (y1 - y0);
+            }
+            this.binSorter.setDimensions(this.binCount, binIdRange);
+            this.aggregationTransform.setDimensions(this.binCount, binIdRange);
+            this.setNeedsUpdate();
+        }
+        if (props.operations) {
+            for (let channel = 0; channel < this.channelCount; channel++) {
+                if (props.operations[channel] !== oldProps.operations[channel]) {
+                    this.setNeedsUpdate(channel);
+                }
+            }
+        }
+        if (props.pointCount !== undefined && props.pointCount !== oldProps.pointCount) {
+            this.binSorter.setModelProps({ vertexCount: props.pointCount });
+            this.setNeedsUpdate();
+        }
+        if (props.binOptions) {
+            if (!deepEqual(props.binOptions, oldProps.binOptions, 2)) {
+                this.setNeedsUpdate();
+            }
+            this.binSorter.model.shaderInputs.setProps({ binOptions: props.binOptions });
+        }
+        if (props.attributes) {
+            const attributeBuffers = {};
+            const constantAttributes = {};
+            for (const attribute of Object.values(props.attributes)) {
+                for (const [attributeName, value] of Object.entries(attribute.getValue())) {
+                    if (ArrayBuffer.isView(value)) {
+                        constantAttributes[attributeName] = value;
+                    }
+                    else if (value) {
+                        attributeBuffers[attributeName] = value;
+                    }
+                }
+            }
+            this.binSorter.setModelProps({ attributes: attributeBuffers, constantAttributes });
+        }
+        if (props.shaderModuleProps) {
+            this.binSorter.setModelProps({ shaderModuleProps: props.shaderModuleProps });
+        }
+        Object.assign(this.props, props);
+    }
+    /** Flags a channel to need update.
+     * This is called internally by setProps() if certain props change
+     * Users of this class still need to manually set the dirty flag sometimes, because even if no props changed
+     * the underlying buffers could have been updated and require rerunning the aggregation
+     * @param {number} channel - mark the given channel as dirty. If not provided, all channels will be updated.
+     */
+    setNeedsUpdate(channel) {
+        if (channel === undefined) {
+            this.needsUpdate.fill(true);
+        }
+        else {
+            this.needsUpdate[channel] = true;
+        }
+    }
+    update() { }
+    /** Run aggregation */
+    preDraw() {
+        if (!this.needsUpdate.some(Boolean)) {
+            return;
+        }
+        const { operations } = this.props;
+        const operationsToUpdate = this.needsUpdate.map((needsUpdate, i) => needsUpdate ? operations[i] : null);
+        // Render data to bins
+        this.binSorter.update(operationsToUpdate);
+        // Read to buffer and calculate domain
+        this.aggregationTransform.update(this.binSorter.texture, operations);
+        for (let i = 0; i < this.channelCount; i++) {
+            if (this.needsUpdate[i]) {
+                this.needsUpdate[i] = false;
+                this.props.onUpdate?.({ channel: i });
+            }
+        }
+        // Uncomment to debug
+        // console.log('binsFBO', new Float32Array(this.device.readPixelsToArrayWebGL(this.binSorter.texture!).buffer));
+        // console.log('binsBuffer', new Float32Array(this.aggregationTransform.binBuffer?.readSyncWebGL().buffer!));
+        // console.log('resultBuffer', new Float32Array(this.aggregationTransform.valueBuffer?.readSyncWebGL().buffer!));
+    }
+}
+//# sourceMappingURL=webgl-aggregator.js.map

package/dist.webgl-only/common/aggregator/gpu-aggregator/webgl-aggregator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-aggregator.js","sourceRoot":"","sources":["../../../../src/common/aggregator/gpu-aggregator/webgl-aggregator.ts"],"names":[],"mappings":"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"}

package/dist.webgl-only/common/aggregator/gpu-aggregator/webgl-bin-sorter.js

@@ -0,0 +1,225 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { Model } from '@luma.gl/engine';
+import { createRenderTarget } from "./utils.js";
+import { binSorterUniforms } from "./bin-sorter-uniforms.js";
+const COLOR_CHANNELS = [0x1, 0x2, 0x4, 0x8]; // GPU color mask RED, GREEN, BLUE, ALPHA
+const MAX_FLOAT32 = 3e38;
+const EMPTY_MASKS = { SUM: 0, MEAN: 0, MIN: 0, MAX: 0, COUNT: 0 };
+export const TEXTURE_WIDTH = 1024;
+/**
+ * This class manages the resources for performing the first step of aggregation
+ * Sort a list of data points into a number of bins
+ */
+export class WebGLBinSorter {
+    constructor(device, props) {
+        /**
+         * A packed texture in which each pixel represents a bin.
+         * The index of the pixel in the memory layout is the bin index.
+         * Alpha value is the count of data points that fall into this bin
+         * R,G,B values are the aggregated values of each channel:
+         *   - Sum of all data points if operation is 'SUM', or 'MEAN'
+         *   - Min of all data points if operation is 'MIN'
+         *   - Max of all data points if operation is 'MAX'
+         */
+        this.binsFBO = null;
+        this.device = device;
+        this.model = createModel(device, props);
+    }
+    get texture() {
+        return this.binsFBO ? this.binsFBO.colorAttachments[0].texture : null;
+    }
+    destroy() {
+        this.model.destroy();
+        this.binsFBO?.colorAttachments[0].texture.destroy();
+        this.binsFBO?.destroy();
+    }
+    getBinValues(index) {
+        if (!this.binsFBO) {
+            return null;
+        }
+        const x = index % TEXTURE_WIDTH;
+        const y = Math.floor(index / TEXTURE_WIDTH);
+        const buffer = this.device.readPixelsToArrayWebGL(this.binsFBO, {
+            sourceX: x,
+            sourceY: y,
+            sourceWidth: 1,
+            sourceHeight: 1
+        }).buffer;
+        return new Float32Array(buffer);
+    }
+    setDimensions(binCount, binIdRange) {
+        const width = TEXTURE_WIDTH;
+        const height = Math.ceil(binCount / width);
+        // Only destroy existing texture if it is not large enough
+        if (!this.binsFBO) {
+            this.binsFBO = createRenderTarget(this.device, width, height);
+        }
+        else if (this.binsFBO.height < height) {
+            this.binsFBO.resize({ width, height });
+        }
+        const binSorterProps = {
+            binIdRange: [
+                binIdRange[0][0],
+                binIdRange[0][1],
+                binIdRange[1]?.[0] || 0,
+                binIdRange[1]?.[1] || 0
+            ],
+            targetSize: [this.binsFBO.width, this.binsFBO.height]
+        };
+        this.model.shaderInputs.setProps({ binSorter: binSorterProps });
+    }
+    setModelProps(props) {
+        const model = this.model;
+        if (props.attributes) {
+            model.setAttributes(props.attributes);
+        }
+        if (props.constantAttributes) {
+            model.setConstantAttributes(props.constantAttributes);
+        }
+        if (props.vertexCount !== undefined) {
+            model.setVertexCount(props.vertexCount);
+        }
+        if (props.shaderModuleProps) {
+            model.shaderInputs.setProps(props.shaderModuleProps);
+        }
+    }
+    /** Update aggregation */
+    update(
+    /** The aggregation operation for each channel. Use null to skip update. */
+    operations) {
+        if (!this.binsFBO) {
+            return;
+        }
+        const masks = getMaskByOperation(operations);
+        this._updateBins('SUM', masks.SUM + masks.MEAN);
+        this._updateBins('MIN', masks.MIN);
+        this._updateBins('MAX', masks.MAX);
+    }
+    /** Recalculate aggregation on the given channels using the given operation */
+    _updateBins(operation, 
+    /** GPU bit mask of one or more channels that should be updated */
+    colorMask) {
+        if (colorMask === 0) {
+            return;
+        }
+        colorMask |= COLOR_CHANNELS[3]; // Also renders to the alpha channel (point count)
+        const model = this.model;
+        const target = this.binsFBO;
+        const initialValue = operation === 'MAX' ? -MAX_FLOAT32 : operation === 'MIN' ? MAX_FLOAT32 : 0;
+        const renderPass = this.device.beginRenderPass({
+            id: `gpu-aggregation-${operation}`,
+            framebuffer: target,
+            parameters: {
+                viewport: [0, 0, target.width, target.height],
+                colorMask
+            },
+            clearColor: [initialValue, initialValue, initialValue, 0],
+            clearDepth: false,
+            clearStencil: false
+        });
+        model.setParameters({
+            blend: true,
+            blendColorSrcFactor: 'one',
+            blendColorDstFactor: 'one',
+            blendAlphaSrcFactor: 'one',
+            blendAlphaDstFactor: 'one',
+            blendColorOperation: operation === 'MAX' ? 'max' : operation === 'MIN' ? 'min' : 'add',
+            blendAlphaOperation: 'add'
+        });
+        model.draw(renderPass);
+        renderPass.end();
+    }
+}
+/** Convert a [channel -> operation] map to a [operation -> GPU color mask] map */
+function getMaskByOperation(operations) {
+    const result = { ...EMPTY_MASKS };
+    for (let channel = 0; channel < operations.length; channel++) {
+        const op = operations[channel];
+        if (op) {
+            result[op] += COLOR_CHANNELS[channel];
+        }
+    }
+    return result;
+}
+function createModel(device, props) {
+    let userVs = props.vs;
+    if (props.dimensions === 2) {
+        // If user provides 2d bin IDs, convert them to 1d indices for data packing
+        userVs += /* glsl */ `
+void getBin(out int binId) {
+  ivec2 binId2;
+  getBin(binId2);
+  if (binId2.x < binSorter.binIdRange.x || binId2.x >= binSorter.binIdRange.y) {
+    binId = -1;
+  } else {
+    binId = (binId2.y - binSorter.binIdRange.z) * (binSorter.binIdRange.y - binSorter.binIdRange.x) + binId2.x;
+  }
+}
+`;
+    }
+    const vs = `\
+#version 300 es
+#define SHADER_NAME gpu-aggregation-sort-bins-vertex
+
+${userVs}
+
+out vec3 v_Value;
+
+void main() {
+  int binIndex;
+  getBin(binIndex);
+  binIndex = binIndex - binSorter.binIdRange.x;
+  if (binIndex < 0) {
+    gl_Position = vec4(0.);
+    return;
+  }
+  int row = binIndex / binSorter.targetSize.x;
+  int col = binIndex - row * binSorter.targetSize.x;
+  vec2 position = (vec2(col, row) + 0.5) / vec2(binSorter.targetSize) * 2.0 - 1.0;
+  gl_Position = vec4(position, 0.0, 1.0);
+  gl_PointSize = 1.0;
+
+#if NUM_CHANNELS == 3
+  getValue(v_Value);
+#elif NUM_CHANNELS == 2
+  getValue(v_Value.xy);
+#else
+  getValue(v_Value.x);
+#endif
+}
+`;
+    const fs = /* glsl */ `\
+#version 300 es
+#define SHADER_NAME gpu-aggregation-sort-bins-fragment
+
+precision highp float;
+
+in vec3 v_Value;
+out vec4 fragColor;
+
+void main() {
+  fragColor.xyz = v_Value;
+
+  #ifdef MODULE_GEOMETRY
+  geometry.uv = vec2(0.);
+  DECKGL_FILTER_COLOR(fragColor, geometry);
+  #endif
+
+  fragColor.w = 1.0;
+}
+`;
+    const model = new Model(device, {
+        bufferLayout: props.bufferLayout,
+        modules: [...(props.modules || []), binSorterUniforms],
+        defines: { ...props.defines, NON_INSTANCED_MODEL: 1, NUM_CHANNELS: props.channelCount },
+        isInstanced: false,
+        vs,
+        fs,
+        topology: 'point-list',
+        disableWarnings: true
+    });
+    return model;
+}
+//# sourceMappingURL=webgl-bin-sorter.js.map