@openglobus/og 0.15.5 → 0.16.1

package/src/og/shaders/drawnode.js

@@ -48,10 +48,15 @@ export function drawnode_screen_nl() {
             defaultTexture: "sampler2d",
             height: "float"
         }, attributes: {
-            aVertexPositionHigh: "vec3", aVertexPositionLow: "vec3", aTextureCoord: "vec2"
+            aVertexPositionHigh: "vec3", 
+            aVertexPositionLow: "vec3", 
+            aTextureCoord: "vec2"
         },
 
-        vertexShader: `attribute vec3 aVertexPositionHigh;
+        vertexShader: 
+            `precision highp float;
+            
+            attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
             attribute vec2 aTextureCoord;
 
@@ -64,16 +69,19 @@ export function drawnode_screen_nl() {
             varying vec2 vTextureCoord;
 
             void main(void) {
-                vTextureCoord = aTextureCoord;
 
-                vec3 aVertexPosition = aVertexPositionHigh + aVertexPositionLow;
-                vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
-                vec3 lowDiff = aVertexPositionLow + normalize(aVertexPosition) * height - eyePositionLow;
+                vTextureCoord = aTextureCoord;
+                vec3 nh = height * normalize(aVertexPositionHigh + aVertexPositionLow);
 
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
-
-                gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+                mat4 m = projectionMatrix * viewMatrixRTE;
+        
+                vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
+                vec3 lowDiff = aVertexPositionLow - eyePositionLow + nh;
+                
+                // This is works for Mac Chrome, prevent some weird optimization I suppose
+                gl_Position =  m * vec4(highDiff + lowDiff, 1.0);
             }`,
 
         fragmentShader: `precision highp float;
@@ -151,37 +159,39 @@ export function drawnode_screen_wl_webgl1NoAtmos() {
 
             uniform mat4 projectionMatrix;
             uniform mat4 viewMatrix;
-            uniform float height;
             uniform vec4 uGlobalTextureCoord;
             uniform vec3 uNormalMapBias;
             uniform vec3 eyePositionHigh;
             uniform vec3 eyePositionLow;
+            uniform float height;
 
             varying vec4 vTextureCoord;
-            varying vec2 vGlobalTextureCoord;
             varying vec3 v_vertex;
-            varying float v_height;
             varying vec3 cameraPosition;
+            varying vec2 vGlobalTextureCoord;
+            varying float v_height;
 
             void main(void) {
 
-                vec3 aVertexPosition = aVertexPositionHigh + aVertexPositionLow;
-                
+                // I replace it here (from the bottom) because it 
+                // somehow affects on float precision on MacPC Chrome
+                vTextureCoord.xy = aTextureCoord;
+                vGlobalTextureCoord = uGlobalTextureCoord.xy + (uGlobalTextureCoord.zw - uGlobalTextureCoord.xy) * aTextureCoord;
+                vTextureCoord.zw = uNormalMapBias.z * ( aTextureCoord + uNormalMapBias.xy );
+
+                vec3 aVertexPosition = aVertexPositionHigh + aVertexPositionLow;                
+                vec3 nh = height * normalize(aVertexPosition);
                 cameraPosition = eyePositionHigh + eyePositionLow;
                 
                 vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
-                vec3 lowDiff = aVertexPositionLow + normalize(aVertexPosition) * height - eyePositionLow;
+                vec3 lowDiff = aVertexPositionLow - eyePositionLow + nh;
 
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
                 v_height = height;
-                v_vertex = aVertexPosition + normalize(aVertexPosition) * height;
-                                
-                vTextureCoord.xy = aTextureCoord;
-                vGlobalTextureCoord = uGlobalTextureCoord.xy + (uGlobalTextureCoord.zw - uGlobalTextureCoord.xy) * aTextureCoord;
-                vTextureCoord.zw = uNormalMapBias.z * ( aTextureCoord + uNormalMapBias.xy );
-                
+                v_vertex = aVertexPosition + nh;
+                            
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
 
@@ -192,23 +202,22 @@ export function drawnode_screen_wl_webgl1NoAtmos() {
             #define MAX_POINT_LIGHTS 1
             #define SLICE_SIZE ${SLICE_SIZE + 1}
 
+            uniform vec4 specular;
             uniform vec3 diffuse;
             uniform vec3 ambient;
-            uniform vec4 specular;     
 
             uniform sampler2D uNormalMap;
-            uniform vec3 lightsPositions[MAX_POINT_LIGHTS];
             uniform sampler2D nightTexture;
             uniform sampler2D specularTexture;
+            uniform sampler2D defaultTexture;
+            uniform sampler2D samplerArr[SLICE_SIZE];
 
             uniform vec4 tileOffsetArr[SLICE_SIZE];
+            uniform vec3 lightsPositions[MAX_POINT_LIGHTS];
             uniform float layerOpacityArr[SLICE_SIZE];
 
-            uniform sampler2D defaultTexture;
-            uniform sampler2D samplerArr[SLICE_SIZE];
             uniform int samplerCount;
-            uniform float nightTextureCoefficient;
-                
+            uniform float nightTextureCoefficient;              
             uniform float camHeight;
 
             varying vec4 vTextureCoord;
@@ -330,43 +339,47 @@ export function drawnode_screen_wl_webgl2NoAtmos() {
         vertexShader:
             `#version 300 es
 
+            precision highp float;
+
             in vec3 aVertexPositionHigh;
             in vec3 aVertexPositionLow;
             in vec2 aTextureCoord;
 
             uniform mat4 projectionMatrix;
             uniform mat4 viewMatrix;
-            uniform float height;
             uniform vec4 uGlobalTextureCoord;
             uniform vec3 uNormalMapBias;
             uniform vec3 eyePositionHigh;
             uniform vec3 eyePositionLow;
+            uniform float height;
 
             out vec4 vTextureCoord;
-            out vec2 vGlobalTextureCoord;
             out vec3 v_vertex;
-            out float v_height;
             out vec3 cameraPosition;
+            out vec2 vGlobalTextureCoord;
+            out float v_height;
 
             void main(void) {
 
-                vec3 aVertexPosition = aVertexPositionHigh + aVertexPositionLow;
-                
+                // I replace it here (from the bottom) because it 
+                // somehow affects on float precision on MacPC Chrome
+                vTextureCoord.xy = aTextureCoord;
+                vGlobalTextureCoord = uGlobalTextureCoord.xy + (uGlobalTextureCoord.zw - uGlobalTextureCoord.xy) * aTextureCoord;
+                vTextureCoord.zw = uNormalMapBias.z * ( aTextureCoord + uNormalMapBias.xy );
+
+                vec3 aVertexPosition = aVertexPositionHigh + aVertexPositionLow;                
+                vec3 nh = height * normalize(aVertexPosition);
                 cameraPosition = eyePositionHigh + eyePositionLow;
                 
                 vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
-                vec3 lowDiff = aVertexPositionLow + normalize(aVertexPosition) * height - eyePositionLow;
+                vec3 lowDiff = aVertexPositionLow - eyePositionLow + nh;
 
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
                 v_height = height;
-                v_vertex = aVertexPosition + normalize(aVertexPosition) * height;
-                                
-                vTextureCoord.xy = aTextureCoord;
-                vGlobalTextureCoord = uGlobalTextureCoord.xy + (uGlobalTextureCoord.zw - uGlobalTextureCoord.xy) * aTextureCoord;
-                vTextureCoord.zw = uNormalMapBias.z * ( aTextureCoord + uNormalMapBias.xy );
-                
+                v_vertex = aVertexPosition + nh;
+                            
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
 
@@ -378,20 +391,20 @@ export function drawnode_screen_wl_webgl2NoAtmos() {
             #define MAX_POINT_LIGHTS 1
             #define SLICE_SIZE ${SLICE_SIZE + 1}
 
+            uniform vec4 specular;
             uniform vec3 diffuse;
-            uniform vec3 ambient;
-            uniform vec4 specular;     
+            uniform vec3 ambient;  
 
             uniform sampler2D uNormalMap;
-            uniform vec3 lightsPositions[MAX_POINT_LIGHTS];
             uniform sampler2D nightTexture;
             uniform sampler2D specularTexture;
+            uniform sampler2D defaultTexture;
+            uniform sampler2D samplerArr[SLICE_SIZE];
 
             uniform vec4 tileOffsetArr[SLICE_SIZE];
+            uniform vec3 lightsPositions[MAX_POINT_LIGHTS];
             uniform float layerOpacityArr[SLICE_SIZE];
 
-            uniform sampler2D defaultTexture;
-            uniform sampler2D samplerArr[SLICE_SIZE];
             uniform int samplerCount;
             uniform float nightTextureCoefficient;
                 
@@ -522,6 +535,8 @@ export function drawnode_screen_wl_webgl2Atmos() {
         vertexShader:
             `#version 300 es
 
+            precision highp float;
+
             in vec3 aVertexPositionHigh;
             in vec3 aVertexPositionLow;
             in vec2 aTextureCoord;
@@ -535,30 +550,32 @@ export function drawnode_screen_wl_webgl2Atmos() {
             uniform float height;
 
             out vec4 vTextureCoord;
-            out vec2 vGlobalTextureCoord;
             out vec3 v_vertex;
-            out float v_height;
             out vec3 cameraPosition;
+            out vec2 vGlobalTextureCoord;
+            out float v_height;
 
             void main(void) {
 
-                vec3 aVertexPosition = aVertexPositionHigh + aVertexPositionLow;
-                
+                // I replace it here (from the bottom) because it 
+                // somehow affects on float precision on MacPC Chrome
+                vTextureCoord.xy = aTextureCoord;
+                vGlobalTextureCoord = uGlobalTextureCoord.xy + (uGlobalTextureCoord.zw - uGlobalTextureCoord.xy) * aTextureCoord;
+                vTextureCoord.zw = uNormalMapBias.z * ( aTextureCoord + uNormalMapBias.xy );
+
+                vec3 aVertexPosition = aVertexPositionHigh + aVertexPositionLow;                
+                vec3 nh = height * normalize(aVertexPosition);
                 cameraPosition = eyePositionHigh + eyePositionLow;
                 
                 vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
-                vec3 lowDiff = aVertexPositionLow + normalize(aVertexPosition) * height - eyePositionLow;
+                vec3 lowDiff = aVertexPositionLow - eyePositionLow + nh;
 
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
                 v_height = height;
-                v_vertex = aVertexPosition + normalize(aVertexPosition) * height;
-                                
-                vTextureCoord.xy = aTextureCoord;
-                vGlobalTextureCoord = uGlobalTextureCoord.xy + (uGlobalTextureCoord.zw - uGlobalTextureCoord.xy) * aTextureCoord;
-                vTextureCoord.zw = uNormalMapBias.z * ( aTextureCoord + uNormalMapBias.xy );
-                
+                v_vertex = aVertexPosition + nh;
+                            
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
 
@@ -570,28 +587,27 @@ export function drawnode_screen_wl_webgl2Atmos() {
             #define MAX_POINT_LIGHTS 1
             #define SLICE_SIZE ${SLICE_SIZE + 1}
 
+            uniform vec4 specular;
             uniform vec3 diffuse;
             uniform vec3 ambient;
-            uniform vec4 specular;
 
-            uniform sampler2D uNormalMap;
             uniform vec3 lightsPositions[MAX_POINT_LIGHTS];
+
+            uniform sampler2D uNormalMap;
             uniform sampler2D nightTexture;
             uniform sampler2D specularTexture;
-
             uniform sampler2D transmittanceTexture;
             uniform sampler2D scatteringTexture;
+            uniform sampler2D defaultTexture;
+            uniform sampler2D samplerArr[SLICE_SIZE];
 
             uniform vec4 tileOffsetArr[SLICE_SIZE];
             uniform float layerOpacityArr[SLICE_SIZE];
 
-            uniform sampler2D defaultTexture;
-            uniform sampler2D samplerArr[SLICE_SIZE];
             uniform int samplerCount;
             uniform float nightTextureCoefficient;
             
-            uniform vec2 maxMinOpacity;
-                
+            uniform vec2 maxMinOpacity;                
             uniform float camHeight;
 
             in vec4 vTextureCoord;
@@ -828,7 +844,10 @@ export function drawnode_colorPicking() {
             aVertexPositionHigh: "vec3", aVertexPositionLow: "vec3", aTextureCoord: "vec2"
         },
 
-        vertexShader: `attribute vec3 aVertexPositionHigh;
+        vertexShader: 
+            `precision highp float;
+            
+            attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
             attribute vec2 aTextureCoord;
 
@@ -842,18 +861,23 @@ export function drawnode_colorPicking() {
 
             void main(void) {
 
-                vec3 aVertexPosition = aVertexPositionHigh + aVertexPositionLow;
-                vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
-                vec3 lowDiff = aVertexPositionLow + normalize(aVertexPosition) * height - eyePositionLow;
+                vTextureCoord = aTextureCoord;
 
                 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);
+                mat4 m = projectionMatrix * viewMatrixRTE;
+
+                vec3 nh = height * normalize(aVertexPositionHigh + aVertexPositionLow);
+
+                vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
+                vec3 lowDiff = aVertexPositionLow - eyePositionLow + nh;
+
+                gl_Position = m * 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];
@@ -901,35 +925,47 @@ export function drawnode_heightPicking() {
             aVertexPositionHigh: "vec3", aVertexPositionLow: "vec3"
         },
 
-        vertexShader: `attribute vec3 aVertexPositionHigh;
+        vertexShader: 
+            `precision highp float;
+
+            attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
 
             uniform mat4 projectionMatrix;
             uniform mat4 viewMatrix;
-            uniform float height;
             uniform vec3 eyePositionHigh;
             uniform vec3 eyePositionLow;
+            uniform float height;
 
-            varying float range;
+            varying vec3 eyePosition;
+            varying vec3 vertexPosition;
 
             void main(void) {
 
-                vec3 cameraPosition = eyePositionHigh + eyePositionLow;
-                vec3 aVertexPosition = aVertexPositionHigh + aVertexPositionLow;
-
-                vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
-                vec3 lowDiff = aVertexPositionLow + normalize(aVertexPosition) * height - eyePositionLow;
+                // This code is works for Mac Chrome and Safari
+                // any other code probably will produce jittering
 
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
-                range = distance(cameraPosition, aVertexPosition + normalize(aVertexPosition) * height);
-                gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+                mat4 m = projectionMatrix * viewMatrixRTE;
+
+                vec3 nh = height * normalize(aVertexPositionHigh + aVertexPositionLow);
+
+                eyePosition = eyePositionHigh + eyePositionLow;
+                vertexPosition = aVertexPositionHigh + aVertexPositionLow;
+
+                vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
+                vec3 lowDiff = aVertexPositionLow - eyePositionLow + nh;
+                
+                gl_Position =  m * vec4(highDiff + lowDiff, 1.0);         
             }`,
 
-        fragmentShader: `precision highp float;
+        fragmentShader: 
+            `precision highp float;
 
-            varying float range;
+            varying vec3 eyePosition;
+            varying vec3 vertexPosition;
 
             vec3 encode24(highp float f) {
                 float F = abs(f);
@@ -944,6 +980,7 @@ export function drawnode_heightPicking() {
             }
 
             void main(void) {
+                float range = distance(eyePosition, vertexPosition);
                 gl_FragColor = vec4(encode24(range), 1.0);
             }`
     });
@@ -962,30 +999,42 @@ export function drawnode_depth() {
             aVertexPositionHigh: "vec3", aVertexPositionLow: "vec3"
         },
 
-        vertexShader: `attribute vec3 aVertexPositionHigh;
+        vertexShader: 
+            `precision highp float;
+
+            attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
 
             uniform mat4 projectionMatrix;
             uniform mat4 viewMatrix;
-            uniform float height;
             uniform vec3 eyePositionHigh;
             uniform vec3 eyePositionLow;
+            uniform float height;
 
             void main(void) {
 
-                vec3 cameraPosition = eyePositionHigh + eyePositionLow;
-                vec3 aVertexPosition = aVertexPositionHigh + aVertexPositionLow;
-
-                vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
-                vec3 lowDiff = aVertexPositionLow + normalize(aVertexPosition) * height - eyePositionLow;
+                // @hack
+                // This code is works for Mac Chrome and Safari
+                // any other code probably will produce jittering
 
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
-                gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+                mat4 m = projectionMatrix * viewMatrixRTE;
+
+                vec3 nh = height * normalize(aVertexPositionHigh + aVertexPositionLow);
+
+                vec3 eyePosition = eyePositionHigh + eyePositionLow;
+                vec3 vertexPosition = aVertexPositionHigh + aVertexPositionLow;
+
+                vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
+                vec3 lowDiff = aVertexPositionLow - eyePositionLow + nh;
+                
+                gl_Position =  m * vec4(highDiff + lowDiff, 1.0);    
             }`,
 
-        fragmentShader: `precision highp float;
+        fragmentShader: 
+            `precision highp float;
             uniform vec3 frustumPickingColor;
 
             void main(void) {

package/src/og/shaders/geoObject.js

@@ -101,8 +101,6 @@ export const geo_object = () =>
                 vec3 r = cross(normalize(-position), aDirection);
                 mat3 modelMatrix = mat3(r, normalize(position), -aDirection) * rotX * rotZ;
 
-                float dist = length(cameraPosition);
-
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
@@ -126,8 +124,12 @@ export const geo_object = () =>
                 
                 vec3 vert = modelMatrix * aVertexPosition * aScale * scd;
                 v_vertex = position + vert;
+                
+                // @hack
+                // Mac/Safari affects on lowDiff somehow. 
+                vert += lowDiff;
                                
-                gl_Position = projectionMatrix * viewMatrixRTE  * vec4(highDiff + lowDiff + vert, 1.0);
+                gl_Position = projectionMatrix * viewMatrixRTE  * vec4(highDiff + vert, 1.0);
             }`,
 
         fragmentShader: `precision highp float;
@@ -170,9 +172,7 @@ export const geo_object_picking = () =>
         uniforms: {
             viewMatrix: "mat4",
             projectionMatrix: "mat4",
-
             uScaleByDistance: "vec3",
-
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3",
             pickingScale: "float"
@@ -193,18 +193,17 @@ export const geo_object_picking = () =>
             attribute vec3 aPositionHigh;
             attribute vec3 aPositionLow;    
             attribute vec3 aDirection;
-            attribute vec2 aPitchRoll;
             attribute vec3 aPickingColor;
+            attribute vec2 aPitchRoll;
             attribute float aScale;
             attribute float aDispose;
             
+            uniform vec3 eyePositionHigh;
+            uniform vec3 eyePositionLow;
             uniform vec3 uScaleByDistance;
             uniform mat4 projectionMatrix;
             uniform mat4 viewMatrix;
             uniform float pickingScale;
-            
-            uniform vec3 eyePositionHigh;
-            uniform vec3 eyePositionLow;
 
             varying vec3 vColor;
             
@@ -213,46 +212,58 @@ export const geo_object_picking = () =>
             void main(void) {
 
                 if (aDispose == 0.0) {
-                   return;
-                }
+                    return;
+                 }
             
-                vColor = aPickingColor;
-              
-                float roll = aPitchRoll.y;
-                mat3 rotZ = mat3(
-                     vec3(cos(roll), sin(roll), 0.0),
-                     vec3(-sin(roll), cos(roll), 0.0), 
-                     vec3(0.0, 0.0, 1.0) 
+                 vColor = aPickingColor;
+               
+                 float roll = aPitchRoll.y;
+                 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;
+                 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 cameraPosition = eyePositionHigh + eyePositionLow;
+                 vec3 r = cross(normalize(-position), aDirection);
+                 mat3 modelMatrix = mat3(r, normalize(position), -aDirection) * rotX * rotZ;
+ 
+                 mat4 viewMatrixRTE = viewMatrix;
+                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+ 
+                 vec3 highDiff = aPositionHigh - eyePositionHigh;
+                 vec3 lowDiff = aPositionLow - eyePositionLow;
+              
+                 vec3 look = cameraPosition - position;
+                 float lookLength = length(look);
+                                
+                 // if(lookLength > uScaleByDistance[1])
+                 // {
+                 //     scd = uScaleByDistance[1] / uScaleByDistance[0];
+                 // }
+                 // else if(lookLength > uScaleByDistance[0])
+                 // {
+                 //     scd = lookLength / uScaleByDistance[0];
+                 // }
+                 // ... is the same math above
+                 // @hack
+                 // pickingScale replace to this line, because when it s
+                 // tays in the vert above it affects on Mac Safari jitter
+                 float scd = pickingScale * uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
 
-                float pitch = aPitchRoll.x;
-                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 cameraPosition = eyePositionHigh + eyePositionLow;
-                vec3 r = cross(normalize(-position), aDirection);
-                mat3 modelMatrix = mat3(r, normalize(position), -aDirection) * rotX * rotZ;
-
-                float dist = length(cameraPosition);
-
-                mat4 viewMatrixRTE = viewMatrix;
-                viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
-
-                vec3 highDiff = aPositionHigh - eyePositionHigh;
-                vec3 lowDiff = aPositionLow - eyePositionLow;
-             
-                vec3 look = cameraPosition - position;
-                float lookLength = length(look);
-                               
-                float scd = uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
-                
-                vec3 vert = modelMatrix * aVertexPosition * aScale * pickingScale * scd;
-                               
-                gl_Position = projectionMatrix * viewMatrixRTE  * vec4(highDiff + lowDiff + vert, 1.0);
+                 vec3 vert = modelMatrix * aVertexPosition * aScale * scd;
+                 
+                 vert += lowDiff;
+                                
+                 gl_Position = projectionMatrix * viewMatrixRTE  * vec4(highDiff + vert, 1.0);
             }`,
         fragmentShader:
             `precision highp float;

package/src/og/shaders/ray.js

@@ -27,13 +27,14 @@ export function rayScreen() {
         },
         vertexShader:
             `precision highp float;
-            attribute vec2 a_vertices;
+
+            attribute vec4 a_rgba;
             attribute vec3 a_startPosHigh;
             attribute vec3 a_startPosLow;
             attribute vec3 a_endPosHigh;
             attribute vec3 a_endPosLow;
+            attribute vec2 a_vertices;
             attribute float a_thickness;
-            attribute vec4 a_rgba;
 
             varying vec4 v_rgba;
 
@@ -48,38 +49,31 @@ export function rayScreen() {
 
                 v_rgba = vec4(a_rgba.rgb, a_rgba.a * uOpacity);
 
-                vec3 camPos = eyePositionHigh + eyePositionLow;
-
-                vec3 startPos = a_startPosHigh + a_startPosLow;
-                float length = length((a_endPosHigh + a_endPosLow) - startPos);
-                vec3 direction = normalize((a_endPosHigh + a_endPosLow) - startPos);
-                vec3 vertPos = startPos + a_vertices.y * direction * length;
+                vec3 v = (a_endPosHigh - a_startPosHigh) + (a_endPosLow - a_startPosLow);
 
-                vec3 look = vertPos - camPos;
-                vec3 up = normalize(direction);
+                vec3 look = (a_startPosHigh - eyePositionHigh) + (a_startPosLow - eyePositionLow) + v * a_vertices.y;
+                vec3 up = normalize(normalize(v));
                 vec3 right = normalize(cross(look,up));
  
-                float dist = dot(camPos - vertPos, vec3(viewMatrix[0][2], viewMatrix[1][2], viewMatrix[2][2]));
+                float dist = dot(look, vec3(viewMatrix[0][2], viewMatrix[1][2], viewMatrix[2][2]));
                 float focalSize = 2.0 * dist * resolution;
-                vec3 rr = right * a_thickness * focalSize * a_vertices.x;
+                vec3 vert = right * a_thickness * focalSize * a_vertices.x;
 
-                vec3 highDiff = -eyePositionHigh;
-                vec3 lowDiff = rr - eyePositionLow;
+                vec3 highDiff;
+                vec3 lowDiff;
 
                 if(a_vertices.y == 0.0){
-                    highDiff += a_startPosHigh;
-                    lowDiff += a_startPosLow;
+                    highDiff = a_startPosHigh - eyePositionHigh;
+                    vert += a_startPosLow - eyePositionLow;
                 }else{
-                    highDiff += a_endPosHigh;
-                    lowDiff += a_endPosLow;
+                    highDiff = a_endPosHigh - eyePositionHigh;
+                    vert += a_endPosLow - eyePositionLow;
                 }
 
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
-
-                vec4 pos = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
                 
-                gl_Position = projectionMatrix * pos;
+                gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + vert, 1.0);
             }`,
         fragmentShader:
             `precision highp float;