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];
/*
......
This diff is collapsed.
//===============================================================================================
//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);
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;
}
//===============================================================================================
//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;
}
#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 {