Shaders fixes and cleanup relief mapping code.

diff --git a/client/shaders/nodes_shader/opengl_fragment.glsl b/client/shaders/nodes_shader/opengl_fragment.glsl
index e531d72b74688498685739a0c4043abab63737e9..8dc3a5683b4fb368758c24f1180750e13c318a53 100644 (file)
--- a/client/shaders/nodes_shader/opengl_fragment.glsl
+++ b/client/shaders/nodes_shader/opengl_fragment.glsl
@@ -39,37 +39,21 @@ vec4 get_normal_map(vec2 uv)
 
 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;
+       const float depth_step = 1.0 / 24.0;
        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;
+       for (int i = 0 ; i < 24 ; i++) {
+               float h = texture2D(normalTexture, dp + ds * depth).a;
+               if (h >= depth)
+                       break;
+               depth -= depth_step;
        }
-       return best_depth;
+       return depth;
 }
 
 float find_intersectionRGB(vec2 dp, vec2 ds) {
-       const float iterations = 24.0;
-       const float depth_step = 1.0 / iterations;
+       const float depth_step = 1.0 / 24.0;
        float depth = 1.0;
-       for (int i = 0 ; i < iterations ; i++) {
+       for (int i = 0 ; i < 24 ; i++) {
                float h = get_rgb_height(dp + ds * depth);
                if (h >= depth)
                        break;
@@ -85,40 +69,41 @@ void main (void)
        vec2 uv = gl_TexCoord[0].st;
        bool use_normalmap = false;
 
-#ifdef USE_NORMALMAPS
+#if USE_NORMALMAPS == 1
        if (texture2D(useNormalmap,vec2(1.0, 1.0)).r > 0.0) {
                normalTexturePresent = true;
        }
 #endif
 
 #ifdef ENABLE_PARALLAX_OCCLUSION
-       vec3 eyeRay = normalize(tsEyeVec);
+       vec2 eyeRay = vec2 (tsEyeVec.x, -tsEyeVec.y);
+       const float scale = PARALLAX_OCCLUSION_SCALE / PARALLAX_OCCLUSION_ITERATIONS;
+       const float bias = PARALLAX_OCCLUSION_BIAS / PARALLAX_OCCLUSION_ITERATIONS;
+               
 #if PARALLAX_OCCLUSION_MODE == 0
        // Parallax occlusion with slope information
        if (normalTexturePresent && area_enable_parallax > 0.0) {
-               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++) {
+               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;
+                       uv += h * normal.z * eyeRay;
                }
 #endif
 #if PARALLAX_OCCLUSION_MODE == 1
        // Relief mapping
        if (normalTexturePresent && area_enable_parallax > 0.0) {
-               vec2 ds = eyeRay.xy * PARALLAX_OCCLUSION_SCALE;
+               vec2 ds = eyeRay * PARALLAX_OCCLUSION_SCALE;
                float dist = find_intersection(uv, ds);
                uv += dist * ds;
 #endif
-       } else if (area_enable_parallax > 0.0) {
-               vec2 ds = eyeRay.xy * PARALLAX_OCCLUSION_SCALE;
+       } else if (GENERATE_NORMALMAPS == 1 && area_enable_parallax > 0.0) {
+               vec2 ds = eyeRay * PARALLAX_OCCLUSION_SCALE;
                float dist = find_intersectionRGB(uv, ds);
                uv += dist * ds;
        }
 #endif
 
-#ifdef USE_NORMALMAPS
+#if USE_NORMALMAPS == 1
        if (normalTexturePresent) {
                bump = get_normal_map(uv);
                use_normalmap = true;
@@ -136,7 +121,7 @@ void main (void)
                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;
        }
 
@@ -145,9 +130,9 @@ void main (void)
 #ifdef ENABLE_BUMPMAPPING
        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), 1.0);
-               float diffuse = dot(E,bump.xyz);
+               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;

diff --git a/client/shaders/nodes_shader/opengl_vertex.glsl b/client/shaders/nodes_shader/opengl_vertex.glsl
index 5c4d46be6c81cdfbb3cc6f73406e6411286ba406..9f8210d12dfed402c0915b5928d58b86eacdb04a 100644 (file)
--- a/client/shaders/nodes_shader/opengl_vertex.glsl
+++ b/client/shaders/nodes_shader/opengl_vertex.glsl
@@ -41,7 +41,7 @@ void main(void)
 \r
        //Allow parallax/relief mapping only for certain kind of nodes\r
        //Variable is also used to control area of the effect
-#if ((DRAW_TYPE == NDT_NORMAL || DRAW_TYPE == NDT_LIQUID || DRAW_TYPE == NDT_FLOWINGLIQUID) && GENERATE_NORMALMAPS)
+#if (DRAW_TYPE == NDT_NORMAL || DRAW_TYPE == NDT_LIQUID || DRAW_TYPE == NDT_FLOWINGLIQUID)
        area_enable_parallax = 1.0;
 #else
        area_enable_parallax = 0.0;
@@ -94,7 +94,7 @@ void main(void)
 
        // Don't generate heightmaps when too far from the eye
        float dist = distance (vec3(0.0, 0.0 ,0.0), vPosition);
-       if (dist > 100.0) {
+       if (dist > 120.0) {
                area_enable_parallax = 0.0;
        }
 
@@ -103,7 +103,7 @@ void main(void)
        vec3 normal, tangent, binormal;\r
        normal = normalize(gl_NormalMatrix * gl_Normal);\r
        tangent = normalize(gl_NormalMatrix * gl_MultiTexCoord1.xyz);
-       binormal = normalize(gl_NormalMatrix * -gl_MultiTexCoord2.xyz);
+       binormal = normalize(gl_NormalMatrix * gl_MultiTexCoord2.xyz);
 
        vec3 v;
 \r
@@ -111,13 +111,13 @@ void main(void)
        v.x = dot(lightVec, tangent);
        v.y = dot(lightVec, binormal);
        v.z = dot(lightVec, normal);
-       tsLightVec = v;
+       tsLightVec = normalize (v);
 
        eyeVec = -(gl_ModelViewMatrix * gl_Vertex).xyz;
        v.x = dot(eyeVec, tangent);
        v.y = dot(eyeVec, binormal);
        v.z = dot(eyeVec, normal);
-       tsEyeVec = v;
+       tsEyeVec = normalize (v);
 \r
        vec4 color;\r
        float day = gl_Color.r;\r

diff --git a/src/shader.cpp b/src/shader.cpp
index a6d18e1bef374881e8334a9bd127e38475b555df..7e4f4081061419e3454b22209692534fdcaa9595 100644 (file)
--- a/src/shader.cpp
+++ b/src/shader.cpp
@@ -731,8 +731,11 @@ ShaderInfo generate_shader(std::string name, u8 material_type, u8 drawtype,
                shaders_header += "\n";
        }
 
+       shaders_header += "#define USE_NORMALMAPS ";
        if (g_settings->getBool("enable_bumpmapping") || g_settings->getBool("enable_parallax_occlusion"))
-               shaders_header += "#define USE_NORMALMAPS\n";
+               shaders_header += "1\n";
+       else
+               shaders_header += "0\n";
 
        if (g_settings->getBool("enable_waving_water")){
                shaders_header += "#define ENABLE_WAVING_WATER 1\n";