@openglobus/og 0.11.5 → 0.12.0

package/src/og/shaders/geoObject.js

@@ -0,0 +1,211 @@
+/**
+ * @module og/shaders/drawnode
+ */
+
+"use strict";
+
+import { Program } from "../webgl/Program.js";
+
+export const geo_object = () =>
+    new Program("geo_object", {
+        uniforms: {
+            viewMatrix: "mat4",
+            projectionMatrix: "mat4",
+            normalMatrix: "mat3",
+
+            uScaleByDistance: "vec3",
+
+            eyePositionHigh: "vec3",
+            eyePositionLow: "vec3",
+
+            lightsPositions: "vec4",
+            lightsParamsv: "vec3",
+            lightsParamsf: "float"
+        },
+        attributes: {
+            aVertexPosition: "vec3",
+            aVertexNormal: "vec3",
+            aPositionHigh: { type: "vec3", divisor: 1 },
+            aPositionLow: { type: "vec3", divisor: 1 },
+            aDirection: { type: "vec3", divisor: 1 },
+            aPitchRoll: { type: "vec2", divisor: 1 },
+            aColor: { type: "vec4", divisor: 1 },
+            aScale: { type: "float", divisor: 1 }
+        },
+        vertexShader: `precision highp float;
+
+            attribute vec3 aVertexPosition;
+            attribute vec3 aVertexNormal; 
+            attribute vec3 aPositionHigh;
+            attribute vec3 aPositionLow;    
+            attribute vec3 aDirection;
+            attribute vec2 aPitchRoll;
+            attribute vec4 aColor;
+            attribute float aScale;
+            
+            uniform vec3 uScaleByDistance;
+            uniform mat4 projectionMatrix;
+            uniform mat4 viewMatrix;
+            uniform mat3 normalMatrix;
+            
+            uniform vec3 eyePositionHigh;
+            uniform vec3 eyePositionLow;
+
+            varying vec3 vNormal;
+            varying vec4 vPosition;           
+            varying vec4 vColor;
+            
+            const float RADIANS = 3.141592653589793 / 180.0;
+
+            void main(void) {
+            
+                vColor = aColor;
+                float roll = aPitchRoll.y * RADIANS;
+                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;
+                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 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 * (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;
+
+                mat4 viewMatrixRTE = viewMatrix;
+                viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+
+                vPosition = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+
+                gl_Position = projectionMatrix * vPosition;
+            }`,
+        fragmentShader: `precision highp float;
+
+                varying vec4 vColor;
+                #define MAX_POINT_LIGHTS 1
+                
+                uniform vec4 lightsPositions[MAX_POINT_LIGHTS];
+                uniform vec3 lightsParamsv[MAX_POINT_LIGHTS * 3];
+                uniform float lightsParamsf[MAX_POINT_LIGHTS];
+                
+                varying vec3 vNormal;
+                varying vec4 vPosition;
+                
+                void main(void) {
+                    vec3 lightWeighting;
+                    vec3 lightDirection;
+                    vec3 normal;
+                    vec3 eyeDirection;
+                    vec3 reflectionDirection;
+                    float specularLightWeighting;
+                    float diffuseLightWeighting;
+                
+                    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;
+                }`
+    });
+
+export const geo_object_picking = () =>
+    new Program("geo_object_picking", {
+        uniforms: {
+            viewMatrix: "mat4",
+            projectionMatrix: "mat4",
+
+            uScaleByDistance: "vec3",
+
+            eyePositionHigh: "vec3",
+            eyePositionLow: "vec3",
+            pickingScale: "float",
+
+        },
+        attributes: {
+            aVertexPosition: "vec3",
+            aPositionHigh: { type: "vec3", divisor: 1 },
+            aPositionLow: { type: "vec3", divisor: 1 },
+            aDirection: { type: "vec3", divisor: 1 },
+            aPitchRoll: { type: "vec2", divisor: 1 },
+            aPickingColor: { type: "vec3", divisor: 1 },
+            aScale: { type: "float", divisor: 1 }
+        },
+        vertexShader: `precision highp float;
+
+            attribute vec3 aVertexPosition;
+            attribute vec3 aPositionHigh;
+            attribute vec3 aPositionLow;    
+            attribute vec3 aDirection;
+            attribute vec2 aPitchRoll;
+            attribute vec3 aPickingColor;
+            attribute float aScale;
+            
+            uniform vec3 uScaleByDistance;
+            uniform mat4 projectionMatrix;
+            uniform mat4 viewMatrix;
+            uniform float pickingScale;
+            
+            uniform vec3 eyePositionHigh;
+            uniform vec3 eyePositionLow;
+
+            varying vec3 vColor;
+            
+            const float RADIANS = 3.141592653589793 / 180.0;
+
+            void main(void) {
+            
+                vColor = aPickingColor;
+                float roll = aPitchRoll.y * RADIANS;
+                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;
+                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 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;
+
+                mat4 viewMatrixRTE = viewMatrix;
+                viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+
+                gl_Position = projectionMatrix *viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+            }`,
+        fragmentShader:
+            `precision highp float;
+            varying vec3 vColor;
+            void main () {
+                gl_FragColor = vec4(vColor, 1.0);
+            }`
+    });

package/src/og/shaders/pointCloud.js

@@ -1,42 +1,42 @@
-/**
- * @module og/shaders/pointCloud
- */
-
-'use strict';
-
-import { Program } from '../webgl/Program.js';
-import { types } from '../webgl/types.js';
-
-//Picking is the same
-export function pointCloud() {
-    return new Program("pointCloud", {
-        uniforms: {
-            projectionViewMatrix: { type: types.MAT4 },
-            opacity: { type: types.FLOAT },
-            pointSize: { type: types.FLOAT }
-        },
-        attributes: {
-            coordinates: { type: types.VEC3, enableArray: true },
-            colors: { type: types.VEC3, enableArray: true }
-        },
-        vertexShader:
-            `attribute vec3 coordinates;
-            attribute vec4 colors;
-            uniform mat4 projectionViewMatrix;
-            uniform float opacity;
-            uniform float pointSize;
-            varying vec4 color;
-            void main() {
-                color = colors;
-                color.a *= opacity;
-                gl_Position = projectionViewMatrix * vec4(coordinates, 1.0);
-                gl_PointSize = pointSize;
-            }`,
-        fragmentShader:
-            `precision highp float;
-            varying vec4 color;
-            void main(void) {
-                gl_FragColor = color;
-            }`
-    });
+/**
+ * @module og/shaders/pointCloud
+ */
+
+'use strict';
+
+import { Program } from '../webgl/Program.js';
+import { types } from '../webgl/types.js';
+
+//Picking is the same
+export function pointCloud() {
+    return new Program("pointCloud", {
+        uniforms: {
+            projectionViewMatrix: { type: types.MAT4 },
+            opacity: { type: types.FLOAT },
+            pointSize: { type: types.FLOAT }
+        },
+        attributes: {
+            coordinates: { type: types.VEC3, enableArray: true },
+            colors: { type: types.VEC3, enableArray: true }
+        },
+        vertexShader:
+            `attribute vec3 coordinates;
+            attribute vec4 colors;
+            uniform mat4 projectionViewMatrix;
+            uniform float opacity;
+            uniform float pointSize;
+            varying vec4 color;
+            void main() {
+                color = colors;
+                color.a *= opacity;
+                gl_Position = projectionViewMatrix * vec4(coordinates, 1.0);
+                gl_PointSize = pointSize;
+            }`,
+        fragmentShader:
+            `precision highp float;
+            varying vec4 color;
+            void main(void) {
+                gl_FragColor = color;
+            }`
+    });
 }

package/src/og/shaders/shape.js

@@ -2,10 +2,10 @@
  * @module og/shaders/shape
  */
 
-'use strict';
+"use strict";
 
-import { Program } from '../webgl/Program.js';
-import { types } from '../webgl/types.js';
+import { Program } from "../webgl/Program.js";
+import { types } from "../webgl/types.js";
 
 export function shape_wl() {
     return new Program("shape_wl", {
@@ -23,12 +23,11 @@ export function shape_wl() {
             uSampler: { type: types.SAMPLER2D }
         },
         attributes: {
-            aVertexNormal: { type: types.VEC3, enableArray: true },
-            aVertexPosition: { type: types.VEC3, enableArray: true },
-            aTextureCoord: { type: types.VEC2, enableArray: true }
+            aVertexNormal: { type: types.VEC3 },
+            aVertexPosition: { type: types.VEC3 },
+            aTextureCoord: { type: types.VEC2 }
         },
-        vertexShader:
-        `attribute vec3 aVertexNormal;
+        vertexShader: `attribute vec3 aVertexNormal;
             attribute vec3 aVertexPosition;
             attribute vec2 aTextureCoord;
             uniform mat4 projectionMatrix;
@@ -45,8 +44,7 @@ export function shape_wl() {
                 vPosition = viewMatrix * modelMatrix * vec4(aVertexPosition, 1.0);
                 gl_Position = projectionMatrix * vPosition;
             }`,
-        fragmentShader:
-        `precision highp float;
+        fragmentShader: `precision highp float;
             varying vec2 vTextureCoord;
             varying vec3 vNormal;
             varying vec4 vPosition;
@@ -90,8 +88,7 @@ export function shape_nl() {
             aVertexPosition: { type: types.VEC3, enableArray: true },
             aTextureCoord: { type: types.VEC2, enableArray: true }
         },
-        vertexShader:
-        `attribute vec3 aVertexPosition;
+        vertexShader: `attribute vec3 aVertexPosition;
             attribute vec2 aTextureCoord;
             uniform mat4 projectionViewMatrix;
             uniform mat4 modelMatrix;
@@ -101,8 +98,7 @@ export function shape_nl() {
                 gl_Position = projectionViewMatrix * (modelMatrix * vec4(aVertexPosition, 1.0));
                 vTextureCoord = aTextureCoord;
             }`,
-        fragmentShader:
-        `precision highp float;
+        fragmentShader: `precision highp float;
             uniform vec4 uColor;
             uniform sampler2D uSampler;
             varying vec2 vTextureCoord;
@@ -122,16 +118,14 @@ export function shape_picking() {
         attributes: {
             aVertexPosition: { type: types.VEC3, enableArray: true }
         },
-        vertexShader:
-        `attribute vec3 aVertexPosition;
+        vertexShader: `attribute vec3 aVertexPosition;
             uniform mat4 projectionViewMatrix;
             uniform mat4 modelMatrix;
 
             void main(void) {
                 gl_Position = projectionViewMatrix * (modelMatrix * vec4(aVertexPosition, 1.0));
             }`,
-        fragmentShader:
-        `precision highp float;
+        fragmentShader: `precision highp float;
             uniform vec4 uColor;
             uniform sampler2D uSampler;
             void main(void) {

package/src/og/shaders/skybox.js

@@ -1,37 +1,37 @@
-/**
- * @module og/shaders/skybox
- */
-
-'use strict';
-
-import { Program } from '../webgl/Program.js';
-import { types } from '../webgl/types.js';
-
-export function skybox() {
-    return new Program("skybox", {
-        uniforms: {
-            projectionViewMatrix: { type: types.MAT4 },
-            uSampler: { type: types.SAMPLERCUBE },
-            pos: { type: types.VEC3 }
-        },
-        attributes: {
-            aVertexPosition: { type: types.VEC3, enableArray: true }
-        },
-        vertexShader:
-            `attribute vec3 aVertexPosition;
-            uniform mat4 projectionViewMatrix;
-            uniform vec3 pos;
-            varying vec3 vTextureCoord;
-            void main(void) {
-                vTextureCoord = aVertexPosition;
-                gl_Position = projectionViewMatrix * vec4(aVertexPosition + pos, 1.0);
-            }`,
-        fragmentShader:
-            `precision lowp float;
-            varying vec3 vTextureCoord;
-            uniform samplerCube uSampler;
-            void main(void) {
-                gl_FragColor = textureCube(uSampler, vTextureCoord);
-            }`
-    });
+/**
+ * @module og/shaders/skybox
+ */
+
+'use strict';
+
+import { Program } from '../webgl/Program.js';
+import { types } from '../webgl/types.js';
+
+export function skybox() {
+    return new Program("skybox", {
+        uniforms: {
+            projectionViewMatrix: { type: types.MAT4 },
+            uSampler: { type: types.SAMPLERCUBE },
+            pos: { type: types.VEC3 }
+        },
+        attributes: {
+            aVertexPosition: { type: types.VEC3, enableArray: true }
+        },
+        vertexShader:
+            `attribute vec3 aVertexPosition;
+            uniform mat4 projectionViewMatrix;
+            uniform vec3 pos;
+            varying vec3 vTextureCoord;
+            void main(void) {
+                vTextureCoord = aVertexPosition;
+                gl_Position = projectionViewMatrix * vec4(aVertexPosition + pos, 1.0);
+            }`,
+        fragmentShader:
+            `precision lowp float;
+            varying vec3 vTextureCoord;
+            uniform samplerCube uSampler;
+            void main(void) {
+                gl_FragColor = textureCube(uSampler, vTextureCoord);
+            }`
+    });
 }

package/src/og/shaders/toneMapping.js

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