_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" );
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++ )
{
avg += bh->system->item_centroid( bh->user, idx, axis );
}
avg /= (float)node->count;
-
split = avg;
+
i32 i = node->start,
j = i + node->count-1;
{
/* 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] )
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 );
}
{
/* 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] )
*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 )
+++ /dev/null
-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 );
-}
+++ /dev/null
-#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 */
+++ /dev/null
-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 );
-}
+++ /dev/null
-#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 */
in vec3 aWorldCo;
flat in ivec4 aLights;
-#include "common_world.glsl"
+#include "common_scene.glsl"
// Water blending
// ==============
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 );
}
"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"
" 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"
"\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"
""},
};
--- /dev/null
+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 );
+}
--- /dev/null
+#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 */
--- /dev/null
+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 );
+}
--- /dev/null
+#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 */
/* 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();
}
v4f q[2];
v2f dims;
- m4x3f to_world, recv_to_world, /* TODO: can probably remove these */
-
- transport;
+ m4x3f to_world, transport;
}
gate;
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)
{
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 );
{
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 );
/* 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 );
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){
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;
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;
}
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;
}
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 );
#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" };
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();
{
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);
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 );
}
}
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);
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 );
}
projects / carveJwlIkooP6JGAAIwe30JlM.git / commitdiff