@openglobus/og 0.11.8 → 0.12.4

package/src/og/shaders/drawnode.js

@@ -5,39 +5,31 @@
 "use strict";
 
 import { Program } from "../webgl/Program.js";
-
-// REMEMBER!
+
+// 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 NIGHT = `const vec3 nightStep = 10.0 * vec3(0.58, 0.48, 0.25);`;
 
+const DEF_BLEND = `#define blend(DEST, SAMPLER, OFFSET, OPACITY) \
+                    src = texture( SAMPLER, OFFSET.xy + vTextureCoord.xy * OFFSET.zw ); \
+                    DEST = DEST * (1.0 - src.a * OPACITY) + src * OPACITY;`;
 
-const NIGHT = `const vec3 nightStep = 10.0 * vec3(0.58, 0.48, 0.25);`;
-
-const BLEND = `
-            void blend(
-                out vec4 dest,
-                in sampler2D sampler,
-                in vec4 tileOffset,
-                in float opacity)
-            {
-                vec4 src = texture( sampler, tileOffset.xy + vTextureCoord.xy * tileOffset.zw );
-                //dest = dest * (1.0 - src.a * opacity) + src * opacity;
-                dest = vec4(mix(dest.rgb, src.rgb, src.a * opacity), 1.0);
-            }`;
+const DEF_BLEND_WEBGL1 = `#define blend(DEST, SAMPLER, OFFSET, OPACITY) \
+                            src = texture2D( SAMPLER, OFFSET.xy + vTextureCoord.xy * OFFSET.zw ); \
+                            DEST = DEST * (1.0 - src.a * OPACITY) + src * OPACITY;`;
 
-const BLEND1 =
-            `void blend(
-                out vec4 dest,
-                in sampler2D sampler,
-                in vec4 tileOffset,
-                in float opacity)
-            {
-                vec4 src = texture2D(sampler, tileOffset.xy + vTextureCoord.xy * tileOffset.zw);
-                dest = vec4(mix(dest.rgb, src.rgb, src.a * opacity), 1.0);
-            }`
+const DEF_BLEND_PICKING = `#define blendPicking(DEST, OFFSET, SAMPLER, MASK, COLOR, OPACITY) \
+    tc = OFFSET.xy + vTextureCoord.xy * OFFSET.zw; \
+    t = texture2D(SAMPLER, tc); \
+    p = texture2D(MASK, tc); \
+    DEST = mix(DEST, vec4(max(COLOR.rgb, p.rgb), OPACITY), (t.a == 0.0 ? 0.0 : 1.0) * COLOR.a);`
 
+
 const SLICE_SIZE = 4;
 
 export function drawnode_screen_nl() {
@@ -48,7 +40,7 @@ export function drawnode_screen_nl() {
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3",
             samplerCount: "int",
-            tileOffsetArr: "vec4",
+            tileOffsetArr: "vec4",
             layerOpacityArr: "float",
             samplerArr: "sampler2darray",
             defaultTexture: "sampler2d",
@@ -85,33 +77,35 @@ export function drawnode_screen_nl() {
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
 
-        fragmentShader: `precision highp float;
+        fragmentShader: `precision highp float;
             #define SLICE_SIZE ${SLICE_SIZE + 1}
-            uniform vec4 tileOffsetArr[SLICE_SIZE];
+            uniform vec4 tileOffsetArr[SLICE_SIZE];
             uniform float layerOpacityArr[SLICE_SIZE];
             uniform sampler2D defaultTexture;
             uniform sampler2D samplerArr[SLICE_SIZE];
             uniform int samplerCount;
-            varying vec2 vTextureCoord;
-
-            ${BLEND1}
+            varying vec2 vTextureCoord;
+
+            ${DEF_BLEND_WEBGL1}
 
             void main(void) {
                 gl_FragColor = texture2D( defaultTexture, vTextureCoord );
                 if( samplerCount == 0 ) return;
 
-                blend(gl_FragColor, samplerArr[0], tileOffsetArr[0], layerOpacityArr[0]);
-                if( samplerCount == 1 ) return;
-
-                blend(gl_FragColor, samplerArr[1], tileOffsetArr[1], layerOpacityArr[1]);
-                if( samplerCount == 2 ) return;
-
-                blend(gl_FragColor, samplerArr[2], tileOffsetArr[2], layerOpacityArr[2]);
-                if( samplerCount == 3 ) return;
-
-                blend(gl_FragColor, samplerArr[3], tileOffsetArr[3], layerOpacityArr[3]);
-                if( samplerCount == 4 ) return;
-
+                vec4 src;
+
+                blend(gl_FragColor, samplerArr[0], tileOffsetArr[0], layerOpacityArr[0]);
+                if( samplerCount == 1 ) return;
+
+                blend(gl_FragColor, samplerArr[1], tileOffsetArr[1], layerOpacityArr[1]);
+                if( samplerCount == 2 ) return;
+
+                blend(gl_FragColor, samplerArr[2], tileOffsetArr[2], layerOpacityArr[2]);
+                if( samplerCount == 3 ) return;
+
+                blend(gl_FragColor, samplerArr[3], tileOffsetArr[3], layerOpacityArr[3]);
+                if( samplerCount == 4 ) return;
+
                 blend(gl_FragColor, samplerArr[4], tileOffsetArr[4], layerOpacityArr[4]);
             }`
     });
@@ -130,7 +124,7 @@ export function drawnode_screen_wl() {
             uNormalMapBias: "vec3",
 
             samplerCount: "int",
-            tileOffsetArr: "vec4",
+            tileOffsetArr: "vec4",
             layerOpacityArr: "float",
             samplerArr: "sampler2darray",
             defaultTexture: "sampler2d",
@@ -199,7 +193,7 @@ export function drawnode_screen_wl() {
             uniform sampler2D nightTexture;
             uniform sampler2D specularTexture;
 
-            uniform vec4 tileOffsetArr[SLICE_SIZE];
+            uniform vec4 tileOffsetArr[SLICE_SIZE];
             uniform float layerOpacityArr[SLICE_SIZE];
 
             uniform sampler2D defaultTexture;
@@ -210,10 +204,10 @@ export function drawnode_screen_wl() {
             varying vec2 vGlobalTextureCoord;
             varying vec4 v_vertex;
             varying float v_height;
-
+
             ${NIGHT}
-
-            ${BLEND}
+
+            ${DEF_BLEND}
 
 
             void main(void) {
@@ -234,36 +228,38 @@ export function drawnode_screen_wl() {
                 vec3 lightWeighting = ambient + diffuse * diffuseLightWeighting + spec + night;
 
                 gl_FragColor = texture2D( defaultTexture, vTextureCoord.xy );
-                if( samplerCount == 0 ) {
-                    gl_FragColor *= lightWeighting;
-                    return;
+                if( samplerCount == 0 ) {
+                    gl_FragColor *= lightWeighting;
+                    return;
+                }
+    
+                vec4 src;
+
+                blend(gl_FragColor, samplerArr[0], tileOffsetArr[0], layerOpacityArr[0]);
+                if( samplerCount == 1 ) {
+                    gl_FragColor *= lightWeighting;
+                    return;
                 }
 
-                blend(gl_FragColor, samplerArr[0], tileOffsetArr[0], layerOpacityArr[0]);
-                if( samplerCount == 1 ) {
-                    gl_FragColor *= lightWeighting;
-                    return;
-                }
-
-                blend(gl_FragColor, samplerArr[1], tileOffsetArr[1], layerOpacityArr[1]);
-                if( samplerCount == 2 ) {
-                    gl_FragColor *= lightWeighting;
-                    return;
-                }
-
-                blend(gl_FragColor, samplerArr[2], tileOffsetArr[2], layerOpacityArr[2]);
-                if( samplerCount == 3 ) {
-                    gl_FragColor *= lightWeighting;
-                    return;
-                }
-
-                blend(gl_FragColor, samplerArr[3], tileOffsetArr[3], layerOpacityArr[3]);
-                if( samplerCount == 4 ) {
-                    gl_FragColor *= lightWeighting;
-                    return;
-                }
-
-                blend(gl_FragColor, samplerArr[4], tileOffsetArr[4], layerOpacityArr[4]);
+                blend(gl_FragColor, samplerArr[1], tileOffsetArr[1], layerOpacityArr[1]);
+                if( samplerCount == 2 ) {
+                    gl_FragColor *= lightWeighting;
+                    return;
+                }
+
+                blend(gl_FragColor, samplerArr[2], tileOffsetArr[2], layerOpacityArr[2]);
+                if( samplerCount == 3 ) {
+                    gl_FragColor *= lightWeighting;
+                    return;
+                }
+
+                blend(gl_FragColor, samplerArr[3], tileOffsetArr[3], layerOpacityArr[3]);
+                if( samplerCount == 4 ) {
+                    gl_FragColor *= lightWeighting;
+                    return;
+                }
+
+                blend(gl_FragColor, samplerArr[4], tileOffsetArr[4], layerOpacityArr[4]);
                 gl_FragColor *= lightWeighting;
             }`
     });
@@ -282,7 +278,7 @@ export function drawnode_screen_wl_webgl2() {
             uNormalMapBias: "vec3",
 
             samplerCount: "int",
-            tileOffsetArr: "vec4",
+            tileOffsetArr: "vec4",
             layerOpacityArr: "float",
             samplerArr: "sampler2darray",
             defaultTexture: "sampler2d",
@@ -301,7 +297,7 @@ export function drawnode_screen_wl_webgl2() {
             aTextureCoord: "vec2"
         },
 
-        vertexShader: `#version 300 es
+        vertexShader: `#version 300 es
 
             in vec3 aVertexPositionHigh;
             in vec3 aVertexPositionLow;
@@ -355,7 +351,7 @@ export function drawnode_screen_wl_webgl2() {
             uniform sampler2D nightTexture;
             uniform sampler2D specularTexture;
 
-            uniform vec4 tileOffsetArr[SLICE_SIZE];
+            uniform vec4 tileOffsetArr[SLICE_SIZE];
             uniform float layerOpacityArr[SLICE_SIZE];
 
             uniform sampler2D defaultTexture;
@@ -365,7 +361,7 @@ 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;
@@ -374,60 +370,62 @@ export function drawnode_screen_wl_webgl2() {
 
             layout(location = 0) out vec4 fragColor;
 
-            ${NIGHT}
-
-            ${BLEND}
+            ${NIGHT}
 
-            void main(void) {
+            ${DEF_BLEND}
+
+            void main(void) {
 
                 float overGround = 1.0 - step(0.1, v_height);
                 vec3 normal = normalize(normalMatrix * ((texture(uNormalMap, vTextureCoord.zw).rgb - 0.5) * 2.0));
                 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 );
+                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 = specular.rgb * pow( reflection, specular.w) * shininess;
-                vec4 lightWeighting = vec4(ambient + diffuse * diffuseLightWeighting + spec + night, 1.0);
+                vec4 lightWeighting = vec4(ambient + diffuse * diffuseLightWeighting + spec + night, 1.0);
 
                 fragColor = texture( defaultTexture, vTextureCoord.xy );
-                if( samplerCount == 0 ) {
-                    fragColor *= lightWeighting;
-                    return;
-                }
-
-                blend(fragColor, samplerArr[0], tileOffsetArr[0], layerOpacityArr[0]);
-                if( samplerCount == 1 ) {
-                    fragColor *= lightWeighting;
-                    return;
+                if( samplerCount == 0 ) {
+                    fragColor *= lightWeighting;
+                    return;
                 }
 
-                blend(fragColor, samplerArr[1], tileOffsetArr[1], layerOpacityArr[1]);
-                if( samplerCount == 2 ) {
-                    fragColor *= lightWeighting;
-                    return;
-                }
-
-                blend(fragColor, samplerArr[2], tileOffsetArr[2], layerOpacityArr[2]);
-                if( samplerCount == 3 ) {
-                    fragColor *= lightWeighting;
-                    return;
-                }
-
-                blend(fragColor, samplerArr[3], tileOffsetArr[3], layerOpacityArr[3]);
-                if( samplerCount == 4 ) {
-                    fragColor *= lightWeighting;
-                    return;
-                }
-
-                blend(fragColor, samplerArr[4], tileOffsetArr[4], layerOpacityArr[4]);
-                fragColor *= lightWeighting;
+                vec4 src;
+
+                blend(fragColor, samplerArr[0], tileOffsetArr[0], layerOpacityArr[0]);
+                if( samplerCount == 1 ) {
+                    fragColor *= lightWeighting;
+                    return;
+                }
+
+                blend(fragColor, samplerArr[1], tileOffsetArr[1], layerOpacityArr[1]);
+                if( samplerCount == 2 ) {
+                    fragColor *= lightWeighting;
+                    return;
+                }
+
+                blend(fragColor, samplerArr[2], tileOffsetArr[2], layerOpacityArr[2]);
+                if( samplerCount == 3 ) {
+                    fragColor *= lightWeighting;
+                    return;
+                }
+
+                blend(fragColor, samplerArr[3], tileOffsetArr[3], layerOpacityArr[3]);
+                if( samplerCount == 4 ) {
+                    fragColor *= lightWeighting;
+                    return;
+                }
+
+                blend(fragColor, samplerArr[4], tileOffsetArr[4], layerOpacityArr[4]);
+                fragColor *= lightWeighting;
             }`
     });
 }
@@ -477,32 +475,24 @@ export function drawnode_colorPicking() {
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
 
-        fragmentShader: `precision highp float;
+        fragmentShader: `precision highp float;
             #define SLICE_SIZE ${SLICE_SIZE + 1}
             uniform vec4 tileOffsetArr[SLICE_SIZE];
             uniform vec4 pickingColorArr[SLICE_SIZE];
             uniform sampler2D samplerArr[SLICE_SIZE];
             uniform sampler2D pickingMaskArr[SLICE_SIZE];
             uniform int samplerCount;
-            varying vec2 vTextureCoord;
-
-            void blendPicking(
-                out vec4 dest,
-                in vec4 tileOffset,
-                in sampler2D sampler,
-                in sampler2D pickingMask,
-                in vec4 pickingColor,
-                in float opacity)
-            {
-                vec2 tc = tileOffset.xy + vTextureCoord.xy * tileOffset.zw;
-                vec4 t = texture2D( sampler, tc );
-                vec4 p = texture2D( pickingMask, tc );
-                dest = mix( dest, vec4(max(pickingColor.rgb, p.rgb), opacity), (t.a == 0.0 ? 0.0 : 1.0) * pickingColor.a);
-            }
+            varying vec2 vTextureCoord;
+
+            ${DEF_BLEND_PICKING}
 
             void main(void) {
                 gl_FragColor = vec4(0.0);
                 if( samplerCount == 0 ) return;
+
+                vec2 tc;
+                vec4 t;
+                vec4 p;
 
                 blendPicking(gl_FragColor, tileOffsetArr[0], samplerArr[0], pickingMaskArr[0], pickingColorArr[0], 1.0);
                 if( samplerCount == 1 ) return;
@@ -526,23 +516,17 @@ export function drawnode_heightPicking() {
         uniforms: {
             projectionMatrix: "mat4",
             viewMatrix: "mat4",
-            samplerCount: "int",
-            tileOffsetArr: "vec4",
-            samplerArr: "sampler2darray",
-            defaultTexture: "sampler2d",
             height: "float",
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3"
         },
         attributes: {
             aVertexPositionHigh: "vec3",
-            aVertexPositionLow: "vec3",
-            aTextureCoord: "vec2"
+            aVertexPositionLow: "vec3"
         },
 
         vertexShader: `attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
-            attribute vec2 aTextureCoord;
 
             uniform mat4 projectionMatrix;
             uniform mat4 viewMatrix;
@@ -550,7 +534,6 @@ export function drawnode_heightPicking() {
             uniform vec3 eyePositionHigh;
             uniform vec3 eyePositionLow;
 
-            varying vec2 vTextureCoord;
             varying float range;
 
             void main(void) {
@@ -565,17 +548,11 @@ export function drawnode_heightPicking() {
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
                 range = distance(cameraPosition, aVertexPosition + normalize(aVertexPosition) * height);
-                vTextureCoord = aTextureCoord;
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
 
-        fragmentShader: `precision highp float;
-            #define SLICE_SIZE ${SLICE_SIZE + 1}
-            uniform sampler2D defaultTexture;
-            uniform vec4 tileOffsetArr[SLICE_SIZE];
-            uniform sampler2D samplerArr[SLICE_SIZE];
-            uniform int samplerCount;
-            varying vec2 vTextureCoord;
+        fragmentShader: `precision highp float;
+
             varying float range;
 
             vec3 encode24(highp float f) {
@@ -591,29 +568,7 @@ export function drawnode_heightPicking() {
             }
 
             void main(void) {
-                gl_FragColor = vec4(encode24(range), texture2D( defaultTexture, vTextureCoord ).a);
-                if( samplerCount == 0 ) return;
-
-                vec4 t = texture2D( samplerArr[0], tileOffsetArr[0].xy + vTextureCoord * tileOffsetArr[0].zw );
-                gl_FragColor = mix( gl_FragColor, vec4(encode24(range), 1.0), 1.0);
-                //
-                // TODO: Seems to be it is not necessary
-                //if( samplerCount == 1 ) return;
-
-                //t = texture2D( samplerArr[1], tileOffsetArr[1].xy + vTextureCoord * tileOffsetArr[1].zw );
-                //gl_FragColor = mix( gl_FragColor, vec4(encode24(range), 1.0), 1.0);
-                //if( samplerCount == 2 ) return;
-
-                //t = texture2D( samplerArr[2], tileOffsetArr[2].xy + vTextureCoord * tileOffsetArr[2].zw );
-                //gl_FragColor = mix( gl_FragColor, vec4(encode24(range), 1.0), 1.0);
-                //if( samplerCount == 3 ) return;
-
-                //t = texture2D( samplerArr[3], tileOffsetArr[3].xy + vTextureCoord * tileOffsetArr[3].zw );
-                //gl_FragColor = mix( gl_FragColor, vec4(encode24(range), 1.0), 1.0);
-                //if( samplerCount == 4 ) return;
-
-                //t = texture2D( samplerArr[4], tileOffsetArr[4].xy + vTextureCoord * tileOffsetArr[4].zw );
-                //gl_FragColor = mix( gl_FragColor, vec4(encode24(range), 1.0), 1.0);
+                gl_FragColor = vec4(encode24(range), 1.0);
             }`
     });
 }
@@ -623,10 +578,6 @@ export function drawnode_depth() {
         uniforms: {
             projectionMatrix: "mat4",
             viewMatrix: "mat4",
-            samplerCount: "int",
-            tileOffsetArr: "vec4",
-            samplerArr: "sampler2darray",
-            defaultTexture: "sampler2d",
             height: "float",
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3",
@@ -634,14 +585,11 @@ export function drawnode_depth() {
         },
         attributes: {
             aVertexPositionHigh: "vec3",
-            aVertexPositionLow: "vec3",
-            aTextureCoord: "vec2"
+            aVertexPositionLow: "vec3"
         },
 
-        vertexShader: `#version 300 es
-            in vec3 aVertexPositionHigh;
-            in vec3 aVertexPositionLow;
-            in vec2 aTextureCoord;
+        vertexShader: `attribute vec3 aVertexPositionHigh;
+            attribute vec3 aVertexPositionLow;
 
             uniform mat4 projectionMatrix;
             uniform mat4 viewMatrix;
@@ -649,8 +597,6 @@ export function drawnode_depth() {
             uniform vec3 eyePositionHigh;
             uniform vec3 eyePositionLow;
 
-            out vec2 vTextureCoord;
-
             void main(void) {
 
                 vec3 cameraPosition = eyePositionHigh + eyePositionLow;
@@ -662,49 +608,14 @@ export function drawnode_depth() {
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
-                vTextureCoord = aTextureCoord;
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
 
-        fragmentShader: `#version 300 es
-            #define SLICE_SIZE ${SLICE_SIZE + 1}
-            precision highp float;
-            uniform sampler2D defaultTexture;
-            uniform vec4 tileOffsetArr[SLICE_SIZE];
-            uniform sampler2D samplerArr[SLICE_SIZE];
-            uniform int samplerCount;
+        fragmentShader: `precision highp float;
             uniform vec3 frustumPickingColor;
 
-            in vec2 vTextureCoord;
-
-            layout(location = 0) out vec4 frustumColor;
-
             void main(void) {
-
-            frustumColor = vec4(frustumPickingColor, texture(defaultTexture, vTextureCoord).a);
-            if(samplerCount == 0) return;
-
-            vec4 t = texture(samplerArr[0], tileOffsetArr[0].xy + vTextureCoord * tileOffsetArr[0].zw);
-            frustumColor = mix(frustumColor, vec4(frustumPickingColor, 1.0), 1.0);
-
-            //
-            // TODO: Seems to be it is not necessary
-            //if (samplerCount == 1) return;
-
-            //t = texture(samplerArr[1], tileOffsetArr[1].xy + vTextureCoord * tileOffsetArr[1].zw);
-            //frustumColor = mix(frustumColor, vec4(frustumPickingColor, 1.0), 1.0);
-            //if (samplerCount == 2) return;
-
-            //t = texture(samplerArr[2], tileOffsetArr[2].xy + vTextureCoord * tileOffsetArr[2].zw);
-            //frustumColor = mix(frustumColor, vec4(frustumPickingColor, 1.0), 1.0);
-            //if (samplerCount == 3) return;
-
-            //t = texture(samplerArr[3], tileOffsetArr[3].xy + vTextureCoord * tileOffsetArr[3].zw);
-            //frustumColor = mix(frustumColor, vec4(frustumPickingColor, 1.0), 1.0);
-            //if (samplerCount == 4) return;
-
-            //t = texture(samplerArr[4], tileOffsetArr[4].xy + vTextureCoord * tileOffsetArr[4].zw);
-            //frustumColor = mix(frustumColor, vec4(frustumPickingColor, 1.0), 1.0);
-        } `
+                gl_FragColor = vec4(frustumPickingColor, 1.0);
+            } `
     });
 }

package/src/og/shaders/geoObject.js

@@ -30,7 +30,8 @@ export const geo_object = () =>
             aDirection: { type: "vec3", divisor: 1 },
             aPitchRoll: { type: "vec2", divisor: 1 },
             aColor: { type: "vec4", divisor: 1 },
-            aScale: { type: "float", divisor: 1 }
+            aScale: { type: "float", divisor: 1 },
+            aDispose: { type: "float", divisor: 1 }
         },
         vertexShader: `precision highp float;
 
@@ -42,6 +43,7 @@ export const geo_object = () =>
             attribute vec2 aPitchRoll;
             attribute vec4 aColor;
             attribute float aScale;
+            attribute float aDispose;
             
             uniform vec3 uScaleByDistance;
             uniform mat4 projectionMatrix;
@@ -54,11 +56,13 @@ export const geo_object = () =>
             varying vec3 vNormal;
             varying vec4 vPosition;           
             varying vec4 vColor;
+            varying float vDispose;
             
             const float RADIANS = 3.141592653589793 / 180.0;
 
             void main(void) {
             
+                vDispose = aDispose;
                 vColor = aColor;
                 float roll = aPitchRoll.y * RADIANS;
                 mat3 rotZ = mat3(
@@ -91,7 +95,7 @@ export const geo_object = () =>
 
                 vPosition = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
 
-                gl_Position = projectionMatrix * vPosition;
+                gl_Position = mix(vec4(0.0, 0.0, 0.0, 0.0), projectionMatrix * vPosition, aDispose);
             }`,
         fragmentShader: `precision highp float;
 
@@ -135,7 +139,7 @@ export const geo_object_picking = () =>
 
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3",
-            pickingScale: "float",
+            pickingScale: "float"
 
         },
         attributes: {
@@ -145,7 +149,8 @@ export const geo_object_picking = () =>
             aDirection: { type: "vec3", divisor: 1 },
             aPitchRoll: { type: "vec2", divisor: 1 },
             aPickingColor: { type: "vec3", divisor: 1 },
-            aScale: { type: "float", divisor: 1 }
+            aScale: { type: "float", divisor: 1 },
+            aDispose: { type: "float", divisor: 1 }
         },
         vertexShader: `precision highp float;
 
@@ -156,6 +161,7 @@ export const geo_object_picking = () =>
             attribute vec2 aPitchRoll;
             attribute vec3 aPickingColor;
             attribute float aScale;
+            attribute float aDispose;
             
             uniform vec3 uScaleByDistance;
             uniform mat4 projectionMatrix;
@@ -165,12 +171,14 @@ export const geo_object_picking = () =>
             uniform vec3 eyePositionHigh;
             uniform vec3 eyePositionLow;
 
+            varying float vDispose;
             varying vec3 vColor;
             
             const float RADIANS = 3.141592653589793 / 180.0;
 
             void main(void) {
             
+                vDispose = aDispose;
                 vColor = aPickingColor;
                 float roll = aPitchRoll.y * RADIANS;
                 mat3 rotZ = mat3(
@@ -200,12 +208,13 @@ export const geo_object_picking = () =>
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
-                gl_Position = projectionMatrix *viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+                gl_Position = mix(vec4(0.0, 0.0, 0.0, 0.0),  projectionMatrix *viewMatrixRTE * vec4(highDiff + lowDiff, 1.0), aDispose);
             }`,
         fragmentShader:
             `precision highp float;
             varying vec3 vColor;
+            varying float vDispose;
             void main () {
-                gl_FragColor = vec4(vColor, 1.0);
+                gl_FragColor = vec4(vColor, vDispose);
             }`
     });

package/src/og/terrain/EmptyTerrain.js

@@ -14,7 +14,9 @@ class EmptyTerrain {
     constructor(options = {}) {
         this.equalizeVertices = false;
 
-        this.equalizeNormals = false;
+        this.equalizeNormals = false;
+
+        this.isEmpty = true;
 
         /**
          * Provider name is "empty"
@@ -106,7 +108,6 @@ class EmptyTerrain {
 
     set geoid(geoid) {
         this._geoid = geoid;
-        //...this._planet
     }
 
     get geoid() {