@openglobus/og 0.14.10 → 0.15.1

package/src/og/shaders/geoObject.js

@@ -11,20 +11,24 @@ export const geo_object = () =>
         uniforms: {
             viewMatrix: "mat4",
             projectionMatrix: "mat4",
-            normalMatrix: "mat3",
 
             uScaleByDistance: "vec3",
 
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3",
 
-            lightsPositions: "vec4",
+            lightsPositions: "vec3",
             lightsParamsv: "vec3",
-            lightsParamsf: "float"
+            lightsParamsf: "float",
+
+            uTexture: "sampler2d",
+            uUseTexture: "float"
         },
         attributes: {
             aVertexPosition: "vec3",
             aVertexNormal: "vec3",
+            aTexCoord: "vec2",
+
             aPositionHigh: { type: "vec3", divisor: 1 },
             aPositionLow: { type: "vec3", divisor: 1 },
             aDirection: { type: "vec3", divisor: 1 },
@@ -33,8 +37,9 @@ export const geo_object = () =>
             aScale: { type: "float", divisor: 1 },
             aDispose: { type: "float", divisor: 1 }
         },
-        vertexShader: `precision highp float;
-
+        vertexShader:
+            `precision highp float;
+            
             attribute vec3 aVertexPosition;
             attribute vec3 aVertexNormal; 
             attribute vec3 aPositionHigh;
@@ -44,34 +49,47 @@ export const geo_object = () =>
             attribute vec4 aColor;
             attribute float aScale;
             attribute float aDispose;
+            attribute float aUseTexture;
+            attribute vec2 aTexCoord;
             
+            uniform float uUseTexture;
             uniform vec3 uScaleByDistance;
             uniform mat4 projectionMatrix;
             uniform mat4 viewMatrix;
-            uniform mat3 normalMatrix;
             
             uniform vec3 eyePositionHigh;
             uniform vec3 eyePositionLow;
 
+            varying vec3 cameraPosition;
             varying vec3 vNormal;
-            varying vec4 vPosition;           
+            varying vec3 v_vertex;           
             varying vec4 vColor;
             varying float vDispose;
+            varying float vUseTexture;
+            varying vec2 vTexCoords;
             
-            const float RADIANS = 3.141592653589793 / 180.0;
-
+            const float PI = 3.141592653589793;
+            
+            const float RADIANS = PI / 180.0;
+           
             void main(void) {
             
-                vDispose = aDispose;
+                if (aDispose == 0.0) {
+                   return;
+                }
+            
+                vUseTexture = uUseTexture;
                 vColor = aColor;
-                float roll = aPitchRoll.y * RADIANS;
+                vTexCoords = aTexCoord;
+              
+                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 * RADIANS;
+                float pitch = aPitchRoll.x;
                 mat3 rotX = mat3(
                     vec3(1.0, 0.0, 0.0),
                     vec3(0.0, cos(pitch), sin(pitch)), 
@@ -79,53 +97,71 @@ export const geo_object = () =>
                );
 
                 vec3 position = aPositionHigh + aPositionLow;
+                cameraPosition = eyePositionHigh + eyePositionLow;
                 vec3 r = cross(normalize(-position), aDirection);
-                mat3 modelMatrix = mat3(r, normalize(position), -aDirection) * rotX * rotZ; /*up=-cross(aDirection, r)*/
+                mat3 modelMatrix = mat3(r, normalize(position), -aDirection) * rotX * rotZ;
 
-                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;
+                float dist = length(cameraPosition);
 
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
-                vPosition = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
-
-                gl_Position = mix(vec4(0.0, 0.0, 0.0, 0.0), projectionMatrix * vPosition, aDispose);
+                vec3 highDiff = aPositionHigh - eyePositionHigh;
+                vec3 lowDiff = aPositionLow - eyePositionLow;
+             
+                vec3 look = cameraPosition - position;
+                float lookLength = length(look);
+                vNormal = modelMatrix * aVertexNormal;
+                               
+                // if(lookLength > uScaleByDistance[1])
+                // {
+                //     scd = uScaleByDistance[1] / uScaleByDistance[0];
+                // }
+                // else if(lookLength > uScaleByDistance[0])
+                // {
+                //     scd = lookLength / uScaleByDistance[0];
+                // }
+                // ... is the same math
+                float scd = uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
+                
+                vec3 vert = modelMatrix * aVertexPosition * aScale * scd;
+                v_vertex = position + vert;
+                               
+                gl_Position = projectionMatrix * viewMatrixRTE  * vec4(highDiff + lowDiff + vert, 1.0);
             }`,
+
         fragmentShader: `precision highp float;
 
-                varying vec4 vColor;
                 #define MAX_POINT_LIGHTS 1
                 
-                uniform vec4 lightsPositions[MAX_POINT_LIGHTS];
+                uniform vec3 lightsPositions[MAX_POINT_LIGHTS];
                 uniform vec3 lightsParamsv[MAX_POINT_LIGHTS * 3];
-                uniform float lightsParamsf[MAX_POINT_LIGHTS];
+                uniform float lightsParamsf[MAX_POINT_LIGHTS];                
+                uniform sampler2D uTexture;
                 
+                varying vec3 cameraPosition;
+                varying vec3 v_vertex;                
+                varying vec4 vColor;
                 varying vec3 vNormal;
-                varying vec4 vPosition;
+                varying vec2 vTexCoords;
+                varying float vUseTexture;
                 
-                void main(void) {
-                    vec3 lightWeighting;
-                    vec3 lightDirection;
-                    vec3 normal;
-                    vec3 eyeDirection;
-                    vec3 reflectionDirection;
-                    float specularLightWeighting;
-                    float diffuseLightWeighting;
+                void main(void) {                
+                    vec3 normal = normalize(vNormal);
                 
-                    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;
+                    vec3 lightDir = normalize(lightsPositions[0]);
+                    vec3 viewDir = normalize(cameraPosition - v_vertex);                
+                    vec3 reflectionDirection = reflect(-lightDir, normal);
+                    float reflection = max( dot(reflectionDirection, viewDir), 0.0);
+                    float specularLightWeighting = pow( reflection, lightsParamsf[0]);                                        
+                    float diffuseLightWeighting = max(dot(normal, lightDir), 0.0);
+                    vec3 lightWeighting = lightsParamsv[0] + lightsParamsv[1] * diffuseLightWeighting + lightsParamsv[2] * specularLightWeighting;
+                    vec4 tColor = texture2D(uTexture, vTexCoords);
+                    if(vUseTexture > 0.0){
+                        gl_FragColor = vec4(tColor.rgb * lightWeighting, tColor.a);
+                    } else {
+                        gl_FragColor = vec4(vColor.rgb * lightWeighting, vColor.a);
+                    }
                 }`
     });
 
@@ -178,7 +214,11 @@ export const geo_object_picking = () =>
 
             void main(void) {
             
-                vDispose = aDispose;
+             
+                if (aDispose == 0.0) {
+                   return;
+                }
+            
                 vColor = aPickingColor;
                 float roll = aPitchRoll.y * RADIANS;
                 mat3 rotZ = mat3(
@@ -198,17 +238,22 @@ export const geo_object_picking = () =>
                 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;
+                float dist = length(eyePositionHigh + eyePositionLow);
 
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
-                gl_Position = mix(vec4(0.0, 0.0, 0.0, 0.0),  projectionMatrix *viewMatrixRTE * vec4(highDiff + lowDiff, 1.0), aDispose);
+                vec3 highDiff = aPositionHigh - eyePositionHigh;
+                vec3 lowDiff = aPositionLow - eyePositionLow;
+             
+                vec3 look = position - (eyePositionHigh + eyePositionLow);
+                float lookLength = length(look);
+                
+                float scd = uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
+                
+                vec4 pos = vec4((highDiff + lowDiff) + modelMatrix * aVertexPosition * aScale * pickingScale * scd, 1.0);
+                                
+                gl_Position = projectionMatrix * viewMatrixRTE * pos;
             }`,
         fragmentShader:
             `precision highp float;

package/src/og/shaders/polyline.js

@@ -6,6 +6,188 @@
 
 import { Program } from '../webgl/Program.js';
 
+// export function polyline_screen() {
+//     return new Program("polyline_screen", {
+//         uniforms: {
+//             viewport: "vec2",
+//             proj: "mat4",
+//             view: "mat4",
+//             eyePositionHigh: "vec3",
+//             eyePositionLow: "vec3",
+//             uFloatParams: "vec2",
+//             thickness: "float",
+//             opacity: "float",
+//             depthOffset: "float"
+//         },
+//         attributes: {
+//             prevHigh: "vec3",
+//             currentHigh: "vec3",
+//             nextHigh: "vec3",
+//
+//             prevLow: "vec3",
+//             currentLow: "vec3",
+//             nextLow: "vec3",
+//
+//             order: "float",
+//
+//             color: "vec4"
+//         },
+//
+//         vertexShader:
+//             `precision highp float;
+//
+//                 attribute vec3 prevHigh;
+//                 attribute vec3 currentHigh;
+//                 attribute vec3 nextHigh;
+//
+//                 attribute vec3 prevLow;
+//                 attribute vec3 currentLow;
+//                 attribute vec3 nextLow;
+//
+//                 attribute float order;
+//
+//                 attribute vec4 color;
+//
+//                 uniform float thickness;
+//                 uniform mat4 proj;
+//                 uniform mat4 view;
+//                 uniform vec2 viewport;
+//                 uniform vec3 eyePositionHigh;
+//                 uniform vec3 eyePositionLow;
+//                 uniform float opacity;
+//                 uniform float depthOffset;
+//
+//                 varying vec4 vColor;
+//                 varying vec3 vPos;
+//                 varying vec3 uCamPos;
+//
+//                 const float NEAR = -1.0;
+//
+//                 vec2 getIntersection(vec2 start1, vec2 end1, vec2 start2, vec2 end2){
+//                     vec2 dir = end2 - start2;
+//                     vec2 perp = vec2(-dir.y, dir.x);
+//                     float d2 = dot(perp, start2);
+//                     float seg = dot(perp, start1) - d2;
+//                     float prl = seg - dot(perp, end1) + d2;
+//                     if(prl > -1.0 && prl < 1.0){
+//                         return start1;
+//                     }
+//                     float u = seg / prl;
+//                     return start1 + u * (end1 - start1);
+//                 }
+//
+//                 vec2 project(vec4 p){
+//                     return (0.5 * p.xyz / p.w + 0.5).xy * viewport;
+//                 }
+//
+//                 void main(){
+//
+//                     uCamPos = eyePositionHigh + eyePositionLow;
+//
+//                     vColor = vec4(color.rgb, color.a * opacity);
+//
+//                     vec3 current = currentHigh + currentLow;
+//
+//                     vPos = current;
+//
+//                     mat4 viewMatrixRTE = view;
+//                     viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+//
+//                     vec3 highDiff, lowDiff;
+//
+//                     highDiff = currentHigh - eyePositionHigh;
+//                     lowDiff = currentLow - eyePositionLow;
+//                     vec4 vCurrent = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+//
+//                     highDiff = prevHigh - eyePositionHigh;
+//                     lowDiff = prevLow - eyePositionLow;
+//                     vec4 vPrev = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+//
+//                     highDiff = nextHigh - eyePositionHigh;
+//                     lowDiff = nextLow - eyePositionLow;
+//                     vec4 vNext = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+//
+//                     /*Clip near plane, the point behind view plane*/
+//                     if(vCurrent.z > NEAR) {
+//                         if(vPrev.z < NEAR && abs(order) == 1.0){
+//                             vCurrent = vPrev + (vCurrent - vPrev) * (NEAR - vPrev.z) / (vCurrent.z - vPrev.z);
+//                         } else if(vNext.z < NEAR && abs(order) == 2.0){
+//                             vCurrent = vNext + (vCurrent - vNext) * (NEAR - vNext.z) / (vCurrent.z - vNext.z);
+//                         }
+//                     }
+//
+//                     vec4 dCurrent = proj * vCurrent;
+//                     vec2 _next = project(proj * vNext);
+//                     vec2 _prev = project(proj * vPrev);
+//                     vec2 _current = project(dCurrent);
+//
+//                     if(_prev == _current){
+//                         if(_next == _current){
+//                             _next = _current + vec2(1.0, 0.0);
+//                             _prev = _current - _next;
+//                         }else{
+//                             _prev = _current + normalize(_current - _next);
+//                         }
+//                     }
+//
+//                     if(_next == _current){
+//                         _next = _current + normalize(_current - _prev);
+//                     }
+//
+//                     vec2 sNext = _next,
+//                          sCurrent = _current,
+//                          sPrev = _prev;
+//
+//                     vec2 dirNext = normalize(sNext - sCurrent);
+//                     vec2 dirPrev = normalize(sPrev - sCurrent);
+//                     float dotNP = dot(dirNext, dirPrev);
+//
+//                     vec2 normalNext = normalize(vec2(-dirNext.y, dirNext.x));
+//                     vec2 normalPrev = normalize(vec2(dirPrev.y, -dirPrev.x));
+//
+//                     float d = thickness * sign(order);
+//
+//                     vec2 m;
+//                     if(dotNP >= 0.99991){
+//                         m = sCurrent - normalPrev * d;
+//                     }else{
+//                         m = getIntersection( sCurrent + normalPrev * d, sPrev + normalPrev * d,
+//                                 sCurrent + normalNext * d, sNext + normalNext * d );
+//
+//                         if( dotNP > 0.5 && dot(dirNext + dirPrev, m - sCurrent) < 0.0 ){
+//                             float occw = order * sign(dirNext.x * dirPrev.y - dirNext.y * dirPrev.x);
+//                             if(occw == -1.0){
+//                                 m = sCurrent + normalPrev * d;
+//                             }else if(occw == 1.0){
+//                                 m = sCurrent + normalNext * d;
+//                             }else if(occw == -2.0){
+//                                 m = sCurrent + normalNext * d;
+//                             }else if(occw == 2.0){
+//                                 m = sCurrent + normalPrev * d;
+//                             }
+//                         }else if(distance(sCurrent, m) > min(distance(sCurrent, sNext), distance(sCurrent, sPrev))){
+//                             m = sCurrent + normalNext * d;
+//                         }
+//                     }
+//
+//                     gl_Position = vec4((2.0 * m / viewport - 1.0) * dCurrent.w, dCurrent.z + depthOffset, dCurrent.w);
+//                 }`,
+//
+//         fragmentShader:
+//             `precision highp float;
+//                 uniform vec2 uFloatParams;
+//                 varying vec3 uCamPos;
+//                 varying vec4 vColor;
+//                 varying vec3 vPos;
+//                 void main() {
+//                     vec3 look = vPos - uCamPos;
+//                     float lookLength = length(look);
+//                     float a = vColor.a * step(lookLength, sqrt(dot(uCamPos,uCamPos) - uFloatParams[0]) + sqrt(dot(vPos,vPos) - uFloatParams[0]));
+//                     gl_FragColor = vec4(vColor.rgb, a);
+//                 }`
+//     });
+// }
+
 export function polyline_screen() {
     return new Program("polyline_screen", {
         uniforms: {
@@ -34,19 +216,21 @@ export function polyline_screen() {
         },
 
         vertexShader:
-            `precision highp float;
+            `#version 300 es
                 
-                attribute vec3 prevHigh;
-                attribute vec3 currentHigh;
-                attribute vec3 nextHigh;
+                precision highp float;
                 
-                attribute vec3 prevLow;
-                attribute vec3 currentLow;
-                attribute vec3 nextLow;
+                in vec3 prevHigh;
+                in vec3 currentHigh;
+                in vec3 nextHigh;
+                
+                in vec3 prevLow;
+                in vec3 currentLow;
+                in vec3 nextLow;
 
-                attribute float order;
+                in float order;
 
-                attribute vec4 color;
+                in vec4 color;
 
                 uniform float thickness;
                 uniform mat4 proj;
@@ -57,9 +241,9 @@ export function polyline_screen() {
                 uniform float opacity;
                 uniform float depthOffset;
 
-                varying vec4 vColor;
-                varying vec3 vPos;
-                varying vec3 uCamPos;
+                out vec4 vColor;
+                out vec3 vPos;
+                out vec3 uCamPos;
                 
                 const float NEAR = -1.0;
                 
@@ -174,16 +358,27 @@ export function polyline_screen() {
                 }`,
 
         fragmentShader:
-            `precision highp float;
+            `#version 300 es
+                
+                precision highp float;
+                
                 uniform vec2 uFloatParams;
-                varying vec3 uCamPos;
-                varying vec4 vColor;
-                varying vec3 vPos;
+                
+                layout(location = 0) out vec4 diffuseColor;
+                layout(location = 1) out vec4 normalColor;
+                layout(location = 2) out vec4 distanceColor;
+                
+                in vec3 uCamPos;
+                in vec4 vColor;
+                in vec3 vPos;
+                
                 void main() {
                     vec3 look = vPos - uCamPos;
                     float lookLength = length(look);
                     float a = vColor.a * step(lookLength, sqrt(dot(uCamPos,uCamPos) - uFloatParams[0]) + sqrt(dot(vPos,vPos) - uFloatParams[0]));                    
-                    gl_FragColor = vec4(vColor.rgb, a);
+                    diffuseColor = vec4(vColor.rgb, a);
+                    normalColor = vec4(1.0);
+                    distanceColor = vec4(1.0);                    
                 }`
     });
 }

package/src/og/shaders/ray.js

@@ -22,7 +22,6 @@ export function rayScreen() {
             a_startPosLow: "vec3",
             a_endPosHigh: "vec3",
             a_endPosLow: "vec3",
-            a_length: "float",
             a_thickness: "float",
             a_rgba: "vec4"
         },
@@ -34,7 +33,6 @@ export function rayScreen() {
             attribute vec3 a_endPosHigh;
             attribute vec3 a_endPosLow;
             attribute float a_thickness;
-            attribute float a_length;
             attribute vec4 a_rgba;
 
             varying vec4 v_rgba;
@@ -53,8 +51,9 @@ export function rayScreen() {
                 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 * a_length;
+                vec3 vertPos = startPos + a_vertices.y * direction * length;
 
                 vec3 look = vertPos - camPos;
                 vec3 up = normalize(direction);
@@ -62,10 +61,18 @@ export function rayScreen() {
  
                 float dist = dot(camPos - vertPos, 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 + up * a_length * a_vertices.y;
+                vec3 rr = right * a_thickness * focalSize * a_vertices.x;
 
-                vec3 highDiff = a_startPosHigh - eyePositionHigh;
-                vec3 lowDiff = a_startPosLow + rr - eyePositionLow;
+                vec3 highDiff = -eyePositionHigh;
+                vec3 lowDiff = rr - eyePositionLow;
+
+                if(a_vertices.y == 0.0){
+                    highDiff += a_startPosHigh;
+                    lowDiff += a_startPosLow;
+                }else{
+                    highDiff += a_endPosHigh;
+                    lowDiff += a_endPosLow;
+                }
 
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);

package/src/og/shaders/toneMapping.js

@@ -75,16 +75,16 @@ export function toneMapping() {
             layout(location = 0) out vec4 fragColor;
             
             void main(void) {
-                vec3 hdrColor = texture(hdrBuffer, tc).rgb;
+                vec4 hdrColor = texture(hdrBuffer, tc).rgba;
                 
                 float oneByGamma = gamma / gamma;
                 float oneByWhitePoint = whitepoint / whitepoint;
-                vec3 mapped = ReinhardToneMapping2(hdrColor) * oneByGamma * oneByWhitePoint;
-                //vec3 mapped = ACESFilmicToneMapping(hdrColor) * oneByGamma * oneByWhitePoint;
+                vec3 mapped = ReinhardToneMapping2(hdrColor.rgb) * oneByGamma * oneByWhitePoint;
+                //vec3 mapped = ACESFilmicToneMapping(hdrColor.rgb) * oneByGamma * oneByWhitePoint;
 
                 mapped = pow(mapped, vec3(1.0 / gamma));
-
-                fragColor = vec4(mapped, 1.0);
+        
+                fragColor = vec4(mapped, hdrColor.a);
             }`
     });
 }

package/src/og/shaders/utils.js

@@ -0,0 +1,88 @@
+'use strict';
+
+export const UTILS = `
+    float getLerpValue(in float min, in float max, in float between)
+    {
+        return (clamp(between, min, max) - min) / (max - min);
+    }
+    
+    vec3 aces(vec3 color) 
+    {
+        float a = 2.51;
+        float b = 0.03;
+        float c = 2.43;
+        float d = 0.59;
+        float e = 0.14;
+        return clamp((color * (a * color + b)) / (color * (c * color + d ) + e), 0.0, 1.0);
+    }
+     
+    bool intersectSphere(vec3 rayOrigin, vec3 rayDirection, float radius, inout float t1, inout float t2) 
+    {
+        float b = dot(rayDirection, rayOrigin);
+        float c = dot(rayOrigin, rayOrigin) - radius * radius;
+        float d = b * b - c;
+        if (d < 0.0) {
+            return false;
+        }
+        t1 = -b - sqrt(d);
+        t2 = -b + sqrt(d);
+        return true;
+    }
+    
+    bool intersectSphere(vec3 rayOrigin, vec3 rayDirection, float radius, inout float t) 
+    {
+        float b = dot(rayDirection, rayOrigin);
+        float c = dot(rayOrigin, rayOrigin) - radius * radius;
+        float d = b * b - c;
+        if (d < 0.0) {
+            return false;
+        }
+        t = -b - sqrt(d);
+        return true;
+    }
+    
+    bool intersectEllipsoid( in vec3 ro, in vec3 rd, in vec3 ra, inout float t )
+    {
+        vec3 ocn = ro/ra;
+        vec3 rdn = rd/ra;
+        float a = dot( rdn, rdn );
+        float b = dot( ocn, rdn );
+        float c = dot( ocn, ocn );
+        float h = b*b - a*(c-1.0);
+                       
+        if (h < 0.0) 
+        { 
+            return false; 
+        }
+        
+        t = (-b-sqrt(h))/a;
+        
+        return true;
+    }
+    
+    bool intersectEllipsoid( in vec3 ro, in vec3 rd, in vec3 ra, inout float t1, inout float t2)
+    {
+        vec3 ocn = ro/ra;
+        vec3 rdn = rd/ra;
+        float a = dot( rdn, rdn );
+        float b = dot( ocn, rdn );
+        float c = dot( ocn, ocn );
+        float h = b*b - a*(c-1.0);
+                
+        if (h < 0.0) 
+        { 
+            return false; 
+        }
+        
+        h = sqrt(h);
+        t1 = (-b-h)/a;
+        t2 = (-b+h)/a;
+        
+        return true;
+    }
+    
+    vec3 normalEllipsoid( in vec3 pos, in vec3 ra )
+    {
+        return normalize( pos/(ra*ra) );
+    }
+`;