merged

data/shader/DispMapping.fsh

@@ -2,6 +2,11 @@
 
 #pragma import "CommonDeferredFrag.glsl"
 #pragma import "Utils.glsl"
+#pragma import "terrain/mountainTexture.glsl"
+
+in vec3 gUpVector_normalized;
+in vec3 gPosInModelspace;
+
 
 float amplify(float d, float scale, float offset){
   d = scale * d + offset;
@@ -11,9 +16,8 @@ float amplify(float d, float scale, float offset){
 }
 
 vec4 color() {
-  vec4 color = texture(uTexture, gTexCoord).rgba * uTintColor;
-  color.rgb *= 0.2;
-  return color;
+  vec4 color = mountainTex_getColor(gPosInModelspace, gUpVector_normalized, oNormal);
+
   float d1 = min(min(gTriDistance.x, gTriDistance.y), gTriDistance.z);
   float d2 = min(min(gPatchDistance.x, gPatchDistance.y), gPatchDistance.z);
   color = amplify(d1, 80, -0.5) * amplify(d2, 120, -0.5) * color;
@@ -26,7 +30,7 @@ vec4 emissive() {
 }
 
 vec3 normal() {
-  return gNormal;
+  return approximateTerrainNormal(normalize(gPosInModelspace));
 }
 
 vec4 specularSmoothness() {

data/shader/DispMapping.gsh

@@ -9,10 +9,19 @@ in vec3 tPatchDistance[3];
 in vec3 tNormal[3];
 in vec2 tTexCoord[3];
 
+//in float tHeight[3];
+in vec3 tUpVector_normalized[3];
+in vec3 tPosInModelspace[3];
+
 out vec3 gNormal;
 out vec3 gPosition;
 out vec2 gTexCoord;
 
+//out float gHeight;
+//out float gSurfaceAngle;
+out vec3 gUpVector_normalized;
+out vec3 gPosInModelspace;
+
 out vec3 gPatchDistance;
 out vec3 gTriDistance;
 
@@ -27,6 +36,11 @@ void main()
     gTexCoord = tTexCoord[0];
     gPosition = tPosition[0];
 
+    //gHeight = tHeight[0];
+    //gSurfaceAngle = acos(dot(gNormal, tUpVector[0]));
+    gUpVector_normalized = tUpVector_normalized[0];
+    gPosInModelspace = tPosInModelspace[0];
+
     gTriDistance = vec3(1, 0, 0);
     gl_Position = gl_in[0].gl_Position; EmitVertex();
 
@@ -34,6 +48,11 @@ void main()
     gTexCoord = tTexCoord[1];
     gPosition = tPosition[1];
 
+    //gHeight = tHeight[1];
+    //gSurfaceAngle = acos(dot(gNormal, tUpVector[1]));
+    gUpVector_normalized = tUpVector_normalized[1];
+    gPosInModelspace = tPosInModelspace[1];
+
     gPatchDistance = tPatchDistance[1];
     gTriDistance = vec3(0, 1, 0);
     gl_Position = gl_in[1].gl_Position; EmitVertex();
@@ -42,6 +61,11 @@ void main()
     gTexCoord = tTexCoord[2];
     gPosition = tPosition[2];
 
+    //gHeight = tHeight[2];
+    //gSurfaceAngle = acos(dot(gNormal, tUpVector[2]));
+    gUpVector_normalized = tUpVector_normalized[2];
+    gPosInModelspace = tPosInModelspace[2];
+
     gPatchDistance = tPatchDistance[2];
     gTriDistance = vec3(0, 0, 1);
     gl_Position = gl_in[2].gl_Position; EmitVertex();

data/shader/DispMapping.tcsh

@@ -59,9 +59,9 @@ void main(){
 	    float d1 = distance(cameraPosition, (uModelMatrix * vec4(tcPosition[1], 1)).xyz );
 	    float d2 = distance(cameraPosition, (uModelMatrix * vec4(tcPosition[2], 1)).xyz );
 
-		gl_TessLevelOuter[0] = getTessLevel(d1, d2);
-	    gl_TessLevelOuter[1] = getTessLevel(d2, d0);
-	    gl_TessLevelOuter[2] = getTessLevel(d0, d1);
+                gl_TessLevelOuter[0] = getTessLevel(d1, d2)*2;
+            gl_TessLevelOuter[1] = getTessLevel(d2, d0)*2;
+            gl_TessLevelOuter[2] = getTessLevel(d0, d1)*2;
 	    gl_TessLevelInner[0] = 0.5 * gl_TessLevelOuter[2];
 
 	    /*

data/shader/noise/noise2d.glsl

+//===============================================================================================
+//The following code is taken from:
+//https://github.com/ashima/webgl-noise/blob/master/src/noise2D.glsl
+// (21.12.2015)
+//===============================================================================================
+
+//
+// Description : Array and textureless GLSL 2D simplex noise function.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : ijm
+//     Lastmod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+//
+
+vec3 mod289(vec3 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec2 mod289(vec2 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec3 permute(vec3 x) {
+  return mod289(((x*34.0)+1.0)*x);
+}
+
+float snoise(vec2 v)
+  {
+  const vec4 C = vec4(0.211324865405187,  // (3.0-sqrt(3.0))/6.0
+                      0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)
+                     -0.577350269189626,  // -1.0 + 2.0 * C.x
+                      0.024390243902439); // 1.0 / 41.0
+// First corner
+  vec2 i  = floor(v + dot(v, C.yy) );
+  vec2 x0 = v -   i + dot(i, C.xx);
+
+// Other corners
+  vec2 i1;
+  //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
+  //i1.y = 1.0 - i1.x;
+  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+  // x0 = x0 - 0.0 + 0.0 * C.xx ;
+  // x1 = x0 - i1 + 1.0 * C.xx ;
+  // x2 = x0 - 1.0 + 2.0 * C.xx ;
+  vec4 x12 = x0.xyxy + C.xxzz;
+  x12.xy -= i1;
+
+// Permutations
+  i = mod289(i); // Avoid truncation effects in permutation
+  vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+                + i.x + vec3(0.0, i1.x, 1.0 ));
+
+  vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
+  m = m*m ;
+  m = m*m ;
+
+// Gradients: 41 points uniformly over a line, mapped onto a diamond.
+// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+
+  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+  vec3 h = abs(x) - 0.5;
+  vec3 ox = floor(x + 0.5);
+  vec3 a0 = x - ox;
+
+// Normalise gradients implicitly by scaling m
+// Approximation of: m *= inversesqrt( a0*a0 + h*h );
+  m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
+
+// Compute final noise value at P
+  vec3 g;
+  g.x  = a0.x  * x0.x  + h.x  * x0.y;
+  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+  return 130.0 * dot(m, g);
+}
+
+
+//================================
+// function based on:
+// https://github.com/ashima/webgl-noise/blob/master/demo/common/noisedemoMain.frag
+// (13.12.2015)
+//================================
+float fbm_2d(vec2 coords, int numberOfOcts, float freq){
+        float fValue = 0.0;
+        float weight = 0.5;
+        for(int i = 0; i < numberOfOcts; i++){
+                fValue += snoise(freq * coords) * weight;
+                weight *= 0.5;
+                freq *= 2.0;
+        }
+        return fValue;
+}
+

data/shader/noise/noise3d.glsl

+//===============================================================================================
+//The following code is taken from:
+//https://github.com/ashima/webgl-noise/blob/master/src/noise3D.glsl
+// (21.12.2015)
+//===============================================================================================
+
+
+//
+// Description : Array and textureless GLSL 2D/3D/4D simplex
+//               noise functions.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : ijm
+//     Lastmod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+//
+
+vec3 mod289(vec3 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec4 mod289(vec4 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec4 permute(vec4 x) {
+     return mod289(((x*34.0)+1.0)*x);
+}
+
+vec4 taylorInvSqrt(vec4 r)
+{
+  return 1.79284291400159 - 0.85373472095314 * r;
+}
+
+float snoise(vec3 v)
+  {
+  const vec2  C = vec2(1.0/6.0, 1.0/3.0) ;
+  const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);
+
+// First corner
+  vec3 i  = floor(v + dot(v, C.yyy) );
+  vec3 x0 =   v - i + dot(i, C.xxx) ;
+
+// Other corners
+  vec3 g = step(x0.yzx, x0.xyz);
+  vec3 l = 1.0 - g;
+  vec3 i1 = min( g.xyz, l.zxy );
+  vec3 i2 = max( g.xyz, l.zxy );
+
+  //   x0 = x0 - 0.0 + 0.0 * C.xxx;
+  //   x1 = x0 - i1  + 1.0 * C.xxx;
+  //   x2 = x0 - i2  + 2.0 * C.xxx;
+  //   x3 = x0 - 1.0 + 3.0 * C.xxx;
+  vec3 x1 = x0 - i1 + C.xxx;
+  vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
+  vec3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y
+
+// Permutations
+  i = mod289(i);
+  vec4 p = permute( permute( permute(
+             i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
+           + i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
+           + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
+
+// Gradients: 7x7 points over a square, mapped onto an octahedron.
+// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
+  float n_ = 0.142857142857; // 1.0/7.0
+  vec3  ns = n_ * D.wyz - D.xzx;
+
+  vec4 j = p - 49.0 * floor(p * ns.z * ns.z);  //  mod(p,7*7)
+
+  vec4 x_ = floor(j * ns.z);
+  vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)
+
+  vec4 x = x_ *ns.x + ns.yyyy;
+  vec4 y = y_ *ns.x + ns.yyyy;
+  vec4 h = 1.0 - abs(x) - abs(y);
+
+  vec4 b0 = vec4( x.xy, y.xy );
+  vec4 b1 = vec4( x.zw, y.zw );
+
+  //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
+  //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
+  vec4 s0 = floor(b0)*2.0 + 1.0;
+  vec4 s1 = floor(b1)*2.0 + 1.0;
+  vec4 sh = -step(h, vec4(0.0));
+
+  vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
+  vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
+
+  vec3 p0 = vec3(a0.xy,h.x);
+  vec3 p1 = vec3(a0.zw,h.y);
+  vec3 p2 = vec3(a1.xy,h.z);
+  vec3 p3 = vec3(a1.zw,h.w);
+
+//Normalise gradients
+  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
+  p0 *= norm.x;
+  p1 *= norm.y;
+  p2 *= norm.z;
+  p3 *= norm.w;
+
+// Mix final noise value
+  vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
+  m = m * m;
+  return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1),
+                                dot(p2,x2), dot(p3,x3) ) );
+  }
+
+
+
+//================================
+// function based on:
+// https://github.com/ashima/webgl-noise/blob/master/demo/common/noisedemoMain.frag
+// (13.12.2015)
+//================================
+//float sumUpOctavesSimple_3d(vec3 coords, int numberOfOcts) {
+//    // coords to be given in range [0., 1.]
+//   return sumUpOctaves_3d(coords, numberOfOcts, 1., .5);
+//}
+
+float fbm_3d(vec3 coords, int numberOfOcts, float freq){
+        float fValue = 0.0;
+        float weight = .5;
+        for(int i = 0; i < numberOfOcts; i++){
+                fValue += snoise(freq * coords) * weight;
+                weight *= 0.5;
+                freq *= 2.0;
+        }
+        return fValue;
+}
+

data/shader/noise/noise4d.glsl

+//===============================================================================================
+//The following code is taken from:
+//https://github.com/ashima/webgl-noise/blob/master/src/noise4D.glsl
+// (21.12.2015)
+//===============================================================================================
+
+//
+// Description : Array and textureless GLSL 2D/3D/4D simplex
+//               noise functions.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : ijm
+//     Lastmod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+//
+
+vec4 mod289(vec4 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0; }
+
+float mod289(float x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0; }
+
+vec4 permute(vec4 x) {
+     return mod289(((x*34.0)+1.0)*x);
+}
+
+float permute(float x) {
+     return mod289(((x*34.0)+1.0)*x);
+}
+
+vec4 taylorInvSqrt(vec4 r)
+{
+  return 1.79284291400159 - 0.85373472095314 * r;
+}
+
+float taylorInvSqrt(float r)
+{
+  return 1.79284291400159 - 0.85373472095314 * r;
+}
+
+vec4 grad4(float j, vec4 ip)
+  {
+  const vec4 ones = vec4(1.0, 1.0, 1.0, -1.0);
+  vec4 p,s;
+
+  p.xyz = floor( fract (vec3(j) * ip.xyz) * 7.0) * ip.z - 1.0;
+  p.w = 1.5 - dot(abs(p.xyz), ones.xyz);
+  s = vec4(lessThan(p, vec4(0.0)));
+  p.xyz = p.xyz + (s.xyz*2.0 - 1.0) * s.www;
+
+  return p;
+  }
+
+// (sqrt(5) - 1)/4 = F4, used once below
+#define F4 0.309016994374947451
+
+float snoise(vec4 v)
+  {
+  const vec4  C = vec4( 0.138196601125011,  // (5 - sqrt(5))/20  G4
+                        0.276393202250021,  // 2 * G4
+                        0.414589803375032,  // 3 * G4
+                       -0.447213595499958); // -1 + 4 * G4
+
+// First corner
+  vec4 i  = floor(v + dot(v, vec4(F4)) );
+  vec4 x0 = v -   i + dot(i, C.xxxx);
+
+// Other corners
+
+// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
+  vec4 i0;
+  vec3 isX = step( x0.yzw, x0.xxx );
+  vec3 isYZ = step( x0.zww, x0.yyz );
+//  i0.x = dot( isX, vec3( 1.0 ) );
+  i0.x = isX.x + isX.y + isX.z;
+  i0.yzw = 1.0 - isX;
+//  i0.y += dot( isYZ.xy, vec2( 1.0 ) );
+  i0.y += isYZ.x + isYZ.y;
+  i0.zw += 1.0 - isYZ.xy;
+  i0.z += isYZ.z;
+  i0.w += 1.0 - isYZ.z;
+
+  // i0 now contains the unique values 0,1,2,3 in each channel
+  vec4 i3 = clamp( i0, 0.0, 1.0 );
+  vec4 i2 = clamp( i0-1.0, 0.0, 1.0 );
+  vec4 i1 = clamp( i0-2.0, 0.0, 1.0 );
+
+  //  x0 = x0 - 0.0 + 0.0 * C.xxxx
+  //  x1 = x0 - i1  + 1.0 * C.xxxx
+  //  x2 = x0 - i2  + 2.0 * C.xxxx
+  //  x3 = x0 - i3  + 3.0 * C.xxxx
+  //  x4 = x0 - 1.0 + 4.0 * C.xxxx
+  vec4 x1 = x0 - i1 + C.xxxx;
+  vec4 x2 = x0 - i2 + C.yyyy;
+  vec4 x3 = x0 - i3 + C.zzzz;
+  vec4 x4 = x0 + C.wwww;
+
+// Permutations
+  i = mod289(i);
+  float j0 = permute( permute( permute( permute(i.w) + i.z) + i.y) + i.x);
+  vec4 j1 = permute( permute( permute( permute (
+             i.w + vec4(i1.w, i2.w, i3.w, 1.0 ))
+           + i.z + vec4(i1.z, i2.z, i3.z, 1.0 ))
+           + i.y + vec4(i1.y, i2.y, i3.y, 1.0 ))
+           + i.x + vec4(i1.x, i2.x, i3.x, 1.0 ));
+
+// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
+// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
+  vec4 ip = vec4(1.0/294.0, 1.0/49.0, 1.0/7.0, 0.0) ;
+
+  vec4 p0 = grad4(j0,   ip);
+  vec4 p1 = grad4(j1.x, ip);
+  vec4 p2 = grad4(j1.y, ip);
+  vec4 p3 = grad4(j1.z, ip);
+  vec4 p4 = grad4(j1.w, ip);
+
+// Normalise gradients
+  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
+  p0 *= norm.x;
+  p1 *= norm.y;
+  p2 *= norm.z;
+  p3 *= norm.w;
+  p4 *= taylorInvSqrt(dot(p4,p4));
+
+// Mix contributions from the five corners
+  vec3 m0 = max(0.6 - vec3(dot(x0,x0), dot(x1,x1), dot(x2,x2)), 0.0);
+  vec2 m1 = max(0.6 - vec2(dot(x3,x3), dot(x4,x4)            ), 0.0);
+  m0 = m0 * m0;
+  m1 = m1 * m1;
+  return 49.0 * ( dot(m0*m0, vec3( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 )))
+               + dot(m1*m1, vec2( dot( p3, x3 ), dot( p4, x4 ) ) ) ) ;
+
+  }
+
+
+//================================
+// function based on:
+// https://github.com/ashima/webgl-noise/blob/master/demo/common/noisedemoMain.frag
+// (13.12.2015)
+//================================
+float sumUpOctavesSimple_4d(vec4 coords, int numberOfOcts) {
+    // coords to be given in range [0., 1.]
+
+    float frequencyFactor = 1.;
+    float weight = 0.5;
+    float noiseValue = 0.;
+    for (int i = 0; i < numberOfOcts; i++) {
+        noiseValue += weight * snoise(frequencyFactor * coords);
+        weight = weight / 2.;
+        frequencyFactor = frequencyFactor * 2;
+    }
+    return noiseValue;
+
+}

data/shader/terrain/mountainTexture.glsl

+#pragma import "../noise/noise3d.glsl"
+
+//needed for calculation of modified normal-vector; change until you get a good result for normals:
+#define SAMPLE_ANGLE__NORMAL_VECTOR 0.0005
+#define M_PI 3.1415926535897932384626433832795
+
+float mountain_getHeight(vec3 normalizedPosInModelspace) {
+    return (fbm_3d( normalizedPosInModelspace , 4, 80.) + fbm_3d (normalizedPosInModelspace , 2, 5.))/2.;
+}
+
+
+vec3 calcGrass(float noiseVal1, float noiseVal2, float phiN, float height) {
+
+    return noiseVal1 * vec3(.1, .7, .1);
+}
+
+vec4 mountainTex_getColor(vec3 texCoord3d, vec3 upVectorNormalized, vec3 normalNormalized){
+    float noiseVal1 = fbm_3d( texCoord3d,6, 128.*128.);// * 0.05;
+    vec3 distortion = vec3 (.1, .1, .1);
+    float noiseVal2 = fbm_3d( texCoord3d, 4, 8*128.*128.);// * 0.05;
+    float noiseVal3 = fbm_3d( texCoord3d + distortion, 4, 8*128.*128.);// * 0.05;
+    vec4 color = vec4(1., 1., 1., 1.);
+
+    float height = mountain_getHeight(texCoord3d)*.9 + noiseVal2 * .1;
+
+
+    //color = vec4(normalNormalized.x,normalNormalized.y, normalNormalized.z, 1.);
+    //color = vec4(upVectorNormalized.x,upVectorNormalized.y, upVectorNormalized.z, 1.);
+    float dt = dot(normalNormalized, upVectorNormalized);
+    float cs = dt / (length(normalNormalized) * length(upVectorNormalized));
+    float phi = acos(dt);
+    float phiNormalized = 2*phi / M_PI; //scale results from [0, M_PI/2] to [0, 1]
+    float c = noiseVal1*.3 +.3;
+
+    float phiPert = .9*phiNormalized + .1 * noiseVal3;
+
+//    if (height < .3) {
+//        color = vec4(c ,c, c,.2);
+//    } else {
+//        if (phiNormalized <= .1) {
+//            color = vec4(c ,c, c,1.);
+//        } else {
+//            c += (1. - phiNormalized) * .5;
+//            color = vec4(c ,c, c,1.);
+//        }
+//    }
+    //vec3 plants = calcGrass(noiseVal1, noiseVal2, phiNormalized, height);
+    //vec3 rock = noiseVal2 * vec3(.3, .3, .3);
+    //plants = rock;
+    //float grassAmount = (2. - phiNormalized - height) / 2.;
+    //plants = (grassAmount) * plants + (1.-grassAmount * rock);
+
+    //return vec4(plants.x, plants.y, plants.z, 1.);
+    //return vec4(.2, (1.-height), .2, 1.);
+
+//    if (phiNormalized < .7) {
+//        color = vec4(0.,(1.-phiNormalized)*.5 + noiseVal1 * .5, 0.,1.);
+//    } else {
+//        if (phiNormalized <= .1) {
+//            color = vec4(c ,c, c,1.);
+//        } else {
+//            c += (1. - phiNormalized) * .5;
+//            color = vec4(c ,c, c,1.);
+//        }
+//    }
+
+//    return color;
+
+
+    if (height> .3 || phiPert > .6) {
+        color = vec4(.1, .1, .1, 1.);
+
+    } else {
+        color = vec4(.2, .6,.2, 1.) * noiseVal1;
+    }
+    return color;
+}
+
+
+
+
+vec3 mountain_getDisplacedPosition_modelspace(vec3 normalizedPosInModelspace, vec3 normalizedNormal) {
+    float noiseValue = mountain_getHeight(normalizedPosInModelspace);
+    vec3 newPosition = normalizedPosInModelspace + normalizedNormal * 0.008 * noiseValue;
+    return newPosition;
+}
+
+//================================ NORMAL APROXIMATION: ==========0
+
+//================================
+// function taken from:
+// http://www.neilmendoza.com/glsl-rotation-about-an-arbitrary-axis/
+// (14.12.2015)
+//================================
+// The following functions are just needed for calculating the modified normal-vectors of the z-displaced vertex;
+// When calculating the normals in a smarter way, they may not be needed anymore..
+//================================
+
+mat4 rotationMatrix4d(vec3 axis, float angle)
+{
+    axis = normalize(axis);
+    float s = sin(angle);
+    float c = cos(angle);
+    float oc = 1.0 - c;
+
+    return mat4(oc * axis.x * axis.x + c,           oc * axis.x * axis.y - axis.z * s,  oc * axis.z * axis.x + axis.y * s,  0.0,
+                oc * axis.x * axis.y + axis.z * s,  oc * axis.y * axis.y + c,           oc * axis.y * axis.z - axis.x * s,  0.0,
+                oc * axis.z * axis.x - axis.y * s,  oc * axis.y * axis.z + axis.x * s,  oc * axis.z * axis.z + c,           0.0,
+                0.0,                                0.0,                                0.0,                                1.0);
+}
+
+//modified version to get 3d-matrix:
+mat3 rotationMatrix3d(vec3 axis, float angle)
+{
+    axis = normalize(axis);
+    float s = sin(angle);
+    float c = cos(angle);
+    float oc = 1.0 - c;
+
+    return mat3(oc * axis.x * axis.x + c,           oc * axis.x * axis.y - axis.z * s,  oc * axis.z * axis.x + axis.y * s,
+                oc * axis.x * axis.y + axis.z * s,  oc * axis.y * axis.y + c,           oc * axis.y * axis.z - axis.x * s,
+                oc * axis.z * axis.x - axis.y * s,  oc * axis.y * axis.z + axis.x * s,  oc * axis.z * axis.z + c           );
+}
+//================================
+
+//================================
+// Returns a vector orthogonal tu the given one. (used for normal-vector calculation)
+vec3 calculateOrthogonalVector(vec3 originalVector) {
+    if (originalVector.z == 0) {
+        return vec3(0., 0., 1.);
+    } else {