@openglobus/og 0.17.2 → 0.18.1

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

@@ -0,0 +1,22 @@
+import { EntityCollection } from "./EntityCollection";
+import { Polyline } from "./Polyline";
+import { Renderer } from "../renderer/Renderer";
+import { RenderNode } from "../scene/RenderNode";
+declare class PolylineHandler {
+    static __counter__: number;
+    protected __id: number;
+    _entityCollection: EntityCollection;
+    pickingEnabled: boolean;
+    protected _renderer: Renderer | null;
+    protected _polylines: Polyline[];
+    constructor(entityCollection: EntityCollection);
+    protected _initProgram(): void;
+    setRenderNode(renderNode: RenderNode): void;
+    add(polyline: Polyline): void;
+    remove(polyline: Polyline): void;
+    reindexPolylineArray(startIndex: number): void;
+    draw(): void;
+    drawPicking(): void;
+    clear(): void;
+}
+export { PolylineHandler };

package/lib/js/entity/PolylineHandler.js

@@ -0,0 +1,78 @@
+import * as shaders from '../shaders/polyline';
+class PolylineHandler {
+    constructor(entityCollection) {
+        this.__id = PolylineHandler.__counter__++;
+        this._entityCollection = entityCollection;
+        this._renderer = null;
+        this._polylines = [];
+        this.pickingEnabled = true;
+    }
+    _initProgram() {
+        if (this._renderer && this._renderer.handler) {
+            if (!this._renderer.handler.programs.polyline_screen) {
+                this._renderer.handler.addProgram(shaders.polyline_screen());
+            }
+            if (!this._renderer.handler.programs.polyline_picking) {
+                this._renderer.handler.addProgram(shaders.polyline_picking());
+            }
+        }
+    }
+    setRenderNode(renderNode) {
+        this._renderer = renderNode.renderer;
+        this._initProgram();
+        for (let i = 0; i < this._polylines.length; i++) {
+            this._polylines[i].setRenderNode(renderNode);
+        }
+    }
+    add(polyline) {
+        if (polyline._handlerIndex === -1) {
+            polyline._handler = this;
+            polyline._handlerIndex = this._polylines.length;
+            this._polylines.push(polyline);
+            this._entityCollection && this._entityCollection.renderNode &&
+                polyline.setRenderNode(this._entityCollection.renderNode);
+        }
+    }
+    remove(polyline) {
+        let index = polyline._handlerIndex;
+        if (index !== -1) {
+            polyline._deleteBuffers();
+            polyline._handlerIndex = -1;
+            polyline._handler = null;
+            this._polylines.splice(index, 1);
+            this.reindexPolylineArray(index);
+        }
+    }
+    reindexPolylineArray(startIndex) {
+        let ls = this._polylines;
+        for (let i = startIndex; i < ls.length; i++) {
+            ls[i]._handlerIndex = i;
+        }
+    }
+    draw() {
+        let i = this._polylines.length;
+        while (i--) {
+            this._polylines[i].draw();
+        }
+    }
+    drawPicking() {
+        if (this.pickingEnabled) {
+            let i = this._polylines.length;
+            while (i--) {
+                this._polylines[i].drawPicking();
+            }
+        }
+    }
+    clear() {
+        let i = this._polylines.length;
+        while (i--) {
+            this._polylines[i]._deleteBuffers();
+            this._polylines[i]._handler = null;
+            this._polylines[i]._handlerIndex = -1;
+        }
+        this._polylines.length = 0;
+        this._polylines = [];
+    }
+}
+PolylineHandler.__counter__ = 0;
+export { PolylineHandler };

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

@@ -0,0 +1,133 @@
+import { NumberArray3, Vec3 } from "../math/Vec3";
+import { NumberArray4, Vec4 } from "../math/Vec4";
+import { Entity } from "./Entity";
+import { RayHandler } from "./RayHandler";
+export interface IRayParams {
+    thickness?: number;
+    startPosition?: Vec3 | NumberArray3;
+    endPosition?: Vec3 | NumberArray3;
+    startColor?: string | NumberArray4;
+    endColor?: string | NumberArray4;
+    visibility?: boolean;
+}
+/**
+ * Ray class.
+ * @class
+ * @param {Object} [options] - Options:
+ * @param {Vec3|Array.<number>} [options.startPosition] - Ray start point position.
+ * @param {Vec3|Array.<number>} [options.endPosition] - Ray end point position.
+ * @param {Vec3|Array.<number>} [options.startColor] - Ray start point color.
+ * @param {Vec3|Array.<number>} [options.endColor] - Ray end point color.
+ * @param {boolean} [options.visibility] - Visibility.
+ */
+declare class Ray {
+    static __counter__: number;
+    /**
+     * Object uniq identifier.
+     * @protected
+     * @type {number}
+     */
+    protected __id: number;
+    _thickness: number;
+    protected _startPosition: Vec3;
+    _startPositionHigh: Vec3;
+    _startPositionLow: Vec3;
+    protected _endPosition: Vec3;
+    _endPositionHigh: Vec3;
+    _endPositionLow: Vec3;
+    _startColor: Vec4;
+    _endColor: Vec4;
+    /**
+     * Ray visibility.
+     * @protected
+     * @type {boolean}
+     */
+    protected _visibility: boolean;
+    /**
+     * Entity instance that holds this billboard.
+     * @public
+     * @type {Entity}
+     */
+    _entity: Entity | null;
+    /**
+     * Handler that stores and renders this billboard object.
+     * @public
+     * @type {BillboardHandler}
+     */
+    _handler: RayHandler | null;
+    /**
+     * Billboard handler array index.
+     * @public
+     * @type {number}
+     */
+    _handlerIndex: number;
+    constructor(options?: IRayParams);
+    /**
+     * Sets ray start position.
+     * @public
+     * @param {number} x - X coordinate.
+     * @param {number} y - Y coordinate.
+     * @param {number} z - Z coordinate.
+     */
+    setStartPosition(x: number, y: number, z: number): void;
+    getLength(): number;
+    /**
+     * Sets ray start position.
+     * @public
+     * @param {Vec3} position - Cartesian coordinates.
+     */
+    setStartPosition3v(position: Vec3): void;
+    /**
+     * Sets ray end position.
+     * @public
+     * @param {number} x - X coordinate.
+     * @param {number} y - Y coordinate.
+     * @param {number} z - Z coordinate.
+     */
+    setEndPosition(x: number, y: number, z: number): void;
+    /**
+     * Sets ray end position.
+     * @public
+     * @param {Vec3} position - Cartesian coordinates.
+     */
+    setEndPosition3v(position: Vec3): void;
+    setThickness(thickness: number): void;
+    setColors4v(startColor?: Vec4, endColor?: Vec4): void;
+    setColorsHTML(startColor?: string, endColor?: string): void;
+    /**
+     * Returns ray start position.
+     * @public
+     * @returns {Vec3}
+     */
+    getStartPosition(): Vec3;
+    /**
+     * Returns ray end position.
+     * @public
+     * @returns {Vec3}
+     */
+    getEndPosition(): Vec3;
+    /**
+     * Sets visibility.
+     * @public
+     * @param {boolean} visibility - Visibility flag.
+     */
+    setVisibility(visibility: boolean): void;
+    /**
+     * Returns visibility.
+     * @public
+     * @returns {boolean}
+     */
+    getVisibility(): boolean;
+    /**
+     * Remove from handler.
+     * @public
+     */
+    remove(): void;
+    /**
+     * Set picking color.
+     * @public
+     * @param {Vec3} color - Picking color.
+     */
+    setPickingColor3v(color: Vec3): void;
+}
+export { Ray };

package/lib/js/entity/Ray.js

@@ -0,0 +1,171 @@
+import * as utils from "../utils/shared";
+import { Vec3 } from "../math/Vec3";
+/**
+ * Ray class.
+ * @class
+ * @param {Object} [options] - Options:
+ * @param {Vec3|Array.<number>} [options.startPosition] - Ray start point position.
+ * @param {Vec3|Array.<number>} [options.endPosition] - Ray end point position.
+ * @param {Vec3|Array.<number>} [options.startColor] - Ray start point color.
+ * @param {Vec3|Array.<number>} [options.endColor] - Ray end point color.
+ * @param {boolean} [options.visibility] - Visibility.
+ */
+class Ray {
+    constructor(options = {}) {
+        this.__id = Ray.__counter__++;
+        this._thickness = options.thickness || 2.0;
+        this._startPosition = utils.createVector3(options.startPosition);
+        this._startPositionHigh = new Vec3();
+        this._startPositionLow = new Vec3();
+        Vec3.doubleToTwoFloats(this._startPosition, this._startPositionHigh, this._startPositionLow);
+        this._endPosition = utils.createVector3(options.endPosition);
+        this._endPositionHigh = new Vec3();
+        this._endPositionLow = new Vec3();
+        Vec3.doubleToTwoFloats(this._endPosition, this._endPositionHigh, this._endPositionLow);
+        this._startColor = utils.createColorRGBA(options.startColor);
+        this._endColor = utils.createColorRGBA(options.endColor);
+        this._visibility = options.visibility != undefined ? options.visibility : true;
+        this._entity = null;
+        this._handler = null;
+        this._handlerIndex = -1;
+    }
+    /**
+     * Sets ray start position.
+     * @public
+     * @param {number} x - X coordinate.
+     * @param {number} y - Y coordinate.
+     * @param {number} z - Z coordinate.
+     */
+    setStartPosition(x, y, z) {
+        this._startPosition.x = x;
+        this._startPosition.y = y;
+        this._startPosition.z = z;
+        Vec3.doubleToTwoFloats(this._startPosition, this._startPositionHigh, this._startPositionLow);
+        this._handler &&
+            this._handler.setStartPositionArr(this._handlerIndex, this._startPositionHigh, this._startPositionLow);
+    }
+    getLength() {
+        return this._startPosition.distance(this._endPosition);
+    }
+    /**
+     * Sets ray start position.
+     * @public
+     * @param {Vec3} position - Cartesian coordinates.
+     */
+    setStartPosition3v(position) {
+        this._startPosition.x = position.x;
+        this._startPosition.y = position.y;
+        this._startPosition.z = position.z;
+        Vec3.doubleToTwoFloats(this._startPosition, this._startPositionHigh, this._startPositionLow);
+        this._handler &&
+            this._handler.setStartPositionArr(this._handlerIndex, this._startPositionHigh, this._startPositionLow);
+    }
+    /**
+     * Sets ray end position.
+     * @public
+     * @param {number} x - X coordinate.
+     * @param {number} y - Y coordinate.
+     * @param {number} z - Z coordinate.
+     */
+    setEndPosition(x, y, z) {
+        this._endPosition.x = x;
+        this._endPosition.y = y;
+        this._endPosition.z = z;
+        Vec3.doubleToTwoFloats(this._endPosition, this._endPositionHigh, this._endPositionLow);
+        this._handler &&
+            this._handler.setEndPositionArr(this._handlerIndex, this._endPositionHigh, this._endPositionLow);
+    }
+    /**
+     * Sets ray end position.
+     * @public
+     * @param {Vec3} position - Cartesian coordinates.
+     */
+    setEndPosition3v(position) {
+        this._endPosition.x = position.x;
+        this._endPosition.y = position.y;
+        this._endPosition.z = position.z;
+        Vec3.doubleToTwoFloats(this._endPosition, this._endPositionHigh, this._endPositionLow);
+        this._handler &&
+            this._handler.setEndPositionArr(this._handlerIndex, this._endPositionHigh, this._endPositionLow);
+    }
+    setThickness(thickness) {
+        this._thickness = thickness;
+        this._handler && this._handler.setThicknessArr(this._handlerIndex, thickness);
+    }
+    setColors4v(startColor, endColor) {
+        if (startColor) {
+            this._startColor.x = startColor.x;
+            this._startColor.y = startColor.y;
+            this._startColor.z = startColor.z;
+            this._startColor.w = startColor.w;
+        }
+        if (endColor) {
+            this._endColor.x = endColor.x;
+            this._endColor.y = endColor.y;
+            this._endColor.z = endColor.z;
+            this._endColor.w = endColor.w;
+        }
+        this._handler &&
+            this._handler.setRgbaArr(this._handlerIndex, this._startColor, this._endColor);
+    }
+    setColorsHTML(startColor, endColor) {
+        if (startColor) {
+            this._startColor = utils.htmlColorToRgba(startColor);
+        }
+        if (endColor) {
+            this._endColor = utils.htmlColorToRgba(endColor);
+        }
+        this._handler && this._handler.setRgbaArr(this._handlerIndex, this._startColor, this._endColor);
+    }
+    /**
+     * Returns ray start position.
+     * @public
+     * @returns {Vec3}
+     */
+    getStartPosition() {
+        return this._startPosition;
+    }
+    /**
+     * Returns ray end position.
+     * @public
+     * @returns {Vec3}
+     */
+    getEndPosition() {
+        return this._endPosition;
+    }
+    /**
+     * Sets visibility.
+     * @public
+     * @param {boolean} visibility - Visibility flag.
+     */
+    setVisibility(visibility) {
+        this._visibility = visibility;
+        this._handler && this._handler.setVisibility(this._handlerIndex, visibility);
+    }
+    /**
+     * Returns visibility.
+     * @public
+     * @returns {boolean}
+     */
+    getVisibility() {
+        return this._visibility;
+    }
+    /**
+     * Remove from handler.
+     * @public
+     */
+    remove() {
+        this._entity = null;
+        this._handler && this._handler.remove(this);
+    }
+    /**
+     * Set picking color.
+     * @public
+     * @param {Vec3} color - Picking color.
+     */
+    setPickingColor3v(color) {
+        this._handler && this._handler.setPickingColorArr(this._handlerIndex, color);
+    }
+}
+Ray.__counter__ = 0;
+export { Ray };

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

@@ -0,0 +1,70 @@
+import { TypedArray } from "../utils/shared";
+import { EntityCollection } from "./EntityCollection";
+import { Ray } from "./Ray";
+import { Renderer } from "../renderer/Renderer";
+import { Vec3 } from "../math/Vec3";
+import { Vec4 } from "../math/Vec4";
+import { WebGLBufferExt } from "../webgl/Handler";
+declare class RayHandler {
+    static __counter__: number;
+    protected __id: number;
+    /**
+     * Picking rendering option.
+     * @public
+     * @type {boolean}
+     */
+    pickingEnabled: boolean;
+    protected _entityCollection: EntityCollection;
+    protected _renderer: Renderer | null;
+    protected _rays: Ray[];
+    protected _vertexBuffer: WebGLBufferExt | null;
+    protected _startPositionHighBuffer: WebGLBufferExt | null;
+    protected _startPositionLowBuffer: WebGLBufferExt | null;
+    protected _endPositionHighBuffer: WebGLBufferExt | null;
+    protected _endPositionLowBuffer: WebGLBufferExt | null;
+    protected _thicknessBuffer: WebGLBufferExt | null;
+    protected _rgbaBuffer: WebGLBufferExt | null;
+    protected _pickingColorBuffer: WebGLBufferExt | null;
+    protected _vertexArr: TypedArray | number[];
+    protected _startPositionHighArr: TypedArray | number[];
+    protected _startPositionLowArr: TypedArray | number[];
+    protected _endPositionHighArr: TypedArray | number[];
+    protected _endPositionLowArr: TypedArray | number[];
+    protected _thicknessArr: TypedArray | number[];
+    protected _rgbaArr: TypedArray | number[];
+    protected _pickingColorArr: TypedArray | number[];
+    protected _buffersUpdateCallbacks: Function[];
+    protected _changedBuffers: boolean[];
+    constructor(entityCollection: EntityCollection);
+    static concArr(dest: number[], curr: number[]): void;
+    initProgram(): void;
+    setRenderer(renderer: Renderer): void;
+    refresh(): void;
+    protected _removeRays(): void;
+    clear(): void;
+    protected _deleteBuffers(): void;
+    update(): void;
+    add(ray: Ray): void;
+    protected _addRayToArrays(ray: Ray): void;
+    protected _displayPASS(): void;
+    protected _pickingPASS(): void;
+    draw(): void;
+    drawPicking(): void;
+    reindexRaysArray(startIndex: number): void;
+    protected _removeRay(ray: Ray): void;
+    remove(ray: Ray): void;
+    setStartPositionArr(index: number, positionHigh: Vec3, positionLow: Vec3): void;
+    setEndPositionArr(index: number, positionHigh: Vec3, positionLow: Vec3): void;
+    setPickingColorArr(index: number, color: Vec3): void;
+    setRgbaArr(index: number, startColor: Vec4, endColor: Vec4): void;
+    setThicknessArr(index: number, thickness: number): void;
+    setVisibility(index: number, visibility: boolean): void;
+    setVertexArr(index: number, vertexArr: number[]): void;
+    createStartPositionBuffer(): void;
+    createEndPositionBuffer(): void;
+    createRgbaBuffer(): void;
+    createThicknessBuffer(): void;
+    createVertexBuffer(): void;
+    createPickingColorBuffer(): void;
+}
+export { RayHandler };