@openglobus/og 0.17.2 → 0.18.1

package/lib/js/entity/LabelWorker.d.ts

@@ -0,0 +1,15 @@
+import { BaseWorker } from "../utils/BaseWorker";
+import { Label } from "../entity/Label";
+import { LabelHandler } from "../entity/LabelHandler";
+export declare const LOCK_UPDATE = -2;
+export declare const LOCK_FREE = -1;
+interface LabelInfo {
+    label: Label;
+    handler: LabelHandler;
+}
+declare class LabelWorker extends BaseWorker<LabelInfo> {
+    constructor(numWorkers?: number);
+    protected _onMessage(e: MessageEvent): void;
+    make(data: LabelInfo): void;
+}
+export { LabelWorker };

package/lib/js/entity/LabelWorker.js

@@ -0,0 +1,163 @@
+import { BaseWorker } from "../utils/BaseWorker";
+export const LOCK_UPDATE = -2;
+export const LOCK_FREE = -1;
+class LabelWorker extends BaseWorker {
+    constructor(numWorkers = 4) {
+        super(numWorkers, LABEL_PROGRAM);
+    }
+    _onMessage(e) {
+        let s = this._source.get(e.data.id);
+        if (s.label._lockId === LOCK_UPDATE) {
+            requestAnimationFrame(() => {
+                this.make({ handler: s.handler, label: s.label });
+            });
+        }
+        else {
+            s.handler.workerCallback(e.data, s.label);
+        }
+        this._source.delete(e.data.id);
+    }
+    make(data) {
+        let label = data.label, handler = data.handler;
+        if (handler._entityCollection) {
+            if (this._workerQueue.length) {
+                let w = this._workerQueue.pop();
+                let labelData = label.serializeWorkerData(this._sourceId);
+                if (labelData) {
+                    this._source.set(this._sourceId, data);
+                    label._lockId = this._sourceId;
+                    this._sourceId++;
+                    w.postMessage({
+                        labelData: labelData
+                    }, [
+                        labelData.buffer,
+                    ]);
+                }
+            }
+            else {
+                this._pendingQueue.push(data);
+            }
+        }
+    }
+}
+const LABEL_PROGRAM = `'use strict';
+
+    function concatTypedArrays(dest, index, source) {
+        let len = source.length,
+            offset = index * len;
+        for(let i = 0; i < len; i++) {
+            dest[offset + i] = source[i];
+        }
+    }
+
+    self.onmessage = function (e) {
+        var labelData = e.data.labelData,
+            id = labelData[0],
+            maxLetters = labelData[1],
+            isVisible = labelData[2],
+            /*3, 4, 5*/_positionHigh_x = labelData[3], _positionHigh_y = labelData[4], _positionHigh_z = labelData[5],
+            /*6, 7, 8*/_positionLow_x = labelData[6], _positionLow_y = labelData[7], _positionLow_z = labelData[8],
+            /*9*/_size = labelData[9],
+            /*10, 11, 12*/_offset_x = labelData[10], _offset_y = labelData[11], _offset_z = labelData[12],
+            /*13, 14, 15, 16*/_color_x = labelData[13], _color_y = labelData[14], _color_z = labelData[15], _color_w = labelData[16],
+            /*17*/_rotation = labelData[17],
+            /*18, 19, 20*/_alignedAxis_x = labelData[18], _alignedAxis_y = labelData[19], _alignedAxis_z = labelData[20],
+            /*21*/_fontIndex = labelData[21],
+            /*22*/_outline = labelData[22],
+            /*23, 24, 25, 26*/_outlineColor_x = labelData[23], _outlineColor_y = labelData[24], _outlineColor_z = labelData[25], _outlineColor_w = labelData[26],
+            /*27, 28, 29*/_pickingColor_x = labelData[27], _pickingColor_y = labelData[28], _pickingColor_z = labelData[29]
+         
+
+        let _vertexArr = new Float32Array(maxLetters * 12),
+            _texCoordArr = new Float32Array(maxLetters * 24),
+            _gliphParamArr = new Float32Array(maxLetters * 24),
+            _positionHighArr = new Float32Array(maxLetters * 18),
+            _positionLowArr = new Float32Array(maxLetters * 18),
+            _sizeArr = new Float32Array(maxLetters * 6),
+            _offsetArr = new Float32Array(maxLetters * 18),
+            _rgbaArr = new Float32Array(maxLetters * 24),
+            _rotationArr = new Float32Array(maxLetters * 6),
+            _alignedAxisArr = new Float32Array(maxLetters * 18),
+            _fontIndexArr = new Float32Array(maxLetters * 6),
+            _outlineArr = new Float32Array(maxLetters * 6),
+            _outlineColorArr = new Float32Array(maxLetters * 24),
+            _pickingColorArr = new Float32Array(maxLetters * 18);
+        
+        for (let i = 0; i < maxLetters; i++) {
+            if (isVisible !== 0) {
+                concatTypedArrays(_vertexArr, i, [0, 0, 0, -1, 1, -1, 1, -1, 1, 0, 0, 0]);
+            } else {
+                concatTypedArrays(_vertexArr, i, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+            }
+
+            concatTypedArrays(_texCoordArr, i, [0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0]);
+            concatTypedArrays(_gliphParamArr, i, [1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0]);
+
+            var x = _positionHigh_x, y = _positionHigh_y, z = _positionHigh_z, w;
+            concatTypedArrays(_positionHighArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);
+
+            x = _positionLow_x; y = _positionLow_y; z = _positionLow_z;
+            concatTypedArrays(_positionLowArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);
+
+            x = _size;
+            concatTypedArrays(_sizeArr, i, [x, x, x, x, x, x]);
+
+            x = _offset_x; y = _offset_y; z = _offset_z;
+            concatTypedArrays(_offsetArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);
+
+            x = _color_x; y = _color_y; z = _color_z; w = _color_w;
+            concatTypedArrays(_rgbaArr, i, [x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w]);
+
+            x = _rotation;
+            concatTypedArrays(_rotationArr, i, [x, x, x, x, x, x]);
+
+            x = _alignedAxis_x; y = _alignedAxis_y; z = _alignedAxis_z;
+            concatTypedArrays(_alignedAxisArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);
+
+            x = _fontIndex;
+            concatTypedArrays(_fontIndexArr, i, [x, x, x, x, x, x]);
+
+            x = _outline;
+            concatTypedArrays(_outlineArr, i, [x, x, x, x, x, x]);
+
+            x = _outlineColor_x; y = _outlineColor_y; z = _outlineColor_z; w = _outlineColor_w;
+            concatTypedArrays(_outlineColorArr, i, [x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w]);
+
+            x = _pickingColor_x / 255; y = _pickingColor_y / 255; z = _pickingColor_z / 255;
+            concatTypedArrays(_pickingColorArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);
+        }
+
+        self.postMessage({
+                id: id,
+                vertexArr: _vertexArr,
+                texCoordArr: _texCoordArr,
+                gliphParamArr: _gliphParamArr,
+                positionHighArr: _positionHighArr,
+                positionLowArr: _positionLowArr,
+                sizeArr: _sizeArr,
+                offsetArr: _offsetArr,
+                rgbaArr: _rgbaArr,
+                rotationArr: _rotationArr,
+                alignedAxisArr: _alignedAxisArr,
+                fontIndexArr: _fontIndexArr,
+                outlineArr: _outlineArr,
+                outlineColorArr: _outlineColorArr,
+                pickingColorArr: _pickingColorArr
+             }, [
+                    _vertexArr.buffer,
+                    _texCoordArr.buffer,
+                    _gliphParamArr.buffer,
+                    _positionHighArr.buffer,
+                    _positionLowArr.buffer,
+                    _sizeArr.buffer,
+                    _offsetArr.buffer,
+                    _rgbaArr.buffer,
+                    _rotationArr.buffer,
+                    _alignedAxisArr.buffer,
+                    _fontIndexArr.buffer,
+                    _outlineArr.buffer,
+                    _outlineColorArr.buffer,
+                    _pickingColorArr.buffer
+            ]);
+    }`;
+export { LabelWorker };

package/lib/js/entity/PointCloud.d.ts

@@ -0,0 +1,179 @@
+import { Entity } from "./Entity";
+import { PointCloudHandler } from "./PointCloudHandler";
+import { RenderNode } from "../scene/RenderNode";
+import { Vec3 } from "../math/Vec3";
+import { Vec4 } from "../math/Vec4";
+import { WebGLBufferExt } from "../webgl/Handler";
+import { EntityCollection } from "./EntityCollection";
+export interface IPointCloudParams {
+    visibility?: boolean;
+    pointSize?: number;
+    pickingScale?: number;
+    points?: Poi[];
+}
+type Poi = [number, number, number, number, number, number, number, any | undefined];
+interface IPoint {
+    _entity: Entity | null;
+    _pickingColor: Vec3;
+    _entityCollection: EntityCollection | null;
+    index: number;
+    position: Vec3;
+    color: Vec4;
+    pointCloud: PointCloud;
+    properties: any;
+}
+/**
+ * PointCloud object.
+ * @class
+ * @param {*} [options] - Point cloud options:
+ * @param {Array.<Array.<number>>} [options.points] - Points cartesian coordinates array,
+ * where first three is cartesian coordinates, next fourth is an RGBA color, and last is a point properties.
+ * @param {number} [options.pointSize] - Point screen size in pixels.
+ * @param {number} [options.pickingScale] - Point border picking size in screen pixels.
+ * @param {boolean} [options.visibility] - Point cloud visibility.
+ * @example <caption>Creates point cloud with two ten pixel size points</caption>
+ * new og.Entity({
+ *     pointCloud: {
+ *         pointSize: 10,
+ *         points: [
+ *             [0, 0, 0, 255, 255, 255, 255, { 'name': 'White point' }],
+ *             [100, 100, 0, 255, 0, 0, 255, { 'name': 'Red point' }]
+ *         ]
+ *     }
+ * });
+ */
+declare class PointCloud {
+    static __counter__: number;
+    protected __id: number;
+    /**
+     * Cloud visibility.
+     * @public
+     * @type {boolean}
+     */
+    visibility: boolean;
+    /**
+     * Point screen size in pixels.
+     * @public
+     * @type {number}
+     */
+    pointSize: number;
+    /**
+     * Point picking border size in pixels.
+     * @public
+     * @type {number}
+     */
+    pickingScale: number;
+    /**
+     * Parent collection render node.
+     * @protected
+     * @type {RenderNode | null}
+     */
+    protected _renderNode: RenderNode | null;
+    /**
+     * Entity instance that holds this point cloud.
+     * @public
+     * @type {Entity | null}
+     */
+    _entity: Entity | null;
+    /**
+     * Points properties.
+     * @protected
+     * @type {IPoint[]}
+     */
+    protected _points: IPoint[];
+    /**
+     * Coordinates array.
+     * @protected
+     * @type {number[]}
+     */
+    protected _coordinatesData: number[];
+    /**
+     * Color array.
+     * @protected
+     * @type {number[]}
+     */
+    protected _colorData: number[];
+    /**
+     * Picking color array.
+     * @protected
+     * @type {number[]}
+     */
+    protected _pickingColorData: number[];
+    protected _coordinatesBuffer: WebGLBufferExt | null;
+    protected _colorBuffer: WebGLBufferExt | null;
+    protected _pickingColorBuffer: WebGLBufferExt | null;
+    /**
+     * Handler that stores and renders this object.
+     * @public
+     * @type {PointCloudHandler}
+     */
+    _handler: PointCloudHandler | null;
+    _handlerIndex: number;
+    protected _buffersUpdateCallbacks: Function[];
+    protected _changedBuffers: boolean[];
+    constructor(options?: IPointCloudParams);
+    /**
+     * Clears point cloud data
+     * @public
+     */
+    clear(): void;
+    /**
+     * Sets cloud visibility.
+     * @public
+     * @param {boolean} visibility - Visibility flag.
+     */
+    setVisibility(visibility: boolean): void;
+    /**
+     * @return {boolean} Point cloud visibility.
+     */
+    getVisibility(): boolean;
+    /**
+     * Assign rendering scene node.
+     * @public
+     * @param {RenderNode}  renderNode - Assigned render node.
+     */
+    setRenderNode(renderNode: RenderNode): void;
+    /**
+     * Removes from entity.
+     * @public
+     */
+    remove(): void;
+    /**
+     * Adds points to render.
+     * @public
+     * @param { Poi[]} points - Point cloud array.
+     * @example
+     * var points = [[0, 0, 0, 255, 255, 255, 255, { 'name': 'White point' }], [100, 100, 0, 255, 0, 0, 255, { 'name': 'Red point' }]];
+     */
+    setPoints(points: Poi[]): void;
+    setPointPosition(index: number, x: number, y: number, z: number): void;
+    setPointColor(index: number, r: number, g: number, b: number, a: number): void;
+    addPoints(points: Poi[]): void;
+    addPoint(index: number, point: Poi): void;
+    /**
+     * Returns specific point by index.
+     * @public
+     * @param {number} index - Point index.
+     * @return {Poi} Specific point
+     */
+    getPoint(index: number): IPoint;
+    removePoint(index: number): void;
+    insertPoint(index: number, point: Poi): void;
+    draw(): void;
+    drawPicking(): void;
+    /**
+     * Update gl buffers.
+     * @protected
+     */
+    protected _update(): void;
+    /**
+     * Delete buffers
+     * @public
+     */
+    _deleteBuffers(): void;
+    protected _createCoordinatesBuffer(): void;
+    protected _createColorBuffer(): void;
+    protected _createPickingColorBuffer(): void;
+    protected _setPickingColors(): void;
+}
+export { PointCloud };

package/lib/js/entity/PointCloud.js

@@ -0,0 +1,327 @@
+import { Vec3 } from "../math/Vec3";
+import { Vec4 } from "../math/Vec4";
+const COORDINATES_BUFFER = 0;
+const COLOR_BUFFER = 1;
+const PICKING_COLOR_BUFFER = 2;
+/**
+ * PointCloud object.
+ * @class
+ * @param {*} [options] - Point cloud options:
+ * @param {Array.<Array.<number>>} [options.points] - Points cartesian coordinates array,
+ * where first three is cartesian coordinates, next fourth is an RGBA color, and last is a point properties.
+ * @param {number} [options.pointSize] - Point screen size in pixels.
+ * @param {number} [options.pickingScale] - Point border picking size in screen pixels.
+ * @param {boolean} [options.visibility] - Point cloud visibility.
+ * @example <caption>Creates point cloud with two ten pixel size points</caption>
+ * new og.Entity({
+ *     pointCloud: {
+ *         pointSize: 10,
+ *         points: [
+ *             [0, 0, 0, 255, 255, 255, 255, { 'name': 'White point' }],
+ *             [100, 100, 0, 255, 0, 0, 255, { 'name': 'Red point' }]
+ *         ]
+ *     }
+ * });
+ */
+class PointCloud {
+    constructor(options = {}) {
+        this.__id = PointCloud.__counter__++;
+        /**
+         * Cloud visibility.
+         * @public
+         * @type {boolean}
+         */
+        this.visibility = options.visibility != undefined ? options.visibility : true;
+        /**
+         * Point screen size in pixels.
+         * @public
+         * @type {number}
+         */
+        this.pointSize = options.pointSize || 3;
+        /**
+         * Point picking border size in pixels.
+         * @public
+         * @type {number}
+         */
+        this.pickingScale = options.pickingScale || 0;
+        /**
+         * Parent collection render node.
+         * @private
+         * @type {RenderNode}
+         */
+        this._renderNode = null;
+        /**
+         * Entity instance that holds this point cloud.
+         * @private
+         * @type {Entity}
+         */
+        this._entity = null;
+        /**
+         * Points properties.
+         * @private
+         * @type {IPoint[]}
+         */
+        this._points = [];
+        /**
+         * Coordinates array.
+         * @private
+         * @type {Array.<number>}
+         */
+        this._coordinatesData = [];
+        /**
+         * Color array.
+         * @private
+         * @type {Array.<number>}
+         */
+        this._colorData = [];
+        /**
+         * Picking color array.
+         * @private
+         * @type {Array.<number>}
+         */
+        this._pickingColorData = [];
+        this._coordinatesBuffer = null;
+        this._colorBuffer = null;
+        this._pickingColorBuffer = null;
+        /**
+         * Handler that stores and renders this object.
+         * @private
+         * @type {PointCloudHandler}
+         */
+        this._handler = null;
+        this._handlerIndex = -1;
+        this._buffersUpdateCallbacks = [];
+        this._buffersUpdateCallbacks[COORDINATES_BUFFER] = this._createCoordinatesBuffer;
+        this._buffersUpdateCallbacks[COLOR_BUFFER] = this._createColorBuffer;
+        this._buffersUpdateCallbacks[PICKING_COLOR_BUFFER] = this._createPickingColorBuffer;
+        this._changedBuffers = new Array(this._buffersUpdateCallbacks.length);
+        if (options.points) {
+            this.setPoints(options.points);
+        }
+    }
+    /**
+     * Clears point cloud data
+     * @public
+     */
+    clear() {
+        this._points.length = 0;
+        this._points = [];
+        this._coordinatesData.length = 0;
+        this._coordinatesData = [];
+        this._colorData.length = 0;
+        this._colorData = [];
+        this._pickingColorData.length = 0;
+        this._pickingColorData = [];
+        this._deleteBuffers();
+    }
+    /**
+     * Sets cloud visibility.
+     * @public
+     * @param {boolean} visibility - Visibility flag.
+     */
+    setVisibility(visibility) {
+        this.visibility = visibility;
+    }
+    /**
+     * @return {boolean} Point cloud visibility.
+     */
+    getVisibility() {
+        return this.visibility;
+    }
+    /**
+     * Assign rendering scene node.
+     * @public
+     * @param {RenderNode}  renderNode - Assigned render node.
+     */
+    setRenderNode(renderNode) {
+        this._renderNode = renderNode;
+        this._setPickingColors();
+    }
+    /**
+     * Removes from entity.
+     * @public
+     */
+    remove() {
+        this._entity = null;
+        this._handler && this._handler.remove(this);
+    }
+    /**
+     * Adds points to render.
+     * @public
+     * @param { Poi[]} points - Point cloud array.
+     * @example
+     * var points = [[0, 0, 0, 255, 255, 255, 255, { 'name': 'White point' }], [100, 100, 0, 255, 0, 0, 255, { 'name': 'Red point' }]];
+     */
+    setPoints(points) {
+        this.clear();
+        for (let i = 0; i < points.length; i++) {
+            let pi = points[i];
+            let pos = new Vec3(pi[0], pi[1], pi[2]), col = new Vec4(pi[3], pi[4], pi[5], pi[6] == undefined ? 255.0 : pi[6]);
+            this._coordinatesData.push(pos.x, pos.y, pos.z);
+            this._colorData.push(col.x / 255.0, col.y / 255.0, col.z / 255.0, col.w / 255.0);
+            let p = {
+                _entity: this._entity,
+                _pickingColor: new Vec3(),
+                _entityCollection: this._entity ? this._entity._entityCollection : null,
+                index: i,
+                position: pos,
+                color: col,
+                pointCloud: this,
+                properties: pi[7] || {}
+            };
+            this._points.push(p);
+            if (this._renderNode && this._renderNode.renderer) {
+                this._renderNode.renderer.assignPickingColor(p);
+                this._pickingColorData.push(p._pickingColor.x / 255.0, p._pickingColor.y / 255.0, p._pickingColor.z / 255.0, 1.0);
+            }
+        }
+        this._changedBuffers[COORDINATES_BUFFER] = true;
+        this._changedBuffers[COLOR_BUFFER] = true;
+        this._changedBuffers[PICKING_COLOR_BUFFER] = true;
+    }
+    setPointPosition(index, x, y, z) {
+        // TODO: ...
+        this._changedBuffers[COORDINATES_BUFFER] = true;
+    }
+    setPointColor(index, r, g, b, a) {
+        // TODO: ...
+        this._changedBuffers[COLOR_BUFFER] = true;
+    }
+    addPoints(points) {
+        // TODO: ...
+        this._changedBuffers[COORDINATES_BUFFER] = true;
+        this._changedBuffers[COLOR_BUFFER] = true;
+        this._changedBuffers[PICKING_COLOR_BUFFER] = true;
+    }
+    addPoint(index, point) {
+        // TODO: ...
+        this._changedBuffers[COORDINATES_BUFFER] = true;
+        this._changedBuffers[COLOR_BUFFER] = true;
+        this._changedBuffers[PICKING_COLOR_BUFFER] = true;
+    }
+    /**
+     * Returns specific point by index.
+     * @public
+     * @param {number} index - Point index.
+     * @return {Poi} Specific point
+     */
+    getPoint(index) {
+        return this._points[index];
+    }
+    removePoint(index) {
+        // TODO: ...
+        this._changedBuffers[COORDINATES_BUFFER] = true;
+        this._changedBuffers[COLOR_BUFFER] = true;
+        this._changedBuffers[PICKING_COLOR_BUFFER] = true;
+    }
+    insertPoint(index, point) {
+        // TODO: ...
+        this._changedBuffers[COORDINATES_BUFFER] = true;
+        this._changedBuffers[COLOR_BUFFER] = true;
+        this._changedBuffers[PICKING_COLOR_BUFFER] = true;
+    }
+    draw() {
+        if (this.visibility && this._coordinatesData.length) {
+            this._update();
+            let rn = this._renderNode;
+            let r = rn.renderer;
+            let sh = r.handler.programs.pointCloud;
+            let p = sh._program;
+            let gl = r.handler.gl, sha = p.attributes, shu = p.uniforms;
+            // gl.polygonOffset(
+            //     this._handler._entityCollection.polygonOffsetFactor,
+            //     this._handler._entityCollection.polygonOffsetUnits
+            // );
+            sh.activate();
+            gl.uniformMatrix4fv(shu.projectionViewMatrix, false, r.activeCamera.getProjectionViewMatrix());
+            gl.uniform1f(shu.opacity, this._handler._entityCollection._fadingOpacity);
+            gl.uniform1f(shu.pointSize, this.pointSize);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._coordinatesBuffer);
+            gl.vertexAttribPointer(sha.coordinates, this._coordinatesBuffer.itemSize, gl.FLOAT, false, 0, 0);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._colorBuffer);
+            gl.vertexAttribPointer(sha.colors, this._colorBuffer.itemSize, gl.FLOAT, false, 0, 0);
+            gl.drawArrays(gl.POINTS, 0, this._coordinatesBuffer.numItems);
+        }
+    }
+    drawPicking() {
+        if (this.visibility && this._coordinatesData.length) {
+            let rn = this._renderNode;
+            let r = rn.renderer;
+            let sh = r.handler.programs.pointCloud;
+            let p = sh._program;
+            let gl = r.handler.gl, sha = p.attributes, shu = p.uniforms;
+            sh.activate();
+            // gl.polygonOffset(
+            //     this._handler._entityCollection.polygonOffsetFactor,
+            //     this._handler._entityCollection.polygonOffsetUnits
+            // );
+            gl.uniformMatrix4fv(shu.projectionViewMatrix, false, r.activeCamera.getProjectionViewMatrix());
+            gl.uniform1f(shu.opacity, this._handler._entityCollection._fadingOpacity);
+            gl.uniform1f(shu.pointSize, this.pointSize + this.pickingScale);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._coordinatesBuffer);
+            gl.vertexAttribPointer(sha.coordinates, this._coordinatesBuffer.itemSize, gl.FLOAT, false, 0, 0);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._pickingColorBuffer);
+            gl.vertexAttribPointer(sha.colors, this._pickingColorBuffer.itemSize, gl.FLOAT, false, 0, 0);
+            gl.drawArrays(gl.POINTS, 0, this._coordinatesBuffer.numItems);
+        }
+    }
+    /**
+     * Update gl buffers.
+     * @protected
+     */
+    _update() {
+        if (this._renderNode) {
+            let i = this._changedBuffers.length;
+            while (i--) {
+                if (this._changedBuffers[i]) {
+                    this._buffersUpdateCallbacks[i].call(this);
+                    this._changedBuffers[i] = false;
+                }
+            }
+        }
+    }
+    /**
+     * Delete buffers
+     * @public
+     */
+    _deleteBuffers() {
+        if (this._renderNode) {
+            let r = this._renderNode.renderer, gl = r.handler.gl;
+            gl.deleteBuffer(this._coordinatesBuffer);
+            gl.deleteBuffer(this._colorBuffer);
+            gl.deleteBuffer(this._pickingColorBuffer);
+        }
+        this._coordinatesBuffer = null;
+        this._colorBuffer = null;
+        this._pickingColorBuffer = null;
+    }
+    _createCoordinatesBuffer() {
+        let h = this._renderNode.renderer.handler;
+        h.gl.deleteBuffer(this._coordinatesBuffer);
+        this._coordinatesBuffer = h.createArrayBuffer(new Float32Array(this._coordinatesData), 3, this._coordinatesData.length / 3);
+    }
+    _createColorBuffer() {
+        let h = this._renderNode.renderer.handler;
+        h.gl.deleteBuffer(this._colorBuffer);
+        this._colorBuffer = h.createArrayBuffer(new Float32Array(this._colorData), 4, this._colorData.length / 4);
+    }
+    _createPickingColorBuffer() {
+        let h = this._renderNode.renderer.handler;
+        h.gl.deleteBuffer(this._pickingColorBuffer);
+        this._pickingColorBuffer = h.createArrayBuffer(new Float32Array(this._pickingColorData), 4, this._pickingColorData.length / 4);
+    }
+    _setPickingColors() {
+        if (this._renderNode && this._renderNode.renderer) {
+            for (let i = 0; i < this._points.length; i++) {
+                let p = this._points[i];
+                p._entity = this._entity;
+                p._entityCollection = this._entity._entityCollection;
+                this._renderNode.renderer.assignPickingColor(p);
+                this._pickingColorData.push(p._pickingColor.x / 255.0, p._pickingColor.y / 255.0, p._pickingColor.z / 255.0, 1.0);
+            }
+            this._changedBuffers[PICKING_COLOR_BUFFER] = true;
+        }
+    }
+}
+PointCloud.__counter__ = 0;
+export { PointCloud };