Commit 61a5368f authored by Dario Seyb's avatar Dario Seyb

merged

parents f5e0c822 8411fc1f
This diff is collapsed.
This diff is collapsed.
......@@ -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() {
......
......@@ -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();
......
......@@ -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];
/*
......
#version 410 core
//#pragma import "noise/noise3d.glsl"
//#pragma import "terrain/sphereUV.glsl"
#pragma import "terrain/mountainTexture.glsl"
layout(triangles, equal_spacing, ccw) in;
in vec2 tcTexCoord[];
......@@ -10,186 +14,179 @@ out vec3 tNormal;
out vec2 tTexCoord;
out vec3 tPosition;
//out float tHeight;
out vec3 tUpVector_normalized;
out vec3 tPosInModelspace;
out vec3 tPatchDistance;
uniform mat4 uViewProjectionMatrix;
uniform mat4 uModelMatrix;
uniform vec3 cameraPostion;
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;
}
vec3 fade(vec3 t) {
return t*t*t*(t*(t*6.0-15.0)+10.0);
}
// Classic Perlin noise
float cnoise(vec3 P)
{
vec3 Pi0 = floor(P); // Integer part for indexing
vec3 Pi1 = Pi0 + vec3(1.0); // Integer part + 1
Pi0 = mod289(Pi0);
Pi1 = mod289(Pi1);
vec3 Pf0 = fract(P); // Fractional part for interpolation
vec3 Pf1 = Pf0 - vec3(1.0); // Fractional part - 1.0
vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
vec4 iy = vec4(Pi0.yy, Pi1.yy);
vec4 iz0 = Pi0.zzzz;
vec4 iz1 = Pi1.zzzz;
vec4 ixy = permute(permute(ix) + iy);
vec4 ixy0 = permute(ixy + iz0);
vec4 ixy1 = permute(ixy + iz1);
vec4 gx0 = ixy0 * (1.0 / 7.0);
vec4 gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5;
gx0 = fract(gx0);
vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);
vec4 sz0 = step(gz0, vec4(0.0));
gx0 -= sz0 * (step(0.0, gx0) - 0.5);
gy0 -= sz0 * (step(0.0, gy0) - 0.5);
vec4 gx1 = ixy1 * (1.0 / 7.0);
vec4 gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5;
gx1 = fract(gx1);
vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);
vec4 sz1 = step(gz1, vec4(0.0));
gx1 -= sz1 * (step(0.0, gx1) - 0.5);
gy1 -= sz1 * (step(0.0, gy1) - 0.5);
vec3 g000 = vec3(gx0.x,gy0.x,gz0.x);
vec3 g100 = vec3(gx0.y,gy0.y,gz0.y);
vec3 g010 = vec3(gx0.z,gy0.z,gz0.z);
vec3 g110 = vec3(gx0.w,gy0.w,gz0.w);
vec3 g001 = vec3(gx1.x,gy1.x,gz1.x);
vec3 g101 = vec3(gx1.y,gy1.y,gz1.y);
vec3 g011 = vec3(gx1.z,gy1.z,gz1.z);
vec3 g111 = vec3(gx1.w,gy1.w,gz1.w);
vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
g000 *= norm0.x;
g010 *= norm0.y;
g100 *= norm0.z;
g110 *= norm0.w;
vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
g001 *= norm1.x;
g011 *= norm1.y;
g101 *= norm1.z;
g111 *= norm1.w;
float n000 = dot(g000, Pf0);
float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));
float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));
float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));
float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));
float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));
float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));
float n111 = dot(g111, Pf1);
vec3 fade_xyz = fade(Pf0);
vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);
vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);
float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);
return 2.2 * n_xyz;
}
// Classic Perlin noise, periodic variant
float pnoise(vec3 P, vec3 rep)
{
vec3 Pi0 = mod(floor(P), rep); // Integer part, modulo period
vec3 Pi1 = mod(Pi0 + vec3(1.0), rep); // Integer part + 1, mod period
Pi0 = mod289(Pi0);
Pi1 = mod289(Pi1);
vec3 Pf0 = fract(P); // Fractional part for interpolation
vec3 Pf1 = Pf0 - vec3(1.0); // Fractional part - 1.0
vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
vec4 iy = vec4(Pi0.yy, Pi1.yy);
vec4 iz0 = Pi0.zzzz;
vec4 iz1 = Pi1.zzzz;
vec4 ixy = permute(permute(ix) + iy);
vec4 ixy0 = permute(ixy + iz0);
vec4 ixy1 = permute(ixy + iz1);
vec4 gx0 = ixy0 * (1.0 / 7.0);
vec4 gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5;
gx0 = fract(gx0);
vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);
vec4 sz0 = step(gz0, vec4(0.0));
gx0 -= sz0 * (step(0.0, gx0) - 0.5);
gy0 -= sz0 * (step(0.0, gy0) - 0.5);
vec4 gx1 = ixy1 * (1.0 / 7.0);
vec4 gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5;
gx1 = fract(gx1);
vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);
vec4 sz1 = step(gz1, vec4(0.0));
gx1 -= sz1 * (step(0.0, gx1) - 0.5);
gy1 -= sz1 * (step(0.0, gy1) - 0.5);
vec3 g000 = vec3(gx0.x,gy0.x,gz0.x);
vec3 g100 = vec3(gx0.y,gy0.y,gz0.y);
vec3 g010 = vec3(gx0.z,gy0.z,gz0.z);
vec3 g110 = vec3(gx0.w,gy0.w,gz0.w);
vec3 g001 = vec3(gx1.x,gy1.x,gz1.x);
vec3 g101 = vec3(gx1.y,gy1.y,gz1.y);
vec3 g011 = vec3(gx1.z,gy1.z,gz1.z);
vec3 g111 = vec3(gx1.w,gy1.w,gz1.w);
vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
g000 *= norm0.x;
g010 *= norm0.y;
g100 *= norm0.z;
g110 *= norm0.w;
vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
g001 *= norm1.x;
g011 *= norm1.y;
g101 *= norm1.z;
g111 *= norm1.w;
float n000 = dot(g000, Pf0);
float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));
float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));
float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));
float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));
float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));
float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));
float n111 = dot(g111, Pf1);
vec3 fade_xyz = fade(Pf0);
vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);
vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);
float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);
return 2.2 * n_xyz;
}
float fBM(vec3 p, int fOct, float freq, float weight){
float fValue = 0.0;
for(int i = 0; i <= fOct; i++){
fValue += cnoise(freq * p) * weight;
weight *= 0.5;
freq *= 2.0;
}
return fValue;
}
//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;
//}
//vec3 fade(vec3 t) {
// return t*t*t*(t*(t*6.0-15.0)+10.0);
//}
//// Classic Perlin noise
//float cnoise(vec3 P)
//{
// vec3 Pi0 = floor(P); // Integer part for indexing
// vec3 Pi1 = Pi0 + vec3(1.0); // Integer part + 1
// Pi0 = mod289(Pi0);
// Pi1 = mod289(Pi1);
// vec3 Pf0 = fract(P); // Fractional part for interpolation
// vec3 Pf1 = Pf0 - vec3(1.0); // Fractional part - 1.0
// vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
// vec4 iy = vec4(Pi0.yy, Pi1.yy);
// vec4 iz0 = Pi0.zzzz;
// vec4 iz1 = Pi1.zzzz;
// vec4 ixy = permute(permute(ix) + iy);
// vec4 ixy0 = permute(ixy + iz0);
// vec4 ixy1 = permute(ixy + iz1);
// vec4 gx0 = ixy0 * (1.0 / 7.0);
// vec4 gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5;
// gx0 = fract(gx0);
// vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);
// vec4 sz0 = step(gz0, vec4(0.0));
// gx0 -= sz0 * (step(0.0, gx0) - 0.5);
// gy0 -= sz0 * (step(0.0, gy0) - 0.5);
// vec4 gx1 = ixy1 * (1.0 / 7.0);
// vec4 gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5;
// gx1 = fract(gx1);
// vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);
// vec4 sz1 = step(gz1, vec4(0.0));
// gx1 -= sz1 * (step(0.0, gx1) - 0.5);
// gy1 -= sz1 * (step(0.0, gy1) - 0.5);
// vec3 g000 = vec3(gx0.x,gy0.x,gz0.x);
// vec3 g100 = vec3(gx0.y,gy0.y,gz0.y);
// vec3 g010 = vec3(gx0.z,gy0.z,gz0.z);
// vec3 g110 = vec3(gx0.w,gy0.w,gz0.w);
// vec3 g001 = vec3(gx1.x,gy1.x,gz1.x);
// vec3 g101 = vec3(gx1.y,gy1.y,gz1.y);
// vec3 g011 = vec3(gx1.z,gy1.z,gz1.z);
// vec3 g111 = vec3(gx1.w,gy1.w,gz1.w);
// vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
// g000 *= norm0.x;
// g010 *= norm0.y;
// g100 *= norm0.z;
// g110 *= norm0.w;
// vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
// g001 *= norm1.x;
// g011 *= norm1.y;
// g101 *= norm1.z;
// g111 *= norm1.w;
// float n000 = dot(g000, Pf0);
// float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));
// float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));
// float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));
// float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));
// float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));
// float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));
// float n111 = dot(g111, Pf1);
// vec3 fade_xyz = fade(Pf0);
// vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);
// vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);
// float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);
// return 2.2 * n_xyz;
//}
//// Classic Perlin noise, periodic variant
//float pnoise(vec3 P, vec3 rep)
//{
// vec3 Pi0 = mod(floor(P), rep); // Integer part, modulo period
// vec3 Pi1 = mod(Pi0 + vec3(1.0), rep); // Integer part + 1, mod period
// Pi0 = mod289(Pi0);
// Pi1 = mod289(Pi1);
// vec3 Pf0 = fract(P); // Fractional part for interpolation
// vec3 Pf1 = Pf0 - vec3(1.0); // Fractional part - 1.0
// vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
// vec4 iy = vec4(Pi0.yy, Pi1.yy);
// vec4 iz0 = Pi0.zzzz;
// vec4 iz1 = Pi1.zzzz;
// vec4 ixy = permute(permute(ix) + iy);
// vec4 ixy0 = permute(ixy + iz0);
// vec4 ixy1 = permute(ixy + iz1);
// vec4 gx0 = ixy0 * (1.0 / 7.0);
// vec4 gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5;
// gx0 = fract(gx0);
// vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);
// vec4 sz0 = step(gz0, vec4(0.0));
// gx0 -= sz0 * (step(0.0, gx0) - 0.5);
// gy0 -= sz0 * (step(0.0, gy0) - 0.5);
// vec4 gx1 = ixy1 * (1.0 / 7.0);
// vec4 gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5;
// gx1 = fract(gx1);
// vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);
// vec4 sz1 = step(gz1, vec4(0.0));
// gx1 -= sz1 * (step(0.0, gx1) - 0.5);
// gy1 -= sz1 * (step(0.0, gy1) - 0.5);
// vec3 g000 = vec3(gx0.x,gy0.x,gz0.x);
// vec3 g100 = vec3(gx0.y,gy0.y,gz0.y);
// vec3 g010 = vec3(gx0.z,gy0.z,gz0.z);
// vec3 g110 = vec3(gx0.w,gy0.w,gz0.w);
// vec3 g001 = vec3(gx1.x,gy1.x,gz1.x);
// vec3 g101 = vec3(gx1.y,gy1.y,gz1.y);
// vec3 g011 = vec3(gx1.z,gy1.z,gz1.z);
// vec3 g111 = vec3(gx1.w,gy1.w,gz1.w);
// vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
// g000 *= norm0.x;
// g010 *= norm0.y;
// g100 *= norm0.z;
// g110 *= norm0.w;
// vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
// g001 *= norm1.x;
// g011 *= norm1.y;
// g101 *= norm1.z;
// g111 *= norm1.w;
// float n000 = dot(g000, Pf0);
// float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));
// float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));
// float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));
// float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));
// float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));
// float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));
// float n111 = dot(g111, Pf1);
// vec3 fade_xyz = fade(Pf0);
// vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);
// vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);
// float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);
// return 2.2 * n_xyz;
//}
vec2 interpolate2D(vec2 v0, vec2 v1, vec2 v2){
......@@ -206,15 +203,22 @@ void main(){
tNormal = interpolate3D(tcNormal[0], tcNormal[1], tcNormal[2]);
tTexCoord = interpolate2D(tcTexCoord[0], tcTexCoord[1], tcTexCoord[2]);
tNormal = normalize(tNormal);
tUpVector_normalized = tNormal;
tPatchDistance = gl_TessCoord;
tPosition = interpolate3D(tcPosition[0], tcPosition[1], tcPosition[2]);
tPosInModelspace = tPosition;
tPosition = normalize(tPosition);
//vec4 camWorld = uModelMatrix * vec4(tPosition, 1.0);
tPosition += tNormal * fBM( tPosition , 8, 80, 0.003) ;
//tTexCoord = vec2(calculateU(tPosition), calculateV(tPosition));
//float noiseValue = sumUpOctaves_3d( tPosition , 8, 80.);
tPosition = mountain_getDisplacedPosition_modelspace(tPosition, tNormal);
//tHeight = noiseValue;
//tPosition += tNormal * re1() ;
//tNormal = inverse(transpose(mat3(uModelMatrix))) * normalize(tNormal);
tPosition = (uModelMatrix * vec4(tPosition, 1)).xyz;
......
//===============================================================================================
//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;
}
//===============================================================================================
//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);