shader vacuuming

diff --git a/build.c b/build.c
index ff01552de9675fc78ae8786b663a6ef187b0f113..5e1652e33152e3088c7aa33ff52cdc05e2b0f90d 100644 (file)
--- a/build.c
+++ b/build.c
@@ -123,6 +123,7 @@ void build_shaders(void)
    _S( "scene_terrain",             "scene.vs", "scene_terrain.fs" );
    _S( "scene_route",               "scene.vs", "scene_route.fs" );
    _S( "scene_depth",               "scene.vs", "scene_depth.fs" );
+   _S( "scene_position",            "scene.vs", "scene_position.fs" );
    _S( "scene_water",               "scene.vs", "scene_water.fs" );
    _S( "scene_water_fast",          "scene.vs", "scene_water_fast.fs" );
 

diff --git a/render.h b/render.h
index 91fe39ea0516585ee37cafecea6ba710e53aca6a..44414ea5f63dd2bea0e808b5df4867fd47e7c19e 100644 (file)
--- a/render.h
+++ b/render.h
@@ -186,8 +186,8 @@ framebuffers[] =
       {
          {
             "colour", k_framebuffer_attachment_type_colour,
-            .internalformat = GL_RGBA,
-            .format         = GL_RGBA,
+            .internalformat = GL_RED,
+            .format         = GL_RED,
             .type           = GL_UNSIGNED_BYTE,
             .attachment     = GL_COLOR_ATTACHMENT0
          },

diff --git a/shaders/common_world.glsl b/shaders/common_world.glsl
index b5c79dfac683779b4ddfe6977f7c20c823b929f5..45e12dff48267ba71c814a07a3272ea3eb29c339 100644 (file)
--- a/shaders/common_world.glsl
+++ b/shaders/common_world.glsl
@@ -25,6 +25,13 @@ float world_depth_sample( vec3 pos )
    return texture( g_world_depth, depth_coord ).r;
 }
 
+float world_water_depth( vec3 pos )
+{
+   vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; 
+   float ref_depth = g_water_plane.y*g_water_plane.w;
+   return texture( g_world_depth, depth_coord ).g - ref_depth;
+}
+
 float shadow_sample( vec3 vdir )
 {
    vec3 sample_pos = aWorldCo + vdir;

diff --git a/shaders/model_character_view.h b/shaders/model_character_view.h
index d1c8efd4e590bade1a3c2cb1f112747b246d6e18..c527d9032beacaead2bb5f08c399ca7f47e57ead 100644 (file)
--- a/shaders/model_character_view.h
+++ b/shaders/model_character_view.h
@@ -111,6 +111,13 @@ static struct vg_shader _shader_model_character_view = {
 "   return texture( g_world_depth, depth_coord ).r;\n"
 "}\n"
 "\n"
+"float world_water_depth( vec3 pos )\n"
+"{\n"
+"   vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
+"   float ref_depth = g_water_plane.y*g_water_plane.w;\n"
+"   return texture( g_world_depth, depth_coord ).g - ref_depth;\n"
+"}\n"
+"\n"
 "float shadow_sample( vec3 vdir )\n"
 "{\n"
 "   vec3 sample_pos = aWorldCo + vdir;\n"

diff --git a/shaders/scene_depth.fs b/shaders/scene_depth.fs
index a2b7642c2df612c6285a630d360254793c1aa303..2ac60135f18e5ab04e510120483b26aa12fe5836 100644 (file)
--- a/shaders/scene_depth.fs
+++ b/shaders/scene_depth.fs
@@ -29,5 +29,5 @@ void main()
 {
    vec3 halfview = normalize( uCamera - aWorldCo );
    float depth = water_depth( aWorldCo, halfview );
-   FragColor = vec4( aWorldCo.y, 0.0, 0.0,depth );
+   FragColor = vec4( depth, 0.0, 0.0, 0.0 );
 }

diff --git a/shaders/scene_depth.h b/shaders/scene_depth.h
index ce1a818cf6ade704fe7536771cb553efcadc1cf0..59a3236c740a3bbcf8052c1ff28986c828329656 100644 (file)
--- a/shaders/scene_depth.h
+++ b/shaders/scene_depth.h
@@ -106,6 +106,13 @@ static struct vg_shader _shader_scene_depth = {
 "   return texture( g_world_depth, depth_coord ).r;\n"
 "}\n"
 "\n"
+"float world_water_depth( vec3 pos )\n"
+"{\n"
+"   vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
+"   float ref_depth = g_water_plane.y*g_water_plane.w;\n"
+"   return texture( g_world_depth, depth_coord ).g - ref_depth;\n"
+"}\n"
+"\n"
 "float shadow_sample( vec3 vdir )\n"
 "{\n"
 "   vec3 sample_pos = aWorldCo + vdir;\n"
@@ -269,7 +276,7 @@ static struct vg_shader _shader_scene_depth = {
 "{\n"
 "   vec3 halfview = normalize( uCamera - aWorldCo );\n"
 "   float depth = water_depth( aWorldCo, halfview );\n"
-"   FragColor = vec4( aWorldCo.y, 0.0, 0.0,depth );\n"
+"   FragColor = vec4( depth, 0.0, 0.0, 0.0 );\n"
 "}\n"
 ""},
 };

diff --git a/shaders/scene_position.fs b/shaders/scene_position.fs
new file mode 100644 (file)
index 0000000..57d1f06
--- /dev/null
+++ b/shaders/scene_position.fs
@@ -0,0 +1,24 @@
+out vec4 FragColor;
+
+uniform vec3 uCamera;
+uniform vec3 uBoard0;
+uniform vec3 uBoard1;
+
+in vec2 aUv;
+in vec4 aNorm;
+in vec3 aCo;
+in vec3 aWorldCo;
+flat in ivec4 aLights;
+
+#include "common_scene.glsl"
+
+void main()
+{
+   float height_full = aWorldCo.y;
+   float height_water = height_full;
+
+   if( height_water > (g_water_plane.y * g_water_plane.w) + 2.0 )
+      height_water = -99999.9;
+
+   FragColor = vec4( height_full, height_water, 0.0, 0.0 );
+}

diff --git a/shaders/scene_position.h b/shaders/scene_position.h
new file mode 100644 (file)
index 0000000..a748f48
--- /dev/null
+++ b/shaders/scene_position.h
@@ -0,0 +1,316 @@
+#ifndef SHADER_scene_position_H
+#define SHADER_scene_position_H
+static void shader_scene_position_link(void);
+static void shader_scene_position_register(void);
+static struct vg_shader _shader_scene_position = {
+   .name = "scene_position",
+   .link = shader_scene_position_link,
+   .vs = 
+{
+.static_src = 
+"layout (location=0) in vec3  a_co;\n"
+"layout (location=1) in vec4  a_norm;\n"
+"layout (location=2) in vec2  a_uv;\n"
+"layout (location=3) in ivec4 a_lights;\n"
+"\n"
+"#line       1        1 \n"
+"const float k_motion_lerp_amount = 0.01;\n"
+"\n"
+"#line      2        0 \n"
+"\n"
+"out vec3 aMotionVec0;\n"
+"out vec3 aMotionVec1;\n"
+"\n"
+"void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
+"{\n"
+"   // This magically solves some artifacting errors!\n"
+"   //\n"
+"   vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
+"\n"
+"   aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
+"   aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
+"}\n"
+"\n"
+"#line      7        0 \n"
+"\n"
+"uniform mat4x3 uMdl;\n"
+"uniform mat4   uPv;\n"
+"uniform mat4   uPvmPrev;\n"
+"\n"
+"out vec2 aUv;\n"
+"out vec4 aNorm;\n"
+"out vec3 aCo;\n"
+"out vec3 aWorldCo;\n"
+"flat out ivec4 aLights;\n"
+"\n"
+"void main()\n"
+"{\n"
+"   vec3 world_pos0 = uMdl     * vec4( a_co, 1.0 );\n"
+"   vec4 vproj0     = uPv      * vec4( world_pos0, 1.0 );\n"
+"   vec4 vproj1     = uPvmPrev * vec4( a_co, 1.0 );\n"
+"\n"
+"   vs_motion_out( vproj0, vproj1 );\n"
+"\n"
+"   gl_Position = vproj0;\n"
+"\n"
+"   aUv = a_uv;\n"
+"   aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
+"   aCo = a_co;\n"
+"   aWorldCo = world_pos0;\n"
+"   aLights = a_lights;\n"
+"}\n"
+""},
+   .fs = 
+{
+.static_src = 
+"out vec4 FragColor;\n"
+"\n"
+"uniform vec3 uCamera;\n"
+"uniform vec3 uBoard0;\n"
+"uniform vec3 uBoard1;\n"
+"\n"
+"in vec2 aUv;\n"
+"in vec4 aNorm;\n"
+"in vec3 aCo;\n"
+"in vec3 aWorldCo;\n"
+"flat in ivec4 aLights;\n"
+"\n"
+"#line       1        1 \n"
+"// :D\n"
+"\n"
+"#line       1        1 \n"
+"layout (location = 0) out vec4 oColour;\n"
+"\n"
+"layout (std140) uniform ub_world_lighting\n"
+"{\n"
+"   vec4 g_light_colours[3];\n"
+"   vec4 g_light_directions[3];\n"
+"   vec4 g_ambient_colour;\n"
+"\n"
+"   vec4 g_water_plane;\n"
+"   vec4 g_depth_bounds;\n"
+"   float g_water_fog;\n"
+"   int g_light_count;\n"
+"   int g_light_preview;\n"
+"   int g_shadow_samples;\n"
+"\n"
+"   vec4 g_point_light_positions[32];\n"
+"   vec4 g_point_light_colours[32];\n"
+"};\n"
+"\n"
+"uniform sampler2D g_world_depth;\n"
+"\n"
+"float world_depth_sample( vec3 pos )\n"
+"{\n"
+"   vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
+"   return texture( g_world_depth, depth_coord ).r;\n"
+"}\n"
+"\n"
+"float world_water_depth( vec3 pos )\n"
+"{\n"
+"   vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
+"   float ref_depth = g_water_plane.y*g_water_plane.w;\n"
+"   return texture( g_world_depth, depth_coord ).g - ref_depth;\n"
+"}\n"
+"\n"
+"float shadow_sample( vec3 vdir )\n"
+"{\n"
+"   vec3 sample_pos = aWorldCo + vdir;\n"
+"   float height_sample = world_depth_sample( sample_pos );\n"
+"\n"
+"   float fdelta = height_sample - sample_pos.y;\n"
+"   return clamp( fdelta, 0.1, 0.2 )-0.1;\n"
+"}\n"
+"\n"
+"float sdLine( vec3 p, vec3 a, vec3 b )\n"
+"{\n"
+"  vec3 pa = p - a;\n"
+"  vec3 ba = b - a;\n"
+"\n"
+"  float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
+"  return length( pa - ba*h );\n"
+"}\n"
+"\n"
+"vec3 apply_fog( vec3 vfrag, float fdist )\n"
+"{\n"
+"   float dist = pow(fdist*0.0008,1.2);\n"
+"   return mix( vfrag, vec3(0.55,0.76,1.0), min( 1.0, dist ) );\n"
+"}\n"
+"\n"
+"\n"
+"// New lighting model\n"
+"\n"
+"vec3 newlight_compute_ambient()\n"
+"{\n"
+"   return g_ambient_colour.rgb;\n"
+"}\n"
+"\n"
+"float newlight_compute_sun_shadow()\n"
+"{\n"
+"   if( g_shadow_samples == 0 )\n"
+"   {\n"
+"      return 1.0;\n"
+"   }\n"
+"\n"
+"   float fspread = g_light_colours[0].w;\n"
+"   vec3  vdir = g_light_directions[0].xyz;\n"
+"   float flength = g_light_directions[0].w;\n"
+"\n"
+"   float famt = 0.0;\n"
+"   famt+=shadow_sample((vdir+vec3(-0.563, 0.550, 0.307)*fspread)*flength*0.1);\n"
+"   famt+=shadow_sample((vdir+vec3( 0.808, 0.686, 0.346)*fspread)*flength*0.2);\n"
+"   famt+=shadow_sample((vdir+vec3( 0.787, 0.074,-0.065)*fspread)*flength*0.3);\n"
+"   famt+=shadow_sample((vdir+vec3(-0.593, 0.071,-0.425)*fspread)*flength*0.4);\n"
+"   famt+=shadow_sample((vdir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
+"   famt+=shadow_sample((vdir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
+"   famt+=shadow_sample((vdir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
+"   famt+=shadow_sample((vdir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
+"\n"
+"   // player shadow\n"
+"   float dist_to_player = max( 0.0, sdLine( aWorldCo, uBoard0, uBoard1 )-0.1 );\n"
+"   float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
+"   player_shadow *= player_shadow*player_shadow*player_shadow;\n"
+"\n"
+"   return 1.0 - max( player_shadow*0.8, famt );\n"
+"}\n"
+"\n"
+"vec3 newlight_compute_world_diffuse( vec3 wnormal )\n"
+"{\n"
+"   vec3 vtotal = g_ambient_colour.rgb;\n"
+"\n"
+"   for( int i=0; i<g_light_count; i++ )\n"
+"   {\n"
+"      vec3 vcolour = g_light_colours[i].rgb;\n"
+"      vec3 vdir = g_light_directions[i].xyz;\n"
+"\n"
+"      float flight = max(dot( vdir, wnormal )*0.75+0.25,0.0);\n"
+"      vtotal += vcolour*flight;\n"
+"   }\n"
+"\n"
+"   return vtotal;\n"
+"}\n"
+"\n"
+"vec3 newlight_compute_sun_spec( vec3 wnormal, vec3 halfview, float fintensity )\n"
+"{\n"
+"   vec3 vcolour = g_light_colours[0].rgb;\n"
+"   vec3 vdir = g_light_directions[0].xyz;\n"
+"\n"
+"   vec3 specdir = reflect( -vdir, wnormal );\n"
+"   float spec = pow(max(dot( halfview, specdir ), 0.0), 10.0);\n"
+"   return vcolour*spec*fintensity;\n"
+"}\n"
+"\n"
+"vec3 newlight_compute_quadratic( vec3 wnormal, vec3 halfview, \n"
+"                                 vec3 light_pos, vec3 light_colour )\n"
+"{\n"
+"   vec3 light_delta = (light_pos-aWorldCo) * 10.0;\n"
+"\n"
+"   float quadratic = dot(light_delta,light_delta);\n"
+"   float attenuation = 1.0f/( 1.0f + quadratic );\n"
+"   attenuation *= max( 0.0, dot( normalize(light_delta), wnormal ) );\n"
+"\n"
+"   return light_colour*attenuation;\n"
+"}\n"
+"\n"
+"#line      4        0 \n"
+"\n"
+"vec3 scene_do_lighting( vec3 diffuse, vec3 wnormal )\n"
+"{\n"
+"   // Lighting\n"
+"   vec3 halfview = uCamera - aWorldCo;\n"
+"   float fdist = length(halfview);\n"
+"   halfview /= fdist;\n"
+"\n"
+"   vec3 total_light = newlight_compute_ambient();\n"
+"   \n"
+"   // Compute world lighting contribution and apply it according to the\n"
+"   // shadow map\n"
+"   //\n"
+"   vec3 world_light = newlight_compute_world_diffuse( wnormal );\n"
+"   world_light += newlight_compute_sun_spec( wnormal, halfview, 0.1 );\n"
+"\n"
+"   float world_shadow = newlight_compute_sun_shadow();\n"
+"\n"
+"   total_light += world_light * world_shadow;\n"
+"\n"
+"   // Compute the other lights that exist in the map, not effected by the sun\n"
+"   // shadow\n"
+"   total_light += newlight_compute_quadratic\n"
+"                  ( \n"
+"                     wnormal, halfview,\n"
+"                     g_point_light_positions[ aLights.x ].xyz,\n"
+"                     g_point_light_colours[ aLights.x ].rgb \n"
+"                  );\n"
+"   total_light += newlight_compute_quadratic\n"
+"                  ( \n"
+"                     wnormal, halfview,\n"
+"                     g_point_light_positions[ aLights.y ].xyz,\n"
+"                     g_point_light_colours[ aLights.y ].rgb \n"
+"                  );\n"
+"   total_light += newlight_compute_quadratic\n"
+"                  ( \n"
+"                     wnormal, halfview,\n"
+"                     g_point_light_positions[ aLights.z ].xyz,\n"
+"                     g_point_light_colours[ aLights.z ].rgb \n"
+"                  );\n"
+"\n"
+"   return apply_fog( diffuse * total_light, fdist );\n"
+"}\n"
+"\n"
+"#line     14        0 \n"
+"\n"
+"void main()\n"
+"{\n"
+"   float height_full = aWorldCo.y;\n"
+"   float height_water = height_full;\n"
+"\n"
+"   if( height_water > (g_water_plane.y * g_water_plane.w) + 2.0 )\n"
+"      height_water = -99999.9;\n"
+"\n"
+"   FragColor = vec4( height_full, height_water, 0.0, 0.0 );\n"
+"}\n"
+""},
+};
+
+static GLuint _uniform_scene_position_uMdl;
+static GLuint _uniform_scene_position_uPv;
+static GLuint _uniform_scene_position_uPvmPrev;
+static GLuint _uniform_scene_position_uCamera;
+static GLuint _uniform_scene_position_uBoard0;
+static GLuint _uniform_scene_position_uBoard1;
+static GLuint _uniform_scene_position_g_world_depth;
+static void shader_scene_position_uMdl(m4x3f m){
+   glUniformMatrix4x3fv(_uniform_scene_position_uMdl,1,GL_FALSE,(float*)m);
+}
+static void shader_scene_position_uPv(m4x4f m){
+   glUniformMatrix4fv(_uniform_scene_position_uPv,1,GL_FALSE,(float*)m);
+}
+static void shader_scene_position_uPvmPrev(m4x4f m){
+   glUniformMatrix4fv(_uniform_scene_position_uPvmPrev,1,GL_FALSE,(float*)m);
+}
+static void shader_scene_position_uCamera(v3f v){
+   glUniform3fv(_uniform_scene_position_uCamera,1,v);
+}
+static void shader_scene_position_uBoard0(v3f v){
+   glUniform3fv(_uniform_scene_position_uBoard0,1,v);
+}
+static void shader_scene_position_uBoard1(v3f v){
+   glUniform3fv(_uniform_scene_position_uBoard1,1,v);
+}
+static void shader_scene_position_g_world_depth(int i){
+   glUniform1i(_uniform_scene_position_g_world_depth,i);
+}
+static void shader_scene_position_register(void){
+   vg_shader_register( &_shader_scene_position );
+}
+static void shader_scene_position_use(void){ glUseProgram(_shader_scene_position.id); }
+static void shader_scene_position_link(void){
+   _uniform_scene_position_uMdl = glGetUniformLocation( _shader_scene_position.id, "uMdl" );
+   _uniform_scene_position_uPv = glGetUniformLocation( _shader_scene_position.id, "uPv" );
+   _uniform_scene_position_uPvmPrev = glGetUniformLocation( _shader_scene_position.id, "uPvmPrev" );
+   _uniform_scene_position_uCamera = glGetUniformLocation( _shader_scene_position.id, "uCamera" );
+   _uniform_scene_position_uBoard0 = glGetUniformLocation( _shader_scene_position.id, "uBoard0" );
+   _uniform_scene_position_uBoard1 = glGetUniformLocation( _shader_scene_position.id, "uBoard1" );
+   _uniform_scene_position_g_world_depth = glGetUniformLocation( _shader_scene_position.id, "g_world_depth" );
+}
+#endif /* SHADER_scene_position_H */

diff --git a/shaders/scene_route.h b/shaders/scene_route.h
index dd36bb284cc1c8e4cd49ed0b2bb17b61cd34b367..5bd8fd574623f83364071ea140c9013113a6336d 100644 (file)
--- a/shaders/scene_route.h
+++ b/shaders/scene_route.h
@@ -107,6 +107,13 @@ static struct vg_shader _shader_scene_route = {
 "   return texture( g_world_depth, depth_coord ).r;\n"
 "}\n"
 "\n"
+"float world_water_depth( vec3 pos )\n"
+"{\n"
+"   vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
+"   float ref_depth = g_water_plane.y*g_water_plane.w;\n"
+"   return texture( g_world_depth, depth_coord ).g - ref_depth;\n"
+"}\n"
+"\n"
 "float shadow_sample( vec3 vdir )\n"
 "{\n"
 "   vec3 sample_pos = aWorldCo + vdir;\n"

diff --git a/shaders/scene_standard.h b/shaders/scene_standard.h
index ccd31a6a52749e7530ec63b223caa860d3d29c4a..232e67693bfbc4c0634cd6e9c508ba2dc411587f 100644 (file)
--- a/shaders/scene_standard.h
+++ b/shaders/scene_standard.h
@@ -107,6 +107,13 @@ static struct vg_shader _shader_scene_standard = {
 "   return texture( g_world_depth, depth_coord ).r;\n"
 "}\n"
 "\n"
+"float world_water_depth( vec3 pos )\n"
+"{\n"
+"   vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
+"   float ref_depth = g_water_plane.y*g_water_plane.w;\n"
+"   return texture( g_world_depth, depth_coord ).g - ref_depth;\n"
+"}\n"
+"\n"
 "float shadow_sample( vec3 vdir )\n"
 "{\n"
 "   vec3 sample_pos = aWorldCo + vdir;\n"

diff --git a/shaders/scene_standard_alphatest.h b/shaders/scene_standard_alphatest.h
index f9aa65097ef062bad94d53314e50ab81060a4cfa..ed4417ba6350cb4cc63e653b79370e80e18802d3 100644 (file)
--- a/shaders/scene_standard_alphatest.h
+++ b/shaders/scene_standard_alphatest.h
@@ -107,6 +107,13 @@ static struct vg_shader _shader_scene_standard_alphatest = {
 "   return texture( g_world_depth, depth_coord ).r;\n"
 "}\n"
 "\n"
+"float world_water_depth( vec3 pos )\n"
+"{\n"
+"   vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
+"   float ref_depth = g_water_plane.y*g_water_plane.w;\n"
+"   return texture( g_world_depth, depth_coord ).g - ref_depth;\n"
+"}\n"
+"\n"
 "float shadow_sample( vec3 vdir )\n"
 "{\n"
 "   vec3 sample_pos = aWorldCo + vdir;\n"

diff --git a/shaders/scene_terrain.h b/shaders/scene_terrain.h
index 467cd91979c369de44f23795da8a16e7bea9eead..5913d2c0d30d7e992be7a282ee37d8a8e6ee03fc 100644 (file)
--- a/shaders/scene_terrain.h
+++ b/shaders/scene_terrain.h
@@ -108,6 +108,13 @@ static struct vg_shader _shader_scene_terrain = {
 "   return texture( g_world_depth, depth_coord ).r;\n"
 "}\n"
 "\n"
+"float world_water_depth( vec3 pos )\n"
+"{\n"
+"   vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
+"   float ref_depth = g_water_plane.y*g_water_plane.w;\n"
+"   return texture( g_world_depth, depth_coord ).g - ref_depth;\n"
+"}\n"
+"\n"
 "float shadow_sample( vec3 vdir )\n"
 "{\n"
 "   vec3 sample_pos = aWorldCo + vdir;\n"

diff --git a/shaders/scene_vertex_blend.h b/shaders/scene_vertex_blend.h
index 1f3946f60d575bf62e8dc2bb3833c3b782d0ece4..1a9c7d2a7ae2768e74fe245a53b530a82cce684e 100644 (file)
--- a/shaders/scene_vertex_blend.h
+++ b/shaders/scene_vertex_blend.h
@@ -106,6 +106,13 @@ static struct vg_shader _shader_scene_vertex_blend = {
 "   return texture( g_world_depth, depth_coord ).r;\n"
 "}\n"
 "\n"
+"float world_water_depth( vec3 pos )\n"
+"{\n"
+"   vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
+"   float ref_depth = g_water_plane.y*g_water_plane.w;\n"
+"   return texture( g_world_depth, depth_coord ).g - ref_depth;\n"
+"}\n"
+"\n"
 "float shadow_sample( vec3 vdir )\n"
 "{\n"
 "   vec3 sample_pos = aWorldCo + vdir;\n"

diff --git a/shaders/scene_water.fs b/shaders/scene_water.fs
index 645569900d14dd1ab6fb6d016584730f196c470f..329374f9dfb80cba7774c186847b909bd1104b6a 100644 (file)
--- a/shaders/scene_water.fs
+++ b/shaders/scene_water.fs
@@ -33,7 +33,7 @@ vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue,
    float spec = pow(max(dot(halfview,specdir),0.0),20.0)*0.3;
    
    // Depth 
-   float depthblend = pow( beneath.a,0.8 );
+   float depthblend = pow( beneath.r, 0.8 );
 
    // Composite
    vec3 vsurface = mix(surface_tint, above.rgb, ffresnel );
@@ -50,7 +50,7 @@ void main()
    vec2 ssuv = gl_FragCoord.xy*uInvRes;
    
    // Surface colour composite
-   float depthvalue = clamp( -world_depth_sample( aCo )*(1.0/25.0), 0.0, 1.0 );
+   float depthvalue = clamp( -world_water_depth( aCo )*(1.0/25.0), 0.0, 1.0 );
 
    vec2 world_coord = aCo.xz * 0.008;
    vec4 time_offsets = vec4( uTime ) * vec4( 0.008, 0.006, 0.003, 0.03 );

diff --git a/shaders/scene_water.h b/shaders/scene_water.h
index 54eaff27742b1435b02222f544ab9bef9fede8d7..1658e96af822cc9393738536d0271e4617af881b 100644 (file)
--- a/shaders/scene_water.h
+++ b/shaders/scene_water.h
@@ -114,6 +114,13 @@ static struct vg_shader _shader_scene_water = {
 "   return texture( g_world_depth, depth_coord ).r;\n"
 "}\n"
 "\n"
+"float world_water_depth( vec3 pos )\n"
+"{\n"
+"   vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
+"   float ref_depth = g_water_plane.y*g_water_plane.w;\n"
+"   return texture( g_world_depth, depth_coord ).g - ref_depth;\n"
+"}\n"
+"\n"
 "float shadow_sample( vec3 vdir )\n"
 "{\n"
 "   vec3 sample_pos = aWorldCo + vdir;\n"
@@ -292,7 +299,7 @@ static struct vg_shader _shader_scene_water = {
 "   float spec = pow(max(dot(halfview,specdir),0.0),20.0)*0.3;\n"
 "   \n"
 "   // Depth \n"
-"   float depthblend = pow( beneath.a,0.8 );\n"
+"   float depthblend = pow( beneath.r, 0.8 );\n"
 "\n"
 "   // Composite\n"
 "   vec3 vsurface = mix(surface_tint, above.rgb, ffresnel );\n"
@@ -309,7 +316,7 @@ static struct vg_shader _shader_scene_water = {
 "   vec2 ssuv = gl_FragCoord.xy*uInvRes;\n"
 "   \n"
 "   // Surface colour composite\n"
-"   float depthvalue = clamp( -world_depth_sample( aCo )*(1.0/25.0), 0.0, 1.0 );\n"
+"   float depthvalue = clamp( -world_water_depth( aCo )*(1.0/25.0), 0.0, 1.0 );\n"
 "\n"
 "   vec2 world_coord = aCo.xz * 0.008;\n"
 "   vec4 time_offsets = vec4( uTime ) * vec4( 0.008, 0.006, 0.003, 0.03 );\n"

diff --git a/shaders/scene_water_fast.fs b/shaders/scene_water_fast.fs
index 81a4b021754e6561f17403e517394cb8552288de..e7cbc487565af8f85230e54ed9ca84d7afec2153 100644 (file)
--- a/shaders/scene_water_fast.fs
+++ b/shaders/scene_water_fast.fs
@@ -36,7 +36,7 @@ void main()
    compute_motion_vectors();
 
    // Surface colour composite
-   float depthvalue = clamp( -world_depth_sample( aCo )*(1.0/25.0), 0.0, 1.0 );
+   float depthvalue = clamp( -world_water_depth( aCo )*(1.0/25.0), 0.0, 1.0 );
 
    vec2 world_coord = aCo.xz * 0.008;
    vec4 time_offsets = vec4( uTime ) * vec4( 0.008, 0.006, 0.003, 0.03 );

diff --git a/shaders/scene_water_fast.h b/shaders/scene_water_fast.h
index d3a7ac4c64a0ff04c73711cfbaeae57504eafaf1..6e19ac3424274471f5ff539891d59a42fb6500eb 100644 (file)
--- a/shaders/scene_water_fast.h
+++ b/shaders/scene_water_fast.h
@@ -111,6 +111,13 @@ static struct vg_shader _shader_scene_water_fast = {
 "   return texture( g_world_depth, depth_coord ).r;\n"
 "}\n"
 "\n"
+"float world_water_depth( vec3 pos )\n"
+"{\n"
+"   vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
+"   float ref_depth = g_water_plane.y*g_water_plane.w;\n"
+"   return texture( g_world_depth, depth_coord ).g - ref_depth;\n"
+"}\n"
+"\n"
 "float shadow_sample( vec3 vdir )\n"
 "{\n"
 "   vec3 sample_pos = aWorldCo + vdir;\n"
@@ -295,7 +302,7 @@ static struct vg_shader _shader_scene_water_fast = {
 "   compute_motion_vectors();\n"
 "\n"
 "   // Surface colour composite\n"
-"   float depthvalue = clamp( -world_depth_sample( aCo )*(1.0/25.0), 0.0, 1.0 );\n"
+"   float depthvalue = clamp( -world_water_depth( aCo )*(1.0/25.0), 0.0, 1.0 );\n"
 "\n"
 "   vec2 world_coord = aCo.xz * 0.008;\n"
 "   vec4 time_offsets = vec4( uTime ) * vec4( 0.008, 0.006, 0.003, 0.03 );\n"

diff --git a/world.h b/world.h
index 16b0e98986260a6d1bda96c0e62c4d5b7af5af87..9a45e3a6cdf862123be3042d6cdc841bfe1a7d3f 100644 (file)
--- a/world.h
+++ b/world.h
@@ -24,6 +24,7 @@ typedef struct world_instance world_instance;
 #include "shaders/scene_vertex_blend.h"
 #include "shaders/scene_terrain.h"
 #include "shaders/scene_depth.h"
+#include "shaders/scene_position.h"
 
 #include "shaders/model_sky.h"
 
@@ -499,6 +500,7 @@ VG_STATIC void world_init(void)
    shader_scene_vertex_blend_register();
    shader_scene_terrain_register();
    shader_scene_depth_register();
+   shader_scene_position_register();
 
    shader_model_sky_register();
 

diff --git a/world_gen.h b/world_gen.h
index 2b2ba57d91b2eaa4ece165ec559d0f4765d9ff8b..5cfc9d102af3a94996e032ac177193ffc7ff4836 100644 (file)
--- a/world_gen.h
+++ b/world_gen.h
@@ -596,6 +596,36 @@ VG_STATIC void world_post_process( world_instance *world )
 
    vg_acquire_thread_sync();
    {
+      /* Upload lighting uniform buffer */
+      if( world->water.enabled )
+         v4_copy( world->water.plane, world->ub_lighting.g_water_plane );
+
+      v4f info_vec;
+      v3f *bounds = world->scene_geo->bbx;
+
+      info_vec[0] = bounds[0][0];
+      info_vec[1] = bounds[0][2];
+      info_vec[2] = 1.0f/ (bounds[1][0]-bounds[0][0]);
+      info_vec[3] = 1.0f/ (bounds[1][2]-bounds[0][2]);
+      v4_copy( info_vec, world->ub_lighting.g_depth_bounds );
+
+      /* add scene lights */
+      for( int i=0; i<world->light_count; i++ )
+      {
+         struct world_light *light = &world->lights[i];
+
+         v3_muls( light->colour, light->colour[3] * 2.0f,
+                  world->ub_lighting.g_point_light_colours[i] );
+         v3_copy( light->co, 
+                  world->ub_lighting.g_point_light_positions[i] );
+      }
+
+      /* upload full buffer */
+      glBindBuffer( GL_UNIFORM_BUFFER, world->ubo_lighting );
+      glBufferSubData( GL_UNIFORM_BUFFER, 0, 
+                       sizeof(struct ub_world_lighting), &world->ub_lighting );
+
+
       /* 
        * Rendering the depth map
        */
@@ -634,39 +664,11 @@ VG_STATIC void world_post_process( world_instance *world )
       glBlendFunc(GL_ONE, GL_ONE);
       glBlendEquation(GL_MAX);
 
-      render_world_depth( world, &ortho );
+      render_world_position( world, &ortho );
       glDisable(GL_BLEND);
       glEnable(GL_DEPTH_TEST);
       glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 
-      /* Upload lighting uniform buffer */
-      if( world->water.enabled )
-         v4_copy( world->water.plane, world->ub_lighting.g_water_plane );
-
-      v4f info_vec;
-      v3f *bounds = world->scene_geo->bbx;
-
-      info_vec[0] = bounds[0][0];
-      info_vec[1] = bounds[0][2];
-      info_vec[2] = 1.0f/ (bounds[1][0]-bounds[0][0]);
-      info_vec[3] = 1.0f/ (bounds[1][2]-bounds[0][2]);
-      v4_copy( info_vec, world->ub_lighting.g_depth_bounds );
-
-      /* add scene lights */
-      for( int i=0; i<world->light_count; i++ )
-      {
-         struct world_light *light = &world->lights[i];
-
-         v3_muls( light->colour, light->colour[3] * 2.0f,
-                  world->ub_lighting.g_point_light_colours[i] );
-         v3_copy( light->co, 
-                  world->ub_lighting.g_point_light_positions[i] );
-      }
-
-      /* upload full buffer */
-      glBindBuffer( GL_UNIFORM_BUFFER, world->ubo_lighting );
-      glBufferSubData( GL_UNIFORM_BUFFER, 0, 
-                       sizeof(struct ub_world_lighting), &world->ub_lighting );
    }
 
    vg_release_thread_sync();

diff --git a/world_render.h b/world_render.h
index e7700e82ca8b73c64ee4cb64bfcc93c7b340f35f..54c58a55d5796078fe1c07a00ebb02fb5cd8d455 100644 (file)
--- a/world_render.h
+++ b/world_render.h
@@ -53,8 +53,8 @@ VG_STATIC void world_render_init(void)
 
          fb->attachments[0].display_name     = NULL;
          fb->attachments[0].purpose = k_framebuffer_attachment_type_colour;
-         fb->attachments[0].internalformat   = GL_R16F;
-         fb->attachments[0].format           = GL_RED;
+         fb->attachments[0].internalformat   = GL_RG16F;
+         fb->attachments[0].format           = GL_RG;
          fb->attachments[0].type             = GL_FLOAT;
          fb->attachments[0].attachment       = GL_COLOR_ATTACHMENT0;
 
@@ -386,13 +386,22 @@ VG_STATIC void render_world_depth( world_instance *world, camera *cam )
 
    mesh_bind( &world->mesh_geo );
    mesh_draw( &world->mesh_geo );
+}
 
-#if 0
-   glDisable(GL_CULL_FACE);
-   scene_bind( &world.foliage );
-   scene_draw( &world.foliage );
-   glEnable(GL_CULL_FACE);
-#endif
+VG_STATIC void render_world_position( world_instance *world, camera *cam )
+{
+   m4x3f identity_matrix;
+   m4x3_identity( identity_matrix );
+
+   shader_scene_position_use();
+   shader_scene_position_uCamera( cam->transform[3] );
+   shader_scene_position_uPv( cam->mtx.pv );
+   shader_scene_position_uPvmPrev( cam->mtx_prev.pv );
+   shader_scene_position_uMdl( identity_matrix );
+   world_link_lighting_ub( world, _shader_scene_position.id, 2 );
+
+   mesh_bind( &world->mesh_geo );
+   mesh_draw( &world->mesh_geo );
 }
 
 #endif /* WORLD_RENDER_H */

diff --git a/world_water.h b/world_water.h
index 9709c43bebb8e6047f1602ca4b376168f930a7f0..a86d4ee0d06cfee68c7a52525fbb2916c441c32f 100644 (file)
--- a/world_water.h
+++ b/world_water.h
@@ -91,6 +91,7 @@ VG_STATIC void render_water_texture( world_instance *world, camera *cam )
     */
    camera beneath_cam;
    render_fb_bind( gpipeline.fb_water_beneath );
+   glClearColor( 1.0f, 0.0f, 0.0f, 0.0f );
    glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
 
    m4x3_copy( cam->transform, beneath_cam.transform );