@openglobus/og 0.17.1 → 0.18.0

package/src/{og/entity/Strip.js → entity/Strip.ts}

@@ -1,8 +1,25 @@
-"use strict";
-
-import { Line3 } from "../math/Line3.js";
-import { Vec3 } from "../math/Vec3.js";
-import * as utils from "../utils/shared.js";
+import * as utils from "../utils/shared";
+import {Entity} from "./Entity";
+import {Line3} from "../math/Line3";
+import {RenderNode} from "../scene/RenderNode";
+import {NumberArray3, Vec3} from "../math/Vec3";
+import {NumberArray4, Vec4} from "../math/Vec4";
+import {StripHandler} from "./StripHandler";
+import {WebGLBufferExt} from "../webgl/Handler";
+
+type TPoiExt = Vec3 | NumberArray3;
+type TStripExt = [TPoiExt, TPoiExt];
+
+type TPoi = Vec3;
+type TStrip = [TPoi, TPoi];
+
+//type TStrip = TEdge[];
+export interface IStripParams {
+    visibility?: boolean;
+    color?: string | NumberArray4 | Vec4;
+    opacity?: number;
+    path?: TStrip[];
+}
 
 let _tempHigh = new Vec3(),
     _tempLow = new Vec3();
@@ -24,22 +41,57 @@ let _tempHigh = new Vec3(),
  * });
  */
 class Strip {
-    constructor(options) {
-        options = options || {};
 
-        /**
-         * Object unic identifier.
-         * @public
-         * @readonly
-         * @type {number}
-         */
-        this.id = Strip._staticCounter++;
+    static __counter__: number = 0;
+
+    protected __id: number;
+
+    /**
+     * Strip visibility.
+     * @public
+     * @type {boolean}
+     */
+    public visibility: boolean;
+
+    public color: Float32Array;
+
+    /**
+     * Parent collection render node.
+     * @protected
+     * @type {RenderNode}
+     */
+    protected _renderNode: RenderNode | null;
+
+    /**
+     * Entity instance that holds this strip.
+     * @public
+     * @type {Entity}
+     */
+    public _entity: Entity | null;
+    protected _verticesHighBuffer: WebGLBufferExt | null;
+    protected _verticesLowBuffer: WebGLBufferExt | null;
+    protected _indexBuffer: WebGLBufferExt | null;
+    protected _verticesHigh: number[];
+    protected _verticesLow: number[];
+    protected _indexes: number[];
+    protected _path: TStrip[];
+
+    protected _pickingColor: Float32Array;
+
+    protected _gridSize: number;
+
+    /**
+     * Handler that stores and renders this object.
+     * @public
+     * @type {StripHandler | null}
+     */
+    public _handler: StripHandler | null;
+    public _handlerIndex: number;
+
+    constructor(options: IStripParams = {}) {
+
+        this.__id = Strip.__counter__++;
 
-        /**
-         * Cloud visibility.
-         * @public
-         * @type {boolean}
-         */
         this.visibility = options.visibility != undefined ? options.visibility : true;
 
         this.color = new Float32Array([1.0, 1.0, 1.0, 0.5]);
@@ -55,14 +107,14 @@ class Strip {
 
         /**
          * Parent collection render node.
-         * @private
+         * @protected
          * @type {RenderNode}
          */
         this._renderNode = null;
 
         /**
          * Entity instance that holds this strip.
-         * @private
+         * @protected
          * @type {Entity}
          */
         this._entity = null;
@@ -70,7 +122,7 @@ class Strip {
         this._verticesHighBuffer = null;
         this._verticesLowBuffer = null;
 
-        this._indexesBuffer = null;
+        this._indexBuffer = null;
 
         this._verticesHigh = [];
         this._verticesLow = [];
@@ -85,7 +137,7 @@ class Strip {
 
         /**
          * Handler that stores and renders this object.
-         * @private
+         * @protected
          * @type {StripHandler}
          */
         this._handler = null;
@@ -96,23 +148,12 @@ class Strip {
         }
     }
 
-    static get _staticCounter() {
-        if (!this._counter && this._counter !== 0) {
-            this._counter = 0;
-        }
-        return this._counter;
-    }
-
-    static set _staticCounter(n) {
-        this._counter = n;
-    }
-
     /**
      * Assign picking color.
-     * @protected
+     * @public
      * @param {Vec3} color - Picking RGB color.
      */
-    setPickingColor3v(color) {
+    public setPickingColor3v(color: Vec3) {
         this._pickingColor[0] = color.x / 255.0;
         this._pickingColor[1] = color.y / 255.0;
         this._pickingColor[2] = color.z / 255.0;
@@ -123,7 +164,7 @@ class Strip {
      * Clears object
      * @public
      */
-    clear() {
+    public clear() {
         this._path.length = 0;
         this._path = [];
 
@@ -139,7 +180,7 @@ class Strip {
         this._deleteBuffers();
     }
 
-    setColor(r, g, b, a) {
+    public setColor(r: number, g: number, b: number, a?: number) {
         a = a || this.color[3];
         this.color[0] = r;
         this.color[1] = g;
@@ -152,23 +193,23 @@ class Strip {
      * @public
      * @param {number} opacity - opacity.
      */
-    setOpacity(opacity) {
+    public setOpacity(opacity: number) {
         this.color[3] = opacity || 0;
     }
 
     /**
      * Sets cloud visibility.
      * @public
-     * @param {number} visibility - Visibility flag.
+     * @param {boolean} visibility - Visibility flag.
      */
-    setVisibility(visibility) {
+    public setVisibility(visibility: boolean) {
         this.visibility = visibility;
     }
 
     /**
-     * @return {boolean} Strip visibily.
+     * @return {boolean} Strip visibility.
      */
-    getVisibility() {
+    public getVisibility(): boolean {
         return this.visibility;
     }
 
@@ -177,7 +218,7 @@ class Strip {
      * @public
      * @param {RenderNode}  renderNode - Assigned render node.
      */
-    setRenderNode(renderNode) {
+    public setRenderNode(renderNode: RenderNode) {
         this._renderNode = renderNode;
         this._createBuffers();
     }
@@ -186,18 +227,18 @@ class Strip {
      * Removes from entity.
      * @public
      */
-    remove() {
+    public remove() {
         this._entity = null;
         this._handler && this._handler.remove(this);
     }
 
-    draw() {
+    public draw() {
         if (this.visibility && this._verticesHigh.length) {
-            var r = this._renderNode.renderer;
+            let r = this._renderNode!.renderer!;
 
-            var gl = r.handler.gl;
+            let gl = r.handler.gl!;
 
-            var sh = r.handler.programs.strip,
+            let sh = r.handler.programs.strip,
                 p = sh._program,
                 sha = p.attributes,
                 shu = p.uniforms;
@@ -206,36 +247,37 @@ class Strip {
 
             gl.disable(gl.CULL_FACE);
 
-            gl.uniformMatrix4fv(shu.viewMatrix, false, r.activeCamera.getViewMatrix());
-            gl.uniformMatrix4fv(shu.projectionMatrix, false, r.activeCamera.getProjectionMatrix());
+            gl.uniformMatrix4fv(shu.viewMatrix, false, r.activeCamera!.getViewMatrix());
+            gl.uniformMatrix4fv(shu.projectionMatrix, false, r.activeCamera!.getProjectionMatrix());
 
-            gl.uniform3fv(shu.eyePositionHigh, r.activeCamera.eyeHigh);
-            gl.uniform3fv(shu.eyePositionLow, r.activeCamera.eyeLow);
+            gl.uniform3fv(shu.eyePositionHigh, r.activeCamera!.eyeHigh);
+            gl.uniform3fv(shu.eyePositionLow, r.activeCamera!.eyeLow);
 
             gl.uniform4fv(shu.uColor, this.color);
-            gl.uniform1f(shu.uOpacity, this._entity._entityCollection._fadingOpacity);
-            gl.bindBuffer(gl.ARRAY_BUFFER, this._verticesHighBuffer);
+
+            gl.uniform1f(shu.uOpacity, this._entity!._entityCollection!._fadingOpacity);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._verticesHighBuffer as WebGLBuffer);
             gl.vertexAttribPointer(
                 sha.aVertexPositionHigh,
-                this._verticesHighBuffer.itemSize,
+                this._verticesHighBuffer!.itemSize,
                 gl.FLOAT,
                 false,
                 0,
                 0
             );
-            gl.bindBuffer(gl.ARRAY_BUFFER, this._verticesLowBuffer);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._verticesLowBuffer as WebGLBuffer);
             gl.vertexAttribPointer(
                 sha.aVertexPositionLow,
-                this._verticesLowBuffer.itemSize,
+                this._verticesLowBuffer!.itemSize,
                 gl.FLOAT,
                 false,
                 0,
                 0
             );
-            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBuffer);
+            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBuffer as WebGLBuffer);
             gl.drawElements(
-                r.handler.gl.TRIANGLE_STRIP,
-                this._indexBuffer.numItems,
+                r.handler.gl!.TRIANGLE_STRIP,
+                this._indexBuffer!.numItems,
                 gl.UNSIGNED_INT,
                 0
             );
@@ -246,11 +288,11 @@ class Strip {
 
     drawPicking() {
         if (this.visibility && this._verticesHigh.length) {
-            var r = this._renderNode.renderer;
+            let r = this._renderNode!.renderer!;
 
-            var gl = r.handler.gl;
+            let gl = r.handler.gl!;
 
-            var sh = r.handler.programs.strip,
+            let sh = r.handler.programs.strip,
                 p = sh._program,
                 sha = p.attributes,
                 shu = p.uniforms;
@@ -259,36 +301,37 @@ class Strip {
 
             gl.disable(gl.CULL_FACE);
 
-            gl.uniformMatrix4fv(shu.viewMatrix, false, r.activeCamera.getViewMatrix());
-            gl.uniformMatrix4fv(shu.projectionMatrix, false, r.activeCamera.getProjectionMatrix());
+            gl.uniformMatrix4fv(shu.viewMatrix, false, r.activeCamera!.getViewMatrix());
+            gl.uniformMatrix4fv(shu.projectionMatrix, false, r.activeCamera!.getProjectionMatrix());
+
+            gl.uniform3fv(shu.eyePositionHigh, r.activeCamera!.eyeHigh);
+            gl.uniform3fv(shu.eyePositionLow, r.activeCamera!.eyeLow);
 
-            gl.uniform3fv(shu.eyePositionHigh, r.activeCamera.eyeHigh);
-            gl.uniform3fv(shu.eyePositionLow, r.activeCamera.eyeLow);
-            gl.uniform1f(shu.uOpacity, this._entity._entityCollection._fadingOpacity != 0 ? 1 : 0);
+            gl.uniform1f(shu.uOpacity, this._entity!._entityCollection!._fadingOpacity != 0 ? 1 : 0);
 
             gl.uniform4fv(shu.uColor, this._pickingColor);
-            gl.bindBuffer(gl.ARRAY_BUFFER, this._verticesHighBuffer);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._verticesHighBuffer as WebGLBuffer);
             gl.vertexAttribPointer(
                 sha.aVertexPositionHigh,
-                this._verticesHighBuffer.itemSize,
+                this._verticesHighBuffer!.itemSize,
                 gl.FLOAT,
                 false,
                 0,
                 0
             );
-            gl.bindBuffer(gl.ARRAY_BUFFER, this._verticesLowBuffer);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._verticesLowBuffer as WebGLBuffer);
             gl.vertexAttribPointer(
                 sha.aVertexPositionLow,
-                this._verticesLowBuffer.itemSize,
+                this._verticesLowBuffer!.itemSize,
                 gl.FLOAT,
                 false,
                 0,
                 0
             );
-            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBuffer);
+            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBuffer as WebGLBuffer);
             gl.drawElements(
-                r.handler.gl.TRIANGLE_STRIP,
-                this._indexBuffer.numItems,
+                r.handler.gl!.TRIANGLE_STRIP,
+                this._indexBuffer!.numItems,
                 gl.UNSIGNED_INT,
                 0
             );
@@ -299,29 +342,29 @@ class Strip {
 
     /**
      * Delete buffers
-     * @private
+     * @public
      */
-    _deleteBuffers() {
+    public _deleteBuffers() {
         if (this._renderNode && this._renderNode.renderer) {
-            var r = this._renderNode.renderer,
-                gl = r.handler.gl;
+            let r = this._renderNode.renderer,
+                gl = r.handler.gl!;
 
-            gl.deleteBuffer(this._indexBuffer);
-            gl.deleteBuffer(this._verticesHighBuffer);
-            gl.deleteBuffer(this._verticesLowBuffer);
+            gl.deleteBuffer(this._indexBuffer!);
+            gl.deleteBuffer(this._verticesHighBuffer!);
+            gl.deleteBuffer(this._verticesLowBuffer!);
         }
         this._verticesHighBuffer = null;
         this._verticesLowBuffer = null;
         this._indexBuffer = null;
     }
 
-    _createBuffers() {
+    protected _createBuffers() {
         if (this._renderNode && this._renderNode.renderer && this._renderNode.renderer.isInitialized()) {
-            var gl = this._renderNode.renderer.handler.gl;
+            let gl = this._renderNode.renderer.handler.gl!;
 
-            gl.deleteBuffer(this._indexBuffer);
-            gl.deleteBuffer(this._verticesHighBuffer);
-            gl.deleteBuffer(this._verticesLowBuffer);
+            gl.deleteBuffer(this._indexBuffer as WebGLBuffer);
+            gl.deleteBuffer(this._verticesHighBuffer as WebGLBuffer);
+            gl.deleteBuffer(this._verticesLowBuffer as WebGLBuffer);
 
             this._verticesHighBuffer = this._renderNode.renderer.handler.createArrayBuffer(
                 new Float32Array(this._verticesHigh),
@@ -341,7 +384,7 @@ class Strip {
         }
     }
 
-    addEdge3v(p2, p3) {
+    public addEdge3v(p2: Vec3, p3: Vec3) {
         let length = this._path.length;
 
         if (length === 0) {
@@ -409,7 +452,7 @@ class Strip {
         }
     }
 
-    setEdge3v(p2, p3, index) {
+    public setEdge3v(p2: Vec3, p3: Vec3, index: number) {
         if (index === this._path.length) {
             this.addEdge3v(p2, p3);
             return;
@@ -578,21 +621,21 @@ class Strip {
         }
     }
 
-    removeEdge(index) {
+    public removeEdge(index: number) {
         this._path.splice(index, 1);
-        this.setPath([].concat(this._path));
+        this.setPath(([] as TStrip[]).concat(this._path));
     }
 
-    setGridSize(gridSize) {
+    public setGridSize(gridSize: number) {
         this._gridSize = gridSize;
-        this.setPath([].concat(this._path));
+        this.setPath(([] as TStrip[]).concat(this._path));
     }
 
-    getPath() {
+    public getPath(): TStrip[] {
         return this._path;
     }
 
-    setPath(path) {
+    public setPath(path: TStripExt[] | TStrip[]) {
         this._verticesHigh = [];
         this._verticesLow = [];
         this._indexes = [];
@@ -610,13 +653,13 @@ class Strip {
                 p1 = new Vec3(p1[0], p1[1], p1[2]);
             }
 
-            this.addEdge3v(p0, p1);
+            this.addEdge3v(p0 as Vec3, p1 as Vec3);
         }
     }
 
-    insertEdge3v(p0, p1, index) {
+    public insertEdge3v(p0: Vec3, p1: Vec3, index: number) {
         if (index < this._path.length) {
-            let p = [].concat(this._path);
+            let p: TStrip[] = ([] as TStrip[]).concat(this._path);
             p.splice(index, 0, [p0, p1]);
             this.setPath(p);
         } else if (index === this._path.length) {
@@ -625,4 +668,4 @@ class Strip {
     }
 }
 
-export { Strip };
+export {Strip};

package/src/{og/entity/StripHandler.js → entity/StripHandler.ts}

@@ -1,69 +1,73 @@
-"use strict";
-
-import { Program } from "../webgl/Program.js";
+import {EntityCollection} from "./EntityCollection";
+import {Program} from "../webgl/Program";
+import {Renderer} from "../renderer/Renderer";
+import {RenderNode} from "../scene/RenderNode";
+import {Strip} from "./Strip";
 
 class StripHandler {
-    constructor(entityCollection) {
-        /**
-         * Picking rendering option.
-         * @public
-         * @type {boolean}
-         */
+
+    static __counter__: number = 0;
+    protected __id: number;
+
+    /**
+     * Picking rendering option.
+     * @public
+     * @type {boolean}
+     */
+    public pickingEnabled: boolean;
+
+    /**
+     * Parent collection
+     * @protected
+     * @type {EntityCollection}
+     */
+    protected _entityCollection: EntityCollection;
+
+    /**
+     * Renderer
+     * @protected
+     * @type {Renderer | null}
+     */
+    protected _renderer: Renderer | null;
+
+    /**
+     * Strip objects array
+     * @protected
+     * @type {Array.<Strip>}
+     */
+    protected _strips: Strip[];
+
+    constructor(entityCollection: EntityCollection) {
+
+        this.__id = StripHandler.__counter__++;
+
         this.pickingEnabled = true;
 
-        /**
-         * Parent collection
-         * @private
-         * @type {EntityCollection}
-         */
         this._entityCollection = entityCollection;
 
-        /**
-         * Renderer
-         * @private
-         * @type {Renderer}
-         */
         this._renderer = null;
 
-        /**
-         * Point cloud array
-         * @private
-         * @type {Array.<Strip>}
-         */
         this._strips = [];
-
-        this.__staticId = StripHandler._staticCounter++;
-    }
-
-    static get _staticCounter() {
-        if (!this._counter && this._counter !== 0) {
-            this._counter = 0;
-        }
-        return this._counter;
-    }
-
-    static set _staticCounter(n) {
-        this._counter = n;
     }
 
-    _initProgram() {
-        if (this._renderer.handler) {
+    protected _initProgram() {
+        if (this._renderer && this._renderer.handler) {
             !this._renderer.handler.programs.strip &&
-                this._renderer.handler.addProgram(
-                    new Program("strip", {
-                        uniforms: {
-                            projectionMatrix: { type: "mat4" },
-                            viewMatrix: { type: "mat4" },
-                            eyePositionHigh: "vec3",
-                            eyePositionLow: "vec3",
-                            uColor: { type: "vec4" },
-                            uOpacity: { type: "float" }
-                        },
-                        attributes: {
-                            aVertexPositionHigh: { type: "vec3" },
-                            aVertexPositionLow: { type: "vec3" }
-                        },
-                        vertexShader: `attribute vec3 aVertexPositionHigh;
+            this._renderer.handler.addProgram(
+                new Program("strip", {
+                    uniforms: {
+                        projectionMatrix: {type: "mat4"},
+                        viewMatrix: {type: "mat4"},
+                        eyePositionHigh: "vec3",
+                        eyePositionLow: "vec3",
+                        uColor: {type: "vec4"},
+                        uOpacity: {type: "float"}
+                    },
+                    attributes: {
+                        aVertexPositionHigh: {type: "vec3"},
+                        aVertexPositionLow: {type: "vec3"}
+                    },
+                    vertexShader: `attribute vec3 aVertexPositionHigh;
                         attribute vec3 aVertexPositionLow;
                         uniform mat4 projectionMatrix;
                         uniform mat4 viewMatrix;
@@ -79,18 +83,18 @@ class StripHandler {
 
                             gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
                         }`,
-                        fragmentShader: `precision highp float;
+                    fragmentShader: `precision highp float;
                         uniform vec4 uColor;
                         uniform float uOpacity;
                         void main(void) {
                             gl_FragColor = vec4(uColor.rgb, uColor.a * uOpacity);
                         }`
-                    })
-                );
+                })
+            );
         }
     }
 
-    setRenderNode(renderNode) {
+    public setRenderNode(renderNode: RenderNode) {
         this._renderer = renderNode.renderer;
         this._initProgram();
         for (let i = 0; i < this._strips.length; i++) {
@@ -98,19 +102,19 @@ class StripHandler {
         }
     }
 
-    add(strip) {
+    public add(strip: Strip) {
         if (strip._handlerIndex === -1) {
             strip._handler = this;
             strip._handlerIndex = this._strips.length;
             this._strips.push(strip);
             this._entityCollection &&
-                this._entityCollection.renderNode &&
-                strip.setRenderNode(this._entityCollection.renderNode);
+            this._entityCollection.renderNode &&
+            strip.setRenderNode(this._entityCollection.renderNode);
         }
     }
 
-    remove(strip) {
-        var index = strip._handlerIndex;
+    public remove(strip: Strip) {
+        let index = strip._handlerIndex;
         if (index !== -1) {
             strip._deleteBuffers();
             strip._handlerIndex = -1;
@@ -120,31 +124,31 @@ class StripHandler {
         }
     }
 
-    reindexStripArray(startIndex) {
-        var pc = this._strips;
+    public reindexStripArray(startIndex: number) {
+        let pc = this._strips;
         for (let i = startIndex; i < pc.length; i++) {
             pc[i]._handlerIndex = i;
         }
     }
 
-    draw() {
-        var i = this._strips.length;
+    public draw() {
+        let i = this._strips.length;
         while (i--) {
             this._strips[i].draw();
         }
     }
 
-    drawPicking() {
+    public drawPicking() {
         if (this.pickingEnabled) {
-            var i = this._strips.length;
+            let i = this._strips.length;
             while (i--) {
                 this._strips[i].drawPicking();
             }
         }
     }
 
-    clear() {
-        var i = this._strips.length;
+    public clear() {
+        let i = this._strips.length;
         while (i--) {
             this._strips[i]._deleteBuffers();
             this._strips[i]._handler = null;
@@ -155,4 +159,4 @@ class StripHandler {
     }
 }
 
-export { StripHandler };
+export {StripHandler};