@openglobus/og 0.11.5 → 0.11.6

package/src/og/renderer/Renderer.js

@@ -16,6 +16,7 @@ import { TextureAtlas } from "../utils/TextureAtlas.js";
 import * as arial from "../arial.js";
 import { depth } from "../shaders/depth.js";
 import { ARIAL_FONT_B64 } from "../res/images.js";
+import { LabelWorker } from "../entity/LabelWorker.js";
 
 let __pickingCallbackCounter__ = 0;
 
@@ -55,7 +56,6 @@ let __depthCallbackCounter__ = 0;
  * @fires og.RendererEvents#touchenter
  */
 class Renderer {
-
     constructor(handler, params) {
         params = params || {};
 
@@ -212,6 +212,8 @@ class Renderer {
         }
 
         this._currentOutput = "screen";
+
+        this.labelWorker = new LabelWorker();
     }
 
     /**
@@ -441,7 +443,7 @@ class Renderer {
             useDepth: false
         }).init();
 
-        this.readPixels = () => { };
+        this.readPixels = () => {};
 
         if (this.handler.gl.type === "webgl") {
             this.sceneFramebuffer = new Framebuffer(this.handler);
@@ -538,7 +540,8 @@ class Renderer {
             );
         this.toneMappingFramebuffer &&
             this.toneMappingFramebuffer.setSize(obj.clientWidth, obj.clientHeight, true);
-        this.depthFramebuffer && this.depthFramebuffer.setSize(obj.clientWidth, obj.clientHeight, true);
+        this.depthFramebuffer &&
+            this.depthFramebuffer.setSize(obj.clientWidth, obj.clientHeight, true);
         this.screenDepthFramebuffer &&
             this.screenDepthFramebuffer.setSize(obj.clientWidth, obj.clientHeight, true);
 
@@ -610,7 +613,11 @@ class Renderer {
 
     getMaxMSAA(internalFormat) {
         var gl = this.handler.gl;
-        let samples = gl.getInternalformatParameter(gl.RENDERBUFFER, gl[internalFormat], gl.SAMPLES);
+        let samples = gl.getInternalformatParameter(
+            gl.RENDERBUFFER,
+            gl[internalFormat],
+            gl.SAMPLES
+        );
         return samples[0];
     }
 
@@ -671,6 +678,12 @@ class Renderer {
                 ec[i]._fadingOpacity && ec[i].labelHandler.draw();
             }
 
+            //geoObject
+            i = ec.length;
+            while (i--) {
+                ec[i]._fadingOpacity && ec[i].geoObjectHandler.draw();
+            }
+
             // rays
             i = ec.length;
             while (i--) {
@@ -735,7 +748,12 @@ class Renderer {
 
         let h = this.handler;
 
-        h.gl.clearColor(this.backgroundColor.x, this.backgroundColor.y, this.backgroundColor.z, 1.0);
+        h.gl.clearColor(
+            this.backgroundColor.x,
+            this.backgroundColor.y,
+            this.backgroundColor.z,
+            1.0
+        );
         h.gl.clear(h.gl.COLOR_BUFFER_BIT | h.gl.DEPTH_BUFFER_BIT);
 
         e.dispatch(e.draw, this);
@@ -964,7 +982,6 @@ class Renderer {
     start() {
         this.handler.start();
     }
-
 }
 
 export { Renderer };

package/src/og/renderer/RendererEvents.js

@@ -335,7 +335,7 @@ class RendererEvents extends Events {
      */
     onMouseMove(event, sys) {
         var ms = this.mouseState;
-        this.updateButtonsStates(sys.buttons)
+        this.updateButtonsStates(sys.buttons);
         ms.sys = event;
 
         let ex = event.clientX,

package/src/og/scene/BaseNode.js

@@ -2,7 +2,7 @@
  * @module og/scene/BaseNode
  */
 
-'use strict';
+"use strict";
 
 /**
  * Scene node base class.
@@ -11,7 +11,6 @@
  */
 class BaseNode {
     constructor(name) {
-
         /**
          * Node name.
          * @public
@@ -111,4 +110,4 @@ class BaseNode {
     }
 }
 
-export { BaseNode };
+export { BaseNode };

package/src/og/scene/Planet.js

@@ -1124,7 +1124,7 @@ export class Planet extends RenderNode {
         gl.disable(gl.POLYGON_OFFSET_FILL);
 
         if (frustumIndex === cam.FARTHEST_FRUSTUM_INDEX) {
-            if (this._skipPreRender && (!this._renderCompletedActivated || cam.isMoved)) {
+            if (this._skipPreRender/* && (!this._renderCompletedActivated || cam.isMoved)*/) {
                 this._collectRenderNodes();
             }
             this._skipPreRender = true;
@@ -1171,7 +1171,7 @@ export class Planet extends RenderNode {
                 gl.TEXTURE_2D,
                 (this.camera._lonLat.height > 329958.0 &&
                     (this._nightTexture || this.transparentTexture)) ||
-                    this.transparentTexture
+                this.transparentTexture
             );
             gl.uniform1i(shu.nightTexture, this.SLICE_SIZE);
 

package/src/og/scene/RenderNode.js

@@ -1,7 +1,7 @@
-'use strict';
+"use strict";
 
-import { BaseNode } from './BaseNode.js';
-import { Events } from '../Events.js';
+import { BaseNode } from "./BaseNode.js";
+import { Events } from "../Events.js";
 
 /**
  * Render node is a logical part of a render mechanism. Represents scene rendering.
@@ -98,8 +98,7 @@ class RenderNode extends BaseNode {
             n = this.name;
 
         if (r) {
-            if (r.renderNodes[n] &&
-                r.renderNodes[n].isEqual(this)) {
+            if (r.renderNodes[n] && r.renderNodes[n].isEqual(this)) {
                 r.renderNodes[n] = null;
                 delete r.renderNodes[n];
             }
@@ -195,7 +194,10 @@ class RenderNode extends BaseNode {
 
         if (this.renderer) {
             if (this._isActive && this._pickingId === -1) {
-                this._pickingId = this.renderer.addPickingCallback(this, this._entityCollectionPickingCallback);
+                this._pickingId = this.renderer.addPickingCallback(
+                    this,
+                    this._entityCollectionPickingCallback
+                );
             } else if (!this._isActive && this._pickingId !== -1) {
                 this.renderer.removePickingCallback(this._pickingId);
                 this._pickingId = -1;
@@ -277,7 +279,6 @@ class RenderNode extends BaseNode {
      */
     drawPickingEntityCollections(ec) {
         if (ec.length) {
-
             var gl = this.renderer.handler.gl;
 
             gl.disable(gl.CULL_FACE);
@@ -292,6 +293,12 @@ class RenderNode extends BaseNode {
                 ec[i]._fadingOpacity && ec[i].billboardHandler.drawPicking();
             }
 
+            // geoObject pass
+            i = ec.length;
+            while (i--) {
+                ec[i]._fadingOpacity && ec[i].geoObjectHandler.drawPicking();
+            }
+
             // label pass
             i = ec.length;
             while (i--) {
@@ -344,4 +351,4 @@ class RenderNode extends BaseNode {
     }
 }
 
-export { RenderNode };
+export { RenderNode };

package/src/og/shaders/geoObject.js

@@ -0,0 +1,211 @@
+/**
+ * @module og/shaders/drawnode
+ */
+
+"use strict";
+
+import { Program } from "../webgl/Program.js";
+
+export const geo_object = () =>
+    new Program("geo_object", {
+        uniforms: {
+            viewMatrix: "mat4",
+            projectionMatrix: "mat4",
+            normalMatrix: "mat3",
+
+            uScaleByDistance: "vec3",
+
+            eyePositionHigh: "vec3",
+            eyePositionLow: "vec3",
+
+            lightsPositions: "vec4",
+            lightsParamsv: "vec3",
+            lightsParamsf: "float"
+        },
+        attributes: {
+            aVertexPosition: "vec3",
+            aVertexNormal: "vec3",
+            aPositionHigh: { type: "vec3", divisor: 1 },
+            aPositionLow: { type: "vec3", divisor: 1 },
+            aDirection: { type: "vec3", divisor: 1 },
+            aPitchRoll: { type: "vec2", divisor: 1 },
+            aColor: { type: "vec4", divisor: 1 },
+            aScale: { type: "float", divisor: 1 }
+        },
+        vertexShader: `precision highp float;
+
+            attribute vec3 aVertexPosition;
+            attribute vec3 aVertexNormal; 
+            attribute vec3 aPositionHigh;
+            attribute vec3 aPositionLow;    
+            attribute vec3 aDirection;
+            attribute vec2 aPitchRoll;
+            attribute vec4 aColor;
+            attribute float aScale;
+            
+            uniform vec3 uScaleByDistance;
+            uniform mat4 projectionMatrix;
+            uniform mat4 viewMatrix;
+            uniform mat3 normalMatrix;
+            
+            uniform vec3 eyePositionHigh;
+            uniform vec3 eyePositionLow;
+
+            varying vec3 vNormal;
+            varying vec4 vPosition;           
+            varying vec4 vColor;
+            
+            const float RADIANS = 3.141592653589793 / 180.0;
+
+            void main(void) {
+            
+                vColor = aColor;
+                float roll = aPitchRoll.y * RADIANS;
+                mat3 rotZ = mat3(
+                     vec3(cos(roll), sin(roll), 0.0),
+                     vec3(-sin(roll), cos(roll), 0.0), 
+                     vec3(0.0, 0.0, 1.0) 
+                );
+
+                float pitch = aPitchRoll.x * RADIANS;
+                mat3 rotX = mat3(
+                    vec3(1.0, 0.0, 0.0),
+                    vec3(0.0, cos(pitch), sin(pitch)), 
+                    vec3(0.0, -sin(pitch), cos(pitch)) 
+               );
+
+                vec3 position = aPositionHigh + aPositionLow;
+                vec3 r = cross(normalize(-position), aDirection);
+                mat3 modelMatrix = mat3(r, normalize(position), -aDirection) * rotX * rotZ; /*up=-cross(aDirection, r)*/
+
+                vec3 look = position - (eyePositionHigh + eyePositionLow);
+                float lookLength = length(look);
+                float scd = aScale * (1.0 - smoothstep(uScaleByDistance[0], uScaleByDistance[1], lookLength)) * (1.0 - step(uScaleByDistance[2], lookLength));
+                vNormal = normalMatrix * modelMatrix * aVertexNormal;
+
+                vec3 highDiff = aPositionHigh - eyePositionHigh;
+                vec3 lowDiff = aPositionLow + modelMatrix * (aVertexPosition * scd) - eyePositionLow;
+
+                mat4 viewMatrixRTE = viewMatrix;
+                viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+
+                vPosition = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+
+                gl_Position = projectionMatrix * vPosition;
+            }`,
+        fragmentShader: `precision highp float;
+
+                varying vec4 vColor;
+                #define MAX_POINT_LIGHTS 1
+                
+                uniform vec4 lightsPositions[MAX_POINT_LIGHTS];
+                uniform vec3 lightsParamsv[MAX_POINT_LIGHTS * 3];
+                uniform float lightsParamsf[MAX_POINT_LIGHTS];
+                
+                varying vec3 vNormal;
+                varying vec4 vPosition;
+                
+                void main(void) {
+                    vec3 lightWeighting;
+                    vec3 lightDirection;
+                    vec3 normal;
+                    vec3 eyeDirection;
+                    vec3 reflectionDirection;
+                    float specularLightWeighting;
+                    float diffuseLightWeighting;
+                
+                    lightDirection = normalize(lightsPositions[0].xyz - vPosition.xyz * lightsPositions[0].w);
+                    normal = normalize(vNormal);
+                    eyeDirection = normalize(-vPosition.xyz);
+                    reflectionDirection = reflect(-lightDirection, normal);
+                    specularLightWeighting = pow(max(dot(reflectionDirection, eyeDirection), 0.0), lightsParamsf[0]);
+                    diffuseLightWeighting = max(dot(normal, lightDirection), 0.0);
+                    lightWeighting = lightsParamsv[0] + lightsParamsv[1] * diffuseLightWeighting + lightsParamsv[2] * specularLightWeighting;
+                    gl_FragColor = vec4(lightWeighting, 1.0) * vColor;
+                }`
+    });
+
+export const geo_object_picking = () =>
+    new Program("geo_object_picking", {
+        uniforms: {
+            viewMatrix: "mat4",
+            projectionMatrix: "mat4",
+
+            uScaleByDistance: "vec3",
+
+            eyePositionHigh: "vec3",
+            eyePositionLow: "vec3",
+            pickingScale: "float",
+
+        },
+        attributes: {
+            aVertexPosition: "vec3",
+            aPositionHigh: { type: "vec3", divisor: 1 },
+            aPositionLow: { type: "vec3", divisor: 1 },
+            aDirection: { type: "vec3", divisor: 1 },
+            aPitchRoll: { type: "vec2", divisor: 1 },
+            aPickingColor: { type: "vec3", divisor: 1 },
+            aScale: { type: "float", divisor: 1 }
+        },
+        vertexShader: `precision highp float;
+
+            attribute vec3 aVertexPosition;
+            attribute vec3 aPositionHigh;
+            attribute vec3 aPositionLow;    
+            attribute vec3 aDirection;
+            attribute vec2 aPitchRoll;
+            attribute vec3 aPickingColor;
+            attribute float aScale;
+            
+            uniform vec3 uScaleByDistance;
+            uniform mat4 projectionMatrix;
+            uniform mat4 viewMatrix;
+            uniform float pickingScale;
+            
+            uniform vec3 eyePositionHigh;
+            uniform vec3 eyePositionLow;
+
+            varying vec3 vColor;
+            
+            const float RADIANS = 3.141592653589793 / 180.0;
+
+            void main(void) {
+            
+                vColor = aPickingColor;
+                float roll = aPitchRoll.y * RADIANS;
+                mat3 rotZ = mat3(
+                     vec3(cos(roll), sin(roll), 0.0),
+                     vec3(-sin(roll), cos(roll), 0.0), 
+                     vec3(0.0, 0.0, 1.0) 
+                );
+
+                float pitch = aPitchRoll.x * RADIANS;
+                mat3 rotX = mat3(
+                    vec3(1.0, 0.0, 0.0),
+                    vec3(0.0, cos(pitch), sin(pitch)), 
+                    vec3(0.0, -sin(pitch), cos(pitch)) 
+               );
+
+                vec3 position = aPositionHigh + aPositionLow;
+                vec3 r = cross(normalize(-position), aDirection);
+                mat3 modelMatrix = mat3(r, normalize(position), -aDirection) * rotX * rotZ; /*up=-cross(aDirection, r)*/
+
+                vec3 look = position - (eyePositionHigh + eyePositionLow);
+                float lookLength = length(look);
+                float scd = aScale * pickingScale * (1.0 - smoothstep(uScaleByDistance[0], uScaleByDistance[1], lookLength)) * (1.0 - step(uScaleByDistance[2], lookLength));
+
+                vec3 highDiff = aPositionHigh - eyePositionHigh;
+                vec3 lowDiff = aPositionLow + modelMatrix * (aVertexPosition * scd) - eyePositionLow;
+
+                mat4 viewMatrixRTE = viewMatrix;
+                viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+
+                gl_Position = projectionMatrix *viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+            }`,
+        fragmentShader:
+            `precision highp float;
+            varying vec3 vColor;
+            void main () {
+                gl_FragColor = vec4(vColor, 1.0);
+            }`
+    });

package/src/og/shaders/pointCloud.js

@@ -1,42 +1,42 @@
-/**
- * @module og/shaders/pointCloud
- */
-
-'use strict';
-
-import { Program } from '../webgl/Program.js';
-import { types } from '../webgl/types.js';
-
-//Picking is the same
-export function pointCloud() {
-    return new Program("pointCloud", {
-        uniforms: {
-            projectionViewMatrix: { type: types.MAT4 },
-            opacity: { type: types.FLOAT },
-            pointSize: { type: types.FLOAT }
-        },
-        attributes: {
-            coordinates: { type: types.VEC3, enableArray: true },
-            colors: { type: types.VEC3, enableArray: true }
-        },
-        vertexShader:
-            `attribute vec3 coordinates;
-            attribute vec4 colors;
-            uniform mat4 projectionViewMatrix;
-            uniform float opacity;
-            uniform float pointSize;
-            varying vec4 color;
-            void main() {
-                color = colors;
-                color.a *= opacity;
-                gl_Position = projectionViewMatrix * vec4(coordinates, 1.0);
-                gl_PointSize = pointSize;
-            }`,
-        fragmentShader:
-            `precision highp float;
-            varying vec4 color;
-            void main(void) {
-                gl_FragColor = color;
-            }`
-    });
+/**
+ * @module og/shaders/pointCloud
+ */
+
+'use strict';
+
+import { Program } from '../webgl/Program.js';
+import { types } from '../webgl/types.js';
+
+//Picking is the same
+export function pointCloud() {
+    return new Program("pointCloud", {
+        uniforms: {
+            projectionViewMatrix: { type: types.MAT4 },
+            opacity: { type: types.FLOAT },
+            pointSize: { type: types.FLOAT }
+        },
+        attributes: {
+            coordinates: { type: types.VEC3, enableArray: true },
+            colors: { type: types.VEC3, enableArray: true }
+        },
+        vertexShader:
+            `attribute vec3 coordinates;
+            attribute vec4 colors;
+            uniform mat4 projectionViewMatrix;
+            uniform float opacity;
+            uniform float pointSize;
+            varying vec4 color;
+            void main() {
+                color = colors;
+                color.a *= opacity;
+                gl_Position = projectionViewMatrix * vec4(coordinates, 1.0);
+                gl_PointSize = pointSize;
+            }`,
+        fragmentShader:
+            `precision highp float;
+            varying vec4 color;
+            void main(void) {
+                gl_FragColor = color;
+            }`
+    });
 }

package/src/og/shaders/shape.js

@@ -2,10 +2,10 @@
  * @module og/shaders/shape
  */
 
-'use strict';
+"use strict";
 
-import { Program } from '../webgl/Program.js';
-import { types } from '../webgl/types.js';
+import { Program } from "../webgl/Program.js";
+import { types } from "../webgl/types.js";
 
 export function shape_wl() {
     return new Program("shape_wl", {
@@ -23,12 +23,11 @@ export function shape_wl() {
             uSampler: { type: types.SAMPLER2D }
         },
         attributes: {
-            aVertexNormal: { type: types.VEC3, enableArray: true },
-            aVertexPosition: { type: types.VEC3, enableArray: true },
-            aTextureCoord: { type: types.VEC2, enableArray: true }
+            aVertexNormal: { type: types.VEC3 },
+            aVertexPosition: { type: types.VEC3 },
+            aTextureCoord: { type: types.VEC2 }
         },
-        vertexShader:
-        `attribute vec3 aVertexNormal;
+        vertexShader: `attribute vec3 aVertexNormal;
             attribute vec3 aVertexPosition;
             attribute vec2 aTextureCoord;
             uniform mat4 projectionMatrix;
@@ -45,8 +44,7 @@ export function shape_wl() {
                 vPosition = viewMatrix * modelMatrix * vec4(aVertexPosition, 1.0);
                 gl_Position = projectionMatrix * vPosition;
             }`,
-        fragmentShader:
-        `precision highp float;
+        fragmentShader: `precision highp float;
             varying vec2 vTextureCoord;
             varying vec3 vNormal;
             varying vec4 vPosition;
@@ -90,8 +88,7 @@ export function shape_nl() {
             aVertexPosition: { type: types.VEC3, enableArray: true },
             aTextureCoord: { type: types.VEC2, enableArray: true }
         },
-        vertexShader:
-        `attribute vec3 aVertexPosition;
+        vertexShader: `attribute vec3 aVertexPosition;
             attribute vec2 aTextureCoord;
             uniform mat4 projectionViewMatrix;
             uniform mat4 modelMatrix;
@@ -101,8 +98,7 @@ export function shape_nl() {
                 gl_Position = projectionViewMatrix * (modelMatrix * vec4(aVertexPosition, 1.0));
                 vTextureCoord = aTextureCoord;
             }`,
-        fragmentShader:
-        `precision highp float;
+        fragmentShader: `precision highp float;
             uniform vec4 uColor;
             uniform sampler2D uSampler;
             varying vec2 vTextureCoord;
@@ -122,16 +118,14 @@ export function shape_picking() {
         attributes: {
             aVertexPosition: { type: types.VEC3, enableArray: true }
         },
-        vertexShader:
-        `attribute vec3 aVertexPosition;
+        vertexShader: `attribute vec3 aVertexPosition;
             uniform mat4 projectionViewMatrix;
             uniform mat4 modelMatrix;
 
             void main(void) {
                 gl_Position = projectionViewMatrix * (modelMatrix * vec4(aVertexPosition, 1.0));
             }`,
-        fragmentShader:
-        `precision highp float;
+        fragmentShader: `precision highp float;
             uniform vec4 uColor;
             uniform sampler2D uSampler;
             void main(void) {

package/src/og/shaders/skybox.js

@@ -1,37 +1,37 @@
-/**
- * @module og/shaders/skybox
- */
-
-'use strict';
-
-import { Program } from '../webgl/Program.js';
-import { types } from '../webgl/types.js';
-
-export function skybox() {
-    return new Program("skybox", {
-        uniforms: {
-            projectionViewMatrix: { type: types.MAT4 },
-            uSampler: { type: types.SAMPLERCUBE },
-            pos: { type: types.VEC3 }
-        },
-        attributes: {
-            aVertexPosition: { type: types.VEC3, enableArray: true }
-        },
-        vertexShader:
-            `attribute vec3 aVertexPosition;
-            uniform mat4 projectionViewMatrix;
-            uniform vec3 pos;
-            varying vec3 vTextureCoord;
-            void main(void) {
-                vTextureCoord = aVertexPosition;
-                gl_Position = projectionViewMatrix * vec4(aVertexPosition + pos, 1.0);
-            }`,
-        fragmentShader:
-            `precision lowp float;
-            varying vec3 vTextureCoord;
-            uniform samplerCube uSampler;
-            void main(void) {
-                gl_FragColor = textureCube(uSampler, vTextureCoord);
-            }`
-    });
+/**
+ * @module og/shaders/skybox
+ */
+
+'use strict';
+
+import { Program } from '../webgl/Program.js';
+import { types } from '../webgl/types.js';
+
+export function skybox() {
+    return new Program("skybox", {
+        uniforms: {
+            projectionViewMatrix: { type: types.MAT4 },
+            uSampler: { type: types.SAMPLERCUBE },
+            pos: { type: types.VEC3 }
+        },
+        attributes: {
+            aVertexPosition: { type: types.VEC3, enableArray: true }
+        },
+        vertexShader:
+            `attribute vec3 aVertexPosition;
+            uniform mat4 projectionViewMatrix;
+            uniform vec3 pos;
+            varying vec3 vTextureCoord;
+            void main(void) {
+                vTextureCoord = aVertexPosition;
+                gl_Position = projectionViewMatrix * vec4(aVertexPosition + pos, 1.0);
+            }`,
+        fragmentShader:
+            `precision lowp float;
+            varying vec3 vTextureCoord;
+            uniform samplerCube uSampler;
+            void main(void) {
+                gl_FragColor = textureCube(uSampler, vTextureCoord);
+            }`
+    });
 }