From: hgn <hgodden00@gmail.com>
Date: Sat, 25 Feb 2023 00:32:18 +0000 (+0000)
Subject: fix da bugs
X-Git-Url: https://harrygodden.com/git/?a=commitdiff_plain;h=192990d6d24e53749ca046fef808a63cf162ab8a;p=carveJwlIkooP6JGAAIwe30JlM.git

fix da bugs
---

diff --git a/build.c b/build.c
index 5f050df..ff01552 100644
--- a/build.c
+++ b/build.c
@@ -123,11 +123,11 @@ 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_water",               "scene.vs", "scene_water.fs" );
+   _S( "scene_water_fast",          "scene.vs", "scene_water_fast.fs" );
 
    /* Models */
    _S( "model_sky",            "model.vs",         "model_sky.fs" );
-   _S( "model_water",          "model.vs",         "model_water.fs" );
-   _S( "model_water_fast",     "model.vs",         "model_water_fast.fs" );
    _S( "model_menu",           "model.vs",         "model_menu.fs" );
    _S( "model_character_view", "model_skinned.vs", "model_character_view.fs" );
    _S( "model_gate",           "model_gate.vs",    "model_gate_lq.fs" );
diff --git a/bvh.h b/bvh.h
index 8b6b078..52ce24a 100644
--- a/bvh.h
+++ b/bvh.h
@@ -90,7 +90,6 @@ VG_STATIC void bh_subdivide( bh_tree *bh, u32 inode )
    if( extent[2] > extent[axis] ) axis = 2;
 
    float split = node->bbx[0][axis] + extent[axis]*0.5f;
-
    float avg = 0.0;
    for( u32 t=0; t<node->count; t++ )
    {
@@ -98,9 +97,9 @@ VG_STATIC void bh_subdivide( bh_tree *bh, u32 inode )
       avg += bh->system->item_centroid( bh->user, idx, axis );
    }
    avg /= (float)node->count;
-
    split = avg;
 
+
    i32 i = node->start,
        j = i + node->count-1;
    
diff --git a/maps_src/mp_home.mdl b/maps_src/mp_home.mdl
index a09afb0..0f9f4d6 100644
Binary files a/maps_src/mp_home.mdl and b/maps_src/mp_home.mdl differ
diff --git a/maps_src/mp_mtzero.mdl b/maps_src/mp_mtzero.mdl
index 9213d01..4175d69 100644
Binary files a/maps_src/mp_mtzero.mdl and b/maps_src/mp_mtzero.mdl differ
diff --git a/player_common.c b/player_common.c
index 0e0c8a9..29ae050 100644
--- a/player_common.c
+++ b/player_common.c
@@ -33,8 +33,8 @@ VG_STATIC void player_camera_portal_correction( player_instance *player )
    {
       /* construct plane equation for reciever gate */
       v4f plane;
-      v3_copy( player->gate_waiting->recv_to_world[2], plane );
-      plane[3] = v3_dot( plane, player->gate_waiting->recv_to_world[3] );
+      q_mulv( player->gate_waiting->q[1], (v3f){0.0f,0.0f,1.0f}, plane );
+      plane[3] = v3_dot( plane, player->gate_waiting->co[1] );
 
       /* check camera polarity */
       if( v3_dot( player->cam.pos, plane ) < plane[3] ) 
@@ -51,15 +51,6 @@ VG_STATIC void player_camera_portal_correction( player_instance *player )
          m4x3_invert_affine( player->gate_waiting->transport, inverse );
          m4x3_mulv( inverse, player->cam.pos, player->cam.pos );
 
-#if 0
-         /* TODO: Find robust method for this */
-         v3f fwd_dir = { cosf(player->cam.angles[0]),
-                         0.0f,
-                         sinf(player->cam.angles[0])};
-         m3x3_mulv( inverse, fwd_dir, fwd_dir );
-         player->cam.angles[0] = atan2f( fwd_dir[2], fwd_dir[0] );
-#endif
-
          struct skeleton *sk = &player->playeravatar->sk;
          skeleton_apply_transform( sk, inverse );
       }
diff --git a/player_interface.h b/player_interface.h
index dc23776..a304fbb 100644
--- a/player_interface.h
+++ b/player_interface.h
@@ -346,8 +346,8 @@ VG_STATIC void player_pre_render( player_interface *player )
    {
       /* construct plane equation for reciever gate */
       v4f plane;
-      v3_copy( player->gate_waiting->recv_to_world[2], plane );
-      plane[3] = v3_dot( plane, player->gate_waiting->recv_to_world[3] );
+      q_mulv( player->gate_waiting->q[1], (v3f){0.0f,0.0f,1.0f}, plane );
+      plane[3] = v3_dot( plane, player->gate_waiting->co[1] );
 
       /* check camera polarity */
       if( v3_dot( player->cam.pos, plane ) < plane[3] ) 
diff --git a/scene.h b/scene.h
index bf69a63..63b351d 100644
--- a/scene.h
+++ b/scene.h
@@ -297,7 +297,20 @@ VG_STATIC float scene_bh_centroid( void *user, u32 item_index, int axis )
               *pb = &s->arrvertices[ s->arrindices[item_index*3+1] ],
               *pc = &s->arrvertices[ s->arrindices[item_index*3+2] ];
 
+   #if 0
+
+   float min, max;
+
+   min = vg_minf( pa->co[axis], pb->co[axis] );
+   max = vg_maxf( pa->co[axis], pb->co[axis] );
+   min = vg_minf( min, pc->co[axis] );
+   max = vg_maxf( max, pc->co[axis] );
+
+   return (min+max) * 0.5f;
+
+   #else
    return (pa->co[axis] + pb->co[axis] + pc->co[axis]) * (1.0f/3.0f);
+   #endif
 }
 
 VG_STATIC void scene_bh_swap( void *user, u32 ia, u32 ib )
diff --git a/shaders/model_water.fs b/shaders/model_water.fs
deleted file mode 100644
index 68fc66d..0000000
--- a/shaders/model_water.fs
+++ /dev/null
@@ -1,81 +0,0 @@
-uniform sampler2D uTexMain;
-uniform sampler2D uTexDudv;
-uniform sampler2D uTexBack;
-
-uniform vec2 uInvRes;
-uniform float uTime;
-uniform vec3 uCamera;
-uniform float uSurfaceY;
-uniform vec3 uBoard0;
-uniform vec3 uBoard1;
-
-uniform vec3 uShoreColour;
-uniform vec3 uOceanColour;
-
-in vec4 aColour;
-in vec2 aUv;
-in vec3 aNorm;
-in vec3 aCo;
-in vec3 aWorldCo;
-
-#include "common_world.glsl"
-#include "motion_vectors_fs.glsl"
-
-vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue, 
-      vec4 beneath, vec4 above )
-{
-   vec3 surface_tint = mix(uShoreColour, uOceanColour, depthvalue);
-
-   float ffresnel = pow(1.0-dot( vnorm, halfview ),5.0);
-
-   vec3 lightdir = vec3(0.95,0.0,-0.3);
-   vec3 specdir = reflect( -lightdir, vnorm );
-   float spec = pow(max(dot(halfview,specdir),0.0),20.0)*0.3;
-   
-   // Depth 
-   float depthblend = pow( beneath.a,0.8 );
-
-   // Composite
-   vec3 vsurface = mix(surface_tint, above.rgb, ffresnel );
-   //vsurface += spec;
-
-   return vec4( vsurface,depthblend );
-}
-
-void main()
-{
-   compute_motion_vectors();
-
-   // Create texture coords
-   vec2 ssuv = gl_FragCoord.xy*uInvRes;
-   
-   // Surface colour composite
-   float depthvalue = clamp( -world_depth_sample( 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 );
-   vec4 dudva = texture( uTexDudv, world_coord + time_offsets.xy )-0.5;
-   vec4 dudvb = texture( uTexDudv, world_coord *7.0 - time_offsets.zw )-0.5;
-
-   vec3 surfnorm = dudva.rgb + dudvb.rgb;
-   surfnorm = normalize(vec3(0.0,1.0,0.0) + dudva.xyz*0.4 + dudvb.xyz*0.1);
-   
-   // Foam
-   float fband = fract( aCo.z*0.02+uTime*0.1+depthvalue*10.0 );
-   fband = step( fband+dudva.a*0.8, 0.3 ) * max((1.0-depthvalue*4.0),0.0);
-
-   // Lighting
-   vec3 halfview = -normalize( aCo-uCamera );
-
-   // Sample textures
-   vec4 above = texture( uTexMain, ssuv+ surfnorm.xz*0.2 );
-   vec4 beneath = texture( uTexBack, ssuv );
-
-   // Fog
-   float fdist = pow(length( aCo.xz-uCamera.xz ) * 0.00047, 2.6);
-
-   // Composite
-   vec4 vsurface = water_surf( halfview, surfnorm, depthvalue, beneath, above );
-   vsurface.a -= fdist;
-   oColour = mix( vsurface, vec4(1.0,1.0,1.0,0.5), fband );
-}
diff --git a/shaders/model_water.h b/shaders/model_water.h
deleted file mode 100644
index 2b4f093..0000000
--- a/shaders/model_water.h
+++ /dev/null
@@ -1,378 +0,0 @@
-#ifndef SHADER_model_water_H
-#define SHADER_model_water_H
-static void shader_model_water_link(void);
-static void shader_model_water_register(void);
-static struct vg_shader _shader_model_water = {
-   .name = "model_water",
-   .link = shader_model_water_link,
-   .vs = 
-{
-.static_src = 
-"layout (location=0) in vec3 a_co;\n"
-"layout (location=1) in vec3 a_norm;\n"
-"layout (location=2) in vec2 a_uv;\n"
-"layout (location=3) in vec4 a_colour;\n"
-"layout (location=4) in vec4 a_weights;\n"
-"layout (location=5) in ivec4 a_groups;\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      9        0 \n"
-"\n"
-"uniform mat4x3 uMdl;\n"
-"uniform mat4 uPv;\n"
-"uniform mat4 uPvmPrev;\n"
-"\n"
-"out vec4 aColour;\n"
-"out vec2 aUv;\n"
-"out vec3 aNorm;\n"
-"out vec3 aCo;\n"
-"out vec3 aWorldCo;\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"
-"   aWorldCo = world_pos0;\n"
-"   aColour = a_colour;\n"
-"   aUv = a_uv;\n"
-"   aNorm = mat3(uMdl) * a_norm;\n"
-"   aCo = a_co;\n"
-"}\n"
-""},
-   .fs = 
-{
-.static_src = 
-"uniform sampler2D uTexMain;\n"
-"uniform sampler2D uTexDudv;\n"
-"uniform sampler2D uTexBack;\n"
-"\n"
-"uniform vec2 uInvRes;\n"
-"uniform float uTime;\n"
-"uniform vec3 uCamera;\n"
-"uniform float uSurfaceY;\n"
-"uniform vec3 uBoard0;\n"
-"uniform vec3 uBoard1;\n"
-"\n"
-"uniform vec3 uShoreColour;\n"
-"uniform vec3 uOceanColour;\n"
-"\n"
-"in vec4 aColour;\n"
-"in vec2 aUv;\n"
-"in vec3 aNorm;\n"
-"in vec3 aCo;\n"
-"in vec3 aWorldCo;\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 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     22        0 \n"
-"#line       1        2 \n"
-"const float k_motion_lerp_amount = 0.01;\n"
-"\n"
-"#line      2        0 \n"
-"\n"
-"layout (location = 1) out vec2 oMotionVec;\n"
-"\n"
-"in vec3 aMotionVec0;\n"
-"in vec3 aMotionVec1;\n"
-"\n"
-"void compute_motion_vectors()\n"
-"{\n"
-"   // Write motion vectors\n"
-"   vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
-"   vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
-"\n"
-"   oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
-"}\n"
-"\n"
-"#line     23        0 \n"
-"\n"
-"vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue, \n"
-"      vec4 beneath, vec4 above )\n"
-"{\n"
-"   vec3 surface_tint = mix(uShoreColour, uOceanColour, depthvalue);\n"
-"\n"
-"   float ffresnel = pow(1.0-dot( vnorm, halfview ),5.0);\n"
-"\n"
-"   vec3 lightdir = vec3(0.95,0.0,-0.3);\n"
-"   vec3 specdir = reflect( -lightdir, vnorm );\n"
-"   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"
-"\n"
-"   // Composite\n"
-"   vec3 vsurface = mix(surface_tint, above.rgb, ffresnel );\n"
-"   //vsurface += spec;\n"
-"\n"
-"   return vec4( vsurface,depthblend );\n"
-"}\n"
-"\n"
-"void main()\n"
-"{\n"
-"   compute_motion_vectors();\n"
-"\n"
-"   // Create texture coords\n"
-"   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"
-"\n"
-"   vec2 world_coord = aCo.xz * 0.008;\n"
-"   vec4 time_offsets = vec4( uTime ) * vec4( 0.008, 0.006, 0.003, 0.03 );\n"
-"   vec4 dudva = texture( uTexDudv, world_coord + time_offsets.xy )-0.5;\n"
-"   vec4 dudvb = texture( uTexDudv, world_coord *7.0 - time_offsets.zw )-0.5;\n"
-"\n"
-"   vec3 surfnorm = dudva.rgb + dudvb.rgb;\n"
-"   surfnorm = normalize(vec3(0.0,1.0,0.0) + dudva.xyz*0.4 + dudvb.xyz*0.1);\n"
-"   \n"
-"   // Foam\n"
-"   float fband = fract( aCo.z*0.02+uTime*0.1+depthvalue*10.0 );\n"
-"   fband = step( fband+dudva.a*0.8, 0.3 ) * max((1.0-depthvalue*4.0),0.0);\n"
-"\n"
-"   // Lighting\n"
-"   vec3 halfview = -normalize( aCo-uCamera );\n"
-"\n"
-"   // Sample textures\n"
-"   vec4 above = texture( uTexMain, ssuv+ surfnorm.xz*0.2 );\n"
-"   vec4 beneath = texture( uTexBack, ssuv );\n"
-"\n"
-"   // Fog\n"
-"   float fdist = pow(length( aCo.xz-uCamera.xz ) * 0.00047, 2.6);\n"
-"\n"
-"   // Composite\n"
-"   vec4 vsurface = water_surf( halfview, surfnorm, depthvalue, beneath, above );\n"
-"   vsurface.a -= fdist;\n"
-"   oColour = mix( vsurface, vec4(1.0,1.0,1.0,0.5), fband );\n"
-"}\n"
-""},
-};
-
-static GLuint _uniform_model_water_uMdl;
-static GLuint _uniform_model_water_uPv;
-static GLuint _uniform_model_water_uPvmPrev;
-static GLuint _uniform_model_water_uTexMain;
-static GLuint _uniform_model_water_uTexDudv;
-static GLuint _uniform_model_water_uTexBack;
-static GLuint _uniform_model_water_uInvRes;
-static GLuint _uniform_model_water_uTime;
-static GLuint _uniform_model_water_uCamera;
-static GLuint _uniform_model_water_uSurfaceY;
-static GLuint _uniform_model_water_uBoard0;
-static GLuint _uniform_model_water_uBoard1;
-static GLuint _uniform_model_water_uShoreColour;
-static GLuint _uniform_model_water_uOceanColour;
-static GLuint _uniform_model_water_g_world_depth;
-static void shader_model_water_uMdl(m4x3f m){
-   glUniformMatrix4x3fv(_uniform_model_water_uMdl,1,GL_FALSE,(float*)m);
-}
-static void shader_model_water_uPv(m4x4f m){
-   glUniformMatrix4fv(_uniform_model_water_uPv,1,GL_FALSE,(float*)m);
-}
-static void shader_model_water_uPvmPrev(m4x4f m){
-   glUniformMatrix4fv(_uniform_model_water_uPvmPrev,1,GL_FALSE,(float*)m);
-}
-static void shader_model_water_uTexMain(int i){
-   glUniform1i(_uniform_model_water_uTexMain,i);
-}
-static void shader_model_water_uTexDudv(int i){
-   glUniform1i(_uniform_model_water_uTexDudv,i);
-}
-static void shader_model_water_uTexBack(int i){
-   glUniform1i(_uniform_model_water_uTexBack,i);
-}
-static void shader_model_water_uInvRes(v2f v){
-   glUniform2fv(_uniform_model_water_uInvRes,1,v);
-}
-static void shader_model_water_uTime(float f){
-   glUniform1f(_uniform_model_water_uTime,f);
-}
-static void shader_model_water_uCamera(v3f v){
-   glUniform3fv(_uniform_model_water_uCamera,1,v);
-}
-static void shader_model_water_uSurfaceY(float f){
-   glUniform1f(_uniform_model_water_uSurfaceY,f);
-}
-static void shader_model_water_uBoard0(v3f v){
-   glUniform3fv(_uniform_model_water_uBoard0,1,v);
-}
-static void shader_model_water_uBoard1(v3f v){
-   glUniform3fv(_uniform_model_water_uBoard1,1,v);
-}
-static void shader_model_water_uShoreColour(v3f v){
-   glUniform3fv(_uniform_model_water_uShoreColour,1,v);
-}
-static void shader_model_water_uOceanColour(v3f v){
-   glUniform3fv(_uniform_model_water_uOceanColour,1,v);
-}
-static void shader_model_water_g_world_depth(int i){
-   glUniform1i(_uniform_model_water_g_world_depth,i);
-}
-static void shader_model_water_register(void){
-   vg_shader_register( &_shader_model_water );
-}
-static void shader_model_water_use(void){ glUseProgram(_shader_model_water.id); }
-static void shader_model_water_link(void){
-   _uniform_model_water_uMdl = glGetUniformLocation( _shader_model_water.id, "uMdl" );
-   _uniform_model_water_uPv = glGetUniformLocation( _shader_model_water.id, "uPv" );
-   _uniform_model_water_uPvmPrev = glGetUniformLocation( _shader_model_water.id, "uPvmPrev" );
-   _uniform_model_water_uTexMain = glGetUniformLocation( _shader_model_water.id, "uTexMain" );
-   _uniform_model_water_uTexDudv = glGetUniformLocation( _shader_model_water.id, "uTexDudv" );
-   _uniform_model_water_uTexBack = glGetUniformLocation( _shader_model_water.id, "uTexBack" );
-   _uniform_model_water_uInvRes = glGetUniformLocation( _shader_model_water.id, "uInvRes" );
-   _uniform_model_water_uTime = glGetUniformLocation( _shader_model_water.id, "uTime" );
-   _uniform_model_water_uCamera = glGetUniformLocation( _shader_model_water.id, "uCamera" );
-   _uniform_model_water_uSurfaceY = glGetUniformLocation( _shader_model_water.id, "uSurfaceY" );
-   _uniform_model_water_uBoard0 = glGetUniformLocation( _shader_model_water.id, "uBoard0" );
-   _uniform_model_water_uBoard1 = glGetUniformLocation( _shader_model_water.id, "uBoard1" );
-   _uniform_model_water_uShoreColour = glGetUniformLocation( _shader_model_water.id, "uShoreColour" );
-   _uniform_model_water_uOceanColour = glGetUniformLocation( _shader_model_water.id, "uOceanColour" );
-   _uniform_model_water_g_world_depth = glGetUniformLocation( _shader_model_water.id, "g_world_depth" );
-}
-#endif /* SHADER_model_water_H */
diff --git a/shaders/model_water_fast.fs b/shaders/model_water_fast.fs
deleted file mode 100644
index 5f68c45..0000000
--- a/shaders/model_water_fast.fs
+++ /dev/null
@@ -1,63 +0,0 @@
-uniform sampler2D uTexDudv;
-
-uniform float uTime;
-uniform vec3 uCamera;
-uniform float uSurfaceY;
-uniform vec3 uBoard0;
-uniform vec3 uBoard1;
-
-uniform vec3 uShoreColour;
-uniform vec3 uOceanColour;
-
-in vec4 aColour;
-in vec2 aUv;
-in vec3 aNorm;
-in vec3 aCo;
-in vec3 aWorldCo;
-
-#include "common_world.glsl"
-#include "motion_vectors_fs.glsl"
-
-vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue )
-{
-   vec3 surface_tint = mix(uShoreColour, uOceanColour, depthvalue);
-
-   float ffresnel = pow(1.0-dot( vnorm, halfview ),5.0);
-
-   vec3 lightdir = vec3(0.95,0.0,-0.3);
-   vec3 specdir = reflect( -lightdir, vnorm );
-   float spec = pow(max(dot(halfview,specdir),0.0),20.0)*0.3;
-   
-   return vec4( surface_tint + spec, max(min(depthvalue*4.0, 1.0),0.0) );
-}
-
-void main()
-{
-   compute_motion_vectors();
-
-   // Surface colour composite
-   float depthvalue = clamp( -world_depth_sample( 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 );
-   vec4 dudva = texture( uTexDudv, world_coord + time_offsets.xy )-0.5;
-   vec4 dudvb = texture( uTexDudv, world_coord *7.0 - time_offsets.zw )-0.5;
-
-   vec3 surfnorm = dudva.rgb + dudvb.rgb;
-   surfnorm = normalize(vec3(0.0,1.0,0.0) + dudva.xyz*0.4 + dudvb.xyz*0.1);
-   
-   // Foam
-   float fband = fract( aCo.z*0.02+uTime*0.1+depthvalue*10.0 );
-   fband = step( fband+dudva.a*0.8, 0.3 ) * max((1.0-depthvalue*4.0),0.0);
-
-   // Lighting
-   vec3 halfview = -normalize( aCo-uCamera );
-
-   // Fog
-   float fdist = pow(length( aCo.xz-uCamera.xz ) * 0.00047, 2.6);
-
-   // Composite
-   vec4 vsurface = water_surf( halfview, surfnorm, depthvalue );
-   vsurface.a -= fdist;
-   oColour = mix( vsurface, vec4(1.0,1.0,1.0,0.5), fband );
-}
diff --git a/shaders/model_water_fast.h b/shaders/model_water_fast.h
deleted file mode 100644
index 32785f3..0000000
--- a/shaders/model_water_fast.h
+++ /dev/null
@@ -1,345 +0,0 @@
-#ifndef SHADER_model_water_fast_H
-#define SHADER_model_water_fast_H
-static void shader_model_water_fast_link(void);
-static void shader_model_water_fast_register(void);
-static struct vg_shader _shader_model_water_fast = {
-   .name = "model_water_fast",
-   .link = shader_model_water_fast_link,
-   .vs = 
-{
-.static_src = 
-"layout (location=0) in vec3 a_co;\n"
-"layout (location=1) in vec3 a_norm;\n"
-"layout (location=2) in vec2 a_uv;\n"
-"layout (location=3) in vec4 a_colour;\n"
-"layout (location=4) in vec4 a_weights;\n"
-"layout (location=5) in ivec4 a_groups;\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      9        0 \n"
-"\n"
-"uniform mat4x3 uMdl;\n"
-"uniform mat4 uPv;\n"
-"uniform mat4 uPvmPrev;\n"
-"\n"
-"out vec4 aColour;\n"
-"out vec2 aUv;\n"
-"out vec3 aNorm;\n"
-"out vec3 aCo;\n"
-"out vec3 aWorldCo;\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"
-"   aWorldCo = world_pos0;\n"
-"   aColour = a_colour;\n"
-"   aUv = a_uv;\n"
-"   aNorm = mat3(uMdl) * a_norm;\n"
-"   aCo = a_co;\n"
-"}\n"
-""},
-   .fs = 
-{
-.static_src = 
-"uniform sampler2D uTexDudv;\n"
-"\n"
-"uniform float uTime;\n"
-"uniform vec3 uCamera;\n"
-"uniform float uSurfaceY;\n"
-"uniform vec3 uBoard0;\n"
-"uniform vec3 uBoard1;\n"
-"\n"
-"uniform vec3 uShoreColour;\n"
-"uniform vec3 uOceanColour;\n"
-"\n"
-"in vec4 aColour;\n"
-"in vec2 aUv;\n"
-"in vec3 aNorm;\n"
-"in vec3 aCo;\n"
-"in vec3 aWorldCo;\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 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     19        0 \n"
-"#line       1        2 \n"
-"const float k_motion_lerp_amount = 0.01;\n"
-"\n"
-"#line      2        0 \n"
-"\n"
-"layout (location = 1) out vec2 oMotionVec;\n"
-"\n"
-"in vec3 aMotionVec0;\n"
-"in vec3 aMotionVec1;\n"
-"\n"
-"void compute_motion_vectors()\n"
-"{\n"
-"   // Write motion vectors\n"
-"   vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
-"   vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
-"\n"
-"   oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
-"}\n"
-"\n"
-"#line     20        0 \n"
-"\n"
-"vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue )\n"
-"{\n"
-"   vec3 surface_tint = mix(uShoreColour, uOceanColour, depthvalue);\n"
-"\n"
-"   float ffresnel = pow(1.0-dot( vnorm, halfview ),5.0);\n"
-"\n"
-"   vec3 lightdir = vec3(0.95,0.0,-0.3);\n"
-"   vec3 specdir = reflect( -lightdir, vnorm );\n"
-"   float spec = pow(max(dot(halfview,specdir),0.0),20.0)*0.3;\n"
-"   \n"
-"   return vec4( surface_tint + spec, max(min(depthvalue*4.0, 1.0),0.0) );\n"
-"}\n"
-"\n"
-"void main()\n"
-"{\n"
-"   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"
-"\n"
-"   vec2 world_coord = aCo.xz * 0.008;\n"
-"   vec4 time_offsets = vec4( uTime ) * vec4( 0.008, 0.006, 0.003, 0.03 );\n"
-"   vec4 dudva = texture( uTexDudv, world_coord + time_offsets.xy )-0.5;\n"
-"   vec4 dudvb = texture( uTexDudv, world_coord *7.0 - time_offsets.zw )-0.5;\n"
-"\n"
-"   vec3 surfnorm = dudva.rgb + dudvb.rgb;\n"
-"   surfnorm = normalize(vec3(0.0,1.0,0.0) + dudva.xyz*0.4 + dudvb.xyz*0.1);\n"
-"   \n"
-"   // Foam\n"
-"   float fband = fract( aCo.z*0.02+uTime*0.1+depthvalue*10.0 );\n"
-"   fband = step( fband+dudva.a*0.8, 0.3 ) * max((1.0-depthvalue*4.0),0.0);\n"
-"\n"
-"   // Lighting\n"
-"   vec3 halfview = -normalize( aCo-uCamera );\n"
-"\n"
-"   // Fog\n"
-"   float fdist = pow(length( aCo.xz-uCamera.xz ) * 0.00047, 2.6);\n"
-"\n"
-"   // Composite\n"
-"   vec4 vsurface = water_surf( halfview, surfnorm, depthvalue );\n"
-"   vsurface.a -= fdist;\n"
-"   oColour = mix( vsurface, vec4(1.0,1.0,1.0,0.5), fband );\n"
-"}\n"
-""},
-};
-
-static GLuint _uniform_model_water_fast_uMdl;
-static GLuint _uniform_model_water_fast_uPv;
-static GLuint _uniform_model_water_fast_uPvmPrev;
-static GLuint _uniform_model_water_fast_uTexDudv;
-static GLuint _uniform_model_water_fast_uTime;
-static GLuint _uniform_model_water_fast_uCamera;
-static GLuint _uniform_model_water_fast_uSurfaceY;
-static GLuint _uniform_model_water_fast_uBoard0;
-static GLuint _uniform_model_water_fast_uBoard1;
-static GLuint _uniform_model_water_fast_uShoreColour;
-static GLuint _uniform_model_water_fast_uOceanColour;
-static GLuint _uniform_model_water_fast_g_world_depth;
-static void shader_model_water_fast_uMdl(m4x3f m){
-   glUniformMatrix4x3fv(_uniform_model_water_fast_uMdl,1,GL_FALSE,(float*)m);
-}
-static void shader_model_water_fast_uPv(m4x4f m){
-   glUniformMatrix4fv(_uniform_model_water_fast_uPv,1,GL_FALSE,(float*)m);
-}
-static void shader_model_water_fast_uPvmPrev(m4x4f m){
-   glUniformMatrix4fv(_uniform_model_water_fast_uPvmPrev,1,GL_FALSE,(float*)m);
-}
-static void shader_model_water_fast_uTexDudv(int i){
-   glUniform1i(_uniform_model_water_fast_uTexDudv,i);
-}
-static void shader_model_water_fast_uTime(float f){
-   glUniform1f(_uniform_model_water_fast_uTime,f);
-}
-static void shader_model_water_fast_uCamera(v3f v){
-   glUniform3fv(_uniform_model_water_fast_uCamera,1,v);
-}
-static void shader_model_water_fast_uSurfaceY(float f){
-   glUniform1f(_uniform_model_water_fast_uSurfaceY,f);
-}
-static void shader_model_water_fast_uBoard0(v3f v){
-   glUniform3fv(_uniform_model_water_fast_uBoard0,1,v);
-}
-static void shader_model_water_fast_uBoard1(v3f v){
-   glUniform3fv(_uniform_model_water_fast_uBoard1,1,v);
-}
-static void shader_model_water_fast_uShoreColour(v3f v){
-   glUniform3fv(_uniform_model_water_fast_uShoreColour,1,v);
-}
-static void shader_model_water_fast_uOceanColour(v3f v){
-   glUniform3fv(_uniform_model_water_fast_uOceanColour,1,v);
-}
-static void shader_model_water_fast_g_world_depth(int i){
-   glUniform1i(_uniform_model_water_fast_g_world_depth,i);
-}
-static void shader_model_water_fast_register(void){
-   vg_shader_register( &_shader_model_water_fast );
-}
-static void shader_model_water_fast_use(void){ glUseProgram(_shader_model_water_fast.id); }
-static void shader_model_water_fast_link(void){
-   _uniform_model_water_fast_uMdl = glGetUniformLocation( _shader_model_water_fast.id, "uMdl" );
-   _uniform_model_water_fast_uPv = glGetUniformLocation( _shader_model_water_fast.id, "uPv" );
-   _uniform_model_water_fast_uPvmPrev = glGetUniformLocation( _shader_model_water_fast.id, "uPvmPrev" );
-   _uniform_model_water_fast_uTexDudv = glGetUniformLocation( _shader_model_water_fast.id, "uTexDudv" );
-   _uniform_model_water_fast_uTime = glGetUniformLocation( _shader_model_water_fast.id, "uTime" );
-   _uniform_model_water_fast_uCamera = glGetUniformLocation( _shader_model_water_fast.id, "uCamera" );
-   _uniform_model_water_fast_uSurfaceY = glGetUniformLocation( _shader_model_water_fast.id, "uSurfaceY" );
-   _uniform_model_water_fast_uBoard0 = glGetUniformLocation( _shader_model_water_fast.id, "uBoard0" );
-   _uniform_model_water_fast_uBoard1 = glGetUniformLocation( _shader_model_water_fast.id, "uBoard1" );
-   _uniform_model_water_fast_uShoreColour = glGetUniformLocation( _shader_model_water_fast.id, "uShoreColour" );
-   _uniform_model_water_fast_uOceanColour = glGetUniformLocation( _shader_model_water_fast.id, "uOceanColour" );
-   _uniform_model_water_fast_g_world_depth = glGetUniformLocation( _shader_model_water_fast.id, "g_world_depth" );
-}
-#endif /* SHADER_model_water_fast_H */
diff --git a/shaders/scene_depth.fs b/shaders/scene_depth.fs
index 05d886b..a2b7642 100644
--- a/shaders/scene_depth.fs
+++ b/shaders/scene_depth.fs
@@ -10,7 +10,7 @@ in vec3 aCo;
 in vec3 aWorldCo;
 flat in ivec4 aLights;
 
-#include "common_world.glsl"
+#include "common_scene.glsl"
 
 // Water blending
 // ==============
@@ -27,7 +27,7 @@ float water_depth( vec3 pos, vec3 halfview )
 
 void main()
 {
-   vec3 halfview = normalize( uCamera - aCo );
-   vec3 world_pos = vec3( aCo.y, aCo.x, aCo.z );
-   FragColor = vec4( world_pos, water_depth( aCo, halfview ) );
+   vec3 halfview = normalize( uCamera - aWorldCo );
+   float depth = water_depth( aWorldCo, halfview );
+   FragColor = vec4( aWorldCo.y, 0.0, 0.0,depth );
 }
diff --git a/shaders/scene_depth.h b/shaders/scene_depth.h
index 53b2bfa..ce1a818 100644
--- a/shaders/scene_depth.h
+++ b/shaders/scene_depth.h
@@ -76,6 +76,9 @@ static struct vg_shader _shader_scene_depth = {
 "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"
@@ -202,6 +205,51 @@ static struct vg_shader _shader_scene_depth = {
 "   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"
 "// Water blending\n"
@@ -219,9 +267,9 @@ static struct vg_shader _shader_scene_depth = {
 "\n"
 "void main()\n"
 "{\n"
-"   vec3 halfview = normalize( uCamera - aCo );\n"
-"   vec3 world_pos = vec3( aCo.y, aCo.x, aCo.z );\n"
-"   FragColor = vec4( world_pos, water_depth( aCo, halfview ) );\n"
+"   vec3 halfview = normalize( uCamera - aWorldCo );\n"
+"   float depth = water_depth( aWorldCo, halfview );\n"
+"   FragColor = vec4( aWorldCo.y, 0.0, 0.0,depth );\n"
 "}\n"
 ""},
 };
diff --git a/shaders/scene_water.fs b/shaders/scene_water.fs
new file mode 100644
index 0000000..6455699
--- /dev/null
+++ b/shaders/scene_water.fs
@@ -0,0 +1,81 @@
+uniform sampler2D uTexMain;
+uniform sampler2D uTexDudv;
+uniform sampler2D uTexBack;
+
+uniform vec2 uInvRes;
+uniform float uTime;
+uniform vec3 uCamera;
+uniform float uSurfaceY;
+uniform vec3 uBoard0;
+uniform vec3 uBoard1;
+
+uniform vec3 uShoreColour;
+uniform vec3 uOceanColour;
+
+in vec2 aUv;
+in vec4 aNorm;
+in vec3 aCo;
+in vec3 aWorldCo;
+flat in ivec4 aLights;
+
+#include "common_scene.glsl"
+#include "motion_vectors_fs.glsl"
+
+vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue, 
+                 vec4 beneath, vec4 above )
+{
+   vec3 surface_tint = mix(uShoreColour, uOceanColour, depthvalue);
+
+   float ffresnel = pow(1.0-dot( vnorm, halfview ),5.0);
+
+   vec3 lightdir = vec3(0.95,0.0,-0.3);
+   vec3 specdir = reflect( -lightdir, vnorm );
+   float spec = pow(max(dot(halfview,specdir),0.0),20.0)*0.3;
+   
+   // Depth 
+   float depthblend = pow( beneath.a,0.8 );
+
+   // Composite
+   vec3 vsurface = mix(surface_tint, above.rgb, ffresnel );
+   //vsurface += spec;
+
+   return vec4( vsurface,depthblend );
+}
+
+void main()
+{
+   compute_motion_vectors();
+
+   // Create texture coords
+   vec2 ssuv = gl_FragCoord.xy*uInvRes;
+   
+   // Surface colour composite
+   float depthvalue = clamp( -world_depth_sample( 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 );
+   vec4 dudva = texture( uTexDudv, world_coord + time_offsets.xy )-0.5;
+   vec4 dudvb = texture( uTexDudv, world_coord *7.0 - time_offsets.zw )-0.5;
+
+   vec3 surfnorm = dudva.rgb + dudvb.rgb;
+   surfnorm = normalize(vec3(0.0,1.0,0.0) + dudva.xyz*0.4 + dudvb.xyz*0.1);
+   
+   // Foam
+   float fband = fract( aCo.z*0.02+uTime*0.1+depthvalue*10.0 );
+   fband = step( fband+dudva.a*0.8, 0.3 ) * max((1.0-depthvalue*4.0),0.0);
+
+   // Lighting
+   vec3 halfview = -normalize( aCo-uCamera );
+
+   // Sample textures
+   vec4 above = texture( uTexMain, ssuv+ surfnorm.xz*0.2 );
+   vec4 beneath = texture( uTexBack, ssuv );
+
+   // Fog
+   float fdist = pow(length( aCo.xz-uCamera.xz ) * 0.00047, 2.6);
+
+   // Composite
+   vec4 vsurface = water_surf( halfview, surfnorm, depthvalue, beneath, above );
+   vsurface.a -= fdist;
+   oColour = mix( vsurface, vec4(1.0,1.0,1.0,0.5), fband );
+}
diff --git a/shaders/scene_water.h b/shaders/scene_water.h
new file mode 100644
index 0000000..54eaff2
--- /dev/null
+++ b/shaders/scene_water.h
@@ -0,0 +1,425 @@
+#ifndef SHADER_scene_water_H
+#define SHADER_scene_water_H
+static void shader_scene_water_link(void);
+static void shader_scene_water_register(void);
+static struct vg_shader _shader_scene_water = {
+   .name = "scene_water",
+   .link = shader_scene_water_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 = 
+"uniform sampler2D uTexMain;\n"
+"uniform sampler2D uTexDudv;\n"
+"uniform sampler2D uTexBack;\n"
+"\n"
+"uniform vec2 uInvRes;\n"
+"uniform float uTime;\n"
+"uniform vec3 uCamera;\n"
+"uniform float uSurfaceY;\n"
+"uniform vec3 uBoard0;\n"
+"uniform vec3 uBoard1;\n"
+"\n"
+"uniform vec3 uShoreColour;\n"
+"uniform vec3 uOceanColour;\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 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     22        0 \n"
+"#line       1        2 \n"
+"const float k_motion_lerp_amount = 0.01;\n"
+"\n"
+"#line      2        0 \n"
+"\n"
+"layout (location = 1) out vec2 oMotionVec;\n"
+"\n"
+"in vec3 aMotionVec0;\n"
+"in vec3 aMotionVec1;\n"
+"\n"
+"void compute_motion_vectors()\n"
+"{\n"
+"   // Write motion vectors\n"
+"   vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
+"   vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
+"\n"
+"   oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
+"}\n"
+"\n"
+"#line     23        0 \n"
+"\n"
+"vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue, \n"
+"                 vec4 beneath, vec4 above )\n"
+"{\n"
+"   vec3 surface_tint = mix(uShoreColour, uOceanColour, depthvalue);\n"
+"\n"
+"   float ffresnel = pow(1.0-dot( vnorm, halfview ),5.0);\n"
+"\n"
+"   vec3 lightdir = vec3(0.95,0.0,-0.3);\n"
+"   vec3 specdir = reflect( -lightdir, vnorm );\n"
+"   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"
+"\n"
+"   // Composite\n"
+"   vec3 vsurface = mix(surface_tint, above.rgb, ffresnel );\n"
+"   //vsurface += spec;\n"
+"\n"
+"   return vec4( vsurface,depthblend );\n"
+"}\n"
+"\n"
+"void main()\n"
+"{\n"
+"   compute_motion_vectors();\n"
+"\n"
+"   // Create texture coords\n"
+"   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"
+"\n"
+"   vec2 world_coord = aCo.xz * 0.008;\n"
+"   vec4 time_offsets = vec4( uTime ) * vec4( 0.008, 0.006, 0.003, 0.03 );\n"
+"   vec4 dudva = texture( uTexDudv, world_coord + time_offsets.xy )-0.5;\n"
+"   vec4 dudvb = texture( uTexDudv, world_coord *7.0 - time_offsets.zw )-0.5;\n"
+"\n"
+"   vec3 surfnorm = dudva.rgb + dudvb.rgb;\n"
+"   surfnorm = normalize(vec3(0.0,1.0,0.0) + dudva.xyz*0.4 + dudvb.xyz*0.1);\n"
+"   \n"
+"   // Foam\n"
+"   float fband = fract( aCo.z*0.02+uTime*0.1+depthvalue*10.0 );\n"
+"   fband = step( fband+dudva.a*0.8, 0.3 ) * max((1.0-depthvalue*4.0),0.0);\n"
+"\n"
+"   // Lighting\n"
+"   vec3 halfview = -normalize( aCo-uCamera );\n"
+"\n"
+"   // Sample textures\n"
+"   vec4 above = texture( uTexMain, ssuv+ surfnorm.xz*0.2 );\n"
+"   vec4 beneath = texture( uTexBack, ssuv );\n"
+"\n"
+"   // Fog\n"
+"   float fdist = pow(length( aCo.xz-uCamera.xz ) * 0.00047, 2.6);\n"
+"\n"
+"   // Composite\n"
+"   vec4 vsurface = water_surf( halfview, surfnorm, depthvalue, beneath, above );\n"
+"   vsurface.a -= fdist;\n"
+"   oColour = mix( vsurface, vec4(1.0,1.0,1.0,0.5), fband );\n"
+"}\n"
+""},
+};
+
+static GLuint _uniform_scene_water_uMdl;
+static GLuint _uniform_scene_water_uPv;
+static GLuint _uniform_scene_water_uPvmPrev;
+static GLuint _uniform_scene_water_uTexMain;
+static GLuint _uniform_scene_water_uTexDudv;
+static GLuint _uniform_scene_water_uTexBack;
+static GLuint _uniform_scene_water_uInvRes;
+static GLuint _uniform_scene_water_uTime;
+static GLuint _uniform_scene_water_uCamera;
+static GLuint _uniform_scene_water_uSurfaceY;
+static GLuint _uniform_scene_water_uBoard0;
+static GLuint _uniform_scene_water_uBoard1;
+static GLuint _uniform_scene_water_uShoreColour;
+static GLuint _uniform_scene_water_uOceanColour;
+static GLuint _uniform_scene_water_g_world_depth;
+static void shader_scene_water_uMdl(m4x3f m){
+   glUniformMatrix4x3fv(_uniform_scene_water_uMdl,1,GL_FALSE,(float*)m);
+}
+static void shader_scene_water_uPv(m4x4f m){
+   glUniformMatrix4fv(_uniform_scene_water_uPv,1,GL_FALSE,(float*)m);
+}
+static void shader_scene_water_uPvmPrev(m4x4f m){
+   glUniformMatrix4fv(_uniform_scene_water_uPvmPrev,1,GL_FALSE,(float*)m);
+}
+static void shader_scene_water_uTexMain(int i){
+   glUniform1i(_uniform_scene_water_uTexMain,i);
+}
+static void shader_scene_water_uTexDudv(int i){
+   glUniform1i(_uniform_scene_water_uTexDudv,i);
+}
+static void shader_scene_water_uTexBack(int i){
+   glUniform1i(_uniform_scene_water_uTexBack,i);
+}
+static void shader_scene_water_uInvRes(v2f v){
+   glUniform2fv(_uniform_scene_water_uInvRes,1,v);
+}
+static void shader_scene_water_uTime(float f){
+   glUniform1f(_uniform_scene_water_uTime,f);
+}
+static void shader_scene_water_uCamera(v3f v){
+   glUniform3fv(_uniform_scene_water_uCamera,1,v);
+}
+static void shader_scene_water_uSurfaceY(float f){
+   glUniform1f(_uniform_scene_water_uSurfaceY,f);
+}
+static void shader_scene_water_uBoard0(v3f v){
+   glUniform3fv(_uniform_scene_water_uBoard0,1,v);
+}
+static void shader_scene_water_uBoard1(v3f v){
+   glUniform3fv(_uniform_scene_water_uBoard1,1,v);
+}
+static void shader_scene_water_uShoreColour(v3f v){
+   glUniform3fv(_uniform_scene_water_uShoreColour,1,v);
+}
+static void shader_scene_water_uOceanColour(v3f v){
+   glUniform3fv(_uniform_scene_water_uOceanColour,1,v);
+}
+static void shader_scene_water_g_world_depth(int i){
+   glUniform1i(_uniform_scene_water_g_world_depth,i);
+}
+static void shader_scene_water_register(void){
+   vg_shader_register( &_shader_scene_water );
+}
+static void shader_scene_water_use(void){ glUseProgram(_shader_scene_water.id); }
+static void shader_scene_water_link(void){
+   _uniform_scene_water_uMdl = glGetUniformLocation( _shader_scene_water.id, "uMdl" );
+   _uniform_scene_water_uPv = glGetUniformLocation( _shader_scene_water.id, "uPv" );
+   _uniform_scene_water_uPvmPrev = glGetUniformLocation( _shader_scene_water.id, "uPvmPrev" );
+   _uniform_scene_water_uTexMain = glGetUniformLocation( _shader_scene_water.id, "uTexMain" );
+   _uniform_scene_water_uTexDudv = glGetUniformLocation( _shader_scene_water.id, "uTexDudv" );
+   _uniform_scene_water_uTexBack = glGetUniformLocation( _shader_scene_water.id, "uTexBack" );
+   _uniform_scene_water_uInvRes = glGetUniformLocation( _shader_scene_water.id, "uInvRes" );
+   _uniform_scene_water_uTime = glGetUniformLocation( _shader_scene_water.id, "uTime" );
+   _uniform_scene_water_uCamera = glGetUniformLocation( _shader_scene_water.id, "uCamera" );
+   _uniform_scene_water_uSurfaceY = glGetUniformLocation( _shader_scene_water.id, "uSurfaceY" );
+   _uniform_scene_water_uBoard0 = glGetUniformLocation( _shader_scene_water.id, "uBoard0" );
+   _uniform_scene_water_uBoard1 = glGetUniformLocation( _shader_scene_water.id, "uBoard1" );
+   _uniform_scene_water_uShoreColour = glGetUniformLocation( _shader_scene_water.id, "uShoreColour" );
+   _uniform_scene_water_uOceanColour = glGetUniformLocation( _shader_scene_water.id, "uOceanColour" );
+   _uniform_scene_water_g_world_depth = glGetUniformLocation( _shader_scene_water.id, "g_world_depth" );
+}
+#endif /* SHADER_scene_water_H */
diff --git a/shaders/scene_water_fast.fs b/shaders/scene_water_fast.fs
new file mode 100644
index 0000000..81a4b02
--- /dev/null
+++ b/shaders/scene_water_fast.fs
@@ -0,0 +1,63 @@
+uniform sampler2D uTexDudv;
+
+uniform float uTime;
+uniform vec3 uCamera;
+uniform float uSurfaceY;
+uniform vec3 uBoard0;
+uniform vec3 uBoard1;
+
+uniform vec3 uShoreColour;
+uniform vec3 uOceanColour;
+
+in vec2 aUv;
+in vec4 aNorm;
+in vec3 aCo;
+in vec3 aWorldCo;
+flat in ivec4 aLights;
+
+#include "common_scene.glsl"
+#include "motion_vectors_fs.glsl"
+
+vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue )
+{
+   vec3 surface_tint = mix(uShoreColour, uOceanColour, depthvalue);
+
+   float ffresnel = pow(1.0-dot( vnorm, halfview ),5.0);
+
+   vec3 lightdir = vec3(0.95,0.0,-0.3);
+   vec3 specdir = reflect( -lightdir, vnorm );
+   float spec = pow(max(dot(halfview,specdir),0.0),20.0)*0.3;
+   
+   return vec4( surface_tint + spec, max(min(depthvalue*4.0, 1.0),0.0) );
+}
+
+void main()
+{
+   compute_motion_vectors();
+
+   // Surface colour composite
+   float depthvalue = clamp( -world_depth_sample( 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 );
+   vec4 dudva = texture( uTexDudv, world_coord + time_offsets.xy )-0.5;
+   vec4 dudvb = texture( uTexDudv, world_coord *7.0 - time_offsets.zw )-0.5;
+
+   vec3 surfnorm = dudva.rgb + dudvb.rgb;
+   surfnorm = normalize(vec3(0.0,1.0,0.0) + dudva.xyz*0.4 + dudvb.xyz*0.1);
+   
+   // Foam
+   float fband = fract( aCo.z*0.02+uTime*0.1+depthvalue*10.0 );
+   fband = step( fband+dudva.a*0.8, 0.3 ) * max((1.0-depthvalue*4.0),0.0);
+
+   // Lighting
+   vec3 halfview = -normalize( aCo-uCamera );
+
+   // Fog
+   float fdist = pow(length( aCo.xz-uCamera.xz ) * 0.00047, 2.6);
+
+   // Composite
+   vec4 vsurface = water_surf( halfview, surfnorm, depthvalue );
+   vsurface.a -= fdist;
+   oColour = mix( vsurface, vec4(1.0,1.0,1.0,0.5), fband );
+}
diff --git a/shaders/scene_water_fast.h b/shaders/scene_water_fast.h
new file mode 100644
index 0000000..d3a7ac4
--- /dev/null
+++ b/shaders/scene_water_fast.h
@@ -0,0 +1,392 @@
+#ifndef SHADER_scene_water_fast_H
+#define SHADER_scene_water_fast_H
+static void shader_scene_water_fast_link(void);
+static void shader_scene_water_fast_register(void);
+static struct vg_shader _shader_scene_water_fast = {
+   .name = "scene_water_fast",
+   .link = shader_scene_water_fast_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 = 
+"uniform sampler2D uTexDudv;\n"
+"\n"
+"uniform float uTime;\n"
+"uniform vec3 uCamera;\n"
+"uniform float uSurfaceY;\n"
+"uniform vec3 uBoard0;\n"
+"uniform vec3 uBoard1;\n"
+"\n"
+"uniform vec3 uShoreColour;\n"
+"uniform vec3 uOceanColour;\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 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     19        0 \n"
+"#line       1        2 \n"
+"const float k_motion_lerp_amount = 0.01;\n"
+"\n"
+"#line      2        0 \n"
+"\n"
+"layout (location = 1) out vec2 oMotionVec;\n"
+"\n"
+"in vec3 aMotionVec0;\n"
+"in vec3 aMotionVec1;\n"
+"\n"
+"void compute_motion_vectors()\n"
+"{\n"
+"   // Write motion vectors\n"
+"   vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
+"   vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
+"\n"
+"   oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
+"}\n"
+"\n"
+"#line     20        0 \n"
+"\n"
+"vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue )\n"
+"{\n"
+"   vec3 surface_tint = mix(uShoreColour, uOceanColour, depthvalue);\n"
+"\n"
+"   float ffresnel = pow(1.0-dot( vnorm, halfview ),5.0);\n"
+"\n"
+"   vec3 lightdir = vec3(0.95,0.0,-0.3);\n"
+"   vec3 specdir = reflect( -lightdir, vnorm );\n"
+"   float spec = pow(max(dot(halfview,specdir),0.0),20.0)*0.3;\n"
+"   \n"
+"   return vec4( surface_tint + spec, max(min(depthvalue*4.0, 1.0),0.0) );\n"
+"}\n"
+"\n"
+"void main()\n"
+"{\n"
+"   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"
+"\n"
+"   vec2 world_coord = aCo.xz * 0.008;\n"
+"   vec4 time_offsets = vec4( uTime ) * vec4( 0.008, 0.006, 0.003, 0.03 );\n"
+"   vec4 dudva = texture( uTexDudv, world_coord + time_offsets.xy )-0.5;\n"
+"   vec4 dudvb = texture( uTexDudv, world_coord *7.0 - time_offsets.zw )-0.5;\n"
+"\n"
+"   vec3 surfnorm = dudva.rgb + dudvb.rgb;\n"
+"   surfnorm = normalize(vec3(0.0,1.0,0.0) + dudva.xyz*0.4 + dudvb.xyz*0.1);\n"
+"   \n"
+"   // Foam\n"
+"   float fband = fract( aCo.z*0.02+uTime*0.1+depthvalue*10.0 );\n"
+"   fband = step( fband+dudva.a*0.8, 0.3 ) * max((1.0-depthvalue*4.0),0.0);\n"
+"\n"
+"   // Lighting\n"
+"   vec3 halfview = -normalize( aCo-uCamera );\n"
+"\n"
+"   // Fog\n"
+"   float fdist = pow(length( aCo.xz-uCamera.xz ) * 0.00047, 2.6);\n"
+"\n"
+"   // Composite\n"
+"   vec4 vsurface = water_surf( halfview, surfnorm, depthvalue );\n"
+"   vsurface.a -= fdist;\n"
+"   oColour = mix( vsurface, vec4(1.0,1.0,1.0,0.5), fband );\n"
+"}\n"
+""},
+};
+
+static GLuint _uniform_scene_water_fast_uMdl;
+static GLuint _uniform_scene_water_fast_uPv;
+static GLuint _uniform_scene_water_fast_uPvmPrev;
+static GLuint _uniform_scene_water_fast_uTexDudv;
+static GLuint _uniform_scene_water_fast_uTime;
+static GLuint _uniform_scene_water_fast_uCamera;
+static GLuint _uniform_scene_water_fast_uSurfaceY;
+static GLuint _uniform_scene_water_fast_uBoard0;
+static GLuint _uniform_scene_water_fast_uBoard1;
+static GLuint _uniform_scene_water_fast_uShoreColour;
+static GLuint _uniform_scene_water_fast_uOceanColour;
+static GLuint _uniform_scene_water_fast_g_world_depth;
+static void shader_scene_water_fast_uMdl(m4x3f m){
+   glUniformMatrix4x3fv(_uniform_scene_water_fast_uMdl,1,GL_FALSE,(float*)m);
+}
+static void shader_scene_water_fast_uPv(m4x4f m){
+   glUniformMatrix4fv(_uniform_scene_water_fast_uPv,1,GL_FALSE,(float*)m);
+}
+static void shader_scene_water_fast_uPvmPrev(m4x4f m){
+   glUniformMatrix4fv(_uniform_scene_water_fast_uPvmPrev,1,GL_FALSE,(float*)m);
+}
+static void shader_scene_water_fast_uTexDudv(int i){
+   glUniform1i(_uniform_scene_water_fast_uTexDudv,i);
+}
+static void shader_scene_water_fast_uTime(float f){
+   glUniform1f(_uniform_scene_water_fast_uTime,f);
+}
+static void shader_scene_water_fast_uCamera(v3f v){
+   glUniform3fv(_uniform_scene_water_fast_uCamera,1,v);
+}
+static void shader_scene_water_fast_uSurfaceY(float f){
+   glUniform1f(_uniform_scene_water_fast_uSurfaceY,f);
+}
+static void shader_scene_water_fast_uBoard0(v3f v){
+   glUniform3fv(_uniform_scene_water_fast_uBoard0,1,v);
+}
+static void shader_scene_water_fast_uBoard1(v3f v){
+   glUniform3fv(_uniform_scene_water_fast_uBoard1,1,v);
+}
+static void shader_scene_water_fast_uShoreColour(v3f v){
+   glUniform3fv(_uniform_scene_water_fast_uShoreColour,1,v);
+}
+static void shader_scene_water_fast_uOceanColour(v3f v){
+   glUniform3fv(_uniform_scene_water_fast_uOceanColour,1,v);
+}
+static void shader_scene_water_fast_g_world_depth(int i){
+   glUniform1i(_uniform_scene_water_fast_g_world_depth,i);
+}
+static void shader_scene_water_fast_register(void){
+   vg_shader_register( &_shader_scene_water_fast );
+}
+static void shader_scene_water_fast_use(void){ glUseProgram(_shader_scene_water_fast.id); }
+static void shader_scene_water_fast_link(void){
+   _uniform_scene_water_fast_uMdl = glGetUniformLocation( _shader_scene_water_fast.id, "uMdl" );
+   _uniform_scene_water_fast_uPv = glGetUniformLocation( _shader_scene_water_fast.id, "uPv" );
+   _uniform_scene_water_fast_uPvmPrev = glGetUniformLocation( _shader_scene_water_fast.id, "uPvmPrev" );
+   _uniform_scene_water_fast_uTexDudv = glGetUniformLocation( _shader_scene_water_fast.id, "uTexDudv" );
+   _uniform_scene_water_fast_uTime = glGetUniformLocation( _shader_scene_water_fast.id, "uTime" );
+   _uniform_scene_water_fast_uCamera = glGetUniformLocation( _shader_scene_water_fast.id, "uCamera" );
+   _uniform_scene_water_fast_uSurfaceY = glGetUniformLocation( _shader_scene_water_fast.id, "uSurfaceY" );
+   _uniform_scene_water_fast_uBoard0 = glGetUniformLocation( _shader_scene_water_fast.id, "uBoard0" );
+   _uniform_scene_water_fast_uBoard1 = glGetUniformLocation( _shader_scene_water_fast.id, "uBoard1" );
+   _uniform_scene_water_fast_uShoreColour = glGetUniformLocation( _shader_scene_water_fast.id, "uShoreColour" );
+   _uniform_scene_water_fast_uOceanColour = glGetUniformLocation( _shader_scene_water_fast.id, "uOceanColour" );
+   _uniform_scene_water_fast_g_world_depth = glGetUniformLocation( _shader_scene_water_fast.id, "g_world_depth" );
+}
+#endif /* SHADER_scene_water_fast_H */
diff --git a/skaterift.c b/skaterift.c
index 6ca61ee..b0324cc 100644
--- a/skaterift.c
+++ b/skaterift.c
@@ -265,7 +265,9 @@ VG_STATIC void vg_load(void)
    /* load home world */
    world_load( &world_global.worlds[0], "maps/mp_home.mdl" );
    world_load( &world_global.worlds[1], "maps/mp_gridmap.mdl" );
+   world_load( &world_global.worlds[2], "maps/mp_mtzero.mdl" );
    world_link_nonlocal_gates( 0, 1 );
+   world_link_nonlocal_gates( 0, 2 );
 
    vg_console_load_autos();
 }
diff --git a/world.h b/world.h
index 7611c24..16b0e98 100644
--- a/world.h
+++ b/world.h
@@ -251,9 +251,7 @@ struct world_instance
          v4f q[2];
          v2f dims;
 
-         m4x3f to_world, recv_to_world,   /* TODO: can probably remove these */
-
-               transport;
+         m4x3f to_world, transport;
       }
       gate;
 
diff --git a/world_gate.h b/world_gate.h
index b694251..15c4a48 100644
--- a/world_gate.h
+++ b/world_gate.h
@@ -15,16 +15,18 @@
 
 VG_STATIC void gate_transform_update( teleport_gate *gate )
 {
-   m4x3f to_local;
+   m4x3f to_local, recv_to_world;
 
    q_m3x3( gate->q[0], gate->to_world );
    v3_copy( gate->co[0], gate->to_world[3] );
    
    m4x3_invert_affine( gate->to_world, to_local );
 
-   q_m3x3( gate->q[1], gate->recv_to_world );
-   v3_copy( gate->co[1], gate->recv_to_world[3] );
-   m4x3_mul( gate->recv_to_world, to_local, gate->transport );
+   q_m3x3( gate->q[1], recv_to_world );
+   v3_copy( gate->co[1], recv_to_world[3] );
+   m4x3_mul( recv_to_world, to_local, gate->transport );
+
+   m4x3_scalev( gate->to_world, (v3f){ gate->dims[0], gate->dims[1], 1.0f } );
 }
 
 VG_STATIC void world_gates_init(void)
@@ -48,7 +50,7 @@ VG_STATIC int render_gate( world_instance *world_inside,
 {
    v3f viewdir, gatedir;
    m3x3_mulv( cam->transform, (v3f){0.0f,0.0f,-1.0f}, viewdir );
-   m3x3_mulv( gate->to_world, (v3f){0.0f,0.0f,-1.0f}, gatedir );
+   q_mulv( gate->q[0], (v3f){0.0f,0.0f,-1.0f}, gatedir );
 
    v3f v0;
    v3_sub( cam->pos, gate->co[0], v0 );
@@ -65,12 +67,10 @@ VG_STATIC int render_gate( world_instance *world_inside,
    {
       v3f a,b,c,d;
 
-      float sx = gate->dims[0],
-            sy = gate->dims[1];
-      m4x3_mulv( gate->to_world, (v3f){-sx,-sy,0.0f}, a );
-      m4x3_mulv( gate->to_world, (v3f){ sx,-sy,0.0f}, b );
-      m4x3_mulv( gate->to_world, (v3f){ sx, sy,0.0f}, c );
-      m4x3_mulv( gate->to_world, (v3f){-sx, sy,0.0f}, d );
+      m4x3_mulv( gate->to_world, (v3f){-1.0f,-1.0f,0.0f}, a );
+      m4x3_mulv( gate->to_world, (v3f){ 1.0f,-1.0f,0.0f}, b );
+      m4x3_mulv( gate->to_world, (v3f){ 1.0f, 1.0f,0.0f}, c );
+      m4x3_mulv( gate->to_world, (v3f){-1.0f, 1.0f,0.0f}, d );
 
       vg_line( a,b, 0xffffa000 );
       vg_line( b,c, 0xffffa000 );
@@ -91,7 +91,7 @@ VG_STATIC int render_gate( world_instance *world_inside,
 
    /* Add special clipping plane to projection */
    v4f surface;
-   m3x3_mulv( gate->recv_to_world, (v3f){0.0f,0.0f,-1.0f}, surface );
+   q_mulv( gate->q[1], (v3f){0.0f,0.0f,-1.0f}, surface );
    surface[3] = v3_dot( surface, gate->co[1] );
    
    m4x3_mulp( gate_camera.transform_inverse, surface, surface );
@@ -105,13 +105,9 @@ VG_STATIC int render_gate( world_instance *world_inside,
 
    vg_line_pt3( gate_camera.transform[3], 0.3f, 0xff00ff00 );
    {
-      m4x3f gate_xform;
-      m4x3_copy( gate->to_world, gate_xform );
-      m4x3_scalev( gate_xform, (v3f){ gate->dims[0], gate->dims[1], 1.0f } );
-   
       shader_model_gate_use();
       shader_model_gate_uPv( cam->mtx.pv );
-      shader_model_gate_uMdl( gate_xform );
+      shader_model_gate_uMdl( gate->to_world );
       shader_model_gate_uCam( cam->pos );
       shader_model_gate_uTime( vg.time*0.25f );
       shader_model_gate_uInvRes( (v2f){
@@ -155,7 +151,7 @@ VG_STATIC int gate_intersect_plane( teleport_gate *gate, v3f pos, v3f last,
                                     v2f where )
 {
    v4f surface;
-   m3x3_mulv( gate->to_world, (v3f){0.0f,0.0f,-1.0f}, surface );
+   q_mulv( gate->q[0], (v3f){0.0f,0.0f,-1.0f}, surface );
    surface[3] = v3_dot( surface, gate->co[0] );
 
    v3f v0, c, delta, p0;
@@ -181,12 +177,11 @@ VG_STATIC int gate_intersect_plane( teleport_gate *gate, v3f pos, v3f last,
          v3_muladds( last, v0, t, local );
          v3_sub( gate->co[0], local, rel );
 
-         v3f vup, vside;
-         m3x3_mulv( gate->to_world, (v3f){0.0f,1.0f,0.0f}, vup );
-         m3x3_mulv( gate->to_world, (v3f){1.0f,0.0f,0.0f}, vside );
+         where[0] = v3_dot( rel, gate->to_world[0] );
+         where[1] = v3_dot( rel, gate->to_world[1] );
 
-         where[0] = v3_dot( rel, vside );
-         where[1] = v3_dot( rel, vup );
+         where[0] /= v3_dot( gate->to_world[0], gate->to_world[0] );
+         where[1] /= v3_dot( gate->to_world[1], gate->to_world[1] );
 
          return 1;
       }
@@ -201,7 +196,8 @@ VG_STATIC int gate_intersect( teleport_gate *gate, v3f pos, v3f last )
 
    if( gate_intersect_plane( gate, pos, last, xy ) )
    {
-      if( fabsf(xy[0]) <= gate->dims[0] && fabsf(xy[1]) <= gate->dims[1] )
+      vg_info( "%f %f\n", xy[0], xy[1] );
+      if( fabsf(xy[0]) <= 1.0f && fabsf(xy[1]) <= 1.0f )
       {
          return 1;
       }
diff --git a/world_render.h b/world_render.h
index 873374f..e7700e8 100644
--- a/world_render.h
+++ b/world_render.h
@@ -382,7 +382,8 @@ VG_STATIC void render_world_depth( world_instance *world, camera *cam )
    shader_scene_depth_uPv( cam->mtx.pv );
    shader_scene_depth_uPvmPrev( cam->mtx_prev.pv );
    shader_scene_depth_uMdl( identity_matrix );
-   
+   world_link_lighting_ub( world, _shader_scene_depth.id, 2 );
+
    mesh_bind( &world->mesh_geo );
    mesh_draw( &world->mesh_geo );
 
diff --git a/world_water.h b/world_water.h
index 382a775..9709c43 100644
--- a/world_water.h
+++ b/world_water.h
@@ -7,8 +7,8 @@
 
 #include "world.h"
 #include "render.h"
-#include "shaders/model_water.h"
-#include "shaders/model_water_fast.h"
+#include "shaders/scene_water.h"
+#include "shaders/scene_water_fast.h"
 #include "scene.h"
 
 vg_tex2d tex_water_surf = { .path = "textures/water_surf.qoi" };
@@ -16,8 +16,8 @@ vg_tex2d tex_water_surf = { .path = "textures/water_surf.qoi" };
 VG_STATIC void world_water_init(void)
 {
    vg_info( "world_water_init\n" );
-   shader_model_water_register();
-   shader_model_water_fast_register();
+   shader_scene_water_register();
+   shader_scene_water_fast_register();
 
    vg_acquire_thread_sync();
    {
@@ -118,31 +118,31 @@ VG_STATIC void render_water_surface( world_instance *world, camera *cam )
    if( vg.quality_profile == k_quality_profile_high )
    {
       /* Draw surface */
-      shader_model_water_use();
+      shader_scene_water_use();
       
       render_fb_bind_texture( gpipeline.fb_water_reflection, 0, 0 );
-      shader_model_water_uTexMain( 0 );
+      shader_scene_water_uTexMain( 0 );
 
       vg_tex2d_bind( &tex_water_surf, 1 );
-      shader_model_water_uTexDudv( 1 );
-      shader_model_water_uInvRes( (v2f){
+      shader_scene_water_uTexDudv( 1 );
+      shader_scene_water_uInvRes( (v2f){
             1.0f / (float)vg.window_x,
             1.0f / (float)vg.window_y });
 
-      world_link_lighting_ub( world, _shader_model_water.id, 2 );
+      world_link_lighting_ub( world, _shader_scene_water.id, 2 );
 
       render_fb_bind_texture( gpipeline.fb_water_beneath, 0, 3 );
-      shader_model_water_uTexBack( 3 );
-      shader_model_water_uTime( world_global.time );
-      shader_model_water_uCamera( cam->transform[3] );
-      shader_model_water_uSurfaceY( world->water.height );
+      shader_scene_water_uTexBack( 3 );
+      shader_scene_water_uTime( world_global.time );
+      shader_scene_water_uCamera( cam->transform[3] );
+      shader_scene_water_uSurfaceY( world->water.height );
 
-      shader_model_water_uPv( cam->mtx.pv );
-      shader_model_water_uPvmPrev( cam->mtx_prev.pv );
+      shader_scene_water_uPv( cam->mtx.pv );
+      shader_scene_water_uPvmPrev( cam->mtx_prev.pv );
 
       m4x3f full;
       m4x3_identity( full );
-      shader_model_water_uMdl( full );
+      shader_scene_water_uMdl( full );
 
       glEnable(GL_BLEND);
       glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
@@ -156,8 +156,8 @@ VG_STATIC void render_water_surface( world_instance *world, camera *cam )
 
          if( mat->info.shader == k_shader_water )
          {
-            shader_model_water_uShoreColour( mat->info.colour );
-            shader_model_water_uOceanColour( mat->info.colour1 );
+            shader_scene_water_uShoreColour( mat->info.colour );
+            shader_scene_water_uOceanColour( mat->info.colour1 );
 
             mdl_draw_submesh( &mat->sm_no_collide );
          }
@@ -167,20 +167,20 @@ VG_STATIC void render_water_surface( world_instance *world, camera *cam )
    }
    else if( vg.quality_profile == k_quality_profile_low )
    {
-      shader_model_water_fast_use();
+      shader_scene_water_fast_use();
 
       vg_tex2d_bind( &tex_water_surf, 1 );
-      shader_model_water_fast_uTexDudv( 1 );
-      shader_model_water_fast_uTime( world_global.time );
-      shader_model_water_fast_uCamera( cam->transform[3] );
-      shader_model_water_fast_uSurfaceY( world->water.height );
-      world_link_lighting_ub( world, _shader_model_water_fast.id, 2 );
+      shader_scene_water_fast_uTexDudv( 1 );
+      shader_scene_water_fast_uTime( world_global.time );
+      shader_scene_water_fast_uCamera( cam->transform[3] );
+      shader_scene_water_fast_uSurfaceY( world->water.height );
+      world_link_lighting_ub( world, _shader_scene_water_fast.id, 2 );
 
       m4x3f full;
       m4x3_identity( full );
-      shader_model_water_fast_uMdl( full );
-      shader_model_water_fast_uPv( cam->mtx.pv );
-      shader_model_water_fast_uPvmPrev( cam->mtx_prev.pv );
+      shader_scene_water_fast_uMdl( full );
+      shader_scene_water_fast_uPv( cam->mtx.pv );
+      shader_scene_water_fast_uPvmPrev( cam->mtx_prev.pv );
 
       glEnable(GL_BLEND);
       glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
@@ -194,8 +194,8 @@ VG_STATIC void render_water_surface( world_instance *world, camera *cam )
 
          if( mat->info.shader == k_shader_water )
          {
-            shader_model_water_fast_uShoreColour( mat->info.colour );
-            shader_model_water_fast_uOceanColour( mat->info.colour1 );
+            shader_scene_water_fast_uShoreColour( mat->info.colour );
+            shader_scene_water_fast_uOceanColour( mat->info.colour1 );
 
             mdl_draw_submesh( &mat->sm_no_collide );
          }