Improved parallax mapping. Generate heightmaps on the fly.

4 files changed, 156 insertions, 98 deletions

diff --git a/client/shaders/nodes_shader/opengl_fragment.glsl b/client/shaders/nodes_shader/opengl_fragment.glsl
index 6dc96eb48..066e49658 100644
--- a/client/shaders/nodes_shader/opengl_fragment.glsl
+++ b/client/shaders/nodes_shader/opengl_fragment.glsl
@@ -8,6 +8,7 @@ uniform vec3 eyePosition;
 
 varying vec3 vPosition;
 varying vec3 worldPosition;
+varying float generate_heightmaps;
 
 varying vec3 eyeVec;
 varying vec3 tsEyeVec;
@@ -19,80 +20,135 @@ bool normalTexturePresent = false;
 const float e = 2.718281828459;
 const float BS = 10.0;
  
-float intensity (vec3 color){
+float intensity (vec3 color)
+{
 	return (color.r + color.g + color.b) / 3.0;
 }
 
-float get_rgb_height (vec2 uv){
+float get_rgb_height (vec2 uv)
+{
 	return intensity(texture2D(baseTexture,uv).rgb);
 }
 
-vec4 get_normal_map(vec2 uv){
+vec4 get_normal_map(vec2 uv)
+{
 	vec4 bump = texture2D(normalTexture, uv).rgba;
-	bump.xyz = normalize(bump.xyz * 2.0 -1.0);
-	bump.y = -bump.y;
+	bump.xyz = normalize(bump.xyz * 2.0 - 1.0);
 	return bump;
 }
 
+float find_intersection(vec2 dp, vec2 ds)
+{
+	const int linear_steps = 10;
+	const int binary_steps = 5;
+	const float depth_step = 1.0 / linear_steps;
+	float size = depth_step;
+	float depth = 1.0;
+	float best_depth = 1.0;
+	for (int i = 0 ; i < linear_steps - 1 ; ++i) {
+		vec4 t = texture2D(normalTexture, dp + ds * depth);
+		if (best_depth > 0.05)
+			if (depth >= t.a)
+				best_depth = depth;
+		depth -= size;
+	}
+	depth = best_depth - size;
+	for (int i = 0 ; i < binary_steps ; ++i) {
+		size *= 0.5;
+		vec4 t = texture2D(normalTexture, dp + ds * depth);
+		if (depth >= t.a) {
+			best_depth = depth;
+			depth -= 2 * size;
+		}
+		depth += size;
+	}
+	return best_depth;
+}
+
+float find_intersectionRGB(vec2 dp, vec2 ds) {
+	const float iterations = 24;
+	const float depth_step = 1.0 / iterations;
+	float depth = 1.0;
+	for (int i = 0 ; i < iterations ; i++) {
+		float h = get_rgb_height(dp + ds * depth);
+		if (h >= depth)
+			break;
+		depth -= depth_step;
+	}
+	return depth;
+}
+
 void main (void)
 {
 	vec3 color;
 	vec4 bump;
 	vec2 uv = gl_TexCoord[0].st;
 	bool use_normalmap = false;
-	
+
 #ifdef USE_NORMALMAPS
-	if (texture2D(useNormalmap,vec2(1.0,1.0)).r > 0.0){
+	if (texture2D(useNormalmap,vec2(1.0, 1.0)).r > 0.0) {
 		normalTexturePresent = true;
 	}
 #endif
 
 #ifdef ENABLE_PARALLAX_OCCLUSION
-	if (normalTexturePresent){
-		vec3 tsEye = normalize(tsEyeVec);
-		float height = PARALLAX_OCCLUSION_SCALE * texture2D(normalTexture, uv).a - PARALLAX_OCCLUSION_BIAS;
-		uv = uv + texture2D(normalTexture, uv).z * height * vec2(tsEye.x,-tsEye.y);
+	vec3 eyeRay = normalize(tsEyeVec);
+#if PARALLAX_OCCLUSION_MODE == 0
+	// Parallax occlusion with slope information
+	if (normalTexturePresent) {
+		const float scale = PARALLAX_OCCLUSION_SCALE / PARALLAX_OCCLUSION_ITERATIONS;
+		const float bias = PARALLAX_OCCLUSION_BIAS / PARALLAX_OCCLUSION_ITERATIONS;
+		for(int i = 0; i < PARALLAX_OCCLUSION_ITERATIONS; i++) {
+			vec4 normal = texture2D(normalTexture, uv.xy);
+			float h = normal.a * scale - bias;
+			uv += h * normal.z * eyeRay.xy;
+		}
+#endif
+#if PARALLAX_OCCLUSION_MODE == 1
+	// Relief mapping
+	if (normalTexturePresent) {
+		vec2 ds = eyeRay.xy * PARALLAX_OCCLUSION_SCALE;
+		float dist = find_intersection(uv, ds);
+		uv += dist * ds;
+#endif
+	} else if (generate_heightmaps > 0.0) {
+		vec2 ds = eyeRay.xy * PARALLAX_OCCLUSION_SCALE;
+		float dist = find_intersectionRGB(uv, ds);
+		uv += dist * ds;
 	}
 #endif
 
 #ifdef USE_NORMALMAPS
-	if (normalTexturePresent){
+	if (normalTexturePresent) {
 		bump = get_normal_map(uv);
 		use_normalmap = true;
 	} 
 #endif
-		
-#ifdef GENERATE_NORMALMAPS
-	if (use_normalmap == false){
-		float tl = get_rgb_height (vec2(uv.x-SAMPLE_STEP,uv.y+SAMPLE_STEP));
-		float t  = get_rgb_height (vec2(uv.x-SAMPLE_STEP,uv.y-SAMPLE_STEP));
-		float tr = get_rgb_height (vec2(uv.x+SAMPLE_STEP,uv.y+SAMPLE_STEP));
-		float r  = get_rgb_height (vec2(uv.x+SAMPLE_STEP,uv.y));
-		float br = get_rgb_height (vec2(uv.x+SAMPLE_STEP,uv.y-SAMPLE_STEP));
-		float b  = get_rgb_height (vec2(uv.x,uv.y-SAMPLE_STEP));
-		float bl = get_rgb_height (vec2(uv.x-SAMPLE_STEP,uv.y-SAMPLE_STEP));
-		float l  = get_rgb_height (vec2(uv.x-SAMPLE_STEP,uv.y));
+
+	if (GENERATE_NORMALMAPS == 1 && use_normalmap == false) {
+		float tl = get_rgb_height(vec2(uv.x - SAMPLE_STEP, uv.y + SAMPLE_STEP));
+		float t  = get_rgb_height(vec2(uv.x - SAMPLE_STEP, uv.y - SAMPLE_STEP));
+		float tr = get_rgb_height(vec2(uv.x + SAMPLE_STEP, uv.y + SAMPLE_STEP));
+		float r  = get_rgb_height(vec2(uv.x + SAMPLE_STEP, uv.y));
+		float br = get_rgb_height(vec2(uv.x + SAMPLE_STEP, uv.y - SAMPLE_STEP));
+		float b  = get_rgb_height(vec2(uv.x, uv.y - SAMPLE_STEP));
+		float bl = get_rgb_height(vec2(uv.x -SAMPLE_STEP, uv.y - SAMPLE_STEP));
+		float l  = get_rgb_height(vec2(uv.x - SAMPLE_STEP, uv.y));
 		float dX = (tr + 2.0 * r + br) - (tl + 2.0 * l + bl);
 		float dY = (bl + 2.0 * b + br) - (tl + 2.0 * t + tr);
-		bump = vec4 (normalize(vec3 (dX, -dY, NORMALMAPS_STRENGTH)),1.0);
+		bump = vec4(normalize(vec3 (-dX, -dY, NORMALMAPS_STRENGTH)), 1.0);
 		use_normalmap = true;
 	}
-#endif
 
-vec4 base = texture2D(baseTexture, uv).rgba;
-	
+	vec4 base = texture2D(baseTexture, uv).rgba;
+
 #ifdef ENABLE_BUMPMAPPING
-	if (use_normalmap){
+	if (use_normalmap) {
 		vec3 L = normalize(lightVec);
-		vec3 E = normalize(eyeVec);
-		float specular = pow(clamp(dot(reflect(L, bump.xyz), E), 0.0, 1.0),0.5); 
-		float diffuse = dot(E,bump.xyz);		
-		/* Mathematic optimization
-		* Original: color = 0.05*base.rgb + diffuse*base.rgb + 0.2*specular*base.rgb;
-		* This optimization save 2 multiplications (orig: 4 multiplications + 3 additions
-		* end: 2 multiplications + 3 additions)
-		*/
-		color = (0.05 + diffuse + 0.2 * specular) * base.rgb;
+		vec3 E = normalize(-eyeVec);
+		float specular = pow(clamp(dot(reflect(L, bump.xyz), -E), 0.0, 1.0), 1.0);
+		float diffuse = dot(E,bump.xyz);
+		color = (diffuse + 0.1 * specular) * base.rgb;
 	} else {
 		color = base.rgb;
 	}
@@ -104,7 +160,7 @@ vec4 base = texture2D(baseTexture, uv).rgba;
 	float alpha = gl_Color.a;
 	vec4 col = vec4(color.rgb, alpha);
 	col *= gl_Color;
-	if(fogDistance != 0.0){
+	if (fogDistance != 0.0) {
 		float d = max(0.0, min(vPosition.z / fogDistance * 1.5 - 0.6, 1.0));
 		alpha = mix(alpha, 0.0, d);
 	}
@@ -112,7 +168,7 @@ vec4 base = texture2D(baseTexture, uv).rgba;
 #else
 	vec4 col = vec4(color.rgb, base.a);
 	col *= gl_Color;
-	if(fogDistance != 0.0){
+	if (fogDistance != 0.0) {
 		float d = max(0.0, min(vPosition.z / fogDistance * 1.5 - 0.6, 1.0));
 		col = mix(col, skyBgColor, d);
 	}
diff --git a/client/shaders/nodes_shader/opengl_vertex.glsl b/client/shaders/nodes_shader/opengl_vertex.glsl
index 07684f616..e5644b8b2 100644
--- a/client/shaders/nodes_shader/opengl_vertex.glsl
+++ b/client/shaders/nodes_shader/opengl_vertex.glsl
@@ -14,25 +14,36 @@ varying vec3 eyeVec;
 varying vec3 lightVec;

 varying vec3 tsEyeVec;

 varying vec3 tsLightVec;

+varying float generate_heightmaps;

 

 const float e = 2.718281828459;

 const float BS = 10.0;

 

-float smoothCurve( float x ) {

-  return x * x *( 3.0 - 2.0 * x );

+float smoothCurve(float x)

+{

+	return x * x * (3.0 - 2.0 * x);

 }

-float triangleWave( float x ) {

-  return abs( fract( x + 0.5 ) * 2.0 - 1.0 );

+float triangleWave(float x)

+{

+	return abs(fract(x + 0.5) * 2.0 - 1.0);

 }

-float smoothTriangleWave( float x ) {

-  return smoothCurve( triangleWave( x ) ) * 2.0 - 1.0;

+float smoothTriangleWave(float x)

+{

+	return smoothCurve(triangleWave(x)) * 2.0 - 1.0;

 }

 

 void main(void)

 {

 	gl_TexCoord[0] = gl_MultiTexCoord0;

-	

-#if (MATERIAL_TYPE == TILE_MATERIAL_LIQUID_TRANSPARENT || MATERIAL_TYPE == TILE_MATERIAL_LIQUID_OPAQUE) && ENABLE_WAVING_WATER

+	gl_TexCoord[0].y += 0.008;

+

+#if ((DRAW_TYPE == NDT_NORMAL || DRAW_TYPE == NDT_LIQUID || DRAW_TYPE == NDT_FLOWINGLIQUID) && GENERATE_NORMALMAPS)

+	generate_heightmaps = 1.0;

+#else 

+	generate_heightmaps = 0.0;

+#endif

+

+#if ((MATERIAL_TYPE == TILE_MATERIAL_LIQUID_TRANSPARENT || MATERIAL_TYPE == TILE_MATERIAL_LIQUID_OPAQUE) && ENABLE_WAVING_WATER)

 	vec4 pos = gl_Vertex;

 	pos.y -= 2.0;

 

@@ -76,43 +87,33 @@ void main(void)
 

 	vPosition = gl_Position.xyz;

 	worldPosition = (mWorld * gl_Vertex).xyz;

+

+	// Don't generate heightmaps when too far from the eye

+	float dist = distance (worldPosition, eyePosition);

+	if (dist > 100.00) {

+		generate_heightmaps = 0.0;

+	}

+

 	vec3 sunPosition = vec3 (0.0, eyePosition.y * BS + 900.0, 0.0);

 

 	vec3 normal, tangent, binormal;

 	normal = normalize(gl_NormalMatrix * gl_Normal);

-	if (gl_Normal.x > 0.5) {

-		//  1.0,  0.0,  0.0

-		tangent  = normalize(gl_NormalMatrix * vec3( 0.0,  0.0, -1.0));

-		binormal = normalize(gl_NormalMatrix * vec3( 0.0, -1.0,  0.0));

-	} else if (gl_Normal.x < -0.5) {

-		// -1.0,  0.0,  0.0

-		tangent  = normalize(gl_NormalMatrix * vec3( 0.0,  0.0,  1.0));

-		binormal = normalize(gl_NormalMatrix * vec3( 0.0, -1.0,  0.0));

-	} else if (gl_Normal.y > 0.5) {

-		//  0.0,  1.0,  0.0

-		tangent  = normalize(gl_NormalMatrix * vec3( 1.0,  0.0,  0.0));

-		binormal = normalize(gl_NormalMatrix * vec3( 0.0,  0.0,  1.0));

-	} else if (gl_Normal.y < -0.5) {

-		//  0.0, -1.0,  0.0

-		tangent  = normalize(gl_NormalMatrix * vec3( 1.0,  0.0,  0.0));

-		binormal = normalize(gl_NormalMatrix * vec3( 0.0,  0.0,  1.0));

-	} else if (gl_Normal.z > 0.5) {

-		//  0.0,  0.0,  1.0

-		tangent  = normalize(gl_NormalMatrix * vec3( 1.0,  0.0,  0.0));

-		binormal = normalize(gl_NormalMatrix * vec3( 0.0, -1.0,  0.0));

-	} else if (gl_Normal.z < -0.5) {

-		//  0.0,  0.0, -1.0

-		tangent  = normalize(gl_NormalMatrix * vec3(-1.0,  0.0,  0.0));

-		binormal = normalize(gl_NormalMatrix * vec3( 0.0, -1.0,  0.0));

-	}

-	mat3 tbnMatrix = mat3(	tangent.x, binormal.x, normal.x,

-							tangent.y, binormal.y, normal.y,

-							tangent.z, binormal.z, normal.z);

+	tangent = normalize(gl_NormalMatrix * gl_MultiTexCoord1.xyz);

+	binormal = normalize(gl_NormalMatrix * -gl_MultiTexCoord2.xyz);

+

+	vec3 v;

 

 	lightVec = sunPosition - worldPosition;

-	tsLightVec = lightVec * tbnMatrix;

-	eyeVec = (gl_ModelViewMatrix * gl_Vertex).xyz;

-	tsEyeVec = eyeVec * tbnMatrix;

+	v.x = dot(lightVec, tangent);

+	v.y = dot(lightVec, binormal);

+	v.z = dot(lightVec, normal);

+	tsLightVec = v;

+

+	eyeVec = -(gl_ModelViewMatrix * gl_Vertex).xyz;

+	v.x = dot(eyeVec, tangent);

+	v.y = dot(eyeVec, binormal);

+	v.z = dot(eyeVec, normal);

+	tsEyeVec = v;

 

 	vec4 color;

 	float day = gl_Color.r;

diff --git a/client/shaders/water_surface_shader/opengl_fragment.glsl b/client/shaders/water_surface_shader/opengl_fragment.glsl
index 6dc96eb48..386f77486 100644
--- a/client/shaders/water_surface_shader/opengl_fragment.glsl
+++ b/client/shaders/water_surface_shader/opengl_fragment.glsl
@@ -14,7 +14,7 @@ varying vec3 tsEyeVec;
 varying vec3 lightVec;
 varying vec3 tsLightVec;
 
-bool normalTexturePresent = false; 
+bool normalTexturePresent = false;
 
 const float e = 2.718281828459;
 const float BS = 10.0;
@@ -40,15 +40,15 @@ void main (void)
 	vec4 bump;
 	vec2 uv = gl_TexCoord[0].st;
 	bool use_normalmap = false;
-	
+
 #ifdef USE_NORMALMAPS
-	if (texture2D(useNormalmap,vec2(1.0,1.0)).r > 0.0){
+	if (texture2D(useNormalmap,vec2(1.0,1.0)).r > 0.0) {
 		normalTexturePresent = true;
 	}
 #endif
 
 #ifdef ENABLE_PARALLAX_OCCLUSION
-	if (normalTexturePresent){
+	if (normalTexturePresent) {
 		vec3 tsEye = normalize(tsEyeVec);
 		float height = PARALLAX_OCCLUSION_SCALE * texture2D(normalTexture, uv).a - PARALLAX_OCCLUSION_BIAS;
 		uv = uv + texture2D(normalTexture, uv).z * height * vec2(tsEye.x,-tsEye.y);
@@ -56,14 +56,13 @@ void main (void)
 #endif
 
 #ifdef USE_NORMALMAPS
-	if (normalTexturePresent){
+	if (normalTexturePresent) {
 		bump = get_normal_map(uv);
 		use_normalmap = true;
 	} 
 #endif
-		
-#ifdef GENERATE_NORMALMAPS
-	if (use_normalmap == false){
+
+	if (GENERATE_NORMALMAPS == 1 && use_normalmap == false) {
 		float tl = get_rgb_height (vec2(uv.x-SAMPLE_STEP,uv.y+SAMPLE_STEP));
 		float t  = get_rgb_height (vec2(uv.x-SAMPLE_STEP,uv.y-SAMPLE_STEP));
 		float tr = get_rgb_height (vec2(uv.x+SAMPLE_STEP,uv.y+SAMPLE_STEP));
@@ -77,16 +76,15 @@ void main (void)
 		bump = vec4 (normalize(vec3 (dX, -dY, NORMALMAPS_STRENGTH)),1.0);
 		use_normalmap = true;
 	}
-#endif
 
 vec4 base = texture2D(baseTexture, uv).rgba;
-	
+
 #ifdef ENABLE_BUMPMAPPING
-	if (use_normalmap){
+	if (use_normalmap) {
 		vec3 L = normalize(lightVec);
 		vec3 E = normalize(eyeVec);
-		float specular = pow(clamp(dot(reflect(L, bump.xyz), E), 0.0, 1.0),0.5); 
-		float diffuse = dot(E,bump.xyz);		
+		float specular = pow(clamp(dot(reflect(L, bump.xyz), E), 0.0, 1.0),0.5);
+		float diffuse = dot(E,bump.xyz);
 		/* Mathematic optimization
 		* Original: color = 0.05*base.rgb + diffuse*base.rgb + 0.2*specular*base.rgb;
 		* This optimization save 2 multiplications (orig: 4 multiplications + 3 additions
diff --git a/client/shaders/water_surface_shader/opengl_vertex.glsl b/client/shaders/water_surface_shader/opengl_vertex.glsl
index 6e70bbc36..53678800d 100644
--- a/client/shaders/water_surface_shader/opengl_vertex.glsl
+++ b/client/shaders/water_surface_shader/opengl_vertex.glsl
@@ -18,20 +18,23 @@ varying vec3 tsLightVec;
 const float e = 2.718281828459;

 const float BS = 10.0;

 

-float smoothCurve( float x ) {

-  return x * x *( 3.0 - 2.0 * x );

+float smoothCurve(float x)

+{

+	return x * x * (3.0 - 2.0 * x);

 }

-float triangleWave( float x ) {

-  return abs( fract( x + 0.5 ) * 2.0 - 1.0 );

+float triangleWave(float x)

+{

+	return abs(fract( x + 0.5 ) * 2.0 - 1.0);

 }

-float smoothTriangleWave( float x ) {

-  return smoothCurve( triangleWave( x ) ) * 2.0 - 1.0;

+float smoothTriangleWave(float x)

+{

+	return smoothCurve(triangleWave( x )) * 2.0 - 1.0;

 }

 

 void main(void)

 {

 	gl_TexCoord[0] = gl_MultiTexCoord0;

-	

+

 #if (MATERIAL_TYPE == TILE_MATERIAL_LIQUID_TRANSPARENT || MATERIAL_TYPE == TILE_MATERIAL_LIQUID_OPAQUE) && ENABLE_WAVING_WATER

 	vec4 pos = gl_Vertex;

 	pos.y -= 2.0;