@openglobus/og 0.22.2 → 0.23.0

package/lib/js/shaders/geoObject.js

@@ -9,9 +9,11 @@ export const geo_object = () => new Program("geo_object", {
         uScaleByDistance: "vec3",
         eyePositionHigh: "vec3",
         eyePositionLow: "vec3",
-        lightsPositions: "vec3",
-        lightsParamsv: "vec3",
-        lightsParamsf: "float",
+        rtcEyePositionHigh: "vec3",
+        rtcEyePositionLow: "vec3",
+        sunPosition: "vec3",
+        materialParams: "vec3",
+        materialShininess: "float",
         uTexture: "sampler2d",
         uUseTexture: "float",
         useLighting: "float"
@@ -20,8 +22,9 @@ export const geo_object = () => new Program("geo_object", {
         aVertexPosition: "vec3",
         aVertexNormal: "vec3",
         aTexCoord: "vec2",
-        aPositionHigh: { type: "vec3", divisor: 1 },
-        aPositionLow: { type: "vec3", divisor: 1 },
+        aLocalPosition: { type: "vec3", divisor: 1 },
+        aRTCPositionHigh: { type: "vec3", divisor: 1 },
+        aRTCPositionLow: { type: "vec3", divisor: 1 },
         aColor: { type: "vec4", divisor: 1 },
         aScale: { type: "vec3", divisor: 1 },
         aTranslate: { type: "vec3", divisor: 1 },
@@ -32,8 +35,10 @@ export const geo_object = () => new Program("geo_object", {
             
             attribute vec3 aVertexPosition;
             attribute vec3 aVertexNormal; 
-            attribute vec3 aPositionHigh;
-            attribute vec3 aPositionLow;    
+            
+            attribute vec3 aRTCPositionHigh;
+            attribute vec3 aRTCPositionLow;    
+            
             attribute vec4 aColor;
             attribute vec3 aScale;
             attribute vec3 aTranslate;
@@ -41,6 +46,7 @@ export const geo_object = () => new Program("geo_object", {
             attribute float aUseTexture;
             attribute vec2 aTexCoord;
             attribute vec4 qRot;
+            attribute vec3 aLocalPosition;
             
             uniform vec3 uScaleByDistance;
             uniform mat4 projectionMatrix;
@@ -48,6 +54,9 @@ export const geo_object = () => new Program("geo_object", {
             
             uniform vec3 eyePositionHigh;
             uniform vec3 eyePositionLow;
+            
+            uniform vec3 rtcEyePositionHigh;
+            uniform vec3 rtcEyePositionLow;
 
             varying vec3 cameraPosition;
             varying vec3 vNormal;
@@ -64,50 +73,37 @@ export const geo_object = () => new Program("geo_object", {
                    return;
                 }
                 
-                vec3 position = aPositionHigh + aPositionLow;
-                cameraPosition = eyePositionHigh + eyePositionLow;
-                
-                vec3 look = cameraPosition - position;
-                float lookLength = length(look);
-
                 vColor = aColor;
-                vTexCoords = aTexCoord;
-              
+                vTexCoords = aTexCoord;      
+                
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
-
-                vec3 highDiff = aPositionHigh - eyePositionHigh;
-                vec3 lowDiff = aPositionLow - eyePositionLow;
-             
-                vNormal = qRotate(qRot, aVertexNormal);
-                               
-                // if(lookLength > uScaleByDistance[1])
-                // {
-                //     scd = uScaleByDistance[1] / uScaleByDistance[0];
-                // }
-                // else if(lookLength > uScaleByDistance[0])
-                // {
-                //     scd = lookLength / uScaleByDistance[0];
-                // }
-                // ... is the same math
-                // use scaleByDistance: [1.0, 1.0, 1.0] for real sized objects 
-                float scd = uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
                 
-                vec3 vert = qRotate(qRot, scd * (aVertexPosition * aScale + aTranslate));
+                vec3 highDiff = aRTCPositionHigh - rtcEyePositionHigh;
+                vec3 lowDiff = aRTCPositionLow - rtcEyePositionLow;
+               
+                cameraPosition = eyePositionHigh + eyePositionLow;
+                
+                highDiff = highDiff * step(1.0, length(highDiff));
                 
-                vert += lowDiff;
+                vec4 positionInViewSpace = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+
+                float lookLength = length(positionInViewSpace.xyz);
+                             
+                vNormal = normalize(qRotate(qRot, aVertexNormal));
                                
-                gl_Position = projectionMatrix * viewMatrixRTE  * vec4(highDiff * step(1.0, length(highDiff)) + vert, 1.0);
+                float scd = uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
+                vec3 vert = qRotate(qRot, scd * (aVertexPosition * aScale + aTranslate)) + scd * aLocalPosition;
+                 
+                gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff + vert, 1.0);
                 
-                v_vertex = position + vert;
+                v_vertex = positionInViewSpace.xyz + vert;
             }`,
     fragmentShader: `precision highp float;
-
-                #define MAX_POINT_LIGHTS 1
                 
-                uniform vec3 lightsPositions[MAX_POINT_LIGHTS];
-                uniform vec3 lightsParamsv[MAX_POINT_LIGHTS * 3];
-                uniform float lightsParamsf[MAX_POINT_LIGHTS];
+                uniform vec3 sunPosition;
+                uniform vec3 materialParams[3];
+                uniform float materialShininess;
                 uniform sampler2D uTexture;
                 uniform float uUseTexture;
                 uniform float useLighting;                
@@ -123,21 +119,23 @@ export const geo_object = () => new Program("geo_object", {
                     vec3 lightWeighting = vec3(1.0);
                 
                     if(useLighting != 0.0){
-                        vec3 normal = normalize(vNormal);
-                        vec3 lightDir = normalize(lightsPositions[0]);
+                        vec3 normal = vNormal;
+                        vec3 lightDir = normalize(sunPosition);
                         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 specularLightWeighting = pow( reflection, materialShininess);                                        
                         float diffuseLightWeighting = max(dot(normal, lightDir), 0.0);
-                        lightWeighting = lightsParamsv[0] + lightsParamsv[1] * diffuseLightWeighting + lightsParamsv[2] * specularLightWeighting;
+                        lightWeighting = vColor.rgb * materialParams[0] + materialParams[1] * diffuseLightWeighting + materialParams[2] * specularLightWeighting;
+                    } else {
+                        lightWeighting = vColor.rgb;
                     }
                                        
                     if(uUseTexture > 0.0) {
-                        vec4 tColor = texture2D(uTexture, vTexCoords);
-                        gl_FragColor = vec4(tColor.rgb * lightWeighting, tColor.a);
+                        vec4 texColor = texture2D(uTexture, vTexCoords);
+                        gl_FragColor = vec4(texColor.rgb * lightWeighting, texColor.a);
                     } else {
-                        gl_FragColor = vec4(vColor.rgb * lightWeighting, vColor.a);
+                        gl_FragColor = vec4(lightWeighting, vColor.a);
                     }
                 }`
 });
@@ -146,33 +144,37 @@ export const geo_object_picking = () => new Program("geo_object_picking", {
         viewMatrix: "mat4",
         projectionMatrix: "mat4",
         uScaleByDistance: "vec3",
-        eyePositionHigh: "vec3",
-        eyePositionLow: "vec3",
-        pickingScale: "vec3"
+        pickingScale: "vec3",
+        rtcEyePositionHigh: "vec3",
+        rtcEyePositionLow: "vec3",
     },
     attributes: {
         aVertexPosition: "vec3",
-        aPositionHigh: { type: "vec3", divisor: 1 },
-        aPositionLow: { type: "vec3", divisor: 1 },
+        aRTCPositionHigh: { type: "vec3", divisor: 1 },
+        aRTCPositionLow: { type: "vec3", divisor: 1 },
         aPickingColor: { type: "vec3", divisor: 1 },
         aScale: { type: "vec3", divisor: 1 },
         aTranslate: { type: "vec3", divisor: 1 },
+        aLocalPosition: { type: "vec3", divisor: 1 },
         aDispose: { type: "float", divisor: 1 },
         qRot: { type: "vec4", divisor: 1 }
     },
     vertexShader: `precision highp float;
 
             attribute vec3 aVertexPosition;
-            attribute vec3 aPositionHigh;
-            attribute vec3 aPositionLow;
+            attribute vec3 aRTCPositionHigh;
+            attribute vec3 aRTCPositionLow;
             attribute vec3 aPickingColor;    
             attribute vec3 aScale;
             attribute vec3 aTranslate;
             attribute float aDispose;
             attribute vec4 qRot;
             
-            uniform vec3 eyePositionHigh;
-            uniform vec3 eyePositionLow;
+            attribute vec3 aLocalPosition;
+            
+            uniform vec3 rtcEyePositionHigh;
+            uniform vec3 rtcEyePositionLow;
+            
             uniform vec3 uScaleByDistance;
             uniform mat4 projectionMatrix;
             uniform mat4 viewMatrix;
@@ -186,42 +188,27 @@ export const geo_object_picking = () => new Program("geo_object_picking", {
 
                 if (aDispose == 0.0) {
                     return;
-                 }
-            
-                 vColor = aPickingColor;
-                
-                 vec3 position = aPositionHigh + aPositionLow;
-                 vec3 cameraPosition = eyePositionHigh + eyePositionLow;
- 
-                 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 = uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
-
-                 //vec3 vert = qRotate(qRot, (aVertexPosition * aScale + aTranslate) * pickingScale) * scd;
-                 vec3 vert = qRotate(qRot, scd * pickingScale * (aVertexPosition * aScale + aTranslate));
+                }          
+                
+                vColor = aPickingColor;
                  
-                 vert += lowDiff;
+                mat4 viewMatrixRTE = viewMatrix;
+                viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+                
+                vec3 highDiff = aRTCPositionHigh - rtcEyePositionHigh;
+                vec3 lowDiff = aRTCPositionLow - rtcEyePositionLow;  
+                
+                highDiff = highDiff * step(1.0, length(highDiff));
+                
+                vec4 positionInViewSpace = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+
+                float lookLength = length(positionInViewSpace.xyz);
                                 
-                 gl_Position = projectionMatrix * viewMatrixRTE  * vec4(highDiff * step(1.0, length(highDiff)) + vert, 1.0);
+                float scd = uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
+
+                vec3 vert = qRotate(qRot, scd * pickingScale * (aVertexPosition * aScale + aTranslate)) + scd * aLocalPosition;
+                    
+                gl_Position = projectionMatrix * viewMatrixRTE  * vec4(highDiff + lowDiff + vert, 1.0);
             }`,
     fragmentShader: `precision highp float;
             varying vec3 vColor;
@@ -229,3 +216,79 @@ export const geo_object_picking = () => new Program("geo_object_picking", {
                 gl_FragColor = vec4(vColor, 1.0);
             }`
 });
+export const geo_object_depth = () => new Program("geo_object_depth", {
+    uniforms: {
+        viewMatrix: "mat4",
+        projectionMatrix: "mat4",
+        uScaleByDistance: "vec3",
+        rtcEyePositionHigh: "vec3",
+        rtcEyePositionLow: "vec3",
+        frustumPickingColor: "float"
+    },
+    attributes: {
+        aVertexPosition: "vec3",
+        aRTCPositionHigh: { type: "vec3", divisor: 1 },
+        aRTCPositionLow: { type: "vec3", divisor: 1 },
+        aScale: { type: "vec3", divisor: 1 },
+        aTranslate: { type: "vec3", divisor: 1 },
+        aDispose: { type: "float", divisor: 1 },
+        qRot: { type: "vec4", divisor: 1 },
+        aLocalPosition: { type: "vec3", divisor: 1 },
+    },
+    vertexShader: `#version 300 es
+            precision highp float;
+
+            in vec3 aVertexPosition;
+            in vec3 aRTCPositionHigh;
+            in vec3 aRTCPositionLow;
+            in vec3 aScale;
+            in vec3 aTranslate;
+            in float aDispose;
+            in vec4 qRot;
+            in vec3 aLocalPosition;
+            
+            uniform vec3 rtcEyePositionHigh;
+            uniform vec3 rtcEyePositionLow;
+            uniform vec3 uScaleByDistance;
+            uniform mat4 projectionMatrix;
+            uniform mat4 viewMatrix;
+                      
+            ${QROT}
+
+            void main(void) {
+
+                if (aDispose == 0.0) {
+                    return;
+                 }
+                
+                mat4 viewMatrixRTE = viewMatrix;
+                viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+                
+                vec3 highDiff = aRTCPositionHigh - rtcEyePositionHigh;
+                vec3 lowDiff = aRTCPositionLow - rtcEyePositionLow;  
+                
+                highDiff = highDiff * step(1.0, length(highDiff));
+                
+                vec4 positionInViewSpace = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+
+                float lookLength = length(positionInViewSpace.xyz);
+                                
+                float scd = uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
+
+                vec3 vert = qRotate(qRot, scd * (aVertexPosition * aScale + aTranslate)) + scd * aLocalPosition;
+                                                 
+                gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff + vert, 1.0);
+            }`,
+    fragmentShader: `#version 300 es
+            precision highp float;
+                        
+            uniform float frustumPickingColor;
+            
+            layout(location = 0) out vec4 frustumColor;
+            layout(location = 1) out vec4 depthColor;
+                        
+            void main () {
+                frustumColor = vec4(frustumPickingColor, frustumPickingColor, frustumPickingColor, 1.0);
+                depthColor = vec4(gl_FragCoord.z, gl_FragCoord.z, gl_FragCoord.z, 1.0);
+            }`
+});

package/lib/js/shaders/polyline.js

@@ -1,16 +1,17 @@
 import { Program } from '../webgl/Program';
+import { UTILS } from "./utils";
 export function polyline_screen() {
     return new Program("polyline_screen", {
         uniforms: {
             viewport: "vec2",
             proj: "mat4",
             view: "mat4",
-            eyePositionHigh: "vec3",
-            eyePositionLow: "vec3",
-            //uFloatParams: "vec2",
+            rtcEyePositionHigh: "vec3",
+            rtcEyePositionLow: "vec3",
             thickness: "float",
             opacity: "float",
-            depthOffset: "float"
+            depthOffset: "float",
+            visibleSphere: "vec4",
         },
         attributes: {
             prevHigh: "vec3",
@@ -40,10 +41,11 @@ export function polyline_screen() {
                 uniform mat4 proj;
                 uniform mat4 view;
                 uniform vec2 viewport;
-                uniform vec3 eyePositionHigh;
-                uniform vec3 eyePositionLow;
+                uniform vec3 rtcEyePositionHigh;
+                uniform vec3 rtcEyePositionLow;
                 uniform float opacity;
                 uniform float depthOffset;
+               
 
                 varying vec4 vColor;
                 varying vec3 vPos;
@@ -70,29 +72,29 @@ export function polyline_screen() {
 
                 void main(){
 
-                    uCamPos = eyePositionHigh + eyePositionLow;
-
+                    uCamPos = rtcEyePositionHigh + rtcEyePositionLow;
+                    vPos = currentHigh + currentLow;
+                    
                     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;
+                    highDiff = currentHigh - rtcEyePositionHigh;
+                    highDiff = highDiff * step(1.0, length(highDiff));
+                    lowDiff = currentLow - rtcEyePositionLow;                   
                     vec4 vCurrent = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
 
-                    highDiff = prevHigh - eyePositionHigh;
-                    lowDiff = prevLow - eyePositionLow;
+                    highDiff = prevHigh - rtcEyePositionHigh;
+                    highDiff = highDiff * step(1.0, length(highDiff));
+                    lowDiff = prevLow - rtcEyePositionLow;
                     vec4 vPrev = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
 
-                    highDiff = nextHigh - eyePositionHigh;
-                    lowDiff = nextLow - eyePositionLow;
+                    highDiff = nextHigh - rtcEyePositionHigh;
+                    highDiff = highDiff * step(1.0, length(highDiff));
+                    lowDiff = nextLow - rtcEyePositionLow;
                     vec4 vNext = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
 
                     /*Clip near plane, the point behind view plane*/
@@ -161,16 +163,26 @@ export function polyline_screen() {
                     gl_Position = vec4((2.0 * m / viewport - 1.0) * dCurrent.w, dCurrent.z + depthOffset, dCurrent.w);
                 }`,
         fragmentShader: `precision highp float;
-                //uniform vec2 uFloatParams;
+            
+                uniform vec4 visibleSphere;
+                            
                 varying vec3 uCamPos;
                 varying vec4 vColor;
-                varying vec3 vPos;
+                varying vec3 vPos;               
+                
+                ${UTILS}
+            
                 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]));
-                    float a = vColor.a;
-                    gl_FragColor = vec4(vColor.rgb, a);
+                    
+                    if(visibleSphere.w != 0.0) {                  
+                        vec3 cam_dir = normalize(vPos - uCamPos);
+                        vec3 sph_dir = normalize(vPos - visibleSphere.xyz);
+                        if( dot(cam_dir, sph_dir) > 0.11 ){
+                            discard;
+                        }
+                   }
+                   
+                    gl_FragColor = vec4(vColor.rgb, vColor.a);
                 }`
     });
 }
@@ -180,12 +192,12 @@ export function polyline_picking() {
             viewport: "vec2",
             proj: "mat4",
             view: "mat4",
-            eyePositionHigh: "vec3",
-            eyePositionLow: "vec3",
-            //uFloatParams: "vec2",
+            rtcEyePositionHigh: "vec3",
+            rtcEyePositionLow: "vec3",
             color: "vec4",
             thickness: "float",
-            depthOffset: "float"
+            depthOffset: "float",
+            visibleSphere: "vec4",
         },
         attributes: {
             prevHigh: "vec3",
@@ -213,8 +225,8 @@ export function polyline_picking() {
                 uniform mat4 proj;
                 uniform mat4 view;
                 uniform vec2 viewport;
-                uniform vec3 eyePositionHigh;
-                uniform vec3 eyePositionLow;
+                uniform vec3 rtcEyePositionHigh;
+                uniform vec3 rtcEyePositionLow;
                 uniform float depthOffset;
 
                 varying vec4 vColor;
@@ -243,29 +255,28 @@ export function polyline_picking() {
                 
                 void main(){
 
-                    uCamPos = eyePositionHigh + eyePositionLow;
-
-                    vColor = color;
-
-                    vec3 current = currentHigh + currentLow;
-
-                    vPos = current;                    
+                    uCamPos = rtcEyePositionHigh + rtcEyePositionLow;
+                    vPos = currentHigh + currentLow;
+                    vColor = color;               
 
                     vec3 highDiff, lowDiff;
 
                     mat4 viewMatrixRTE = view;
                     viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
-
-                    highDiff = currentHigh - eyePositionHigh;
-                    lowDiff = currentLow - eyePositionLow;
+                    
+                    highDiff = currentHigh - rtcEyePositionHigh;
+                    highDiff = highDiff * step(1.0, length(highDiff));
+                    lowDiff = currentLow - rtcEyePositionLow;
                     vec4 vCurrent = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
 
-                    highDiff = prevHigh - eyePositionHigh;
-                    lowDiff = prevLow - eyePositionLow;    
+                    highDiff = prevHigh - rtcEyePositionHigh;
+                    highDiff = highDiff * step(1.0, length(highDiff));
+                    lowDiff = prevLow - rtcEyePositionLow;    
                     vec4 vPrev = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
 
-                    highDiff = nextHigh - eyePositionHigh;
-                    lowDiff = nextLow - eyePositionLow;    
+                    highDiff = nextHigh - rtcEyePositionHigh;
+                    highDiff = highDiff * step(1.0, length(highDiff));
+                    lowDiff = nextLow - rtcEyePositionLow;    
                     vec4 vNext = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
 
                     /*Clip near plane*/
@@ -332,16 +343,22 @@ export function polyline_picking() {
                     gl_Position = vec4((2.0 * m / viewport - 1.0) * dCurrent.w, dCurrent.z + depthOffset, dCurrent.w);
                 }`,
         fragmentShader: `precision highp float;
-                //uniform vec2 uFloatParams;
+            
+                uniform vec4 visibleSphere;
+                            
                 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]));
-                    float a = vColor.a;                    
-                    gl_FragColor = vec4(vColor.rgb, a);
+                    if(visibleSphere.w != 0.0) {                  
+                        vec3 cam_dir = normalize(vPos - uCamPos);
+                        vec3 sph_dir = normalize(vPos - visibleSphere.xyz);
+                        if( dot(cam_dir, sph_dir) > 0.11 ){
+                            discard;
+                        }
+                    }                 
+                    gl_FragColor = vec4(vColor.rgb, vColor.a);
                 }`
     });
 }

package/lib/js/shaders/utils.d.ts

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

package/lib/js/shaders/utils.js

@@ -39,6 +39,17 @@ export const UTILS = `
         return true;
     }
     
+    float intersectSphere( vec3 ro, vec3 rd, vec4 sph )
+    {
+        vec3 oc = ro - sph.xyz;
+        float b = dot( oc, rd );
+        float c = dot( oc, oc ) - sph.w*sph.w;
+        float h = b*b - c;
+        if( h<0.0 ) return -1.0;
+        h = sqrt( h );
+        return -b - h;
+    }
+    
     bool intersectEllipsoid( in vec3 ro, in vec3 rd, in vec3 ra, inout float t )
     {
         vec3 ocn = ro/ra;

package/lib/js/ui/Checkbox.d.ts

@@ -0,0 +1,31 @@
+import { EventsHandler } from "../Events";
+import { IViewParams, View, ViewEventsList } from './View';
+interface ICheckboxParams extends IViewParams {
+    label?: string;
+    checked?: boolean;
+    disabled?: boolean;
+}
+type CheckboxEventsList = ["change"];
+declare class Checkbox extends View<null> {
+    events: EventsHandler<CheckboxEventsList> & EventsHandler<ViewEventsList>;
+    protected $label: HTMLElement | null;
+    protected $input: HTMLInputElement | null;
+    protected _checked: boolean;
+    protected _disabled: boolean;
+    constructor(options?: ICheckboxParams);
+    set disabled(disabled: boolean);
+    protected _updateDisabled(): void;
+    get disabled(): boolean;
+    render(params: any): this;
+    protected _onResize: () => void;
+    set checked(isChecked: boolean);
+    get checked(): boolean;
+    protected _initEvents(): void;
+    protected _clearEvents(): void;
+    protected _onMouseWheel: (e: WheelEvent) => void;
+    protected _onMouseWheelFF: (e: WheelEvent) => void;
+    protected _onClick: (e: Event) => void;
+    remove(): void;
+    set visibility(visibility: boolean);
+}
+export { Checkbox };