@openglobus/og 0.11.6 → 0.11.7

package/src/og/renderer/RendererEvents.js

@@ -84,10 +84,14 @@ class RendererEvents extends Events {
                     ms.moving ||
                     ms.justStopped
                 );
-            },
-            /** Current mouse X position. */
+            },
+            /** Current screen mouse X position. */
+            clientX: 0,
+            /** Current screen mouse Y position. */
+            clientY: 0,
+            /** Current viewport mouse X position. */
             x: 0,
-            /** Current mouse Y position. */
+            /** Current viewport mouse Y position. */
             y: 0,
             /** Current mouse X position from 0 to 1 */
             nx: 0,
@@ -357,16 +361,20 @@ class RendererEvents extends Events {
             this._mClkBegins = 0;
         }
 
-        if (ms.x === event.clientX && ms.y === event.clientY) {
+        if (ms.clientX === event.clientX && ms.clientY === event.clientY) {
             return;
-        }
+        }
 
-        ms.x = event.clientX;
-        ms.y = event.clientY;
+        ms.clientX = event.clientX;
+        ms.clientY = event.clientY;
+
+        let h = this.renderer.handler;
+
+        ms.x = event.clientX * h.pixelRatio;
+        ms.y = event.clientY * h.pixelRatio;
 
-        var cnv = this.renderer.handler.canvas;
-        ms.nx = ms.x / cnv.width;
-        ms.ny = ms.y / cnv.height;
+        ms.nx = ms.x / h.canvas.width;
+        ms.ny = ms.y / h.canvas.height;
 
         ms.moving = true;
 
@@ -492,12 +500,18 @@ class RendererEvents extends Events {
      */
     onTouchStart(event) {
         var ts = this.touchState;
-        ts.sys = event;
-        ts.x = event.touches.item(0).clientX - event.offsetLeft;
-        ts.y = event.touches.item(0).clientY - event.offsetTop;
-        var cnv = this.renderer.handler.canvas;
-        ts.nx = ts.x / cnv.width;
-        ts.ny = ts.y / cnv.height;
+        ts.sys = event;
+
+        ts.clienX = event.touches.item(0).clientX - event.offsetLeft;
+        ts.clientY = event.touches.item(0).clientY - event.offsetTop;
+
+        let h = this.renderer.handler;
+
+        ts.x = ts.clientX * h.pixelRatio;
+        ts.y = ts.clientY * h.pixelRatio;
+
+        ts.nx = ts.x / h.canvas.width;
+        ts.ny = ts.y / h.canvas.height;
         ts.prev_x = ts.x;
         ts.prev_y = ts.y;
         ts.touchStart = true;
@@ -551,11 +565,17 @@ class RendererEvents extends Events {
      */
     onTouchMove(event) {
         var ts = this.touchState;
-        ts.x = event.touches.item(0).clientX - event.offsetLeft;
-        ts.y = event.touches.item(0).clientY - event.offsetTop;
-        var cnv = this.renderer.handler.canvas;
-        ts.nx = ts.x / cnv.width;
-        ts.ny = ts.y / cnv.height;
+        ts.clientX = event.touches.item(0).clientX - event.offsetLeft;
+        ts.clientY = event.touches.item(0).clientY - event.offsetTop;
+
+        var h = this.renderer.handler;
+
+        ts.x = ts.clientX * h.pixelRatio;
+        ts.y = ts.clientY * h.pixelRatio;
+
+        ts.nx = ts.x / h.canvas.width;
+        ts.ny = ts.y / h.canvas.height;
+
         ts.sys = event;
         ts.moving = true;
         this._dblTchBegins = 0;

package/src/og/scene/Planet.js

@@ -32,7 +32,7 @@ import { NIGHT, SPECULAR } from "../res/images.js";
 import { Geoid } from "../terrain/Geoid.js";
 import { isUndef } from "../utils/shared.js";
 
-const MAX_LOD = 0.9;
+const MAX_LOD = 1.0;
 const MIN_LOD = 0.75;
 
 let _tempPickingPix_ = new Uint8Array(4),
@@ -93,7 +93,7 @@ const EVENT_NAMES = [
  * @param {string} [options.name="Earth"] - Planet name(Earth by default)
  * @param {Ellipsoid} [options.ellipsoid] - Planet ellipsoid(WGS84 by default)
  * @param {Number} [options.maxGridSize=128] - Segment maximal grid size
- * @param {Number} [options.maxEqualZoomAltitude=850000.0] - Maximal altitude since segments on the screen bacame the same zoom level
+ * @param {Number} [options.maxEqualZoomAltitude=15000000.0] - Maximal altitude since segments on the screen bacame the same zoom level
  * @param {Number} [options.minEqualZoomAltitude=10000.0] - Minimal altitude since segments on the screen bacame the same zoom level
  * @param {Number} [options.minEqualZoomCameraSlope=0.8] - Minimal camera slope above te globe where segments on the screen bacame the same zoom level
  * @fires og.scene.Planet#draw
@@ -180,7 +180,7 @@ export class Planet extends RenderNode {
         this._minAltitude = options.minAltitude;
         this._maxAltitude = options.maxAltitude;
 
-        this.maxEqualZoomAltitude = options.maxEqualZoomAltitude || 850000.0;
+        this.maxEqualZoomAltitude = options.maxEqualZoomAltitude || 15000000.0;
         this.minEqualZoomAltitude = options.minEqualZoomAltitude || 10000.0;
         this.minEqualZoomCameraSlope = options.minEqualZoomCameraSlope || 0.8;
 
@@ -731,31 +731,13 @@ export class Planet extends RenderNode {
         }
 
         // Creating quad trees nodes
-        this._quadTree = new Node(
-            Segment,
-            this,
-            quadTree.NW,
-            null,
-            0,
-            0,
+        this._quadTree = new Node(Segment, this, quadTree.NW, null, 0, 0,
             Extent.createFromArray([-20037508.34, -20037508.34, 20037508.34, 20037508.34])
         );
-        this._quadTreeNorth = new Node(
-            SegmentLonLat,
-            this,
-            quadTree.NW,
-            null,
-            0,
-            0,
+        this._quadTreeNorth = new Node(SegmentLonLat, this, quadTree.NW, null, 0, 0,
             Extent.createFromArray([-180, mercator.MAX_LAT, 180, 90])
         );
-        this._quadTreeSouth = new Node(
-            SegmentLonLat,
-            this,
-            quadTree.NW,
-            null,
-            0,
-            0,
+        this._quadTreeSouth = new Node(SegmentLonLat, this, quadTree.NW, null, 0, 0,
             Extent.createFromArray([-180, -90, 180, mercator.MIN_LAT])
         );
 
@@ -771,7 +753,7 @@ export class Planet extends RenderNode {
         // loading Earth night glowing texture
         if (this._useNightTexture) {
             createImageBitmap(NIGHT).then(
-                (e) => (this._nightTexture = this.renderer.handler.createTexture(e))
+                (e) => (this._nightTexture = this.renderer.handler.createTextureDefault(e))
             );
         }
 
@@ -1147,12 +1129,13 @@ export class Planet extends RenderNode {
             this._vectorTileCreator.frame();
         }
 
-        gl.blendEquation(gl.FUNC_ADD);
 
-        gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+        gl.enable(gl.CULL_FACE);
 
         gl.enable(gl.BLEND);
-        gl.enable(gl.CULL_FACE);
+        gl.blendEquation(gl.FUNC_ADD);
+        gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+        //gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ZERO);
 
         if (this.lightEnabled) {
             h.programs.drawnode_screen_wl.activate();

package/src/og/shaders/drawnode.js

@@ -5,9 +5,17 @@
 "use strict";
 
 import { Program } from "../webgl/Program.js";
+
+// REMEMBER!
+// src*(1)+dest*(1-src.alpha)
+// glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+// src*(src.alpha)+dest*(1-src.alpha)
+// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
 const CORNERS = `const vec2 BOTTOMLEFT = vec2(-0.01);
-                const vec2 TOPRIGHT = vec2(1.01);`;
+                const vec2 TOPRIGHT = vec2(1.01);`;
+
+const NIGHT = `const vec3 nightStep = 10.0 * vec3(0.58, 0.48, 0.25);`;
 
 export function drawnode_screen_nl() {
     return new Program("drawnode_screen_nl", {
@@ -66,42 +74,48 @@ export function drawnode_screen_nl() {
             uniform sampler2D defaultTexture;
             uniform sampler2D samplerArr[5];
             uniform int samplerCount;
-            varying vec2 vTextureCoord;
+            varying vec2 vTextureCoord;
+
             /* return 1 if v inside the box, return 0 otherwise */
             float insideBox(vec2 v, vec2 bottomLeft, vec2 topRight) {
                 vec2 s = step(bottomLeft, v) - step(topRight, v);
                 return s.x * s.y;
+            }
+
+            ${CORNERS}
+
+            void blend(
+                out vec4 prevColor,
+                in sampler2D sampler,
+                in vec4 tileOffset,
+                in vec4 visibleExtentOffset,
+                in vec4 transparentColor)
+            {
+                vec4 t = texture2D( sampler, tileOffset.xy + vTextureCoord.xy * tileOffset.zw );
+
+                float emptiness = smoothstep(0.35, 0.5, distance( t.rgb, transparentColor.rgb )) *
+                    insideBox(visibleExtentOffset.xy + vTextureCoord.xy * visibleExtentOffset.zw, BOTTOMLEFT, TOPRIGHT);
+
+                prevColor = prevColor * (1.0 - t.a * transparentColor.a * emptiness) + vec4(t.rgb, t.a) * transparentColor.a * emptiness;
             }
 
-            ${CORNERS}
-
             void main(void) {
                 gl_FragColor = texture2D( defaultTexture, vTextureCoord );
-                if( samplerCount == 0 ) return;
-
-                vec4 t = texture2D( samplerArr[0], tileOffsetArr[0].xy + vTextureCoord * tileOffsetArr[0].zw ) * insideBox(visibleExtentOffsetArr[0].xy + vTextureCoord * visibleExtentOffsetArr[0].zw, BOTTOMLEFT, TOPRIGHT);
-                float emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[0].rgb ));
-                gl_FragColor = mix( gl_FragColor, vec4(t.rgb, 1.0), transparentColorArr[0].a * t.a * emptiness);
-                if( samplerCount == 1 ) return;
-
-                t = texture2D( samplerArr[1], tileOffsetArr[1].xy + vTextureCoord * tileOffsetArr[1].zw ) * insideBox(visibleExtentOffsetArr[1].xy + vTextureCoord * visibleExtentOffsetArr[1].zw, BOTTOMLEFT, TOPRIGHT);
-                emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[1].rgb ));
-                gl_FragColor = mix( gl_FragColor, vec4(t.rgb, 1.0), transparentColorArr[1].a * t.a * emptiness);
-                if( samplerCount == 2 ) return;
-
-                t = texture2D( samplerArr[2], tileOffsetArr[2].xy + vTextureCoord * tileOffsetArr[2].zw ) * insideBox(visibleExtentOffsetArr[2].xy + vTextureCoord * visibleExtentOffsetArr[2].zw, BOTTOMLEFT, TOPRIGHT);
-                emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[2].rgb ));
-                gl_FragColor = mix( gl_FragColor, vec4(t.rgb, 1.0), transparentColorArr[2].a * t.a * emptiness);
-                if( samplerCount == 3 ) return;
-
-                t = texture2D( samplerArr[3], tileOffsetArr[3].xy + vTextureCoord * tileOffsetArr[3].zw ) * insideBox(visibleExtentOffsetArr[3].xy + vTextureCoord * visibleExtentOffsetArr[3].zw, BOTTOMLEFT, TOPRIGHT);
-                emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[3].rgb ));
-                gl_FragColor = mix( gl_FragColor, vec4(t.rgb, 1.0), transparentColorArr[3].a * t.a * emptiness);
-                if( samplerCount == 4 ) return;
-
-                t = texture2D( samplerArr[4], tileOffsetArr[4].xy + vTextureCoord * tileOffsetArr[4].zw ) * insideBox(visibleExtentOffsetArr[4].xy + vTextureCoord * visibleExtentOffsetArr[4].zw, BOTTOMLEFT, TOPRIGHT);
-                emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[4].rgb ));
-                gl_FragColor = mix( gl_FragColor, vec4(t.rgb, 1.0), transparentColorArr[4].a * t.a * emptiness);
+                if( samplerCount == 0 ) return;
+
+                blend(gl_FragColor, samplerArr[0], tileOffsetArr[0], visibleExtentOffsetArr[0], transparentColorArr[0]);
+                if( samplerCount == 1 ) return;
+
+                blend(gl_FragColor, samplerArr[1], tileOffsetArr[1], visibleExtentOffsetArr[1], transparentColorArr[1]);
+                if( samplerCount == 2 ) return;
+
+                blend(gl_FragColor, samplerArr[2], tileOffsetArr[2], visibleExtentOffsetArr[2], transparentColorArr[2]);
+                if( samplerCount == 3 ) return;
+
+                blend(gl_FragColor, samplerArr[3], tileOffsetArr[3], visibleExtentOffsetArr[3], transparentColorArr[3]);
+                if( samplerCount == 4 ) return;
+
+                blend(gl_FragColor, samplerArr[4], tileOffsetArr[4], visibleExtentOffsetArr[4], transparentColorArr[4]);
             }`
     });
 }
@@ -209,9 +223,24 @@ export function drawnode_screen_wl() {
                 return s.x * s.y;
             }
 
-            ${CORNERS}
-
-            const vec3 nightStep = 10.0 * vec3(0.58, 0.48, 0.25);
+            ${CORNERS}
+
+            ${NIGHT}
+
+            void blend(
+                out vec4 prevColor,
+                in sampler2D sampler,
+                in vec4 tileOffset,
+                in vec4 visibleExtentOffset,
+                in vec4 transparentColor)
+            {
+                vec4 t = texture2D( sampler, tileOffset.xy + vTextureCoord.xy * tileOffset.zw );
+
+                float emptiness = smoothstep(0.35, 0.5, distance( t.rgb, transparentColor.rgb )) *
+                    insideBox(visibleExtentOffset.xy + vTextureCoord.xy * visibleExtentOffset.zw, BOTTOMLEFT, TOPRIGHT);
+
+                prevColor = prevColor * (1.0 - t.a * transparentColor.a * emptiness) + vec4(t.rgb, t.a) * transparentColor.a * emptiness;
+            }
 
             void main(void) {
 
@@ -236,54 +265,24 @@ export function drawnode_screen_wl() {
                 gl_FragColor = vec4(t.rgb * lightWeighting + night + spec, t.a);
                 if( samplerCount == 0 ) return;
 
-
-
-                spec = specularMaterial[1].rgb * pow( reflection, specularMaterial[1].w) * (1.0 + shininess);
-                lightWeighting = ambientMaterial[1] + diffuseMaterial[1] * diffuseLightWeighting + spec;
-
-                t = texture2D( samplerArr[0], tileOffsetArr[0].xy + vTextureCoord.xy * tileOffsetArr[0].zw ) * insideBox(visibleExtentOffsetArr[0].xy + vTextureCoord.xy * visibleExtentOffsetArr[0].zw, BOTTOMLEFT, TOPRIGHT);
-                float emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[0].rgb ));
-                gl_FragColor = mix( gl_FragColor, vec4(t.rgb * lightWeighting + night + spec, 1.0), transparentColorArr[0].a * t.a * emptiness);
-                if( samplerCount == 1 ) return;
-
-
-
-                spec = specularMaterial[2].rgb * pow( reflection, specularMaterial[2].w);
-                lightWeighting = ambientMaterial[2] + diffuseMaterial[2] * diffuseLightWeighting + spec;
-
-                t = texture2D( samplerArr[1], tileOffsetArr[1].xy + vTextureCoord.xy * tileOffsetArr[1].zw ) * insideBox(visibleExtentOffsetArr[1].xy + vTextureCoord.xy * visibleExtentOffsetArr[1].zw, BOTTOMLEFT, TOPRIGHT);
-                emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[1].rgb ));
-                gl_FragColor = mix( gl_FragColor, vec4(t.rgb * lightWeighting + night + spec, 1.0), transparentColorArr[1].a * t.a * emptiness);
-                if( samplerCount == 2 ) return;
-
-
-
-                spec = specularMaterial[3].rgb * pow( reflection, specularMaterial[3].w);
-                lightWeighting = ambientMaterial[3] + diffuseMaterial[3] * diffuseLightWeighting + spec;
-
-                t = texture2D( samplerArr[2], tileOffsetArr[2].xy + vTextureCoord.xy * tileOffsetArr[2].zw ) * insideBox(visibleExtentOffsetArr[2].xy + vTextureCoord.xy * visibleExtentOffsetArr[2].zw, BOTTOMLEFT, TOPRIGHT);
-                emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[2].rgb ));
-                gl_FragColor = mix( gl_FragColor, vec4(t.rgb * lightWeighting + night + spec, 1.0), transparentColorArr[2].a * t.a * emptiness);
-                if( samplerCount == 3 ) return;
-
-
-
-                spec = specularMaterial[4].rgb * pow( reflection, specularMaterial[4].w);
-                lightWeighting = ambientMaterial[4] + diffuseMaterial[4] * diffuseLightWeighting + spec;
-
-                t = texture2D( samplerArr[3], tileOffsetArr[3].xy + vTextureCoord.xy * tileOffsetArr[3].zw ) * insideBox(visibleExtentOffsetArr[3].xy + vTextureCoord.xy * visibleExtentOffsetArr[3].zw, BOTTOMLEFT, TOPRIGHT);
-                emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[3].rgb ));
-                gl_FragColor = mix( gl_FragColor, vec4(t.rgb * lightWeighting + night + spec, 1.0), transparentColorArr[3].a * t.a * emptiness);
-                if( samplerCount == 4 ) return;
-
-
-
-                spec = specularMaterial[5].rgb * pow( reflection, specularMaterial[5].w);
-                lightWeighting = ambientMaterial[5] + diffuseMaterial[5] * diffuseLightWeighting + spec;
-
-                t = texture2D( samplerArr[4], tileOffsetArr[4].xy + vTextureCoord.xy * tileOffsetArr[4].zw ) * insideBox(visibleExtentOffsetArr[4].xy + vTextureCoord.xy * visibleExtentOffsetArr[4].zw, BOTTOMLEFT, TOPRIGHT);
-                emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[4].rgb ));
-                gl_FragColor = mix( gl_FragColor, vec4(t.rgb * lightWeighting + night + spec, 1.0), transparentColorArr[4].a * t.a * emptiness);
+                blend(gl_FragColor, samplerArr[0], tileOffsetArr[0], visibleExtentOffsetArr[0], transparentColorArr[0],
+                    specularMaterial[1], ambientMaterial[1], diffuseMaterial[1]);
+                if( samplerCount == 1 ) return;
+
+                blend(gl_FragColor, samplerArr[1], tileOffsetArr[1], visibleExtentOffsetArr[1], transparentColorArr[1],
+                    specularMaterial[2], ambientMaterial[2], diffuseMaterial[2]);
+                if( samplerCount == 2 ) return;
+
+                blend(gl_FragColor, samplerArr[2], tileOffsetArr[2], visibleExtentOffsetArr[2], transparentColorArr[2],
+                    specularMaterial[3], ambientMaterial[3], diffuseMaterial[3]);
+                if( samplerCount == 3 ) return;
+
+                blend(gl_FragColor, samplerArr[3], tileOffsetArr[3], visibleExtentOffsetArr[3], transparentColorArr[3],
+                    specularMaterial[4], ambientMaterial[4], diffuseMaterial[4]);
+                if( samplerCount == 4 ) return;
+
+                blend(gl_FragColor, samplerArr[4], tileOffsetArr[4], visibleExtentOffsetArr[4], transparentColorArr[4],
+                    specularMaterial[5], ambientMaterial[5], diffuseMaterial[5]);
             }`
     });
 }
@@ -321,7 +320,7 @@ export function drawnode_screen_wl_webgl2() {
             aTextureCoord: "vec2"
         },
 
-        vertexShader: `#version 300 es
+        vertexShader: `#version 300 es
 
             in vec3 aVertexPositionHigh;
             in vec3 aVertexPositionLow;
@@ -387,7 +386,12 @@ export function drawnode_screen_wl_webgl2() {
             in vec4 vTextureCoord;
             in vec2 vGlobalTextureCoord;
             in vec4 v_vertex;
-            in float v_height;
+            in float v_height;
+
+            float shininess;
+            float reflection;
+            float diffuseLightWeighting;
+            vec3 night;
 
             layout(location = 0) out vec4 fragColor;
 
@@ -399,7 +403,28 @@ export function drawnode_screen_wl_webgl2() {
 
             ${CORNERS}
 
-            const vec3 nightStep = 10.0 * vec3(0.58, 0.48, 0.25);
+            ${NIGHT}
+
+            void blend(
+                out vec4 dest,
+                in sampler2D sampler,
+                in vec4 tileOffset,
+                in vec4 visibleExtentOffset,
+                in vec4 transparentColor,
+                in vec4 specular,
+                in vec3 ambient,
+                in vec3 diffuse)
+            {
+                vec3 spec = specular.rgb * pow(reflection, specular.w) * (1.0 + shininess);
+                vec3 lightWeighting = ambient + diffuse * diffuseLightWeighting + spec;
+
+                vec4 src = texture( sampler, tileOffset.xy + vTextureCoord.xy * tileOffset.zw );
+
+                float emptiness = smoothstep(0.35, 0.5, distance( src.rgb, transparentColor.rgb )) *
+                    insideBox(visibleExtentOffset.xy + vTextureCoord.xy * visibleExtentOffset.zw, BOTTOMLEFT, TOPRIGHT);
+
+                dest = dest * (1.0 - src.a * transparentColor.a * emptiness) + vec4(src.rgb * lightWeighting + night + spec * src.a, src.a) * transparentColor.a * emptiness;
+            }
 
             void main(void) {
 
@@ -408,70 +433,38 @@ export function drawnode_screen_wl_webgl2() {
                 vec3 lightDirection = normalize(lightsPositions[0].xyz - v_vertex.xyz * lightsPositions[0].w);
                 vec3 eyeDirection = normalize(-v_vertex.xyz);
                 vec3 reflectionDirection = reflect(-lightDirection, normal);
-                vec4 nightImageColor = texture( nightTexture, vGlobalTextureCoord.st );
-                float shininess = texture( specularTexture, vGlobalTextureCoord.st ).r * 255.0 * overGround;
-                float reflection = max( dot(reflectionDirection, eyeDirection), 0.0);
-                float diffuseLightWeighting = max(dot(normal, lightDirection), 0.0);
-                vec3 night = nightStep * (0.3 - diffuseLightWeighting) * nightImageColor.rgb;
-                night *= overGround * step(0.0, night);
-
-
+                vec4 nightImageColor = texture( nightTexture, vGlobalTextureCoord.st );
 
+                shininess = texture( specularTexture, vGlobalTextureCoord.st ).r * 255.0 * overGround;
+                reflection = max( dot(reflectionDirection, eyeDirection), 0.0);
+                diffuseLightWeighting = max(dot(normal, lightDirection), 0.0);
+                night = nightStep * (.18 - diffuseLightWeighting * 3.0) * nightImageColor.rgb;
+                night *= overGround * step(0.0, night);
+
                 vec3 spec = specularMaterial[0].rgb * pow( reflection, specularMaterial[0].w) * shininess;
                 vec3 lightWeighting = ambientMaterial[0] + diffuseMaterial[0] * diffuseLightWeighting + spec;
-
                 vec4 t = texture( defaultTexture, vTextureCoord.xy );
                 fragColor = vec4(t.rgb * lightWeighting + night + spec, t.a);
-                if( samplerCount == 0 ) return;
-
-
-
-                spec = specularMaterial[1].rgb * pow( reflection, specularMaterial[1].w) * (1.0 + shininess);
-                lightWeighting = ambientMaterial[1] + diffuseMaterial[1] * diffuseLightWeighting + spec;
-
-                t = texture( samplerArr[0], tileOffsetArr[0].xy + vTextureCoord.xy * tileOffsetArr[0].zw ) * insideBox(visibleExtentOffsetArr[0].xy + vTextureCoord.xy * visibleExtentOffsetArr[0].zw, BOTTOMLEFT, TOPRIGHT);
-                float emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[0].rgb ));
-                fragColor = mix( fragColor, vec4(t.rgb * lightWeighting + night + spec, 1.0), transparentColorArr[0].a * t.a * emptiness);
-                if( samplerCount == 1 ) return;
-
-
-
-                spec = specularMaterial[2].rgb * pow( reflection, specularMaterial[2].w);
-                lightWeighting = ambientMaterial[2] + diffuseMaterial[2] * diffuseLightWeighting + spec;
-
-                t = texture( samplerArr[1], tileOffsetArr[1].xy + vTextureCoord.xy * tileOffsetArr[1].zw ) * insideBox(visibleExtentOffsetArr[1].xy + vTextureCoord.xy * visibleExtentOffsetArr[1].zw, BOTTOMLEFT, TOPRIGHT);
-                emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[1].rgb ));
-                fragColor = mix( fragColor, vec4(t.rgb * lightWeighting + night + spec, 1.0), transparentColorArr[1].a * t.a * emptiness);
-                if( samplerCount == 2 ) return;
-
-
-
-                spec = specularMaterial[3].rgb * pow( reflection, specularMaterial[3].w);
-                lightWeighting = ambientMaterial[3] + diffuseMaterial[3] * diffuseLightWeighting + spec;
-
-                t = texture( samplerArr[2], tileOffsetArr[2].xy + vTextureCoord.xy * tileOffsetArr[2].zw ) * insideBox(visibleExtentOffsetArr[2].xy + vTextureCoord.xy * visibleExtentOffsetArr[2].zw, BOTTOMLEFT, TOPRIGHT);
-                emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[2].rgb ));
-                fragColor = mix( fragColor, vec4(t.rgb * lightWeighting + night + spec, 1.0), transparentColorArr[2].a * t.a * emptiness);
-                if( samplerCount == 3 ) return;
-
-
-
-                spec = specularMaterial[4].rgb * pow( reflection, specularMaterial[4].w);
-                lightWeighting = ambientMaterial[4] + diffuseMaterial[4] * diffuseLightWeighting + spec;
-
-                t = texture( samplerArr[3], tileOffsetArr[3].xy + vTextureCoord.xy * tileOffsetArr[3].zw ) * insideBox(visibleExtentOffsetArr[3].xy + vTextureCoord.xy * visibleExtentOffsetArr[3].zw, BOTTOMLEFT, TOPRIGHT);
-                emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[3].rgb ));
-                fragColor = mix( fragColor, vec4(t.rgb * lightWeighting + night + spec, 1.0), transparentColorArr[3].a * t.a * emptiness);
-                if( samplerCount == 4 ) return;
-
-
-
-                spec = specularMaterial[5].rgb * pow( reflection, specularMaterial[5].w);
-                lightWeighting = ambientMaterial[5] + diffuseMaterial[5] * diffuseLightWeighting + spec;
-
-                t = texture( samplerArr[4], tileOffsetArr[4].xy + vTextureCoord.xy * tileOffsetArr[4].zw ) * insideBox(visibleExtentOffsetArr[4].xy + vTextureCoord.xy * visibleExtentOffsetArr[4].zw, BOTTOMLEFT, TOPRIGHT);
-                emptiness = t.a * smoothstep(0.35, 0.5, distance( t.rgb, transparentColorArr[4].rgb ));
-                fragColor = mix( fragColor, vec4(t.rgb * lightWeighting + night + spec, 1.0), transparentColorArr[4].a * t.a * emptiness);
+                if( samplerCount == 0 ) return;
+
+                blend(fragColor, samplerArr[0], tileOffsetArr[0], visibleExtentOffsetArr[0], transparentColorArr[0],
+                    specularMaterial[1], ambientMaterial[1], diffuseMaterial[1]);
+                if( samplerCount == 1 ) return;
+
+                blend(fragColor, samplerArr[1], tileOffsetArr[1], visibleExtentOffsetArr[1], transparentColorArr[1],
+                    specularMaterial[2], ambientMaterial[2], diffuseMaterial[2]);
+                if( samplerCount == 2 ) return;
+
+                blend(fragColor, samplerArr[2], tileOffsetArr[2], visibleExtentOffsetArr[2], transparentColorArr[2],
+                    specularMaterial[3], ambientMaterial[3], diffuseMaterial[3]);
+                if( samplerCount == 3 ) return;
+
+                blend(fragColor, samplerArr[3], tileOffsetArr[3], visibleExtentOffsetArr[3], transparentColorArr[3],
+                    specularMaterial[4], ambientMaterial[4], diffuseMaterial[4]);
+                if( samplerCount == 4 ) return;
+
+                blend(fragColor, samplerArr[4], tileOffsetArr[4], visibleExtentOffsetArr[4], transparentColorArr[4],
+                    specularMaterial[5], ambientMaterial[5], diffuseMaterial[5]);
             }`
     });
 }

package/src/og/shaders/toneMapping.js

@@ -80,6 +80,7 @@ export function toneMapping() {
                 float oneByGamma = gamma / gamma;
                 float oneByWhitePoint = whitepoint / whitepoint;
                 vec3 mapped = ReinhardToneMapping2(hdrColor) * oneByGamma * oneByWhitePoint;
+                //vec3 mapped = ACESFilmicToneMapping(hdrColor) * oneByGamma * oneByWhitePoint;
 
                 mapped = pow(mapped, vec3(1.0 / gamma));
 

package/src/og/shapes/BaseShape.js

@@ -304,7 +304,7 @@ class BaseShape {
             var img = new Image();
             var that = this;
             img.onload = function () {
-                that.texture = renderNode.renderer.handler.createTexture(this);
+                that.texture = renderNode.renderer.handler.createTextureDefault(this);
             };
             img.src = this._src;
         }

package/src/og/utils/FontAtlas.js

@@ -138,10 +138,14 @@ class FontAtlas {
 
         let img = new Image();
         img.onload = () => {
-            atlas.createTexture(img);
+            this._createTexture(atlas, img);
             def.resolve(index);
         };
         img.src = ARIAL_FONT_B64;
+    }
+
+    _createTexture(atlas, img) {
+        atlas.createTexture(img);
     }
 
     loadFont(faceName, srcDir, atlasUrl) {
@@ -183,7 +187,7 @@ class FontAtlas {
 
                 let img = new Image();
                 img.onload = () => {
-                    atlas.createTexture(img);
+                    this._createTexture(atlas, img);
                     def.resolve(index);
                 };
 

package/src/og/utils/TextureAtlas.js

@@ -180,14 +180,14 @@ class TextureAtlas {
      * Creates atlas gl texture.
      * @public
      */
-    createTexture(img) {
+    createTexture(img, internalFormat) {
         if (this._handler) {
             this._handler.gl.deleteTexture(this.texture);
             if (img) {
                 this.canvas.resize(img.width, img.height);
                 this.canvas.drawImage(img, 0, 0, img.width, img.height);
             }
-            this.texture = this._handler.createTexture_l(this.canvas._canvas);
+            this.texture = this._handler.createTexture_l(this.canvas._canvas, internalFormat);
         }
     }
 

package/src/og/utils/VectorTileCreator.js

@@ -217,8 +217,6 @@ export class VectorTileCreator {
 
             // var prevLayerId = -1;
 
-            var extentParams = new Float32Array(4);
-
             var extentParamsHigh = new Float32Array(4);
             var extentParamsLow = new Float32Array(4);
 
@@ -245,7 +243,7 @@ export class VectorTileCreator {
 
                     f.bindOutputTexture(texture);
 
-                    gl.clearColor(1.0, 1.0, 1.0, 0.0);
+                    gl.clearColor(0.0, 0.0, 0.0, 0.0);
                     gl.clear(gl.COLOR_BUFFER_BIT);
 
                     var extent = material.segment.getExtentMerc();

package/src/og/utils/shared.js

@@ -940,4 +940,4 @@ export function cloneArray(items) {
  */
 export function isUndef(obj) {
     return obj === void 0;
-}
+}