1 #include "shaders/scene_standard.h"
2 struct vg_shader _shader_scene_standard
= {
3 .name
= "scene_standard",
6 .orig_file
= "shaders/scene.vs",
8 "layout (location=0) in vec3 a_co;\n"
9 "layout (location=1) in vec4 a_norm;\n"
10 "layout (location=2) in vec2 a_uv;\n"
13 "const float k_motion_lerp_amount = 0.01;\n"
17 "out vec3 aMotionVec0;\n"
18 "out vec3 aMotionVec1;\n"
20 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
22 " // This magically solves some artifacting errors!\n"
24 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
26 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
27 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
32 "uniform mat4x3 uMdl;\n"
34 "uniform mat4 uPvmPrev;\n"
39 "out vec3 aWorldCo;\n"
43 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
44 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
45 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
47 " vs_motion_out( vproj0, vproj1 );\n"
49 " gl_Position = vproj0;\n"
52 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
54 " aWorldCo = world_pos0;\n"
59 .orig_file
= "shaders/scene_standard.fs",
61 "uniform sampler2D uTexGarbage;\n"
62 "uniform sampler2D uTexMain;\n"
63 "uniform vec3 uCamera;\n"
64 "uniform vec4 uPlane;\n"
68 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
80 "layout (location = 0) out vec4 oColour;\n"
82 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
83 "layout (std140) uniform ub_world_lighting\n"
86 " vec4 g_cube_inv_range;\n"
88 " vec4 g_water_plane;\n"
89 " vec4 g_depth_bounds;\n"
91 " vec4 g_daysky_colour;\n"
92 " vec4 g_nightsky_colour;\n"
93 " vec4 g_sunset_colour;\n"
94 " vec4 g_ambient_colour;\n"
95 " vec4 g_sunset_ambient;\n"
96 " vec4 g_sun_colour;\n"
101 " float g_water_fog;\n"
103 " float g_realtime;\n"
104 " float g_shadow_length;\n"
105 " float g_shadow_spread;\n"
107 " float g_time_of_day;\n"
108 " float g_day_phase;\n"
109 " float g_sunset_phase;\n"
111 " int g_light_preview;\n"
112 " int g_shadow_samples;\n"
114 " int g_debug_indices;\n"
115 " int g_debug_complexity;\n"
118 "uniform sampler2D g_world_depth;\n"
119 "uniform samplerBuffer uLightsArray;\n"
120 "uniform usampler3D uLightsIndex;\n"
123 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
124 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
125 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
126 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
127 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
128 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
130 "const float SUN_ANGLE = 0.0001;\n"
131 "const float PI = 3.14159265358979323846264;\n"
133 "//struct world_info\n"
143 "vec3 rand33(vec3 p3)\n"
145 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
146 " p3 += dot(p3, p3.yxz+33.33);\n"
147 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
150 "float stars( vec3 rd, float rr, float size ){\n"
151 " vec3 co = rd * rr;\n"
153 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
155 " float spaces = 1.0 / rr;\n"
156 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
157 " a -= mod(a, spaces) - spaces * 0.5;\n"
159 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
161 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
162 " plane = plane - mod(plane, PI / count);\n"
164 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
166 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
167 " float ydist = sqrt(rr * rr - level * level);\n"
168 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
169 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
170 " float star = smoothstep(size, 0.0, distance(center, co));\n"
174 "float luminance( vec3 v )\n"
176 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
179 "vec3 clearskies_ambient( vec3 dir )\n"
181 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
182 " float sky_gradient = dir.y;\n"
184 " /* Blend phase colours */\n"
185 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
186 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
187 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
189 " /* Add gradient */\n"
190 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
195 "vec3 clearskies_sky( vec3 ray_dir )\n"
197 " ray_dir.y = abs( ray_dir.y );\n"
198 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
201 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
202 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
203 " float sun_shape = pow( sun_size, 2000.0 );\n"
204 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
206 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
207 " sun_colour *= sun_shape;\n"
210 " float star = 0.0;\n"
211 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
213 " if( star_blend > 0.001 ){\n"
214 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
215 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
216 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
220 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
221 " return composite;\n"
224 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
226 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
228 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
229 " g_sunset_phase );\n"
231 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
232 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
233 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
234 " ) * g_sun_colour.rgb * g_day_phase;\n"
236 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
237 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
238 " g_sunset_phase );\n"
240 " return ambient + (light_sun + sky_reflection) * shadow;\n"
245 "float world_depth_sample( vec3 pos )\n"
247 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
248 " return texture( g_world_depth, depth_coord ).r;\n"
251 "float world_water_depth( vec3 pos )\n"
253 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
254 " return world_depth_sample( pos ) - ref_depth;\n"
257 "float shadow_sample( vec3 co ){\n"
258 " float height_sample = world_depth_sample( co );\n"
260 " float fdelta = height_sample - co.y;\n"
261 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
264 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
265 " if( g_shadow_samples == 0 ){\n"
269 " float fspread = g_shadow_spread;\n"
270 " float flength = g_shadow_length;\n"
272 " float famt = 0.0;\n"
273 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
274 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
275 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
276 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
278 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
279 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
280 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
281 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
283 " return 1.0 - famt;\n"
286 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
288 " vec3 specdir = reflect( -dir, wnormal );\n"
289 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
292 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
293 " float dist = pow(fdist*0.0010,0.78);\n"
294 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
297 "vec3 scene_calculate_light( int light_index, \n"
298 " vec3 halfview, vec3 co, vec3 normal )\n"
300 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
301 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
302 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
304 " vec3 light_delta = light_co.xyz-co;\n"
305 " float dist2 = dot(light_delta,light_delta);\n"
307 " light_delta = normalize( light_delta );\n"
309 " float quadratic = dist2*100.0;\n"
310 " float attenuation = 1.0/( 1.0 + quadratic );\n"
311 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
313 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
315 " if( light_dir.w < 0.999999 ){\n"
316 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
317 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
320 " return light_colour.rgb * attenuation * falloff \n"
321 " * step( g_day_phase, light_colour.w );\n"
324 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
325 " vec3 halfview, vec3 co, vec3 normal )\n"
327 " uint light_count = packed_index & 0x3u;\n"
329 " vec3 l = vec3(0.0);\n"
331 " if( light_count >= 1u ){\n"
332 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
333 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
334 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
336 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
338 " if( light_count >= 2u ){\n"
339 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
341 " if( light_count >= 3u ){\n"
342 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
350 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
351 " float light_mask )\n"
353 " if( g_light_preview == 1 )\n"
354 " diffuse = vec3(0.75);\n"
357 " vec3 halfview = uCamera - co;\n"
358 " float fdist = length(halfview);\n"
359 " halfview /= fdist;\n"
361 " float world_shadow = newlight_compute_sun_shadow( \n"
362 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
364 " vec3 total_light = clearskies_lighting( \n"
365 " normal, min( light_mask, world_shadow ), halfview );\n"
367 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
368 " cube_coord = floor( cube_coord );\n"
370 " if( g_debug_indices == 1 )\n"
372 " return rand33(cube_coord);\n"
375 " if( g_debug_complexity == 1 )\n"
377 " ivec3 coord = ivec3( cube_coord );\n"
378 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
380 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
381 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
384 " // FIXME: this coord should absolutely must be clamped!\n"
386 " ivec3 coord = ivec3( cube_coord );\n"
387 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
390 " scene_calculate_packed_light_patch( index_sample.x,\n"
391 " halfview, co, normal ) \n"
394 " scene_calculate_packed_light_patch( index_sample.y,\n"
395 " halfview, co, normal )\n"
398 " // Take a section of the sky function to give us a matching fog colour\n"
400 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
401 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
402 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
403 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
405 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
406 " sun_colour *= sun_shape;\n"
408 " fog_colour += sun_colour;\n"
409 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
414 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
416 " vec3 pa = p - a;\n"
417 " vec3 ba = b - a;\n"
419 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
420 " return length( pa - ba*h );\n"
423 "float compute_board_shadow()\n"
425 " // player shadow\n"
426 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
427 " g_board_1.xyz )-0.1 );\n"
428 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
429 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
431 " return 1.0 - player_shadow*0.8;\n"
434 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
436 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
441 "const float k_motion_lerp_amount = 0.01;\n"
445 "layout (location = 1) out vec2 oMotionVec;\n"
447 "in vec3 aMotionVec0;\n"
448 "in vec3 aMotionVec1;\n"
450 "void compute_motion_vectors()\n"
452 " // Write motion vectors\n"
453 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
454 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
456 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
463 " compute_motion_vectors();\n"
465 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
466 " vec4 vsamplemain = texture( uTexMain, aUv );\n"
467 " vec3 qnorm = aNorm.xyz;\n"
469 " vfrag = vsamplemain.rgb;\n"
471 " if( g_light_preview == 1 )\n"
473 " vfrag = vec3(0.5);\n"
476 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
477 " oColour = vec4( vfrag, 1.0 );\n"
482 GLuint _uniform_scene_standard_uMdl
;
483 GLuint _uniform_scene_standard_uPv
;
484 GLuint _uniform_scene_standard_uPvmPrev
;
485 GLuint _uniform_scene_standard_uTexGarbage
;
486 GLuint _uniform_scene_standard_uTexMain
;
487 GLuint _uniform_scene_standard_uCamera
;
488 GLuint _uniform_scene_standard_uPlane
;
489 GLuint _uniform_scene_standard_g_world_depth
;
490 GLuint _uniform_scene_standard_uLightsArray
;
491 GLuint _uniform_scene_standard_uLightsIndex
;
492 #include "shaders/scene_standard_alphatest.h"
493 struct vg_shader _shader_scene_standard_alphatest
= {
494 .name
= "scene_standard_alphatest",
497 .orig_file
= "shaders/scene.vs",
499 "layout (location=0) in vec3 a_co;\n"
500 "layout (location=1) in vec4 a_norm;\n"
501 "layout (location=2) in vec2 a_uv;\n"
504 "const float k_motion_lerp_amount = 0.01;\n"
508 "out vec3 aMotionVec0;\n"
509 "out vec3 aMotionVec1;\n"
511 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
513 " // This magically solves some artifacting errors!\n"
515 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
517 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
518 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
523 "uniform mat4x3 uMdl;\n"
524 "uniform mat4 uPv;\n"
525 "uniform mat4 uPvmPrev;\n"
530 "out vec3 aWorldCo;\n"
534 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
535 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
536 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
538 " vs_motion_out( vproj0, vproj1 );\n"
540 " gl_Position = vproj0;\n"
543 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
545 " aWorldCo = world_pos0;\n"
550 .orig_file
= "shaders/scene_standard_alphatest.fs",
552 "uniform sampler2D uTexGarbage;\n"
553 "uniform sampler2D uTexMain;\n"
554 "uniform vec3 uCamera;\n"
555 "uniform vec4 uPlane;\n"
559 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
568 "in vec3 aWorldCo;\n"
571 "layout (location = 0) out vec4 oColour;\n"
573 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
574 "layout (std140) uniform ub_world_lighting\n"
576 " vec4 g_cube_min;\n"
577 " vec4 g_cube_inv_range;\n"
579 " vec4 g_water_plane;\n"
580 " vec4 g_depth_bounds;\n"
582 " vec4 g_daysky_colour;\n"
583 " vec4 g_nightsky_colour;\n"
584 " vec4 g_sunset_colour;\n"
585 " vec4 g_ambient_colour;\n"
586 " vec4 g_sunset_ambient;\n"
587 " vec4 g_sun_colour;\n"
592 " float g_water_fog;\n"
594 " float g_realtime;\n"
595 " float g_shadow_length;\n"
596 " float g_shadow_spread;\n"
598 " float g_time_of_day;\n"
599 " float g_day_phase;\n"
600 " float g_sunset_phase;\n"
602 " int g_light_preview;\n"
603 " int g_shadow_samples;\n"
605 " int g_debug_indices;\n"
606 " int g_debug_complexity;\n"
609 "uniform sampler2D g_world_depth;\n"
610 "uniform samplerBuffer uLightsArray;\n"
611 "uniform usampler3D uLightsIndex;\n"
614 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
615 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
616 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
617 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
618 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
619 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
621 "const float SUN_ANGLE = 0.0001;\n"
622 "const float PI = 3.14159265358979323846264;\n"
624 "//struct world_info\n"
634 "vec3 rand33(vec3 p3)\n"
636 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
637 " p3 += dot(p3, p3.yxz+33.33);\n"
638 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
641 "float stars( vec3 rd, float rr, float size ){\n"
642 " vec3 co = rd * rr;\n"
644 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
646 " float spaces = 1.0 / rr;\n"
647 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
648 " a -= mod(a, spaces) - spaces * 0.5;\n"
650 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
652 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
653 " plane = plane - mod(plane, PI / count);\n"
655 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
657 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
658 " float ydist = sqrt(rr * rr - level * level);\n"
659 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
660 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
661 " float star = smoothstep(size, 0.0, distance(center, co));\n"
665 "float luminance( vec3 v )\n"
667 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
670 "vec3 clearskies_ambient( vec3 dir )\n"
672 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
673 " float sky_gradient = dir.y;\n"
675 " /* Blend phase colours */\n"
676 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
677 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
678 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
680 " /* Add gradient */\n"
681 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
686 "vec3 clearskies_sky( vec3 ray_dir )\n"
688 " ray_dir.y = abs( ray_dir.y );\n"
689 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
692 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
693 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
694 " float sun_shape = pow( sun_size, 2000.0 );\n"
695 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
697 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
698 " sun_colour *= sun_shape;\n"
701 " float star = 0.0;\n"
702 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
704 " if( star_blend > 0.001 ){\n"
705 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
706 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
707 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
711 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
712 " return composite;\n"
715 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
717 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
719 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
720 " g_sunset_phase );\n"
722 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
723 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
724 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
725 " ) * g_sun_colour.rgb * g_day_phase;\n"
727 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
728 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
729 " g_sunset_phase );\n"
731 " return ambient + (light_sun + sky_reflection) * shadow;\n"
736 "float world_depth_sample( vec3 pos )\n"
738 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
739 " return texture( g_world_depth, depth_coord ).r;\n"
742 "float world_water_depth( vec3 pos )\n"
744 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
745 " return world_depth_sample( pos ) - ref_depth;\n"
748 "float shadow_sample( vec3 co ){\n"
749 " float height_sample = world_depth_sample( co );\n"
751 " float fdelta = height_sample - co.y;\n"
752 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
755 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
756 " if( g_shadow_samples == 0 ){\n"
760 " float fspread = g_shadow_spread;\n"
761 " float flength = g_shadow_length;\n"
763 " float famt = 0.0;\n"
764 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
765 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
766 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
767 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
769 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
770 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
771 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
772 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
774 " return 1.0 - famt;\n"
777 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
779 " vec3 specdir = reflect( -dir, wnormal );\n"
780 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
783 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
784 " float dist = pow(fdist*0.0010,0.78);\n"
785 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
788 "vec3 scene_calculate_light( int light_index, \n"
789 " vec3 halfview, vec3 co, vec3 normal )\n"
791 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
792 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
793 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
795 " vec3 light_delta = light_co.xyz-co;\n"
796 " float dist2 = dot(light_delta,light_delta);\n"
798 " light_delta = normalize( light_delta );\n"
800 " float quadratic = dist2*100.0;\n"
801 " float attenuation = 1.0/( 1.0 + quadratic );\n"
802 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
804 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
806 " if( light_dir.w < 0.999999 ){\n"
807 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
808 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
811 " return light_colour.rgb * attenuation * falloff \n"
812 " * step( g_day_phase, light_colour.w );\n"
815 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
816 " vec3 halfview, vec3 co, vec3 normal )\n"
818 " uint light_count = packed_index & 0x3u;\n"
820 " vec3 l = vec3(0.0);\n"
822 " if( light_count >= 1u ){\n"
823 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
824 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
825 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
827 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
829 " if( light_count >= 2u ){\n"
830 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
832 " if( light_count >= 3u ){\n"
833 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
841 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
842 " float light_mask )\n"
844 " if( g_light_preview == 1 )\n"
845 " diffuse = vec3(0.75);\n"
848 " vec3 halfview = uCamera - co;\n"
849 " float fdist = length(halfview);\n"
850 " halfview /= fdist;\n"
852 " float world_shadow = newlight_compute_sun_shadow( \n"
853 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
855 " vec3 total_light = clearskies_lighting( \n"
856 " normal, min( light_mask, world_shadow ), halfview );\n"
858 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
859 " cube_coord = floor( cube_coord );\n"
861 " if( g_debug_indices == 1 )\n"
863 " return rand33(cube_coord);\n"
866 " if( g_debug_complexity == 1 )\n"
868 " ivec3 coord = ivec3( cube_coord );\n"
869 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
871 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
872 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
875 " // FIXME: this coord should absolutely must be clamped!\n"
877 " ivec3 coord = ivec3( cube_coord );\n"
878 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
881 " scene_calculate_packed_light_patch( index_sample.x,\n"
882 " halfview, co, normal ) \n"
885 " scene_calculate_packed_light_patch( index_sample.y,\n"
886 " halfview, co, normal )\n"
889 " // Take a section of the sky function to give us a matching fog colour\n"
891 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
892 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
893 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
894 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
896 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
897 " sun_colour *= sun_shape;\n"
899 " fog_colour += sun_colour;\n"
900 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
905 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
907 " vec3 pa = p - a;\n"
908 " vec3 ba = b - a;\n"
910 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
911 " return length( pa - ba*h );\n"
914 "float compute_board_shadow()\n"
916 " // player shadow\n"
917 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
918 " g_board_1.xyz )-0.1 );\n"
919 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
920 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
922 " return 1.0 - player_shadow*0.8;\n"
925 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
927 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
932 "const float k_motion_lerp_amount = 0.01;\n"
936 "layout (location = 1) out vec2 oMotionVec;\n"
938 "in vec3 aMotionVec0;\n"
939 "in vec3 aMotionVec1;\n"
941 "void compute_motion_vectors()\n"
943 " // Write motion vectors\n"
944 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
945 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
947 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
954 " compute_motion_vectors();\n"
956 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
957 " vec4 vsamplemain = texture( uTexMain, aUv );\n"
958 " vec3 qnorm = aNorm.xyz;\n"
960 " if( vsamplemain.a < 0.15 )\n"
963 " vfrag = vsamplemain.rgb;\n"
965 " if( g_light_preview == 1 )\n"
967 " vfrag = vec3(0.5);\n"
970 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
971 " oColour = vec4(vfrag, 1.0);\n"
976 GLuint _uniform_scene_standard_alphatest_uMdl
;
977 GLuint _uniform_scene_standard_alphatest_uPv
;
978 GLuint _uniform_scene_standard_alphatest_uPvmPrev
;
979 GLuint _uniform_scene_standard_alphatest_uTexGarbage
;
980 GLuint _uniform_scene_standard_alphatest_uTexMain
;
981 GLuint _uniform_scene_standard_alphatest_uCamera
;
982 GLuint _uniform_scene_standard_alphatest_uPlane
;
983 GLuint _uniform_scene_standard_alphatest_g_world_depth
;
984 GLuint _uniform_scene_standard_alphatest_uLightsArray
;
985 GLuint _uniform_scene_standard_alphatest_uLightsIndex
;
986 #include "shaders/scene_foliage.h"
987 struct vg_shader _shader_scene_foliage
= {
988 .name
= "scene_foliage",
991 .orig_file
= "shaders/scene_foliage.vs",
993 "layout (location=0) in vec3 a_co;\n"
994 "layout (location=1) in vec4 a_norm;\n"
995 "layout (location=2) in vec2 a_uv;\n"
998 "const float k_motion_lerp_amount = 0.01;\n"
1002 "out vec3 aMotionVec0;\n"
1003 "out vec3 aMotionVec1;\n"
1005 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
1007 " // This magically solves some artifacting errors!\n"
1009 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
1011 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
1012 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
1017 "uniform mat4x3 uMdl;\n"
1018 "uniform mat4 uPv;\n"
1019 "uniform mat4 uPvmPrev;\n"
1020 "uniform float uTime;\n"
1025 "out vec3 aWorldCo;\n"
1028 " vec4 vsine = sin(vec4(uTime + a_co.x, uTime*0.7 + a_co.z,uTime,uTime*1.3));\n"
1029 " vec3 co = a_co + vsine.xyz * a_norm.w * 0.5;\n"
1031 " vec3 world_pos0 = uMdl * vec4( co, 1.0 );\n"
1032 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
1033 " vec4 vproj1 = uPvmPrev * vec4( co, 1.0 );\n"
1035 " vs_motion_out( vproj0, vproj1 );\n"
1037 " gl_Position = vproj0;\n"
1040 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
1042 " aWorldCo = world_pos0;\n"
1047 .orig_file
= "shaders/scene_foliage.fs",
1049 "uniform sampler2D uTexGarbage;\n"
1050 "uniform sampler2D uTexMain;\n"
1051 "uniform vec3 uCamera;\n"
1052 "uniform vec4 uPlane;\n"
1054 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.4;\n"
1061 "in vec3 aWorldCo;\n"
1064 "layout (location = 0) out vec4 oColour;\n"
1066 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
1067 "layout (std140) uniform ub_world_lighting\n"
1069 " vec4 g_cube_min;\n"
1070 " vec4 g_cube_inv_range;\n"
1072 " vec4 g_water_plane;\n"
1073 " vec4 g_depth_bounds;\n"
1075 " vec4 g_daysky_colour;\n"
1076 " vec4 g_nightsky_colour;\n"
1077 " vec4 g_sunset_colour;\n"
1078 " vec4 g_ambient_colour;\n"
1079 " vec4 g_sunset_ambient;\n"
1080 " vec4 g_sun_colour;\n"
1081 " vec4 g_sun_dir;\n"
1082 " vec4 g_board_0;\n"
1083 " vec4 g_board_1;\n"
1085 " float g_water_fog;\n"
1087 " float g_realtime;\n"
1088 " float g_shadow_length;\n"
1089 " float g_shadow_spread;\n"
1091 " float g_time_of_day;\n"
1092 " float g_day_phase;\n"
1093 " float g_sunset_phase;\n"
1095 " int g_light_preview;\n"
1096 " int g_shadow_samples;\n"
1098 " int g_debug_indices;\n"
1099 " int g_debug_complexity;\n"
1102 "uniform sampler2D g_world_depth;\n"
1103 "uniform samplerBuffer uLightsArray;\n"
1104 "uniform usampler3D uLightsIndex;\n"
1107 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
1108 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
1109 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
1110 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
1111 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
1112 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
1114 "const float SUN_ANGLE = 0.0001;\n"
1115 "const float PI = 3.14159265358979323846264;\n"
1117 "//struct world_info\n"
1122 "// sunset_phase;\n"
1124 "// vec3 sun_dir;\n"
1127 "vec3 rand33(vec3 p3)\n"
1129 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
1130 " p3 += dot(p3, p3.yxz+33.33);\n"
1131 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
1134 "float stars( vec3 rd, float rr, float size ){\n"
1135 " vec3 co = rd * rr;\n"
1137 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
1139 " float spaces = 1.0 / rr;\n"
1140 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
1141 " a -= mod(a, spaces) - spaces * 0.5;\n"
1143 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
1145 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
1146 " plane = plane - mod(plane, PI / count);\n"
1148 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
1150 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
1151 " float ydist = sqrt(rr * rr - level * level);\n"
1152 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
1153 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
1154 " float star = smoothstep(size, 0.0, distance(center, co));\n"
1158 "float luminance( vec3 v )\n"
1160 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
1163 "vec3 clearskies_ambient( vec3 dir )\n"
1165 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
1166 " float sky_gradient = dir.y;\n"
1168 " /* Blend phase colours */\n"
1169 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
1170 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
1171 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
1173 " /* Add gradient */\n"
1174 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
1176 " return ambient;\n"
1179 "vec3 clearskies_sky( vec3 ray_dir )\n"
1181 " ray_dir.y = abs( ray_dir.y );\n"
1182 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
1185 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
1186 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
1187 " float sun_shape = pow( sun_size, 2000.0 );\n"
1188 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
1190 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
1191 " sun_colour *= sun_shape;\n"
1194 " float star = 0.0;\n"
1195 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
1197 " if( star_blend > 0.001 ){\n"
1198 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
1199 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
1200 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
1204 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
1205 " return composite;\n"
1208 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
1210 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
1212 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
1213 " g_sunset_phase );\n"
1215 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
1216 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
1217 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
1218 " ) * g_sun_colour.rgb * g_day_phase;\n"
1220 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
1221 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
1222 " g_sunset_phase );\n"
1224 " return ambient + (light_sun + sky_reflection) * shadow;\n"
1229 "float world_depth_sample( vec3 pos )\n"
1231 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
1232 " return texture( g_world_depth, depth_coord ).r;\n"
1235 "float world_water_depth( vec3 pos )\n"
1237 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
1238 " return world_depth_sample( pos ) - ref_depth;\n"
1241 "float shadow_sample( vec3 co ){\n"
1242 " float height_sample = world_depth_sample( co );\n"
1244 " float fdelta = height_sample - co.y;\n"
1245 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
1248 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
1249 " if( g_shadow_samples == 0 ){\n"
1253 " float fspread = g_shadow_spread;\n"
1254 " float flength = g_shadow_length;\n"
1256 " float famt = 0.0;\n"
1257 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
1258 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
1259 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
1260 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
1262 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
1263 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
1264 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
1265 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
1267 " return 1.0 - famt;\n"
1270 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
1272 " vec3 specdir = reflect( -dir, wnormal );\n"
1273 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
1276 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
1277 " float dist = pow(fdist*0.0010,0.78);\n"
1278 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
1281 "vec3 scene_calculate_light( int light_index, \n"
1282 " vec3 halfview, vec3 co, vec3 normal )\n"
1284 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
1285 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
1286 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
1288 " vec3 light_delta = light_co.xyz-co;\n"
1289 " float dist2 = dot(light_delta,light_delta);\n"
1291 " light_delta = normalize( light_delta );\n"
1293 " float quadratic = dist2*100.0;\n"
1294 " float attenuation = 1.0/( 1.0 + quadratic );\n"
1295 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
1297 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
1299 " if( light_dir.w < 0.999999 ){\n"
1300 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
1301 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
1304 " return light_colour.rgb * attenuation * falloff \n"
1305 " * step( g_day_phase, light_colour.w );\n"
1308 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
1309 " vec3 halfview, vec3 co, vec3 normal )\n"
1311 " uint light_count = packed_index & 0x3u;\n"
1313 " vec3 l = vec3(0.0);\n"
1315 " if( light_count >= 1u ){\n"
1316 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
1317 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
1318 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
1320 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
1322 " if( light_count >= 2u ){\n"
1323 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
1325 " if( light_count >= 3u ){\n"
1326 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
1334 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
1335 " float light_mask )\n"
1337 " if( g_light_preview == 1 )\n"
1338 " diffuse = vec3(0.75);\n"
1341 " vec3 halfview = uCamera - co;\n"
1342 " float fdist = length(halfview);\n"
1343 " halfview /= fdist;\n"
1345 " float world_shadow = newlight_compute_sun_shadow( \n"
1346 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
1348 " vec3 total_light = clearskies_lighting( \n"
1349 " normal, min( light_mask, world_shadow ), halfview );\n"
1351 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
1352 " cube_coord = floor( cube_coord );\n"
1354 " if( g_debug_indices == 1 )\n"
1356 " return rand33(cube_coord);\n"
1359 " if( g_debug_complexity == 1 )\n"
1361 " ivec3 coord = ivec3( cube_coord );\n"
1362 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
1364 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
1365 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
1368 " // FIXME: this coord should absolutely must be clamped!\n"
1370 " ivec3 coord = ivec3( cube_coord );\n"
1371 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
1373 " total_light += \n"
1374 " scene_calculate_packed_light_patch( index_sample.x,\n"
1375 " halfview, co, normal ) \n"
1377 " total_light += \n"
1378 " scene_calculate_packed_light_patch( index_sample.y,\n"
1379 " halfview, co, normal )\n"
1382 " // Take a section of the sky function to give us a matching fog colour\n"
1384 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
1385 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
1386 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
1387 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
1389 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
1390 " sun_colour *= sun_shape;\n"
1392 " fog_colour += sun_colour;\n"
1393 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
1398 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
1400 " vec3 pa = p - a;\n"
1401 " vec3 ba = b - a;\n"
1403 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
1404 " return length( pa - ba*h );\n"
1407 "float compute_board_shadow()\n"
1409 " // player shadow\n"
1410 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
1411 " g_board_1.xyz )-0.1 );\n"
1412 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
1413 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
1415 " return 1.0 - player_shadow*0.8;\n"
1418 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
1420 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
1425 "const float k_motion_lerp_amount = 0.01;\n"
1429 "layout (location = 1) out vec2 oMotionVec;\n"
1431 "in vec3 aMotionVec0;\n"
1432 "in vec3 aMotionVec1;\n"
1434 "void compute_motion_vectors()\n"
1436 " // Write motion vectors\n"
1437 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
1438 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
1440 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
1446 " compute_motion_vectors();\n"
1448 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
1449 " vec4 vsamplemain = texture( uTexMain, aUv );\n"
1450 " vec3 qnorm = aNorm.xyz;\n"
1452 " if( vsamplemain.a < 0.15 )\n"
1455 " vfrag = vsamplemain.rgb;\n"
1457 " if( g_light_preview == 1 ){\n"
1458 " vfrag = vec3(0.5);\n"
1461 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
1462 " oColour = vec4(vfrag, 1.0);\n"
1467 GLuint _uniform_scene_foliage_uMdl
;
1468 GLuint _uniform_scene_foliage_uPv
;
1469 GLuint _uniform_scene_foliage_uPvmPrev
;
1470 GLuint _uniform_scene_foliage_uTime
;
1471 GLuint _uniform_scene_foliage_uTexGarbage
;
1472 GLuint _uniform_scene_foliage_uTexMain
;
1473 GLuint _uniform_scene_foliage_uCamera
;
1474 GLuint _uniform_scene_foliage_uPlane
;
1475 GLuint _uniform_scene_foliage_g_world_depth
;
1476 GLuint _uniform_scene_foliage_uLightsArray
;
1477 GLuint _uniform_scene_foliage_uLightsIndex
;
1478 #include "shaders/scene_override.h"
1479 struct vg_shader _shader_scene_override
= {
1480 .name
= "scene_override",
1483 .orig_file
= "shaders/scene_override.vs",
1485 "layout (location=0) in vec3 a_co;\n"
1486 "layout (location=1) in vec4 a_norm;\n"
1487 "layout (location=2) in vec2 a_uv;\n"
1490 "const float k_motion_lerp_amount = 0.01;\n"
1494 "out vec3 aMotionVec0;\n"
1495 "out vec3 aMotionVec1;\n"
1497 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
1499 " // This magically solves some artifacting errors!\n"
1501 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
1503 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
1504 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
1509 "uniform mat4x3 uMdl;\n"
1510 "uniform mat4 uPv;\n"
1511 "uniform mat4 uPvmPrev;\n"
1512 "uniform mat3 uNormalMtx;\n"
1517 "out vec3 aWorldCo;\n"
1521 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
1522 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
1523 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
1525 " vs_motion_out( vproj0, vproj1 );\n"
1527 " gl_Position = vproj0;\n"
1530 " aNorm = vec4( uNormalMtx * a_norm.xyz, a_norm.w );\n"
1532 " aWorldCo = world_pos0;\n"
1537 .orig_file
= "shaders/scene_override.fs",
1539 "uniform sampler2D uTexGarbage;\n"
1540 "uniform sampler2D uTexMain;\n"
1541 "uniform vec3 uCamera;\n"
1542 "uniform vec4 uPlane;\n"
1544 "uniform vec4 uPlayerPos; /* w: distance to uSpawnPos */\n"
1545 "uniform vec4 uSpawnPos; /* w: inverse distance to uPlayerPos */\n"
1546 "uniform bool uAlphatest;\n"
1547 "uniform vec4 uMapInfo; /* x: min, y: max, z: iso line amount */\n"
1551 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
1560 "in vec3 aWorldCo;\n"
1563 "layout (location = 0) out vec4 oColour;\n"
1565 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
1566 "layout (std140) uniform ub_world_lighting\n"
1568 " vec4 g_cube_min;\n"
1569 " vec4 g_cube_inv_range;\n"
1571 " vec4 g_water_plane;\n"
1572 " vec4 g_depth_bounds;\n"
1574 " vec4 g_daysky_colour;\n"
1575 " vec4 g_nightsky_colour;\n"
1576 " vec4 g_sunset_colour;\n"
1577 " vec4 g_ambient_colour;\n"
1578 " vec4 g_sunset_ambient;\n"
1579 " vec4 g_sun_colour;\n"
1580 " vec4 g_sun_dir;\n"
1581 " vec4 g_board_0;\n"
1582 " vec4 g_board_1;\n"
1584 " float g_water_fog;\n"
1586 " float g_realtime;\n"
1587 " float g_shadow_length;\n"
1588 " float g_shadow_spread;\n"
1590 " float g_time_of_day;\n"
1591 " float g_day_phase;\n"
1592 " float g_sunset_phase;\n"
1594 " int g_light_preview;\n"
1595 " int g_shadow_samples;\n"
1597 " int g_debug_indices;\n"
1598 " int g_debug_complexity;\n"
1601 "uniform sampler2D g_world_depth;\n"
1602 "uniform samplerBuffer uLightsArray;\n"
1603 "uniform usampler3D uLightsIndex;\n"
1606 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
1607 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
1608 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
1609 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
1610 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
1611 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
1613 "const float SUN_ANGLE = 0.0001;\n"
1614 "const float PI = 3.14159265358979323846264;\n"
1616 "//struct world_info\n"
1621 "// sunset_phase;\n"
1623 "// vec3 sun_dir;\n"
1626 "vec3 rand33(vec3 p3)\n"
1628 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
1629 " p3 += dot(p3, p3.yxz+33.33);\n"
1630 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
1633 "float stars( vec3 rd, float rr, float size ){\n"
1634 " vec3 co = rd * rr;\n"
1636 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
1638 " float spaces = 1.0 / rr;\n"
1639 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
1640 " a -= mod(a, spaces) - spaces * 0.5;\n"
1642 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
1644 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
1645 " plane = plane - mod(plane, PI / count);\n"
1647 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
1649 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
1650 " float ydist = sqrt(rr * rr - level * level);\n"
1651 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
1652 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
1653 " float star = smoothstep(size, 0.0, distance(center, co));\n"
1657 "float luminance( vec3 v )\n"
1659 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
1662 "vec3 clearskies_ambient( vec3 dir )\n"
1664 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
1665 " float sky_gradient = dir.y;\n"
1667 " /* Blend phase colours */\n"
1668 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
1669 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
1670 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
1672 " /* Add gradient */\n"
1673 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
1675 " return ambient;\n"
1678 "vec3 clearskies_sky( vec3 ray_dir )\n"
1680 " ray_dir.y = abs( ray_dir.y );\n"
1681 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
1684 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
1685 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
1686 " float sun_shape = pow( sun_size, 2000.0 );\n"
1687 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
1689 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
1690 " sun_colour *= sun_shape;\n"
1693 " float star = 0.0;\n"
1694 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
1696 " if( star_blend > 0.001 ){\n"
1697 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
1698 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
1699 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
1703 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
1704 " return composite;\n"
1707 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
1709 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
1711 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
1712 " g_sunset_phase );\n"
1714 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
1715 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
1716 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
1717 " ) * g_sun_colour.rgb * g_day_phase;\n"
1719 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
1720 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
1721 " g_sunset_phase );\n"
1723 " return ambient + (light_sun + sky_reflection) * shadow;\n"
1728 "float world_depth_sample( vec3 pos )\n"
1730 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
1731 " return texture( g_world_depth, depth_coord ).r;\n"
1734 "float world_water_depth( vec3 pos )\n"
1736 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
1737 " return world_depth_sample( pos ) - ref_depth;\n"
1740 "float shadow_sample( vec3 co ){\n"
1741 " float height_sample = world_depth_sample( co );\n"
1743 " float fdelta = height_sample - co.y;\n"
1744 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
1747 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
1748 " if( g_shadow_samples == 0 ){\n"
1752 " float fspread = g_shadow_spread;\n"
1753 " float flength = g_shadow_length;\n"
1755 " float famt = 0.0;\n"
1756 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
1757 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
1758 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
1759 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
1761 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
1762 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
1763 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
1764 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
1766 " return 1.0 - famt;\n"
1769 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
1771 " vec3 specdir = reflect( -dir, wnormal );\n"
1772 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
1775 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
1776 " float dist = pow(fdist*0.0010,0.78);\n"
1777 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
1780 "vec3 scene_calculate_light( int light_index, \n"
1781 " vec3 halfview, vec3 co, vec3 normal )\n"
1783 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
1784 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
1785 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
1787 " vec3 light_delta = light_co.xyz-co;\n"
1788 " float dist2 = dot(light_delta,light_delta);\n"
1790 " light_delta = normalize( light_delta );\n"
1792 " float quadratic = dist2*100.0;\n"
1793 " float attenuation = 1.0/( 1.0 + quadratic );\n"
1794 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
1796 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
1798 " if( light_dir.w < 0.999999 ){\n"
1799 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
1800 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
1803 " return light_colour.rgb * attenuation * falloff \n"
1804 " * step( g_day_phase, light_colour.w );\n"
1807 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
1808 " vec3 halfview, vec3 co, vec3 normal )\n"
1810 " uint light_count = packed_index & 0x3u;\n"
1812 " vec3 l = vec3(0.0);\n"
1814 " if( light_count >= 1u ){\n"
1815 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
1816 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
1817 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
1819 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
1821 " if( light_count >= 2u ){\n"
1822 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
1824 " if( light_count >= 3u ){\n"
1825 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
1833 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
1834 " float light_mask )\n"
1836 " if( g_light_preview == 1 )\n"
1837 " diffuse = vec3(0.75);\n"
1840 " vec3 halfview = uCamera - co;\n"
1841 " float fdist = length(halfview);\n"
1842 " halfview /= fdist;\n"
1844 " float world_shadow = newlight_compute_sun_shadow( \n"
1845 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
1847 " vec3 total_light = clearskies_lighting( \n"
1848 " normal, min( light_mask, world_shadow ), halfview );\n"
1850 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
1851 " cube_coord = floor( cube_coord );\n"
1853 " if( g_debug_indices == 1 )\n"
1855 " return rand33(cube_coord);\n"
1858 " if( g_debug_complexity == 1 )\n"
1860 " ivec3 coord = ivec3( cube_coord );\n"
1861 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
1863 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
1864 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
1867 " // FIXME: this coord should absolutely must be clamped!\n"
1869 " ivec3 coord = ivec3( cube_coord );\n"
1870 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
1872 " total_light += \n"
1873 " scene_calculate_packed_light_patch( index_sample.x,\n"
1874 " halfview, co, normal ) \n"
1876 " total_light += \n"
1877 " scene_calculate_packed_light_patch( index_sample.y,\n"
1878 " halfview, co, normal )\n"
1881 " // Take a section of the sky function to give us a matching fog colour\n"
1883 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
1884 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
1885 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
1886 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
1888 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
1889 " sun_colour *= sun_shape;\n"
1891 " fog_colour += sun_colour;\n"
1892 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
1897 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
1899 " vec3 pa = p - a;\n"
1900 " vec3 ba = b - a;\n"
1902 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
1903 " return length( pa - ba*h );\n"
1906 "float compute_board_shadow()\n"
1908 " // player shadow\n"
1909 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
1910 " g_board_1.xyz )-0.1 );\n"
1911 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
1912 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
1914 " return 1.0 - player_shadow*0.8;\n"
1917 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
1919 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
1924 "const float k_motion_lerp_amount = 0.01;\n"
1928 "layout (location = 1) out vec2 oMotionVec;\n"
1930 "in vec3 aMotionVec0;\n"
1931 "in vec3 aMotionVec1;\n"
1933 "void compute_motion_vectors()\n"
1935 " // Write motion vectors\n"
1936 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
1937 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
1939 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
1944 "vec2 smin( float a, float b, float k ){\n"
1945 " float h = max( k-abs(a-b), 0.0 )/k;\n"
1946 " float m = h*h*0.5;\n"
1947 " float s = m*k*(1.0/2.0);\n"
1950 " return vec2(a-s,m);\n"
1952 " return vec2(b-s,1.0-m);\n"
1956 " vec2 ssuv = gl_FragCoord.xy;\n"
1957 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
1958 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
1960 " float dcam = (-8.0+distance( aCo, uCamera ))/4.0;\n"
1961 " float dy0 = aCo.y - uMapInfo.x;\n"
1962 " float dy1 = uMapInfo.y - aCo.y;\n"
1964 " if( min(min(dy0,dy1)*0.5, dcam) + dither < 0.51 ) \n"
1967 " compute_motion_vectors();\n"
1969 " vec3 vfrag = vec3(0.898,0.811,0.716);\n"
1970 " vec3 qnorm = aNorm.xyz;\n"
1972 " qnorm = normalize(floor(aNorm.xyz*4.0)*0.25);\n"
1973 " qnorm += vec3(0.001,0.0,0.0);\n"
1975 " if( uAlphatest ){\n"
1976 " vec4 vSample = texture( uTexMain, aUv );\n"
1977 " if( vSample.a < 0.5 )\n"
1983 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
1986 " float d0 = distance( aCo, uPlayerPos.xyz )*2.0;\n"
1987 " float d1 = distance( aCo, uSpawnPos.xyz );\n"
1989 " vec2 dm = smin( d0, d1, 10.0 );\n"
1990 " float dd = fract(dm.x*0.2-g_realtime*0.5) * \n"
1991 " max(0.0,1.0-dm.x*0.04) * \n"
1992 " max(0.0,qnorm.y);\n"
1993 " vec3 emit = mix(vec3(1.0,0.0,0.0),vec3(0.0,1.0,0.0),dm.y)*dd;\n"
1996 " vec3 v0 = (uSpawnPos.xyz-uPlayerPos.xyz)*uSpawnPos.w;\n"
1997 " float t = clamp( dot(aCo-uPlayerPos.xyz,v0), 0.0, uPlayerPos.w );\n"
1998 " vec3 p0 = uPlayerPos.xyz + v0*t;\n"
1999 " float d3 = distance(p0,aCo);\n"
2000 " emit += vec3(fract(t*0.2-g_realtime+d3*0.2)*max(0.0,1.0-d3*0.2));\n"
2004 " if( uMapInfo.z > 0.0 ){\n"
2005 " float height = fract( aCo.y * 0.1 );\n"
2006 " float lg = 2.0*length(vec2(dFdx(height), dFdy(height)));\n"
2007 " vfrag *= 1.0f+(lg*0.2*uMapInfo.z);\n"
2010 " oColour = vec4( vfrag, 1.0 );\n"
2011 " //oColour = vec4( vfrag, 1.0 );\n"
2016 GLuint _uniform_scene_override_uMdl
;
2017 GLuint _uniform_scene_override_uPv
;
2018 GLuint _uniform_scene_override_uPvmPrev
;
2019 GLuint _uniform_scene_override_uNormalMtx
;
2020 GLuint _uniform_scene_override_uTexGarbage
;
2021 GLuint _uniform_scene_override_uTexMain
;
2022 GLuint _uniform_scene_override_uCamera
;
2023 GLuint _uniform_scene_override_uPlane
;
2024 GLuint _uniform_scene_override_uPlayerPos
;
2025 GLuint _uniform_scene_override_uSpawnPos
;
2026 GLuint _uniform_scene_override_uAlphatest
;
2027 GLuint _uniform_scene_override_uMapInfo
;
2028 GLuint _uniform_scene_override_g_world_depth
;
2029 GLuint _uniform_scene_override_uLightsArray
;
2030 GLuint _uniform_scene_override_uLightsIndex
;
2031 #include "shaders/scene_fxglow.h"
2032 struct vg_shader _shader_scene_fxglow
= {
2033 .name
= "scene_fxglow",
2036 .orig_file
= "shaders/scene_fxglow.vs",
2038 "layout (location=0) in vec3 a_co;\n"
2039 "layout (location=1) in vec4 a_norm;\n"
2040 "layout (location=2) in vec2 a_uv;\n"
2043 "const float k_motion_lerp_amount = 0.01;\n"
2047 "out vec3 aMotionVec0;\n"
2048 "out vec3 aMotionVec1;\n"
2050 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
2052 " // This magically solves some artifacting errors!\n"
2054 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
2056 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
2057 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
2062 "uniform mat4x3 uMdl;\n"
2063 "uniform mat4 uPv;\n"
2064 "uniform mat4 uPvmPrev;\n"
2065 "uniform vec2 uUvOffset;\n"
2070 "out vec3 aWorldCo;\n"
2074 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
2075 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
2076 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
2078 " vs_motion_out( vproj0, vproj1 );\n"
2080 " gl_Position = vproj0;\n"
2082 " aUv = a_uv + uUvOffset;\n"
2083 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
2085 " aWorldCo = world_pos0;\n"
2090 .orig_file
= "shaders/scene_fxglow.fs",
2092 "uniform sampler2D uTexMain;\n"
2093 "uniform vec3 uCamera;\n"
2097 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
2106 "in vec3 aWorldCo;\n"
2109 "layout (location = 0) out vec4 oColour;\n"
2111 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
2112 "layout (std140) uniform ub_world_lighting\n"
2114 " vec4 g_cube_min;\n"
2115 " vec4 g_cube_inv_range;\n"
2117 " vec4 g_water_plane;\n"
2118 " vec4 g_depth_bounds;\n"
2120 " vec4 g_daysky_colour;\n"
2121 " vec4 g_nightsky_colour;\n"
2122 " vec4 g_sunset_colour;\n"
2123 " vec4 g_ambient_colour;\n"
2124 " vec4 g_sunset_ambient;\n"
2125 " vec4 g_sun_colour;\n"
2126 " vec4 g_sun_dir;\n"
2127 " vec4 g_board_0;\n"
2128 " vec4 g_board_1;\n"
2130 " float g_water_fog;\n"
2132 " float g_realtime;\n"
2133 " float g_shadow_length;\n"
2134 " float g_shadow_spread;\n"
2136 " float g_time_of_day;\n"
2137 " float g_day_phase;\n"
2138 " float g_sunset_phase;\n"
2140 " int g_light_preview;\n"
2141 " int g_shadow_samples;\n"
2143 " int g_debug_indices;\n"
2144 " int g_debug_complexity;\n"
2147 "uniform sampler2D g_world_depth;\n"
2148 "uniform samplerBuffer uLightsArray;\n"
2149 "uniform usampler3D uLightsIndex;\n"
2152 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
2153 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
2154 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
2155 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
2156 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
2157 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
2159 "const float SUN_ANGLE = 0.0001;\n"
2160 "const float PI = 3.14159265358979323846264;\n"
2162 "//struct world_info\n"
2167 "// sunset_phase;\n"
2169 "// vec3 sun_dir;\n"
2172 "vec3 rand33(vec3 p3)\n"
2174 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
2175 " p3 += dot(p3, p3.yxz+33.33);\n"
2176 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
2179 "float stars( vec3 rd, float rr, float size ){\n"
2180 " vec3 co = rd * rr;\n"
2182 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
2184 " float spaces = 1.0 / rr;\n"
2185 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
2186 " a -= mod(a, spaces) - spaces * 0.5;\n"
2188 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
2190 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
2191 " plane = plane - mod(plane, PI / count);\n"
2193 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
2195 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
2196 " float ydist = sqrt(rr * rr - level * level);\n"
2197 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
2198 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
2199 " float star = smoothstep(size, 0.0, distance(center, co));\n"
2203 "float luminance( vec3 v )\n"
2205 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
2208 "vec3 clearskies_ambient( vec3 dir )\n"
2210 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
2211 " float sky_gradient = dir.y;\n"
2213 " /* Blend phase colours */\n"
2214 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
2215 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
2216 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
2218 " /* Add gradient */\n"
2219 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
2221 " return ambient;\n"
2224 "vec3 clearskies_sky( vec3 ray_dir )\n"
2226 " ray_dir.y = abs( ray_dir.y );\n"
2227 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
2230 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
2231 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
2232 " float sun_shape = pow( sun_size, 2000.0 );\n"
2233 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
2235 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
2236 " sun_colour *= sun_shape;\n"
2239 " float star = 0.0;\n"
2240 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
2242 " if( star_blend > 0.001 ){\n"
2243 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
2244 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
2245 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
2249 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
2250 " return composite;\n"
2253 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
2255 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
2257 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
2258 " g_sunset_phase );\n"
2260 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
2261 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
2262 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
2263 " ) * g_sun_colour.rgb * g_day_phase;\n"
2265 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
2266 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
2267 " g_sunset_phase );\n"
2269 " return ambient + (light_sun + sky_reflection) * shadow;\n"
2274 "float world_depth_sample( vec3 pos )\n"
2276 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
2277 " return texture( g_world_depth, depth_coord ).r;\n"
2280 "float world_water_depth( vec3 pos )\n"
2282 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
2283 " return world_depth_sample( pos ) - ref_depth;\n"
2286 "float shadow_sample( vec3 co ){\n"
2287 " float height_sample = world_depth_sample( co );\n"
2289 " float fdelta = height_sample - co.y;\n"
2290 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
2293 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
2294 " if( g_shadow_samples == 0 ){\n"
2298 " float fspread = g_shadow_spread;\n"
2299 " float flength = g_shadow_length;\n"
2301 " float famt = 0.0;\n"
2302 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
2303 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
2304 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
2305 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
2307 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
2308 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
2309 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
2310 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
2312 " return 1.0 - famt;\n"
2315 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
2317 " vec3 specdir = reflect( -dir, wnormal );\n"
2318 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
2321 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
2322 " float dist = pow(fdist*0.0010,0.78);\n"
2323 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
2326 "vec3 scene_calculate_light( int light_index, \n"
2327 " vec3 halfview, vec3 co, vec3 normal )\n"
2329 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
2330 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
2331 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
2333 " vec3 light_delta = light_co.xyz-co;\n"
2334 " float dist2 = dot(light_delta,light_delta);\n"
2336 " light_delta = normalize( light_delta );\n"
2338 " float quadratic = dist2*100.0;\n"
2339 " float attenuation = 1.0/( 1.0 + quadratic );\n"
2340 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
2342 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
2344 " if( light_dir.w < 0.999999 ){\n"
2345 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
2346 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
2349 " return light_colour.rgb * attenuation * falloff \n"
2350 " * step( g_day_phase, light_colour.w );\n"
2353 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
2354 " vec3 halfview, vec3 co, vec3 normal )\n"
2356 " uint light_count = packed_index & 0x3u;\n"
2358 " vec3 l = vec3(0.0);\n"
2360 " if( light_count >= 1u ){\n"
2361 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
2362 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
2363 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
2365 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
2367 " if( light_count >= 2u ){\n"
2368 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
2370 " if( light_count >= 3u ){\n"
2371 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
2379 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
2380 " float light_mask )\n"
2382 " if( g_light_preview == 1 )\n"
2383 " diffuse = vec3(0.75);\n"
2386 " vec3 halfview = uCamera - co;\n"
2387 " float fdist = length(halfview);\n"
2388 " halfview /= fdist;\n"
2390 " float world_shadow = newlight_compute_sun_shadow( \n"
2391 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
2393 " vec3 total_light = clearskies_lighting( \n"
2394 " normal, min( light_mask, world_shadow ), halfview );\n"
2396 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
2397 " cube_coord = floor( cube_coord );\n"
2399 " if( g_debug_indices == 1 )\n"
2401 " return rand33(cube_coord);\n"
2404 " if( g_debug_complexity == 1 )\n"
2406 " ivec3 coord = ivec3( cube_coord );\n"
2407 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
2409 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
2410 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
2413 " // FIXME: this coord should absolutely must be clamped!\n"
2415 " ivec3 coord = ivec3( cube_coord );\n"
2416 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
2418 " total_light += \n"
2419 " scene_calculate_packed_light_patch( index_sample.x,\n"
2420 " halfview, co, normal ) \n"
2422 " total_light += \n"
2423 " scene_calculate_packed_light_patch( index_sample.y,\n"
2424 " halfview, co, normal )\n"
2427 " // Take a section of the sky function to give us a matching fog colour\n"
2429 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
2430 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
2431 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
2432 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
2434 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
2435 " sun_colour *= sun_shape;\n"
2437 " fog_colour += sun_colour;\n"
2438 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
2443 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
2445 " vec3 pa = p - a;\n"
2446 " vec3 ba = b - a;\n"
2448 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
2449 " return length( pa - ba*h );\n"
2452 "float compute_board_shadow()\n"
2454 " // player shadow\n"
2455 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
2456 " g_board_1.xyz )-0.1 );\n"
2457 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
2458 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
2460 " return 1.0 - player_shadow*0.8;\n"
2463 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
2465 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
2470 "const float k_motion_lerp_amount = 0.01;\n"
2474 "layout (location = 1) out vec2 oMotionVec;\n"
2476 "in vec3 aMotionVec0;\n"
2477 "in vec3 aMotionVec1;\n"
2479 "void compute_motion_vectors()\n"
2481 " // Write motion vectors\n"
2482 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
2483 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
2485 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
2491 " oMotionVec = vec2(0.0);\n"
2493 " vec4 vsamplemain = texture( uTexMain, aUv );\n"
2495 " vec2 ssuv = gl_FragCoord.xy;\n"
2496 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
2497 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
2499 " if( vsamplemain.a+dither<0.5 )\n"
2502 " oColour = vec4( vsamplemain.rgb, 1.0 );\n"
2507 GLuint _uniform_scene_fxglow_uMdl
;
2508 GLuint _uniform_scene_fxglow_uPv
;
2509 GLuint _uniform_scene_fxglow_uPvmPrev
;
2510 GLuint _uniform_scene_fxglow_uUvOffset
;
2511 GLuint _uniform_scene_fxglow_uTexMain
;
2512 GLuint _uniform_scene_fxglow_uCamera
;
2513 GLuint _uniform_scene_fxglow_g_world_depth
;
2514 GLuint _uniform_scene_fxglow_uLightsArray
;
2515 GLuint _uniform_scene_fxglow_uLightsIndex
;
2516 #include "shaders/scene_vertex_blend.h"
2517 struct vg_shader _shader_scene_vertex_blend
= {
2518 .name
= "scene_vertex_blend",
2521 .orig_file
= "shaders/scene.vs",
2523 "layout (location=0) in vec3 a_co;\n"
2524 "layout (location=1) in vec4 a_norm;\n"
2525 "layout (location=2) in vec2 a_uv;\n"
2528 "const float k_motion_lerp_amount = 0.01;\n"
2532 "out vec3 aMotionVec0;\n"
2533 "out vec3 aMotionVec1;\n"
2535 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
2537 " // This magically solves some artifacting errors!\n"
2539 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
2541 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
2542 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
2547 "uniform mat4x3 uMdl;\n"
2548 "uniform mat4 uPv;\n"
2549 "uniform mat4 uPvmPrev;\n"
2554 "out vec3 aWorldCo;\n"
2558 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
2559 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
2560 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
2562 " vs_motion_out( vproj0, vproj1 );\n"
2564 " gl_Position = vproj0;\n"
2567 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
2569 " aWorldCo = world_pos0;\n"
2574 .orig_file
= "shaders/scene_vertex_blend.fs",
2576 "uniform sampler2D uTexGarbage;\n"
2577 "uniform sampler2D uTexGradients;\n"
2578 "uniform vec3 uCamera;\n"
2582 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
2591 "in vec3 aWorldCo;\n"
2594 "layout (location = 0) out vec4 oColour;\n"
2596 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
2597 "layout (std140) uniform ub_world_lighting\n"
2599 " vec4 g_cube_min;\n"
2600 " vec4 g_cube_inv_range;\n"
2602 " vec4 g_water_plane;\n"
2603 " vec4 g_depth_bounds;\n"
2605 " vec4 g_daysky_colour;\n"
2606 " vec4 g_nightsky_colour;\n"
2607 " vec4 g_sunset_colour;\n"
2608 " vec4 g_ambient_colour;\n"
2609 " vec4 g_sunset_ambient;\n"
2610 " vec4 g_sun_colour;\n"
2611 " vec4 g_sun_dir;\n"
2612 " vec4 g_board_0;\n"
2613 " vec4 g_board_1;\n"
2615 " float g_water_fog;\n"
2617 " float g_realtime;\n"
2618 " float g_shadow_length;\n"
2619 " float g_shadow_spread;\n"
2621 " float g_time_of_day;\n"
2622 " float g_day_phase;\n"
2623 " float g_sunset_phase;\n"
2625 " int g_light_preview;\n"
2626 " int g_shadow_samples;\n"
2628 " int g_debug_indices;\n"
2629 " int g_debug_complexity;\n"
2632 "uniform sampler2D g_world_depth;\n"
2633 "uniform samplerBuffer uLightsArray;\n"
2634 "uniform usampler3D uLightsIndex;\n"
2637 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
2638 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
2639 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
2640 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
2641 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
2642 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
2644 "const float SUN_ANGLE = 0.0001;\n"
2645 "const float PI = 3.14159265358979323846264;\n"
2647 "//struct world_info\n"
2652 "// sunset_phase;\n"
2654 "// vec3 sun_dir;\n"
2657 "vec3 rand33(vec3 p3)\n"
2659 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
2660 " p3 += dot(p3, p3.yxz+33.33);\n"
2661 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
2664 "float stars( vec3 rd, float rr, float size ){\n"
2665 " vec3 co = rd * rr;\n"
2667 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
2669 " float spaces = 1.0 / rr;\n"
2670 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
2671 " a -= mod(a, spaces) - spaces * 0.5;\n"
2673 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
2675 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
2676 " plane = plane - mod(plane, PI / count);\n"
2678 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
2680 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
2681 " float ydist = sqrt(rr * rr - level * level);\n"
2682 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
2683 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
2684 " float star = smoothstep(size, 0.0, distance(center, co));\n"
2688 "float luminance( vec3 v )\n"
2690 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
2693 "vec3 clearskies_ambient( vec3 dir )\n"
2695 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
2696 " float sky_gradient = dir.y;\n"
2698 " /* Blend phase colours */\n"
2699 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
2700 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
2701 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
2703 " /* Add gradient */\n"
2704 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
2706 " return ambient;\n"
2709 "vec3 clearskies_sky( vec3 ray_dir )\n"
2711 " ray_dir.y = abs( ray_dir.y );\n"
2712 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
2715 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
2716 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
2717 " float sun_shape = pow( sun_size, 2000.0 );\n"
2718 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
2720 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
2721 " sun_colour *= sun_shape;\n"
2724 " float star = 0.0;\n"
2725 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
2727 " if( star_blend > 0.001 ){\n"
2728 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
2729 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
2730 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
2734 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
2735 " return composite;\n"
2738 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
2740 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
2742 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
2743 " g_sunset_phase );\n"
2745 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
2746 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
2747 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
2748 " ) * g_sun_colour.rgb * g_day_phase;\n"
2750 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
2751 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
2752 " g_sunset_phase );\n"
2754 " return ambient + (light_sun + sky_reflection) * shadow;\n"
2759 "float world_depth_sample( vec3 pos )\n"
2761 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
2762 " return texture( g_world_depth, depth_coord ).r;\n"
2765 "float world_water_depth( vec3 pos )\n"
2767 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
2768 " return world_depth_sample( pos ) - ref_depth;\n"
2771 "float shadow_sample( vec3 co ){\n"
2772 " float height_sample = world_depth_sample( co );\n"
2774 " float fdelta = height_sample - co.y;\n"
2775 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
2778 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
2779 " if( g_shadow_samples == 0 ){\n"
2783 " float fspread = g_shadow_spread;\n"
2784 " float flength = g_shadow_length;\n"
2786 " float famt = 0.0;\n"
2787 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
2788 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
2789 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
2790 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
2792 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
2793 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
2794 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
2795 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
2797 " return 1.0 - famt;\n"
2800 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
2802 " vec3 specdir = reflect( -dir, wnormal );\n"
2803 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
2806 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
2807 " float dist = pow(fdist*0.0010,0.78);\n"
2808 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
2811 "vec3 scene_calculate_light( int light_index, \n"
2812 " vec3 halfview, vec3 co, vec3 normal )\n"
2814 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
2815 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
2816 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
2818 " vec3 light_delta = light_co.xyz-co;\n"
2819 " float dist2 = dot(light_delta,light_delta);\n"
2821 " light_delta = normalize( light_delta );\n"
2823 " float quadratic = dist2*100.0;\n"
2824 " float attenuation = 1.0/( 1.0 + quadratic );\n"
2825 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
2827 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
2829 " if( light_dir.w < 0.999999 ){\n"
2830 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
2831 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
2834 " return light_colour.rgb * attenuation * falloff \n"
2835 " * step( g_day_phase, light_colour.w );\n"
2838 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
2839 " vec3 halfview, vec3 co, vec3 normal )\n"
2841 " uint light_count = packed_index & 0x3u;\n"
2843 " vec3 l = vec3(0.0);\n"
2845 " if( light_count >= 1u ){\n"
2846 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
2847 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
2848 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
2850 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
2852 " if( light_count >= 2u ){\n"
2853 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
2855 " if( light_count >= 3u ){\n"
2856 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
2864 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
2865 " float light_mask )\n"
2867 " if( g_light_preview == 1 )\n"
2868 " diffuse = vec3(0.75);\n"
2871 " vec3 halfview = uCamera - co;\n"
2872 " float fdist = length(halfview);\n"
2873 " halfview /= fdist;\n"
2875 " float world_shadow = newlight_compute_sun_shadow( \n"
2876 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
2878 " vec3 total_light = clearskies_lighting( \n"
2879 " normal, min( light_mask, world_shadow ), halfview );\n"
2881 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
2882 " cube_coord = floor( cube_coord );\n"
2884 " if( g_debug_indices == 1 )\n"
2886 " return rand33(cube_coord);\n"
2889 " if( g_debug_complexity == 1 )\n"
2891 " ivec3 coord = ivec3( cube_coord );\n"
2892 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
2894 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
2895 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
2898 " // FIXME: this coord should absolutely must be clamped!\n"
2900 " ivec3 coord = ivec3( cube_coord );\n"
2901 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
2903 " total_light += \n"
2904 " scene_calculate_packed_light_patch( index_sample.x,\n"
2905 " halfview, co, normal ) \n"
2907 " total_light += \n"
2908 " scene_calculate_packed_light_patch( index_sample.y,\n"
2909 " halfview, co, normal )\n"
2912 " // Take a section of the sky function to give us a matching fog colour\n"
2914 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
2915 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
2916 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
2917 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
2919 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
2920 " sun_colour *= sun_shape;\n"
2922 " fog_colour += sun_colour;\n"
2923 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
2928 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
2930 " vec3 pa = p - a;\n"
2931 " vec3 ba = b - a;\n"
2933 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
2934 " return length( pa - ba*h );\n"
2937 "float compute_board_shadow()\n"
2939 " // player shadow\n"
2940 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
2941 " g_board_1.xyz )-0.1 );\n"
2942 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
2943 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
2945 " return 1.0 - player_shadow*0.8;\n"
2948 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
2950 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
2955 "const float k_motion_lerp_amount = 0.01;\n"
2959 "layout (location = 1) out vec2 oMotionVec;\n"
2961 "in vec3 aMotionVec0;\n"
2962 "in vec3 aMotionVec1;\n"
2964 "void compute_motion_vectors()\n"
2966 " // Write motion vectors\n"
2967 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
2968 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
2970 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
2977 " compute_motion_vectors();\n"
2979 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
2981 " // ws modulation\n"
2982 " vec4 wgarbage = vec4(0.5,0.5,0.5,1.0);\n"
2984 " // Creating normal patches\n"
2985 " vec3 modnorm = (wgarbage.rgb-0.4) * 1.4;\n"
2986 " vec3 qnorm = normalize(floor(aNorm.xyz*4.0+modnorm)*0.25);\n"
2987 " qnorm += vec3(0.001,0.0,0.0);\n"
2989 " vec3 tangent0 = normalize(cross(qnorm,vec3(0.0,1.0,0.0)));\n"
2990 " vec3 tangent1 = cross(qnorm,tangent0);\n"
2991 " vec2 uvdiffuse = vec2( dot(tangent0,aCo), dot(tangent1,aCo) ) * 0.160;\n"
2993 " // Patch local noise\n"
2994 " vec4 rgarbage = texture( uTexGarbage, uvdiffuse );\n"
2996 " // Colour blending\n"
2997 " float fblendclip = step(0.380,aNorm.w + (rgarbage.r-0.5)*-1.740)*0.320;\n"
2998 " vec2 uvgradients = aUv + vec2( fblendclip, 0.0 );\n"
3000 " vfrag = texture( uTexGradients, uvgradients ).rgb;\n"
3001 " vfrag -= rgarbage.a*0.04;\n"
3003 " if( g_light_preview == 1 )\n"
3005 " vfrag = vec3(0.5);\n"
3008 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
3009 " oColour = vec4(vfrag, 1.0);\n"
3014 GLuint _uniform_scene_vertex_blend_uMdl
;
3015 GLuint _uniform_scene_vertex_blend_uPv
;
3016 GLuint _uniform_scene_vertex_blend_uPvmPrev
;
3017 GLuint _uniform_scene_vertex_blend_uTexGarbage
;
3018 GLuint _uniform_scene_vertex_blend_uTexGradients
;
3019 GLuint _uniform_scene_vertex_blend_uCamera
;
3020 GLuint _uniform_scene_vertex_blend_g_world_depth
;
3021 GLuint _uniform_scene_vertex_blend_uLightsArray
;
3022 GLuint _uniform_scene_vertex_blend_uLightsIndex
;
3023 #include "shaders/scene_terrain.h"
3024 struct vg_shader _shader_scene_terrain
= {
3025 .name
= "scene_terrain",
3028 .orig_file
= "shaders/scene.vs",
3030 "layout (location=0) in vec3 a_co;\n"
3031 "layout (location=1) in vec4 a_norm;\n"
3032 "layout (location=2) in vec2 a_uv;\n"
3035 "const float k_motion_lerp_amount = 0.01;\n"
3039 "out vec3 aMotionVec0;\n"
3040 "out vec3 aMotionVec1;\n"
3042 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
3044 " // This magically solves some artifacting errors!\n"
3046 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
3048 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
3049 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
3054 "uniform mat4x3 uMdl;\n"
3055 "uniform mat4 uPv;\n"
3056 "uniform mat4 uPvmPrev;\n"
3061 "out vec3 aWorldCo;\n"
3065 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
3066 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
3067 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
3069 " vs_motion_out( vproj0, vproj1 );\n"
3071 " gl_Position = vproj0;\n"
3074 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
3076 " aWorldCo = world_pos0;\n"
3081 .orig_file
= "shaders/scene_terrain.fs",
3083 "uniform sampler2D uTexGarbage;\n"
3084 "uniform sampler2D uTexGradients;\n"
3085 "uniform vec3 uCamera;\n"
3086 "uniform vec3 uSandColour;\n"
3087 "uniform vec2 uBlendOffset;\n"
3091 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
3100 "in vec3 aWorldCo;\n"
3103 "layout (location = 0) out vec4 oColour;\n"
3105 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
3106 "layout (std140) uniform ub_world_lighting\n"
3108 " vec4 g_cube_min;\n"
3109 " vec4 g_cube_inv_range;\n"
3111 " vec4 g_water_plane;\n"
3112 " vec4 g_depth_bounds;\n"
3114 " vec4 g_daysky_colour;\n"
3115 " vec4 g_nightsky_colour;\n"
3116 " vec4 g_sunset_colour;\n"
3117 " vec4 g_ambient_colour;\n"
3118 " vec4 g_sunset_ambient;\n"
3119 " vec4 g_sun_colour;\n"
3120 " vec4 g_sun_dir;\n"
3121 " vec4 g_board_0;\n"
3122 " vec4 g_board_1;\n"
3124 " float g_water_fog;\n"
3126 " float g_realtime;\n"
3127 " float g_shadow_length;\n"
3128 " float g_shadow_spread;\n"
3130 " float g_time_of_day;\n"
3131 " float g_day_phase;\n"
3132 " float g_sunset_phase;\n"
3134 " int g_light_preview;\n"
3135 " int g_shadow_samples;\n"
3137 " int g_debug_indices;\n"
3138 " int g_debug_complexity;\n"
3141 "uniform sampler2D g_world_depth;\n"
3142 "uniform samplerBuffer uLightsArray;\n"
3143 "uniform usampler3D uLightsIndex;\n"
3146 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
3147 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
3148 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
3149 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
3150 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
3151 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
3153 "const float SUN_ANGLE = 0.0001;\n"
3154 "const float PI = 3.14159265358979323846264;\n"
3156 "//struct world_info\n"
3161 "// sunset_phase;\n"
3163 "// vec3 sun_dir;\n"
3166 "vec3 rand33(vec3 p3)\n"
3168 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
3169 " p3 += dot(p3, p3.yxz+33.33);\n"
3170 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
3173 "float stars( vec3 rd, float rr, float size ){\n"
3174 " vec3 co = rd * rr;\n"
3176 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
3178 " float spaces = 1.0 / rr;\n"
3179 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
3180 " a -= mod(a, spaces) - spaces * 0.5;\n"
3182 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
3184 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
3185 " plane = plane - mod(plane, PI / count);\n"
3187 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
3189 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
3190 " float ydist = sqrt(rr * rr - level * level);\n"
3191 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
3192 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
3193 " float star = smoothstep(size, 0.0, distance(center, co));\n"
3197 "float luminance( vec3 v )\n"
3199 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
3202 "vec3 clearskies_ambient( vec3 dir )\n"
3204 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
3205 " float sky_gradient = dir.y;\n"
3207 " /* Blend phase colours */\n"
3208 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
3209 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
3210 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
3212 " /* Add gradient */\n"
3213 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
3215 " return ambient;\n"
3218 "vec3 clearskies_sky( vec3 ray_dir )\n"
3220 " ray_dir.y = abs( ray_dir.y );\n"
3221 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
3224 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
3225 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
3226 " float sun_shape = pow( sun_size, 2000.0 );\n"
3227 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
3229 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
3230 " sun_colour *= sun_shape;\n"
3233 " float star = 0.0;\n"
3234 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
3236 " if( star_blend > 0.001 ){\n"
3237 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
3238 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
3239 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
3243 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
3244 " return composite;\n"
3247 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
3249 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
3251 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
3252 " g_sunset_phase );\n"
3254 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
3255 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
3256 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
3257 " ) * g_sun_colour.rgb * g_day_phase;\n"
3259 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
3260 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
3261 " g_sunset_phase );\n"
3263 " return ambient + (light_sun + sky_reflection) * shadow;\n"
3268 "float world_depth_sample( vec3 pos )\n"
3270 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
3271 " return texture( g_world_depth, depth_coord ).r;\n"
3274 "float world_water_depth( vec3 pos )\n"
3276 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
3277 " return world_depth_sample( pos ) - ref_depth;\n"
3280 "float shadow_sample( vec3 co ){\n"
3281 " float height_sample = world_depth_sample( co );\n"
3283 " float fdelta = height_sample - co.y;\n"
3284 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
3287 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
3288 " if( g_shadow_samples == 0 ){\n"
3292 " float fspread = g_shadow_spread;\n"
3293 " float flength = g_shadow_length;\n"
3295 " float famt = 0.0;\n"
3296 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
3297 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
3298 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
3299 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
3301 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
3302 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
3303 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
3304 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
3306 " return 1.0 - famt;\n"
3309 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
3311 " vec3 specdir = reflect( -dir, wnormal );\n"
3312 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
3315 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
3316 " float dist = pow(fdist*0.0010,0.78);\n"
3317 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
3320 "vec3 scene_calculate_light( int light_index, \n"
3321 " vec3 halfview, vec3 co, vec3 normal )\n"
3323 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
3324 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
3325 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
3327 " vec3 light_delta = light_co.xyz-co;\n"
3328 " float dist2 = dot(light_delta,light_delta);\n"
3330 " light_delta = normalize( light_delta );\n"
3332 " float quadratic = dist2*100.0;\n"
3333 " float attenuation = 1.0/( 1.0 + quadratic );\n"
3334 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
3336 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
3338 " if( light_dir.w < 0.999999 ){\n"
3339 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
3340 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
3343 " return light_colour.rgb * attenuation * falloff \n"
3344 " * step( g_day_phase, light_colour.w );\n"
3347 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
3348 " vec3 halfview, vec3 co, vec3 normal )\n"
3350 " uint light_count = packed_index & 0x3u;\n"
3352 " vec3 l = vec3(0.0);\n"
3354 " if( light_count >= 1u ){\n"
3355 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
3356 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
3357 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
3359 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
3361 " if( light_count >= 2u ){\n"
3362 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
3364 " if( light_count >= 3u ){\n"
3365 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
3373 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
3374 " float light_mask )\n"
3376 " if( g_light_preview == 1 )\n"
3377 " diffuse = vec3(0.75);\n"
3380 " vec3 halfview = uCamera - co;\n"
3381 " float fdist = length(halfview);\n"
3382 " halfview /= fdist;\n"
3384 " float world_shadow = newlight_compute_sun_shadow( \n"
3385 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
3387 " vec3 total_light = clearskies_lighting( \n"
3388 " normal, min( light_mask, world_shadow ), halfview );\n"
3390 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
3391 " cube_coord = floor( cube_coord );\n"
3393 " if( g_debug_indices == 1 )\n"
3395 " return rand33(cube_coord);\n"
3398 " if( g_debug_complexity == 1 )\n"
3400 " ivec3 coord = ivec3( cube_coord );\n"
3401 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
3403 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
3404 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
3407 " // FIXME: this coord should absolutely must be clamped!\n"
3409 " ivec3 coord = ivec3( cube_coord );\n"
3410 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
3412 " total_light += \n"
3413 " scene_calculate_packed_light_patch( index_sample.x,\n"
3414 " halfview, co, normal ) \n"
3416 " total_light += \n"
3417 " scene_calculate_packed_light_patch( index_sample.y,\n"
3418 " halfview, co, normal )\n"
3421 " // Take a section of the sky function to give us a matching fog colour\n"
3423 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
3424 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
3425 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
3426 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
3428 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
3429 " sun_colour *= sun_shape;\n"
3431 " fog_colour += sun_colour;\n"
3432 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
3437 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
3439 " vec3 pa = p - a;\n"
3440 " vec3 ba = b - a;\n"
3442 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
3443 " return length( pa - ba*h );\n"
3446 "float compute_board_shadow()\n"
3448 " // player shadow\n"
3449 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
3450 " g_board_1.xyz )-0.1 );\n"
3451 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
3452 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
3454 " return 1.0 - player_shadow*0.8;\n"
3457 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
3459 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
3464 "const float k_motion_lerp_amount = 0.01;\n"
3468 "layout (location = 1) out vec2 oMotionVec;\n"
3470 "in vec3 aMotionVec0;\n"
3471 "in vec3 aMotionVec1;\n"
3473 "void compute_motion_vectors()\n"
3475 " // Write motion vectors\n"
3476 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
3477 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
3479 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
3486 " compute_motion_vectors();\n"
3490 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
3492 " // ws modulation\n"
3493 " vec4 wgarbage = texture( uTexGarbage, aCo.xz * 0.015 );\n"
3495 " // Creating normal patches\n"
3496 " vec3 modnorm = (wgarbage.rgb-0.4) * 1.4;\n"
3497 " vec3 qnorm = normalize(floor(aNorm.xyz*4.0+modnorm)*0.25);\n"
3498 " qnorm += vec3(0.001,0.0,0.0);\n"
3500 " vec2 dir = normalize(qnorm.xz);\n"
3501 " vec2 uvdiffuse = aCo.xz * 0.02;\n"
3502 " uvdiffuse = mat2(dir.y, dir.x, -dir.x, dir.y) * uvdiffuse;\n"
3504 " // Patch local noise\n"
3505 " vec4 rgarbage = texture( uTexGarbage, uvdiffuse );\n"
3507 " // Colour blending\n"
3508 " float amtgrass = step(qnorm.y,0.6);\n"
3509 " float amtsand = min(max((aCo.y - 10.0) * -0.1,0.0)*qnorm.y,1.0);\n"
3510 " vec2 uvgradients = aUv + vec2( amtgrass + rgarbage.a*0.8 )*uBlendOffset;\n"
3511 " vfrag = texture( uTexGradients, uvgradients ).rgb;\n"
3512 " vfrag = mix( vfrag, uSandColour, amtsand );\n"
3514 " qnorm = mix( qnorm, aNorm.xyz, amtsand );\n"
3516 " if( g_light_preview == 1 )\n"
3518 " vfrag = vec3(0.5);\n"
3521 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
3522 " oColour = vec4(vfrag, 1.0);\n"
3527 GLuint _uniform_scene_terrain_uMdl
;
3528 GLuint _uniform_scene_terrain_uPv
;
3529 GLuint _uniform_scene_terrain_uPvmPrev
;
3530 GLuint _uniform_scene_terrain_uTexGarbage
;
3531 GLuint _uniform_scene_terrain_uTexGradients
;
3532 GLuint _uniform_scene_terrain_uCamera
;
3533 GLuint _uniform_scene_terrain_uSandColour
;
3534 GLuint _uniform_scene_terrain_uBlendOffset
;
3535 GLuint _uniform_scene_terrain_g_world_depth
;
3536 GLuint _uniform_scene_terrain_uLightsArray
;
3537 GLuint _uniform_scene_terrain_uLightsIndex
;
3538 #include "shaders/scene_route.h"
3539 struct vg_shader _shader_scene_route
= {
3540 .name
= "scene_route",
3543 .orig_file
= "shaders/scene_override.vs",
3545 "layout (location=0) in vec3 a_co;\n"
3546 "layout (location=1) in vec4 a_norm;\n"
3547 "layout (location=2) in vec2 a_uv;\n"
3550 "const float k_motion_lerp_amount = 0.01;\n"
3554 "out vec3 aMotionVec0;\n"
3555 "out vec3 aMotionVec1;\n"
3557 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
3559 " // This magically solves some artifacting errors!\n"
3561 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
3563 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
3564 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
3569 "uniform mat4x3 uMdl;\n"
3570 "uniform mat4 uPv;\n"
3571 "uniform mat4 uPvmPrev;\n"
3572 "uniform mat3 uNormalMtx;\n"
3577 "out vec3 aWorldCo;\n"
3581 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
3582 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
3583 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
3585 " vs_motion_out( vproj0, vproj1 );\n"
3587 " gl_Position = vproj0;\n"
3590 " aNorm = vec4( uNormalMtx * a_norm.xyz, a_norm.w );\n"
3592 " aWorldCo = world_pos0;\n"
3597 .orig_file
= "shaders/scene_route.fs",
3599 "uniform sampler2D uTexGarbage;\n"
3600 "uniform sampler2D uTexGradients;\n"
3601 "uniform vec3 uCamera;\n"
3602 "uniform vec4 uColour;\n"
3606 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
3615 "in vec3 aWorldCo;\n"
3618 "layout (location = 0) out vec4 oColour;\n"
3620 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
3621 "layout (std140) uniform ub_world_lighting\n"
3623 " vec4 g_cube_min;\n"
3624 " vec4 g_cube_inv_range;\n"
3626 " vec4 g_water_plane;\n"
3627 " vec4 g_depth_bounds;\n"
3629 " vec4 g_daysky_colour;\n"
3630 " vec4 g_nightsky_colour;\n"
3631 " vec4 g_sunset_colour;\n"
3632 " vec4 g_ambient_colour;\n"
3633 " vec4 g_sunset_ambient;\n"
3634 " vec4 g_sun_colour;\n"
3635 " vec4 g_sun_dir;\n"
3636 " vec4 g_board_0;\n"
3637 " vec4 g_board_1;\n"
3639 " float g_water_fog;\n"
3641 " float g_realtime;\n"
3642 " float g_shadow_length;\n"
3643 " float g_shadow_spread;\n"
3645 " float g_time_of_day;\n"
3646 " float g_day_phase;\n"
3647 " float g_sunset_phase;\n"
3649 " int g_light_preview;\n"
3650 " int g_shadow_samples;\n"
3652 " int g_debug_indices;\n"
3653 " int g_debug_complexity;\n"
3656 "uniform sampler2D g_world_depth;\n"
3657 "uniform samplerBuffer uLightsArray;\n"
3658 "uniform usampler3D uLightsIndex;\n"
3661 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
3662 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
3663 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
3664 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
3665 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
3666 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
3668 "const float SUN_ANGLE = 0.0001;\n"
3669 "const float PI = 3.14159265358979323846264;\n"
3671 "//struct world_info\n"
3676 "// sunset_phase;\n"
3678 "// vec3 sun_dir;\n"
3681 "vec3 rand33(vec3 p3)\n"
3683 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
3684 " p3 += dot(p3, p3.yxz+33.33);\n"
3685 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
3688 "float stars( vec3 rd, float rr, float size ){\n"
3689 " vec3 co = rd * rr;\n"
3691 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
3693 " float spaces = 1.0 / rr;\n"
3694 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
3695 " a -= mod(a, spaces) - spaces * 0.5;\n"
3697 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
3699 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
3700 " plane = plane - mod(plane, PI / count);\n"
3702 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
3704 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
3705 " float ydist = sqrt(rr * rr - level * level);\n"
3706 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
3707 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
3708 " float star = smoothstep(size, 0.0, distance(center, co));\n"
3712 "float luminance( vec3 v )\n"
3714 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
3717 "vec3 clearskies_ambient( vec3 dir )\n"
3719 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
3720 " float sky_gradient = dir.y;\n"
3722 " /* Blend phase colours */\n"
3723 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
3724 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
3725 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
3727 " /* Add gradient */\n"
3728 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
3730 " return ambient;\n"
3733 "vec3 clearskies_sky( vec3 ray_dir )\n"
3735 " ray_dir.y = abs( ray_dir.y );\n"
3736 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
3739 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
3740 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
3741 " float sun_shape = pow( sun_size, 2000.0 );\n"
3742 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
3744 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
3745 " sun_colour *= sun_shape;\n"
3748 " float star = 0.0;\n"
3749 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
3751 " if( star_blend > 0.001 ){\n"
3752 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
3753 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
3754 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
3758 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
3759 " return composite;\n"
3762 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
3764 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
3766 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
3767 " g_sunset_phase );\n"
3769 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
3770 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
3771 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
3772 " ) * g_sun_colour.rgb * g_day_phase;\n"
3774 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
3775 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
3776 " g_sunset_phase );\n"
3778 " return ambient + (light_sun + sky_reflection) * shadow;\n"
3783 "float world_depth_sample( vec3 pos )\n"
3785 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
3786 " return texture( g_world_depth, depth_coord ).r;\n"
3789 "float world_water_depth( vec3 pos )\n"
3791 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
3792 " return world_depth_sample( pos ) - ref_depth;\n"
3795 "float shadow_sample( vec3 co ){\n"
3796 " float height_sample = world_depth_sample( co );\n"
3798 " float fdelta = height_sample - co.y;\n"
3799 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
3802 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
3803 " if( g_shadow_samples == 0 ){\n"
3807 " float fspread = g_shadow_spread;\n"
3808 " float flength = g_shadow_length;\n"
3810 " float famt = 0.0;\n"
3811 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
3812 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
3813 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
3814 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
3816 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
3817 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
3818 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
3819 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
3821 " return 1.0 - famt;\n"
3824 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
3826 " vec3 specdir = reflect( -dir, wnormal );\n"
3827 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
3830 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
3831 " float dist = pow(fdist*0.0010,0.78);\n"
3832 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
3835 "vec3 scene_calculate_light( int light_index, \n"
3836 " vec3 halfview, vec3 co, vec3 normal )\n"
3838 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
3839 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
3840 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
3842 " vec3 light_delta = light_co.xyz-co;\n"
3843 " float dist2 = dot(light_delta,light_delta);\n"
3845 " light_delta = normalize( light_delta );\n"
3847 " float quadratic = dist2*100.0;\n"
3848 " float attenuation = 1.0/( 1.0 + quadratic );\n"
3849 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
3851 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
3853 " if( light_dir.w < 0.999999 ){\n"
3854 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
3855 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
3858 " return light_colour.rgb * attenuation * falloff \n"
3859 " * step( g_day_phase, light_colour.w );\n"
3862 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
3863 " vec3 halfview, vec3 co, vec3 normal )\n"
3865 " uint light_count = packed_index & 0x3u;\n"
3867 " vec3 l = vec3(0.0);\n"
3869 " if( light_count >= 1u ){\n"
3870 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
3871 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
3872 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
3874 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
3876 " if( light_count >= 2u ){\n"
3877 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
3879 " if( light_count >= 3u ){\n"
3880 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
3888 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
3889 " float light_mask )\n"
3891 " if( g_light_preview == 1 )\n"
3892 " diffuse = vec3(0.75);\n"
3895 " vec3 halfview = uCamera - co;\n"
3896 " float fdist = length(halfview);\n"
3897 " halfview /= fdist;\n"
3899 " float world_shadow = newlight_compute_sun_shadow( \n"
3900 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
3902 " vec3 total_light = clearskies_lighting( \n"
3903 " normal, min( light_mask, world_shadow ), halfview );\n"
3905 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
3906 " cube_coord = floor( cube_coord );\n"
3908 " if( g_debug_indices == 1 )\n"
3910 " return rand33(cube_coord);\n"
3913 " if( g_debug_complexity == 1 )\n"
3915 " ivec3 coord = ivec3( cube_coord );\n"
3916 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
3918 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
3919 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
3922 " // FIXME: this coord should absolutely must be clamped!\n"
3924 " ivec3 coord = ivec3( cube_coord );\n"
3925 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
3927 " total_light += \n"
3928 " scene_calculate_packed_light_patch( index_sample.x,\n"
3929 " halfview, co, normal ) \n"
3931 " total_light += \n"
3932 " scene_calculate_packed_light_patch( index_sample.y,\n"
3933 " halfview, co, normal )\n"
3936 " // Take a section of the sky function to give us a matching fog colour\n"
3938 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
3939 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
3940 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
3941 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
3943 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
3944 " sun_colour *= sun_shape;\n"
3946 " fog_colour += sun_colour;\n"
3947 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
3952 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
3954 " vec3 pa = p - a;\n"
3955 " vec3 ba = b - a;\n"
3957 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
3958 " return length( pa - ba*h );\n"
3961 "float compute_board_shadow()\n"
3963 " // player shadow\n"
3964 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
3965 " g_board_1.xyz )-0.1 );\n"
3966 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
3967 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
3969 " return 1.0 - player_shadow*0.8;\n"
3972 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
3974 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
3979 "const float k_motion_lerp_amount = 0.01;\n"
3983 "layout (location = 1) out vec2 oMotionVec;\n"
3985 "in vec3 aMotionVec0;\n"
3986 "in vec3 aMotionVec1;\n"
3988 "void compute_motion_vectors()\n"
3990 " // Write motion vectors\n"
3991 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
3992 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
3994 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
3999 "float filtered_stripe( in float p, in float ddx, in float ddy )\n"
4001 " float w = max(abs(ddx), abs(ddy)) + 0.02;\n"
4002 " float i = (abs(fract((p-0.5*w)/2.0)-0.5)-abs(fract((p+0.5*w)/2.0)-0.5))/w;\n"
4003 " return 0.5 - i;\n"
4008 " compute_motion_vectors();\n"
4010 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
4012 " // ws modulation\n"
4013 " vec4 wgarbage = texture( uTexGarbage, aCo.xz * 0.015 );\n"
4015 " // Creating normal patches\n"
4016 " vec3 modnorm = (wgarbage.rgb-0.4) * 1.4;\n"
4017 " vec3 qnorm = normalize(floor(aNorm.xyz*4.0+modnorm)*0.25);\n"
4018 " qnorm += vec3(0.001,0.0,0.0);\n"
4020 " vec3 tangent0 = normalize(cross(qnorm,vec3(0.0,1.0,0.0)));\n"
4021 " vec3 tangent1 = cross(qnorm,tangent0);\n"
4022 " vec2 uvdiffuse = vec2( dot(tangent0,aCo), dot(tangent1,aCo) ) * 0.035;\n"
4024 " // Patch local noise\n"
4025 " vec4 rgarbage = texture( uTexGarbage, uvdiffuse );\n"
4027 " vfrag = pow(uColour.rgb,vec3(1.0/2.2));\n"
4028 " vfrag -= rgarbage.a*0.1;\n"
4030 " if( wgarbage.g < 0.1 )\n"
4033 " float movep = (aUv.x + abs(aUv.y-0.5)*0.4 - g_realtime)*2.0;\n"
4034 " float stripe = filtered_stripe( movep, dFdx(movep), dFdy(movep) );\n"
4035 " vfrag *= 0.9+stripe*uColour.a; \n"
4037 " if( g_light_preview == 1 )\n"
4039 " vfrag = vec3(0.5);\n"
4043 " oColour = vec4( scene_compute_lighting( vfrag, qnorm, aWorldCo ), 1.0 );\n"
4048 GLuint _uniform_scene_route_uMdl
;
4049 GLuint _uniform_scene_route_uPv
;
4050 GLuint _uniform_scene_route_uPvmPrev
;
4051 GLuint _uniform_scene_route_uNormalMtx
;
4052 GLuint _uniform_scene_route_uTexGarbage
;
4053 GLuint _uniform_scene_route_uTexGradients
;
4054 GLuint _uniform_scene_route_uCamera
;
4055 GLuint _uniform_scene_route_uColour
;
4056 GLuint _uniform_scene_route_g_world_depth
;
4057 GLuint _uniform_scene_route_uLightsArray
;
4058 GLuint _uniform_scene_route_uLightsIndex
;
4059 #include "shaders/scene_depth.h"
4060 struct vg_shader _shader_scene_depth
= {
4061 .name
= "scene_depth",
4064 .orig_file
= "shaders/scene.vs",
4066 "layout (location=0) in vec3 a_co;\n"
4067 "layout (location=1) in vec4 a_norm;\n"
4068 "layout (location=2) in vec2 a_uv;\n"
4071 "const float k_motion_lerp_amount = 0.01;\n"
4075 "out vec3 aMotionVec0;\n"
4076 "out vec3 aMotionVec1;\n"
4078 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
4080 " // This magically solves some artifacting errors!\n"
4082 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
4084 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
4085 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
4090 "uniform mat4x3 uMdl;\n"
4091 "uniform mat4 uPv;\n"
4092 "uniform mat4 uPvmPrev;\n"
4097 "out vec3 aWorldCo;\n"
4101 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
4102 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
4103 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
4105 " vs_motion_out( vproj0, vproj1 );\n"
4107 " gl_Position = vproj0;\n"
4110 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
4112 " aWorldCo = world_pos0;\n"
4117 .orig_file
= "shaders/scene_depth.fs",
4119 "out vec4 FragColor;\n"
4121 "uniform vec3 uCamera;\n"
4122 "uniform vec3 uBoard0;\n"
4123 "uniform vec3 uBoard1;\n"
4127 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
4136 "in vec3 aWorldCo;\n"
4139 "layout (location = 0) out vec4 oColour;\n"
4141 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
4142 "layout (std140) uniform ub_world_lighting\n"
4144 " vec4 g_cube_min;\n"
4145 " vec4 g_cube_inv_range;\n"
4147 " vec4 g_water_plane;\n"
4148 " vec4 g_depth_bounds;\n"
4150 " vec4 g_daysky_colour;\n"
4151 " vec4 g_nightsky_colour;\n"
4152 " vec4 g_sunset_colour;\n"
4153 " vec4 g_ambient_colour;\n"
4154 " vec4 g_sunset_ambient;\n"
4155 " vec4 g_sun_colour;\n"
4156 " vec4 g_sun_dir;\n"
4157 " vec4 g_board_0;\n"
4158 " vec4 g_board_1;\n"
4160 " float g_water_fog;\n"
4162 " float g_realtime;\n"
4163 " float g_shadow_length;\n"
4164 " float g_shadow_spread;\n"
4166 " float g_time_of_day;\n"
4167 " float g_day_phase;\n"
4168 " float g_sunset_phase;\n"
4170 " int g_light_preview;\n"
4171 " int g_shadow_samples;\n"
4173 " int g_debug_indices;\n"
4174 " int g_debug_complexity;\n"
4177 "uniform sampler2D g_world_depth;\n"
4178 "uniform samplerBuffer uLightsArray;\n"
4179 "uniform usampler3D uLightsIndex;\n"
4182 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
4183 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
4184 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
4185 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
4186 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
4187 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
4189 "const float SUN_ANGLE = 0.0001;\n"
4190 "const float PI = 3.14159265358979323846264;\n"
4192 "//struct world_info\n"
4197 "// sunset_phase;\n"
4199 "// vec3 sun_dir;\n"
4202 "vec3 rand33(vec3 p3)\n"
4204 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
4205 " p3 += dot(p3, p3.yxz+33.33);\n"
4206 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
4209 "float stars( vec3 rd, float rr, float size ){\n"
4210 " vec3 co = rd * rr;\n"
4212 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
4214 " float spaces = 1.0 / rr;\n"
4215 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
4216 " a -= mod(a, spaces) - spaces * 0.5;\n"
4218 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
4220 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
4221 " plane = plane - mod(plane, PI / count);\n"
4223 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
4225 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
4226 " float ydist = sqrt(rr * rr - level * level);\n"
4227 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
4228 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
4229 " float star = smoothstep(size, 0.0, distance(center, co));\n"
4233 "float luminance( vec3 v )\n"
4235 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
4238 "vec3 clearskies_ambient( vec3 dir )\n"
4240 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
4241 " float sky_gradient = dir.y;\n"
4243 " /* Blend phase colours */\n"
4244 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
4245 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
4246 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
4248 " /* Add gradient */\n"
4249 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
4251 " return ambient;\n"
4254 "vec3 clearskies_sky( vec3 ray_dir )\n"
4256 " ray_dir.y = abs( ray_dir.y );\n"
4257 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
4260 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
4261 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
4262 " float sun_shape = pow( sun_size, 2000.0 );\n"
4263 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
4265 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
4266 " sun_colour *= sun_shape;\n"
4269 " float star = 0.0;\n"
4270 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
4272 " if( star_blend > 0.001 ){\n"
4273 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
4274 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
4275 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
4279 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
4280 " return composite;\n"
4283 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
4285 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
4287 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
4288 " g_sunset_phase );\n"
4290 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
4291 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
4292 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
4293 " ) * g_sun_colour.rgb * g_day_phase;\n"
4295 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
4296 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
4297 " g_sunset_phase );\n"
4299 " return ambient + (light_sun + sky_reflection) * shadow;\n"
4304 "float world_depth_sample( vec3 pos )\n"
4306 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
4307 " return texture( g_world_depth, depth_coord ).r;\n"
4310 "float world_water_depth( vec3 pos )\n"
4312 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
4313 " return world_depth_sample( pos ) - ref_depth;\n"
4316 "float shadow_sample( vec3 co ){\n"
4317 " float height_sample = world_depth_sample( co );\n"
4319 " float fdelta = height_sample - co.y;\n"
4320 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
4323 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
4324 " if( g_shadow_samples == 0 ){\n"
4328 " float fspread = g_shadow_spread;\n"
4329 " float flength = g_shadow_length;\n"
4331 " float famt = 0.0;\n"
4332 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
4333 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
4334 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
4335 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
4337 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
4338 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
4339 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
4340 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
4342 " return 1.0 - famt;\n"
4345 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
4347 " vec3 specdir = reflect( -dir, wnormal );\n"
4348 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
4351 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
4352 " float dist = pow(fdist*0.0010,0.78);\n"
4353 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
4356 "vec3 scene_calculate_light( int light_index, \n"
4357 " vec3 halfview, vec3 co, vec3 normal )\n"
4359 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
4360 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
4361 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
4363 " vec3 light_delta = light_co.xyz-co;\n"
4364 " float dist2 = dot(light_delta,light_delta);\n"
4366 " light_delta = normalize( light_delta );\n"
4368 " float quadratic = dist2*100.0;\n"
4369 " float attenuation = 1.0/( 1.0 + quadratic );\n"
4370 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
4372 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
4374 " if( light_dir.w < 0.999999 ){\n"
4375 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
4376 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
4379 " return light_colour.rgb * attenuation * falloff \n"
4380 " * step( g_day_phase, light_colour.w );\n"
4383 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
4384 " vec3 halfview, vec3 co, vec3 normal )\n"
4386 " uint light_count = packed_index & 0x3u;\n"
4388 " vec3 l = vec3(0.0);\n"
4390 " if( light_count >= 1u ){\n"
4391 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
4392 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
4393 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
4395 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
4397 " if( light_count >= 2u ){\n"
4398 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
4400 " if( light_count >= 3u ){\n"
4401 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
4409 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
4410 " float light_mask )\n"
4412 " if( g_light_preview == 1 )\n"
4413 " diffuse = vec3(0.75);\n"
4416 " vec3 halfview = uCamera - co;\n"
4417 " float fdist = length(halfview);\n"
4418 " halfview /= fdist;\n"
4420 " float world_shadow = newlight_compute_sun_shadow( \n"
4421 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
4423 " vec3 total_light = clearskies_lighting( \n"
4424 " normal, min( light_mask, world_shadow ), halfview );\n"
4426 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
4427 " cube_coord = floor( cube_coord );\n"
4429 " if( g_debug_indices == 1 )\n"
4431 " return rand33(cube_coord);\n"
4434 " if( g_debug_complexity == 1 )\n"
4436 " ivec3 coord = ivec3( cube_coord );\n"
4437 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
4439 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
4440 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
4443 " // FIXME: this coord should absolutely must be clamped!\n"
4445 " ivec3 coord = ivec3( cube_coord );\n"
4446 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
4448 " total_light += \n"
4449 " scene_calculate_packed_light_patch( index_sample.x,\n"
4450 " halfview, co, normal ) \n"
4452 " total_light += \n"
4453 " scene_calculate_packed_light_patch( index_sample.y,\n"
4454 " halfview, co, normal )\n"
4457 " // Take a section of the sky function to give us a matching fog colour\n"
4459 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
4460 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
4461 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
4462 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
4464 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
4465 " sun_colour *= sun_shape;\n"
4467 " fog_colour += sun_colour;\n"
4468 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
4473 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
4475 " vec3 pa = p - a;\n"
4476 " vec3 ba = b - a;\n"
4478 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
4479 " return length( pa - ba*h );\n"
4482 "float compute_board_shadow()\n"
4484 " // player shadow\n"
4485 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
4486 " g_board_1.xyz )-0.1 );\n"
4487 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
4488 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
4490 " return 1.0 - player_shadow*0.8;\n"
4493 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
4495 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
4500 "// Water blending\n"
4501 "// ==============\n"
4503 "float water_depth( vec3 pos, vec3 halfview )\n"
4505 " vec3 pnorm = g_water_plane.xyz;\n"
4506 " float pdist = g_water_plane.w;\n"
4508 " float d = dot( pnorm, halfview );\n"
4509 " float t = dot((pnorm*pdist - pos), pnorm) / d;\n"
4510 " return t * g_water_fog;\n"
4515 " vec3 halfview = normalize( uCamera - aWorldCo );\n"
4516 " float depth = water_depth( aWorldCo, halfview );\n"
4517 " FragColor = vec4( depth, 0.0, 0.0, 0.0 );\n"
4522 GLuint _uniform_scene_depth_uMdl
;
4523 GLuint _uniform_scene_depth_uPv
;
4524 GLuint _uniform_scene_depth_uPvmPrev
;
4525 GLuint _uniform_scene_depth_uCamera
;
4526 GLuint _uniform_scene_depth_uBoard0
;
4527 GLuint _uniform_scene_depth_uBoard1
;
4528 GLuint _uniform_scene_depth_g_world_depth
;
4529 GLuint _uniform_scene_depth_uLightsArray
;
4530 GLuint _uniform_scene_depth_uLightsIndex
;
4531 #include "shaders/scene_position.h"
4532 struct vg_shader _shader_scene_position
= {
4533 .name
= "scene_position",
4536 .orig_file
= "shaders/scene.vs",
4538 "layout (location=0) in vec3 a_co;\n"
4539 "layout (location=1) in vec4 a_norm;\n"
4540 "layout (location=2) in vec2 a_uv;\n"
4543 "const float k_motion_lerp_amount = 0.01;\n"
4547 "out vec3 aMotionVec0;\n"
4548 "out vec3 aMotionVec1;\n"
4550 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
4552 " // This magically solves some artifacting errors!\n"
4554 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
4556 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
4557 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
4562 "uniform mat4x3 uMdl;\n"
4563 "uniform mat4 uPv;\n"
4564 "uniform mat4 uPvmPrev;\n"
4569 "out vec3 aWorldCo;\n"
4573 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
4574 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
4575 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
4577 " vs_motion_out( vproj0, vproj1 );\n"
4579 " gl_Position = vproj0;\n"
4582 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
4584 " aWorldCo = world_pos0;\n"
4589 .orig_file
= "shaders/scene_position.fs",
4591 "out vec4 FragColor;\n"
4593 "uniform vec3 uCamera;\n"
4594 "uniform vec3 uBoard0;\n"
4595 "uniform vec3 uBoard1;\n"
4599 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
4608 "in vec3 aWorldCo;\n"
4611 "layout (location = 0) out vec4 oColour;\n"
4613 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
4614 "layout (std140) uniform ub_world_lighting\n"
4616 " vec4 g_cube_min;\n"
4617 " vec4 g_cube_inv_range;\n"
4619 " vec4 g_water_plane;\n"
4620 " vec4 g_depth_bounds;\n"
4622 " vec4 g_daysky_colour;\n"
4623 " vec4 g_nightsky_colour;\n"
4624 " vec4 g_sunset_colour;\n"
4625 " vec4 g_ambient_colour;\n"
4626 " vec4 g_sunset_ambient;\n"
4627 " vec4 g_sun_colour;\n"
4628 " vec4 g_sun_dir;\n"
4629 " vec4 g_board_0;\n"
4630 " vec4 g_board_1;\n"
4632 " float g_water_fog;\n"
4634 " float g_realtime;\n"
4635 " float g_shadow_length;\n"
4636 " float g_shadow_spread;\n"
4638 " float g_time_of_day;\n"
4639 " float g_day_phase;\n"
4640 " float g_sunset_phase;\n"
4642 " int g_light_preview;\n"
4643 " int g_shadow_samples;\n"
4645 " int g_debug_indices;\n"
4646 " int g_debug_complexity;\n"
4649 "uniform sampler2D g_world_depth;\n"
4650 "uniform samplerBuffer uLightsArray;\n"
4651 "uniform usampler3D uLightsIndex;\n"
4654 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
4655 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
4656 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
4657 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
4658 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
4659 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
4661 "const float SUN_ANGLE = 0.0001;\n"
4662 "const float PI = 3.14159265358979323846264;\n"
4664 "//struct world_info\n"
4669 "// sunset_phase;\n"
4671 "// vec3 sun_dir;\n"
4674 "vec3 rand33(vec3 p3)\n"
4676 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
4677 " p3 += dot(p3, p3.yxz+33.33);\n"
4678 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
4681 "float stars( vec3 rd, float rr, float size ){\n"
4682 " vec3 co = rd * rr;\n"
4684 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
4686 " float spaces = 1.0 / rr;\n"
4687 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
4688 " a -= mod(a, spaces) - spaces * 0.5;\n"
4690 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
4692 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
4693 " plane = plane - mod(plane, PI / count);\n"
4695 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
4697 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
4698 " float ydist = sqrt(rr * rr - level * level);\n"
4699 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
4700 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
4701 " float star = smoothstep(size, 0.0, distance(center, co));\n"
4705 "float luminance( vec3 v )\n"
4707 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
4710 "vec3 clearskies_ambient( vec3 dir )\n"
4712 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
4713 " float sky_gradient = dir.y;\n"
4715 " /* Blend phase colours */\n"
4716 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
4717 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
4718 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
4720 " /* Add gradient */\n"
4721 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
4723 " return ambient;\n"
4726 "vec3 clearskies_sky( vec3 ray_dir )\n"
4728 " ray_dir.y = abs( ray_dir.y );\n"
4729 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
4732 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
4733 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
4734 " float sun_shape = pow( sun_size, 2000.0 );\n"
4735 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
4737 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
4738 " sun_colour *= sun_shape;\n"
4741 " float star = 0.0;\n"
4742 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
4744 " if( star_blend > 0.001 ){\n"
4745 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
4746 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
4747 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
4751 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
4752 " return composite;\n"
4755 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
4757 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
4759 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
4760 " g_sunset_phase );\n"
4762 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
4763 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
4764 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
4765 " ) * g_sun_colour.rgb * g_day_phase;\n"
4767 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
4768 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
4769 " g_sunset_phase );\n"
4771 " return ambient + (light_sun + sky_reflection) * shadow;\n"
4776 "float world_depth_sample( vec3 pos )\n"
4778 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
4779 " return texture( g_world_depth, depth_coord ).r;\n"
4782 "float world_water_depth( vec3 pos )\n"
4784 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
4785 " return world_depth_sample( pos ) - ref_depth;\n"
4788 "float shadow_sample( vec3 co ){\n"
4789 " float height_sample = world_depth_sample( co );\n"
4791 " float fdelta = height_sample - co.y;\n"
4792 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
4795 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
4796 " if( g_shadow_samples == 0 ){\n"
4800 " float fspread = g_shadow_spread;\n"
4801 " float flength = g_shadow_length;\n"
4803 " float famt = 0.0;\n"
4804 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
4805 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
4806 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
4807 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
4809 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
4810 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
4811 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
4812 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
4814 " return 1.0 - famt;\n"
4817 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
4819 " vec3 specdir = reflect( -dir, wnormal );\n"
4820 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
4823 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
4824 " float dist = pow(fdist*0.0010,0.78);\n"
4825 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
4828 "vec3 scene_calculate_light( int light_index, \n"
4829 " vec3 halfview, vec3 co, vec3 normal )\n"
4831 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
4832 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
4833 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
4835 " vec3 light_delta = light_co.xyz-co;\n"
4836 " float dist2 = dot(light_delta,light_delta);\n"
4838 " light_delta = normalize( light_delta );\n"
4840 " float quadratic = dist2*100.0;\n"
4841 " float attenuation = 1.0/( 1.0 + quadratic );\n"
4842 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
4844 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
4846 " if( light_dir.w < 0.999999 ){\n"
4847 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
4848 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
4851 " return light_colour.rgb * attenuation * falloff \n"
4852 " * step( g_day_phase, light_colour.w );\n"
4855 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
4856 " vec3 halfview, vec3 co, vec3 normal )\n"
4858 " uint light_count = packed_index & 0x3u;\n"
4860 " vec3 l = vec3(0.0);\n"
4862 " if( light_count >= 1u ){\n"
4863 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
4864 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
4865 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
4867 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
4869 " if( light_count >= 2u ){\n"
4870 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
4872 " if( light_count >= 3u ){\n"
4873 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
4881 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
4882 " float light_mask )\n"
4884 " if( g_light_preview == 1 )\n"
4885 " diffuse = vec3(0.75);\n"
4888 " vec3 halfview = uCamera - co;\n"
4889 " float fdist = length(halfview);\n"
4890 " halfview /= fdist;\n"
4892 " float world_shadow = newlight_compute_sun_shadow( \n"
4893 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
4895 " vec3 total_light = clearskies_lighting( \n"
4896 " normal, min( light_mask, world_shadow ), halfview );\n"
4898 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
4899 " cube_coord = floor( cube_coord );\n"
4901 " if( g_debug_indices == 1 )\n"
4903 " return rand33(cube_coord);\n"
4906 " if( g_debug_complexity == 1 )\n"
4908 " ivec3 coord = ivec3( cube_coord );\n"
4909 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
4911 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
4912 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
4915 " // FIXME: this coord should absolutely must be clamped!\n"
4917 " ivec3 coord = ivec3( cube_coord );\n"
4918 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
4920 " total_light += \n"
4921 " scene_calculate_packed_light_patch( index_sample.x,\n"
4922 " halfview, co, normal ) \n"
4924 " total_light += \n"
4925 " scene_calculate_packed_light_patch( index_sample.y,\n"
4926 " halfview, co, normal )\n"
4929 " // Take a section of the sky function to give us a matching fog colour\n"
4931 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
4932 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
4933 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
4934 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
4936 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
4937 " sun_colour *= sun_shape;\n"
4939 " fog_colour += sun_colour;\n"
4940 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
4945 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
4947 " vec3 pa = p - a;\n"
4948 " vec3 ba = b - a;\n"
4950 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
4951 " return length( pa - ba*h );\n"
4954 "float compute_board_shadow()\n"
4956 " // player shadow\n"
4957 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
4958 " g_board_1.xyz )-0.1 );\n"
4959 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
4960 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
4962 " return 1.0 - player_shadow*0.8;\n"
4965 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
4967 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
4974 " float height_full = aWorldCo.y;\n"
4975 " float height_water = height_full;\n"
4977 " if( height_water > (g_water_plane.y * g_water_plane.w) + 2.0 )\n"
4978 " height_water = -99999.9;\n"
4980 " FragColor = vec4( height_full, height_water, 0.0, 0.0 );\n"
4985 GLuint _uniform_scene_position_uMdl
;
4986 GLuint _uniform_scene_position_uPv
;
4987 GLuint _uniform_scene_position_uPvmPrev
;
4988 GLuint _uniform_scene_position_uCamera
;
4989 GLuint _uniform_scene_position_uBoard0
;
4990 GLuint _uniform_scene_position_uBoard1
;
4991 GLuint _uniform_scene_position_g_world_depth
;
4992 GLuint _uniform_scene_position_uLightsArray
;
4993 GLuint _uniform_scene_position_uLightsIndex
;
4994 #include "shaders/scene_cubemapped.h"
4995 struct vg_shader _shader_scene_cubemapped
= {
4996 .name
= "scene_cubemapped",
4999 .orig_file
= "shaders/scene.vs",
5001 "layout (location=0) in vec3 a_co;\n"
5002 "layout (location=1) in vec4 a_norm;\n"
5003 "layout (location=2) in vec2 a_uv;\n"
5006 "const float k_motion_lerp_amount = 0.01;\n"
5010 "out vec3 aMotionVec0;\n"
5011 "out vec3 aMotionVec1;\n"
5013 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
5015 " // This magically solves some artifacting errors!\n"
5017 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
5019 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
5020 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
5025 "uniform mat4x3 uMdl;\n"
5026 "uniform mat4 uPv;\n"
5027 "uniform mat4 uPvmPrev;\n"
5032 "out vec3 aWorldCo;\n"
5036 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
5037 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
5038 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
5040 " vs_motion_out( vproj0, vproj1 );\n"
5042 " gl_Position = vproj0;\n"
5045 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
5047 " aWorldCo = world_pos0;\n"
5052 .orig_file
= "shaders/scene_cubemapped.fs",
5054 "uniform sampler2D uTexGarbage;\n"
5055 "uniform sampler2D uTexMain;\n"
5056 "uniform samplerCube uTexCubemap;\n"
5057 "uniform vec3 uCamera;\n"
5058 "uniform vec4 uPlane;\n"
5059 "uniform vec4 uColour;\n"
5063 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
5072 "in vec3 aWorldCo;\n"
5075 "layout (location = 0) out vec4 oColour;\n"
5077 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
5078 "layout (std140) uniform ub_world_lighting\n"
5080 " vec4 g_cube_min;\n"
5081 " vec4 g_cube_inv_range;\n"
5083 " vec4 g_water_plane;\n"
5084 " vec4 g_depth_bounds;\n"
5086 " vec4 g_daysky_colour;\n"
5087 " vec4 g_nightsky_colour;\n"
5088 " vec4 g_sunset_colour;\n"
5089 " vec4 g_ambient_colour;\n"
5090 " vec4 g_sunset_ambient;\n"
5091 " vec4 g_sun_colour;\n"
5092 " vec4 g_sun_dir;\n"
5093 " vec4 g_board_0;\n"
5094 " vec4 g_board_1;\n"
5096 " float g_water_fog;\n"
5098 " float g_realtime;\n"
5099 " float g_shadow_length;\n"
5100 " float g_shadow_spread;\n"
5102 " float g_time_of_day;\n"
5103 " float g_day_phase;\n"
5104 " float g_sunset_phase;\n"
5106 " int g_light_preview;\n"
5107 " int g_shadow_samples;\n"
5109 " int g_debug_indices;\n"
5110 " int g_debug_complexity;\n"
5113 "uniform sampler2D g_world_depth;\n"
5114 "uniform samplerBuffer uLightsArray;\n"
5115 "uniform usampler3D uLightsIndex;\n"
5118 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
5119 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
5120 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
5121 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
5122 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
5123 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
5125 "const float SUN_ANGLE = 0.0001;\n"
5126 "const float PI = 3.14159265358979323846264;\n"
5128 "//struct world_info\n"
5133 "// sunset_phase;\n"
5135 "// vec3 sun_dir;\n"
5138 "vec3 rand33(vec3 p3)\n"
5140 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
5141 " p3 += dot(p3, p3.yxz+33.33);\n"
5142 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
5145 "float stars( vec3 rd, float rr, float size ){\n"
5146 " vec3 co = rd * rr;\n"
5148 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
5150 " float spaces = 1.0 / rr;\n"
5151 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
5152 " a -= mod(a, spaces) - spaces * 0.5;\n"
5154 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
5156 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
5157 " plane = plane - mod(plane, PI / count);\n"
5159 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
5161 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
5162 " float ydist = sqrt(rr * rr - level * level);\n"
5163 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
5164 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
5165 " float star = smoothstep(size, 0.0, distance(center, co));\n"
5169 "float luminance( vec3 v )\n"
5171 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
5174 "vec3 clearskies_ambient( vec3 dir )\n"
5176 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
5177 " float sky_gradient = dir.y;\n"
5179 " /* Blend phase colours */\n"
5180 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
5181 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
5182 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
5184 " /* Add gradient */\n"
5185 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
5187 " return ambient;\n"
5190 "vec3 clearskies_sky( vec3 ray_dir )\n"
5192 " ray_dir.y = abs( ray_dir.y );\n"
5193 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
5196 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
5197 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
5198 " float sun_shape = pow( sun_size, 2000.0 );\n"
5199 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
5201 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
5202 " sun_colour *= sun_shape;\n"
5205 " float star = 0.0;\n"
5206 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
5208 " if( star_blend > 0.001 ){\n"
5209 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
5210 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
5211 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
5215 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
5216 " return composite;\n"
5219 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
5221 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
5223 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
5224 " g_sunset_phase );\n"
5226 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
5227 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
5228 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
5229 " ) * g_sun_colour.rgb * g_day_phase;\n"
5231 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
5232 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
5233 " g_sunset_phase );\n"
5235 " return ambient + (light_sun + sky_reflection) * shadow;\n"
5240 "float world_depth_sample( vec3 pos )\n"
5242 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
5243 " return texture( g_world_depth, depth_coord ).r;\n"
5246 "float world_water_depth( vec3 pos )\n"
5248 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
5249 " return world_depth_sample( pos ) - ref_depth;\n"
5252 "float shadow_sample( vec3 co ){\n"
5253 " float height_sample = world_depth_sample( co );\n"
5255 " float fdelta = height_sample - co.y;\n"
5256 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
5259 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
5260 " if( g_shadow_samples == 0 ){\n"
5264 " float fspread = g_shadow_spread;\n"
5265 " float flength = g_shadow_length;\n"
5267 " float famt = 0.0;\n"
5268 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
5269 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
5270 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
5271 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
5273 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
5274 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
5275 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
5276 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
5278 " return 1.0 - famt;\n"
5281 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
5283 " vec3 specdir = reflect( -dir, wnormal );\n"
5284 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
5287 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
5288 " float dist = pow(fdist*0.0010,0.78);\n"
5289 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
5292 "vec3 scene_calculate_light( int light_index, \n"
5293 " vec3 halfview, vec3 co, vec3 normal )\n"
5295 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
5296 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
5297 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
5299 " vec3 light_delta = light_co.xyz-co;\n"
5300 " float dist2 = dot(light_delta,light_delta);\n"
5302 " light_delta = normalize( light_delta );\n"
5304 " float quadratic = dist2*100.0;\n"
5305 " float attenuation = 1.0/( 1.0 + quadratic );\n"
5306 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
5308 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
5310 " if( light_dir.w < 0.999999 ){\n"
5311 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
5312 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
5315 " return light_colour.rgb * attenuation * falloff \n"
5316 " * step( g_day_phase, light_colour.w );\n"
5319 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
5320 " vec3 halfview, vec3 co, vec3 normal )\n"
5322 " uint light_count = packed_index & 0x3u;\n"
5324 " vec3 l = vec3(0.0);\n"
5326 " if( light_count >= 1u ){\n"
5327 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
5328 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
5329 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
5331 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
5333 " if( light_count >= 2u ){\n"
5334 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
5336 " if( light_count >= 3u ){\n"
5337 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
5345 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
5346 " float light_mask )\n"
5348 " if( g_light_preview == 1 )\n"
5349 " diffuse = vec3(0.75);\n"
5352 " vec3 halfview = uCamera - co;\n"
5353 " float fdist = length(halfview);\n"
5354 " halfview /= fdist;\n"
5356 " float world_shadow = newlight_compute_sun_shadow( \n"
5357 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
5359 " vec3 total_light = clearskies_lighting( \n"
5360 " normal, min( light_mask, world_shadow ), halfview );\n"
5362 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
5363 " cube_coord = floor( cube_coord );\n"
5365 " if( g_debug_indices == 1 )\n"
5367 " return rand33(cube_coord);\n"
5370 " if( g_debug_complexity == 1 )\n"
5372 " ivec3 coord = ivec3( cube_coord );\n"
5373 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
5375 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
5376 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
5379 " // FIXME: this coord should absolutely must be clamped!\n"
5381 " ivec3 coord = ivec3( cube_coord );\n"
5382 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
5384 " total_light += \n"
5385 " scene_calculate_packed_light_patch( index_sample.x,\n"
5386 " halfview, co, normal ) \n"
5388 " total_light += \n"
5389 " scene_calculate_packed_light_patch( index_sample.y,\n"
5390 " halfview, co, normal )\n"
5393 " // Take a section of the sky function to give us a matching fog colour\n"
5395 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
5396 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
5397 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
5398 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
5400 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
5401 " sun_colour *= sun_shape;\n"
5403 " fog_colour += sun_colour;\n"
5404 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
5409 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
5411 " vec3 pa = p - a;\n"
5412 " vec3 ba = b - a;\n"
5414 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
5415 " return length( pa - ba*h );\n"
5418 "float compute_board_shadow()\n"
5420 " // player shadow\n"
5421 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
5422 " g_board_1.xyz )-0.1 );\n"
5423 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
5424 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
5426 " return 1.0 - player_shadow*0.8;\n"
5429 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
5431 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
5436 "const float k_motion_lerp_amount = 0.01;\n"
5440 "layout (location = 1) out vec2 oMotionVec;\n"
5442 "in vec3 aMotionVec0;\n"
5443 "in vec3 aMotionVec1;\n"
5445 "void compute_motion_vectors()\n"
5447 " // Write motion vectors\n"
5448 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
5449 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
5451 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
5458 " compute_motion_vectors();\n"
5460 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
5461 " vec4 vsamplemain = texture( uTexMain, aUv );\n"
5462 " vec4 wgarbage = texture( uTexGarbage, aCo.xz * 0.0015 + aCo.yx*0.002 );\n"
5463 " vec3 qnorm = aNorm.xyz;\n"
5464 " vfrag = vsamplemain.rgb;\n"
5466 " if( g_light_preview == 1 ){\n"
5467 " vfrag = vec3(0.5);\n"
5470 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
5471 " oColour = vec4( vfrag, 1.0 );\n"
5473 " vec3 halfdir = normalize( aWorldCo - uCamera );\n"
5474 " vec3 reflectdir = reflect( halfdir, qnorm );\n"
5475 " oColour = mix( oColour, \n"
5476 " vec4(texture(uTexCubemap,reflectdir).rgb * uColour.rgb, 1.0),\n"
5477 " uColour.a*wgarbage.b );\n"
5482 GLuint _uniform_scene_cubemapped_uMdl
;
5483 GLuint _uniform_scene_cubemapped_uPv
;
5484 GLuint _uniform_scene_cubemapped_uPvmPrev
;
5485 GLuint _uniform_scene_cubemapped_uTexGarbage
;
5486 GLuint _uniform_scene_cubemapped_uTexMain
;
5487 GLuint _uniform_scene_cubemapped_uTexCubemap
;
5488 GLuint _uniform_scene_cubemapped_uCamera
;
5489 GLuint _uniform_scene_cubemapped_uPlane
;
5490 GLuint _uniform_scene_cubemapped_uColour
;
5491 GLuint _uniform_scene_cubemapped_g_world_depth
;
5492 GLuint _uniform_scene_cubemapped_uLightsArray
;
5493 GLuint _uniform_scene_cubemapped_uLightsIndex
;
5494 #include "shaders/scene_water.h"
5495 struct vg_shader _shader_scene_water
= {
5496 .name
= "scene_water",
5499 .orig_file
= "shaders/scene.vs",
5501 "layout (location=0) in vec3 a_co;\n"
5502 "layout (location=1) in vec4 a_norm;\n"
5503 "layout (location=2) in vec2 a_uv;\n"
5506 "const float k_motion_lerp_amount = 0.01;\n"
5510 "out vec3 aMotionVec0;\n"
5511 "out vec3 aMotionVec1;\n"
5513 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
5515 " // This magically solves some artifacting errors!\n"
5517 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
5519 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
5520 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
5525 "uniform mat4x3 uMdl;\n"
5526 "uniform mat4 uPv;\n"
5527 "uniform mat4 uPvmPrev;\n"
5532 "out vec3 aWorldCo;\n"
5536 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
5537 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
5538 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
5540 " vs_motion_out( vproj0, vproj1 );\n"
5542 " gl_Position = vproj0;\n"
5545 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
5547 " aWorldCo = world_pos0;\n"
5552 .orig_file
= "shaders/scene_water.fs",
5554 "uniform sampler2D uTexMain;\n"
5555 "uniform sampler2D uTexDudv;\n"
5556 "uniform sampler2D uTexBack;\n"
5558 "uniform vec2 uInvRes;\n"
5559 "uniform float uTime;\n"
5560 "uniform vec3 uCamera;\n"
5561 "uniform float uSurfaceY;\n"
5562 "uniform vec3 uBoard0;\n"
5563 "uniform vec3 uBoard1;\n"
5565 "uniform vec3 uShoreColour;\n"
5566 "uniform vec3 uOceanColour;\n"
5570 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
5579 "in vec3 aWorldCo;\n"
5582 "layout (location = 0) out vec4 oColour;\n"
5584 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
5585 "layout (std140) uniform ub_world_lighting\n"
5587 " vec4 g_cube_min;\n"
5588 " vec4 g_cube_inv_range;\n"
5590 " vec4 g_water_plane;\n"
5591 " vec4 g_depth_bounds;\n"
5593 " vec4 g_daysky_colour;\n"
5594 " vec4 g_nightsky_colour;\n"
5595 " vec4 g_sunset_colour;\n"
5596 " vec4 g_ambient_colour;\n"
5597 " vec4 g_sunset_ambient;\n"
5598 " vec4 g_sun_colour;\n"
5599 " vec4 g_sun_dir;\n"
5600 " vec4 g_board_0;\n"
5601 " vec4 g_board_1;\n"
5603 " float g_water_fog;\n"
5605 " float g_realtime;\n"
5606 " float g_shadow_length;\n"
5607 " float g_shadow_spread;\n"
5609 " float g_time_of_day;\n"
5610 " float g_day_phase;\n"
5611 " float g_sunset_phase;\n"
5613 " int g_light_preview;\n"
5614 " int g_shadow_samples;\n"
5616 " int g_debug_indices;\n"
5617 " int g_debug_complexity;\n"
5620 "uniform sampler2D g_world_depth;\n"
5621 "uniform samplerBuffer uLightsArray;\n"
5622 "uniform usampler3D uLightsIndex;\n"
5625 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
5626 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
5627 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
5628 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
5629 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
5630 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
5632 "const float SUN_ANGLE = 0.0001;\n"
5633 "const float PI = 3.14159265358979323846264;\n"
5635 "//struct world_info\n"
5640 "// sunset_phase;\n"
5642 "// vec3 sun_dir;\n"
5645 "vec3 rand33(vec3 p3)\n"
5647 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
5648 " p3 += dot(p3, p3.yxz+33.33);\n"
5649 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
5652 "float stars( vec3 rd, float rr, float size ){\n"
5653 " vec3 co = rd * rr;\n"
5655 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
5657 " float spaces = 1.0 / rr;\n"
5658 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
5659 " a -= mod(a, spaces) - spaces * 0.5;\n"
5661 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
5663 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
5664 " plane = plane - mod(plane, PI / count);\n"
5666 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
5668 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
5669 " float ydist = sqrt(rr * rr - level * level);\n"
5670 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
5671 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
5672 " float star = smoothstep(size, 0.0, distance(center, co));\n"
5676 "float luminance( vec3 v )\n"
5678 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
5681 "vec3 clearskies_ambient( vec3 dir )\n"
5683 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
5684 " float sky_gradient = dir.y;\n"
5686 " /* Blend phase colours */\n"
5687 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
5688 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
5689 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
5691 " /* Add gradient */\n"
5692 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
5694 " return ambient;\n"
5697 "vec3 clearskies_sky( vec3 ray_dir )\n"
5699 " ray_dir.y = abs( ray_dir.y );\n"
5700 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
5703 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
5704 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
5705 " float sun_shape = pow( sun_size, 2000.0 );\n"
5706 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
5708 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
5709 " sun_colour *= sun_shape;\n"
5712 " float star = 0.0;\n"
5713 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
5715 " if( star_blend > 0.001 ){\n"
5716 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
5717 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
5718 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
5722 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
5723 " return composite;\n"
5726 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
5728 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
5730 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
5731 " g_sunset_phase );\n"
5733 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
5734 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
5735 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
5736 " ) * g_sun_colour.rgb * g_day_phase;\n"
5738 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
5739 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
5740 " g_sunset_phase );\n"
5742 " return ambient + (light_sun + sky_reflection) * shadow;\n"
5747 "float world_depth_sample( vec3 pos )\n"
5749 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
5750 " return texture( g_world_depth, depth_coord ).r;\n"
5753 "float world_water_depth( vec3 pos )\n"
5755 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
5756 " return world_depth_sample( pos ) - ref_depth;\n"
5759 "float shadow_sample( vec3 co ){\n"
5760 " float height_sample = world_depth_sample( co );\n"
5762 " float fdelta = height_sample - co.y;\n"
5763 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
5766 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
5767 " if( g_shadow_samples == 0 ){\n"
5771 " float fspread = g_shadow_spread;\n"
5772 " float flength = g_shadow_length;\n"
5774 " float famt = 0.0;\n"
5775 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
5776 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
5777 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
5778 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
5780 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
5781 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
5782 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
5783 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
5785 " return 1.0 - famt;\n"
5788 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
5790 " vec3 specdir = reflect( -dir, wnormal );\n"
5791 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
5794 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
5795 " float dist = pow(fdist*0.0010,0.78);\n"
5796 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
5799 "vec3 scene_calculate_light( int light_index, \n"
5800 " vec3 halfview, vec3 co, vec3 normal )\n"
5802 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
5803 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
5804 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
5806 " vec3 light_delta = light_co.xyz-co;\n"
5807 " float dist2 = dot(light_delta,light_delta);\n"
5809 " light_delta = normalize( light_delta );\n"
5811 " float quadratic = dist2*100.0;\n"
5812 " float attenuation = 1.0/( 1.0 + quadratic );\n"
5813 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
5815 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
5817 " if( light_dir.w < 0.999999 ){\n"
5818 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
5819 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
5822 " return light_colour.rgb * attenuation * falloff \n"
5823 " * step( g_day_phase, light_colour.w );\n"
5826 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
5827 " vec3 halfview, vec3 co, vec3 normal )\n"
5829 " uint light_count = packed_index & 0x3u;\n"
5831 " vec3 l = vec3(0.0);\n"
5833 " if( light_count >= 1u ){\n"
5834 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
5835 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
5836 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
5838 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
5840 " if( light_count >= 2u ){\n"
5841 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
5843 " if( light_count >= 3u ){\n"
5844 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
5852 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
5853 " float light_mask )\n"
5855 " if( g_light_preview == 1 )\n"
5856 " diffuse = vec3(0.75);\n"
5859 " vec3 halfview = uCamera - co;\n"
5860 " float fdist = length(halfview);\n"
5861 " halfview /= fdist;\n"
5863 " float world_shadow = newlight_compute_sun_shadow( \n"
5864 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
5866 " vec3 total_light = clearskies_lighting( \n"
5867 " normal, min( light_mask, world_shadow ), halfview );\n"
5869 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
5870 " cube_coord = floor( cube_coord );\n"
5872 " if( g_debug_indices == 1 )\n"
5874 " return rand33(cube_coord);\n"
5877 " if( g_debug_complexity == 1 )\n"
5879 " ivec3 coord = ivec3( cube_coord );\n"
5880 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
5882 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
5883 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
5886 " // FIXME: this coord should absolutely must be clamped!\n"
5888 " ivec3 coord = ivec3( cube_coord );\n"
5889 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
5891 " total_light += \n"
5892 " scene_calculate_packed_light_patch( index_sample.x,\n"
5893 " halfview, co, normal ) \n"
5895 " total_light += \n"
5896 " scene_calculate_packed_light_patch( index_sample.y,\n"
5897 " halfview, co, normal )\n"
5900 " // Take a section of the sky function to give us a matching fog colour\n"
5902 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
5903 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
5904 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
5905 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
5907 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
5908 " sun_colour *= sun_shape;\n"
5910 " fog_colour += sun_colour;\n"
5911 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
5916 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
5918 " vec3 pa = p - a;\n"
5919 " vec3 ba = b - a;\n"
5921 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
5922 " return length( pa - ba*h );\n"
5925 "float compute_board_shadow()\n"
5927 " // player shadow\n"
5928 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
5929 " g_board_1.xyz )-0.1 );\n"
5930 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
5931 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
5933 " return 1.0 - player_shadow*0.8;\n"
5936 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
5938 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
5943 "const float k_motion_lerp_amount = 0.01;\n"
5947 "layout (location = 1) out vec2 oMotionVec;\n"
5949 "in vec3 aMotionVec0;\n"
5950 "in vec3 aMotionVec1;\n"
5952 "void compute_motion_vectors()\n"
5954 " // Write motion vectors\n"
5955 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
5956 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
5958 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
5963 "// Pasted from common_world.glsl\n"
5964 "vec3 water_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
5966 " float light_mask = compute_board_shadow();\n"
5968 " if( g_light_preview == 1 )\n"
5969 " diffuse = vec3(0.75);\n"
5972 " vec3 halfview = uCamera - co;\n"
5973 " float fdist = length(halfview);\n"
5974 " halfview /= fdist;\n"
5976 " float world_shadow = newlight_compute_sun_shadow( \n"
5977 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
5979 " vec3 total_light = clearskies_lighting( \n"
5980 " normal, min( light_mask, world_shadow ), halfview );\n"
5982 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
5983 " cube_coord = floor( cube_coord );\n"
5985 " if( g_debug_indices == 1 )\n"
5987 " return rand33(cube_coord);\n"
5990 " if( g_debug_complexity == 1 )\n"
5992 " ivec3 coord = ivec3( cube_coord );\n"
5993 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
5995 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
5996 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
5999 " // FIXME: this coord should absolutely must be clamped!\n"
6001 " ivec3 coord = ivec3( cube_coord );\n"
6002 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
6004 " total_light += \n"
6005 " scene_calculate_packed_light_patch( index_sample.x,\n"
6006 " halfview, co, normal ) \n"
6008 " total_light += \n"
6009 " scene_calculate_packed_light_patch( index_sample.y,\n"
6010 " halfview, co, normal )\n"
6013 " return diffuse * total_light;\n"
6016 "vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue, \n"
6017 " vec4 beneath, vec4 above, vec4 dudva )\n"
6019 " vec3 surface_tint = mix(uShoreColour, uOceanColour, depthvalue);\n"
6021 " float ffresnel = pow(1.0-dot( vnorm, halfview ),5.0);\n"
6023 " vec3 lightdir = vec3(0.95,0.0,-0.3);\n"
6024 " vec3 specdir = reflect( -lightdir, vnorm );\n"
6025 " float spec = pow(max(dot(halfview,specdir),0.0),20.0)*0.3;\n"
6028 " float depthblend = pow( beneath.r, 0.8 );\n"
6031 " float fband = fract( aCo.z*0.02+uTime*0.1+depthvalue*10.0 );\n"
6032 " fband = step( fband+dudva.a*0.8, 0.3 ) * max((1.0-depthvalue*4.0),0.0);\n"
6034 " vec4 surf = mix( vec4(surface_tint,depthblend), \n"
6035 " vec4(1.0,1.0,1.0,0.5), fband );\n"
6036 " surf.rgb = water_compute_lighting( surf.rgb, aNorm.xyz, aWorldCo );\n"
6037 " surf.rgb = mix(surf.rgb, above.rgb, ffresnel );\n"
6039 " // Take a section of the sky function to give us a matching fog colour\n"
6040 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
6041 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
6042 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
6043 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
6045 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
6046 " sun_colour *= sun_shape;\n"
6048 " fog_colour += sun_colour;\n"
6049 " surf.rgb = scene_apply_fog( surf.rgb, fog_colour, \n"
6050 " distance(uCamera, aWorldCo) );\n"
6057 " compute_motion_vectors();\n"
6059 " // Create texture coords\n"
6060 " vec2 ssuv = gl_FragCoord.xy*uInvRes;\n"
6062 " // Surface colour composite\n"
6063 " float depthvalue = clamp( -world_water_depth(aCo)*(1.0/25.0), 0.0,1.0 );\n"
6065 " vec2 world_coord = aCo.xz * 0.008;\n"
6066 " vec4 time_offsets = vec4( uTime ) * vec4( 0.008, 0.006, 0.003, 0.03 );\n"
6067 " vec4 dudva = texture( uTexDudv, world_coord + time_offsets.xy )-0.5;\n"
6068 " vec4 dudvb = texture( uTexDudv, world_coord *7.0 - time_offsets.zw )-0.5;\n"
6070 " vec3 surfnorm = dudva.rgb + dudvb.rgb;\n"
6071 " surfnorm = normalize(vec3(0.0,1.0,0.0) + dudva.xyz*0.4 + dudvb.xyz*0.1);\n"
6074 " vec3 halfview = -normalize( aCo-uCamera );\n"
6076 " // Sample textures\n"
6077 " vec4 above = texture( uTexMain, ssuv+ surfnorm.xz*0.2 );\n"
6078 " vec4 beneath = texture( uTexBack, ssuv );\n"
6081 " float fdist = pow(length( aCo.xz-uCamera.xz ) * 0.00047, 2.6);\n"
6084 " vec4 vsurface = water_surf( halfview, surfnorm, depthvalue, beneath, above, dudva );\n"
6085 " vsurface.a -= fdist;\n"
6087 " oColour = vsurface;\n"
6092 GLuint _uniform_scene_water_uMdl
;
6093 GLuint _uniform_scene_water_uPv
;
6094 GLuint _uniform_scene_water_uPvmPrev
;
6095 GLuint _uniform_scene_water_uTexMain
;
6096 GLuint _uniform_scene_water_uTexDudv
;
6097 GLuint _uniform_scene_water_uTexBack
;
6098 GLuint _uniform_scene_water_uInvRes
;
6099 GLuint _uniform_scene_water_uTime
;
6100 GLuint _uniform_scene_water_uCamera
;
6101 GLuint _uniform_scene_water_uSurfaceY
;
6102 GLuint _uniform_scene_water_uBoard0
;
6103 GLuint _uniform_scene_water_uBoard1
;
6104 GLuint _uniform_scene_water_uShoreColour
;
6105 GLuint _uniform_scene_water_uOceanColour
;
6106 GLuint _uniform_scene_water_g_world_depth
;
6107 GLuint _uniform_scene_water_uLightsArray
;
6108 GLuint _uniform_scene_water_uLightsIndex
;
6109 #include "shaders/scene_water_fast.h"
6110 struct vg_shader _shader_scene_water_fast
= {
6111 .name
= "scene_water_fast",
6114 .orig_file
= "shaders/scene.vs",
6116 "layout (location=0) in vec3 a_co;\n"
6117 "layout (location=1) in vec4 a_norm;\n"
6118 "layout (location=2) in vec2 a_uv;\n"
6121 "const float k_motion_lerp_amount = 0.01;\n"
6125 "out vec3 aMotionVec0;\n"
6126 "out vec3 aMotionVec1;\n"
6128 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
6130 " // This magically solves some artifacting errors!\n"
6132 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
6134 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
6135 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
6140 "uniform mat4x3 uMdl;\n"
6141 "uniform mat4 uPv;\n"
6142 "uniform mat4 uPvmPrev;\n"
6147 "out vec3 aWorldCo;\n"
6151 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
6152 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
6153 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
6155 " vs_motion_out( vproj0, vproj1 );\n"
6157 " gl_Position = vproj0;\n"
6160 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
6162 " aWorldCo = world_pos0;\n"
6167 .orig_file
= "shaders/scene_water_fast.fs",
6169 "uniform sampler2D uTexDudv;\n"
6171 "uniform float uTime;\n"
6172 "uniform vec3 uCamera;\n"
6173 "uniform float uSurfaceY;\n"
6174 "uniform vec3 uBoard0;\n"
6175 "uniform vec3 uBoard1;\n"
6177 "uniform vec3 uShoreColour;\n"
6178 "uniform vec3 uOceanColour;\n"
6182 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
6191 "in vec3 aWorldCo;\n"
6194 "layout (location = 0) out vec4 oColour;\n"
6196 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
6197 "layout (std140) uniform ub_world_lighting\n"
6199 " vec4 g_cube_min;\n"
6200 " vec4 g_cube_inv_range;\n"
6202 " vec4 g_water_plane;\n"
6203 " vec4 g_depth_bounds;\n"
6205 " vec4 g_daysky_colour;\n"
6206 " vec4 g_nightsky_colour;\n"
6207 " vec4 g_sunset_colour;\n"
6208 " vec4 g_ambient_colour;\n"
6209 " vec4 g_sunset_ambient;\n"
6210 " vec4 g_sun_colour;\n"
6211 " vec4 g_sun_dir;\n"
6212 " vec4 g_board_0;\n"
6213 " vec4 g_board_1;\n"
6215 " float g_water_fog;\n"
6217 " float g_realtime;\n"
6218 " float g_shadow_length;\n"
6219 " float g_shadow_spread;\n"
6221 " float g_time_of_day;\n"
6222 " float g_day_phase;\n"
6223 " float g_sunset_phase;\n"
6225 " int g_light_preview;\n"
6226 " int g_shadow_samples;\n"
6228 " int g_debug_indices;\n"
6229 " int g_debug_complexity;\n"
6232 "uniform sampler2D g_world_depth;\n"
6233 "uniform samplerBuffer uLightsArray;\n"
6234 "uniform usampler3D uLightsIndex;\n"
6237 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
6238 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
6239 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
6240 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
6241 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
6242 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
6244 "const float SUN_ANGLE = 0.0001;\n"
6245 "const float PI = 3.14159265358979323846264;\n"
6247 "//struct world_info\n"
6252 "// sunset_phase;\n"
6254 "// vec3 sun_dir;\n"
6257 "vec3 rand33(vec3 p3)\n"
6259 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
6260 " p3 += dot(p3, p3.yxz+33.33);\n"
6261 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
6264 "float stars( vec3 rd, float rr, float size ){\n"
6265 " vec3 co = rd * rr;\n"
6267 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
6269 " float spaces = 1.0 / rr;\n"
6270 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
6271 " a -= mod(a, spaces) - spaces * 0.5;\n"
6273 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
6275 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
6276 " plane = plane - mod(plane, PI / count);\n"
6278 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
6280 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
6281 " float ydist = sqrt(rr * rr - level * level);\n"
6282 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
6283 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
6284 " float star = smoothstep(size, 0.0, distance(center, co));\n"
6288 "float luminance( vec3 v )\n"
6290 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
6293 "vec3 clearskies_ambient( vec3 dir )\n"
6295 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
6296 " float sky_gradient = dir.y;\n"
6298 " /* Blend phase colours */\n"
6299 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
6300 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
6301 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
6303 " /* Add gradient */\n"
6304 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
6306 " return ambient;\n"
6309 "vec3 clearskies_sky( vec3 ray_dir )\n"
6311 " ray_dir.y = abs( ray_dir.y );\n"
6312 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
6315 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
6316 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
6317 " float sun_shape = pow( sun_size, 2000.0 );\n"
6318 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
6320 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
6321 " sun_colour *= sun_shape;\n"
6324 " float star = 0.0;\n"
6325 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
6327 " if( star_blend > 0.001 ){\n"
6328 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
6329 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
6330 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
6334 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
6335 " return composite;\n"
6338 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
6340 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
6342 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
6343 " g_sunset_phase );\n"
6345 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
6346 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
6347 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
6348 " ) * g_sun_colour.rgb * g_day_phase;\n"
6350 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
6351 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
6352 " g_sunset_phase );\n"
6354 " return ambient + (light_sun + sky_reflection) * shadow;\n"
6359 "float world_depth_sample( vec3 pos )\n"
6361 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
6362 " return texture( g_world_depth, depth_coord ).r;\n"
6365 "float world_water_depth( vec3 pos )\n"
6367 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
6368 " return world_depth_sample( pos ) - ref_depth;\n"
6371 "float shadow_sample( vec3 co ){\n"
6372 " float height_sample = world_depth_sample( co );\n"
6374 " float fdelta = height_sample - co.y;\n"
6375 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
6378 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
6379 " if( g_shadow_samples == 0 ){\n"
6383 " float fspread = g_shadow_spread;\n"
6384 " float flength = g_shadow_length;\n"
6386 " float famt = 0.0;\n"
6387 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
6388 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
6389 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
6390 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
6392 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
6393 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
6394 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
6395 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
6397 " return 1.0 - famt;\n"
6400 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
6402 " vec3 specdir = reflect( -dir, wnormal );\n"
6403 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
6406 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
6407 " float dist = pow(fdist*0.0010,0.78);\n"
6408 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
6411 "vec3 scene_calculate_light( int light_index, \n"
6412 " vec3 halfview, vec3 co, vec3 normal )\n"
6414 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
6415 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
6416 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
6418 " vec3 light_delta = light_co.xyz-co;\n"
6419 " float dist2 = dot(light_delta,light_delta);\n"
6421 " light_delta = normalize( light_delta );\n"
6423 " float quadratic = dist2*100.0;\n"
6424 " float attenuation = 1.0/( 1.0 + quadratic );\n"
6425 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
6427 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
6429 " if( light_dir.w < 0.999999 ){\n"
6430 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
6431 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
6434 " return light_colour.rgb * attenuation * falloff \n"
6435 " * step( g_day_phase, light_colour.w );\n"
6438 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
6439 " vec3 halfview, vec3 co, vec3 normal )\n"
6441 " uint light_count = packed_index & 0x3u;\n"
6443 " vec3 l = vec3(0.0);\n"
6445 " if( light_count >= 1u ){\n"
6446 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
6447 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
6448 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
6450 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
6452 " if( light_count >= 2u ){\n"
6453 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
6455 " if( light_count >= 3u ){\n"
6456 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
6464 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
6465 " float light_mask )\n"
6467 " if( g_light_preview == 1 )\n"
6468 " diffuse = vec3(0.75);\n"
6471 " vec3 halfview = uCamera - co;\n"
6472 " float fdist = length(halfview);\n"
6473 " halfview /= fdist;\n"
6475 " float world_shadow = newlight_compute_sun_shadow( \n"
6476 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
6478 " vec3 total_light = clearskies_lighting( \n"
6479 " normal, min( light_mask, world_shadow ), halfview );\n"
6481 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
6482 " cube_coord = floor( cube_coord );\n"
6484 " if( g_debug_indices == 1 )\n"
6486 " return rand33(cube_coord);\n"
6489 " if( g_debug_complexity == 1 )\n"
6491 " ivec3 coord = ivec3( cube_coord );\n"
6492 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
6494 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
6495 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
6498 " // FIXME: this coord should absolutely must be clamped!\n"
6500 " ivec3 coord = ivec3( cube_coord );\n"
6501 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
6503 " total_light += \n"
6504 " scene_calculate_packed_light_patch( index_sample.x,\n"
6505 " halfview, co, normal ) \n"
6507 " total_light += \n"
6508 " scene_calculate_packed_light_patch( index_sample.y,\n"
6509 " halfview, co, normal )\n"
6512 " // Take a section of the sky function to give us a matching fog colour\n"
6514 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
6515 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
6516 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
6517 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
6519 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
6520 " sun_colour *= sun_shape;\n"
6522 " fog_colour += sun_colour;\n"
6523 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
6528 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
6530 " vec3 pa = p - a;\n"
6531 " vec3 ba = b - a;\n"
6533 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
6534 " return length( pa - ba*h );\n"
6537 "float compute_board_shadow()\n"
6539 " // player shadow\n"
6540 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
6541 " g_board_1.xyz )-0.1 );\n"
6542 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
6543 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
6545 " return 1.0 - player_shadow*0.8;\n"
6548 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
6550 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
6555 "const float k_motion_lerp_amount = 0.01;\n"
6559 "layout (location = 1) out vec2 oMotionVec;\n"
6561 "in vec3 aMotionVec0;\n"
6562 "in vec3 aMotionVec1;\n"
6564 "void compute_motion_vectors()\n"
6566 " // Write motion vectors\n"
6567 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
6568 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
6570 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
6575 "vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue )\n"
6577 " vec3 surface_tint = mix(uShoreColour, uOceanColour, depthvalue);\n"
6579 " float ffresnel = pow(1.0-dot( vnorm, halfview ),5.0);\n"
6581 " vec3 lightdir = vec3(0.95,0.0,-0.3);\n"
6582 " vec3 specdir = reflect( -lightdir, vnorm );\n"
6583 " float spec = pow(max(dot(halfview,specdir),0.0),20.0)*0.3;\n"
6585 " return vec4( surface_tint + spec, max(min(depthvalue*4.0, 1.0),0.0) );\n"
6590 " compute_motion_vectors();\n"
6592 " // Surface colour composite\n"
6593 " float depthvalue = clamp( -world_water_depth( aCo )*(1.0/25.0), 0.0, 1.0 );\n"
6595 " vec2 world_coord = aCo.xz * 0.008;\n"
6596 " vec4 time_offsets = vec4( uTime ) * vec4( 0.008, 0.006, 0.003, 0.03 );\n"
6597 " vec4 dudva = texture( uTexDudv, world_coord + time_offsets.xy )-0.5;\n"
6598 " vec4 dudvb = texture( uTexDudv, world_coord *7.0 - time_offsets.zw )-0.5;\n"
6600 " vec3 surfnorm = dudva.rgb + dudvb.rgb;\n"
6601 " surfnorm = normalize(vec3(0.0,1.0,0.0) + dudva.xyz*0.4 + dudvb.xyz*0.1);\n"
6604 " float fband = fract( aCo.z*0.02+uTime*0.1+depthvalue*10.0 );\n"
6605 " fband = step( fband+dudva.a*0.8, 0.3 ) * max((1.0-depthvalue*4.0),0.0);\n"
6608 " vec3 halfview = -normalize( aCo-uCamera );\n"
6611 " float fdist = pow(length( aCo.xz-uCamera.xz ) * 0.00047, 2.6);\n"
6614 " vec4 vsurface = water_surf( halfview, surfnorm, depthvalue );\n"
6615 " vsurface.a -= fdist;\n"
6616 " oColour = mix( vsurface, vec4(1.0,1.0,1.0,0.5), fband );\n"
6617 " oColour.rgb = scene_compute_lighting( oColour.rgb, aNorm.xyz, aWorldCo );\n"
6622 GLuint _uniform_scene_water_fast_uMdl
;
6623 GLuint _uniform_scene_water_fast_uPv
;
6624 GLuint _uniform_scene_water_fast_uPvmPrev
;
6625 GLuint _uniform_scene_water_fast_uTexDudv
;
6626 GLuint _uniform_scene_water_fast_uTime
;
6627 GLuint _uniform_scene_water_fast_uCamera
;
6628 GLuint _uniform_scene_water_fast_uSurfaceY
;
6629 GLuint _uniform_scene_water_fast_uBoard0
;
6630 GLuint _uniform_scene_water_fast_uBoard1
;
6631 GLuint _uniform_scene_water_fast_uShoreColour
;
6632 GLuint _uniform_scene_water_fast_uOceanColour
;
6633 GLuint _uniform_scene_water_fast_g_world_depth
;
6634 GLuint _uniform_scene_water_fast_uLightsArray
;
6635 GLuint _uniform_scene_water_fast_uLightsIndex
;
6636 #include "shaders/scene_scoretext.h"
6637 struct vg_shader _shader_scene_scoretext
= {
6638 .name
= "scene_scoretext",
6641 .orig_file
= "shaders/scene_sfd.vs",
6643 "layout (location=0) in vec3 a_co;\n"
6644 "layout (location=1) in vec4 a_norm;\n"
6645 "layout (location=2) in vec2 a_uv;\n"
6648 "const float k_motion_lerp_amount = 0.01;\n"
6652 "out vec3 aMotionVec0;\n"
6653 "out vec3 aMotionVec1;\n"
6655 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
6657 " // This magically solves some artifacting errors!\n"
6659 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
6661 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
6662 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
6667 "uniform mat4x3 uMdl;\n"
6668 "uniform mat4 uPv;\n"
6669 "uniform mat4 uPvmPrev;\n"
6670 "uniform vec3 uInfo;\n"
6675 "out vec3 aWorldCo;\n"
6679 " float w = ((a_norm.w)-0.5)*2.0 + fract(uInfo.z) - 0.0;\n"
6680 " float c = -cos(w*0.6);\n"
6681 " float s = -sin(w*0.6);\n"
6684 " float w1 = clamp( w*4.0 - a_co.y*10.0, -1.0, 1.0 ) * (3.14159265*0.5);\n"
6685 " float c1 = cos(w1);\n"
6686 " float s1 = sin(w1);\n"
6688 " float yoff = step(0.01,fract(uInfo.z))*-0.5;\n"
6691 " mlocal[0] = vec3(c1, s1,0.0);\n"
6692 " mlocal[1] = vec3(-s1,c1,0.0);\n"
6693 " mlocal[2] = vec3(0.0,0.0,1.0);\n"
6694 " mlocal[3] = vec3(c*r,uInfo.y*0.875 + s*r,uInfo.x*0.5);\n"
6696 " vec3 local_pos0 = mlocal * vec4( a_co, 1.0 );\n"
6697 " vec3 world_pos0 = uMdl * vec4( local_pos0, 1.0 );\n"
6699 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
6700 " vec4 vproj1 = uPvmPrev * vec4( local_pos0, 1.0 );\n"
6702 " vs_motion_out( vproj0, vproj1 );\n"
6704 " gl_Position = vproj0;\n"
6706 " aUv = a_uv + vec2( floor(uInfo.z+0.5)*(1.0/64.0), yoff );\n"
6707 " aNorm = vec4( mat3(uMdl) * mat3(mlocal) * a_norm.xyz, a_norm.w );\n"
6709 " aWorldCo = world_pos0;\n"
6714 .orig_file
= "shaders/scene_standard.fs",
6716 "uniform sampler2D uTexGarbage;\n"
6717 "uniform sampler2D uTexMain;\n"
6718 "uniform vec3 uCamera;\n"
6719 "uniform vec4 uPlane;\n"
6723 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
6732 "in vec3 aWorldCo;\n"
6735 "layout (location = 0) out vec4 oColour;\n"
6737 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
6738 "layout (std140) uniform ub_world_lighting\n"
6740 " vec4 g_cube_min;\n"
6741 " vec4 g_cube_inv_range;\n"
6743 " vec4 g_water_plane;\n"
6744 " vec4 g_depth_bounds;\n"
6746 " vec4 g_daysky_colour;\n"
6747 " vec4 g_nightsky_colour;\n"
6748 " vec4 g_sunset_colour;\n"
6749 " vec4 g_ambient_colour;\n"
6750 " vec4 g_sunset_ambient;\n"
6751 " vec4 g_sun_colour;\n"
6752 " vec4 g_sun_dir;\n"
6753 " vec4 g_board_0;\n"
6754 " vec4 g_board_1;\n"
6756 " float g_water_fog;\n"
6758 " float g_realtime;\n"
6759 " float g_shadow_length;\n"
6760 " float g_shadow_spread;\n"
6762 " float g_time_of_day;\n"
6763 " float g_day_phase;\n"
6764 " float g_sunset_phase;\n"
6766 " int g_light_preview;\n"
6767 " int g_shadow_samples;\n"
6769 " int g_debug_indices;\n"
6770 " int g_debug_complexity;\n"
6773 "uniform sampler2D g_world_depth;\n"
6774 "uniform samplerBuffer uLightsArray;\n"
6775 "uniform usampler3D uLightsIndex;\n"
6778 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
6779 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
6780 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
6781 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
6782 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
6783 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
6785 "const float SUN_ANGLE = 0.0001;\n"
6786 "const float PI = 3.14159265358979323846264;\n"
6788 "//struct world_info\n"
6793 "// sunset_phase;\n"
6795 "// vec3 sun_dir;\n"
6798 "vec3 rand33(vec3 p3)\n"
6800 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
6801 " p3 += dot(p3, p3.yxz+33.33);\n"
6802 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
6805 "float stars( vec3 rd, float rr, float size ){\n"
6806 " vec3 co = rd * rr;\n"
6808 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
6810 " float spaces = 1.0 / rr;\n"
6811 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
6812 " a -= mod(a, spaces) - spaces * 0.5;\n"
6814 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
6816 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
6817 " plane = plane - mod(plane, PI / count);\n"
6819 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
6821 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
6822 " float ydist = sqrt(rr * rr - level * level);\n"
6823 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
6824 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
6825 " float star = smoothstep(size, 0.0, distance(center, co));\n"
6829 "float luminance( vec3 v )\n"
6831 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
6834 "vec3 clearskies_ambient( vec3 dir )\n"
6836 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
6837 " float sky_gradient = dir.y;\n"
6839 " /* Blend phase colours */\n"
6840 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
6841 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
6842 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
6844 " /* Add gradient */\n"
6845 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
6847 " return ambient;\n"
6850 "vec3 clearskies_sky( vec3 ray_dir )\n"
6852 " ray_dir.y = abs( ray_dir.y );\n"
6853 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
6856 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
6857 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
6858 " float sun_shape = pow( sun_size, 2000.0 );\n"
6859 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
6861 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
6862 " sun_colour *= sun_shape;\n"
6865 " float star = 0.0;\n"
6866 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
6868 " if( star_blend > 0.001 ){\n"
6869 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
6870 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
6871 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
6875 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
6876 " return composite;\n"
6879 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
6881 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
6883 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
6884 " g_sunset_phase );\n"
6886 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
6887 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
6888 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
6889 " ) * g_sun_colour.rgb * g_day_phase;\n"
6891 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
6892 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
6893 " g_sunset_phase );\n"
6895 " return ambient + (light_sun + sky_reflection) * shadow;\n"
6900 "float world_depth_sample( vec3 pos )\n"
6902 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
6903 " return texture( g_world_depth, depth_coord ).r;\n"
6906 "float world_water_depth( vec3 pos )\n"
6908 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
6909 " return world_depth_sample( pos ) - ref_depth;\n"
6912 "float shadow_sample( vec3 co ){\n"
6913 " float height_sample = world_depth_sample( co );\n"
6915 " float fdelta = height_sample - co.y;\n"
6916 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
6919 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
6920 " if( g_shadow_samples == 0 ){\n"
6924 " float fspread = g_shadow_spread;\n"
6925 " float flength = g_shadow_length;\n"
6927 " float famt = 0.0;\n"
6928 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
6929 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
6930 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
6931 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
6933 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
6934 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
6935 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
6936 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
6938 " return 1.0 - famt;\n"
6941 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
6943 " vec3 specdir = reflect( -dir, wnormal );\n"
6944 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
6947 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
6948 " float dist = pow(fdist*0.0010,0.78);\n"
6949 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
6952 "vec3 scene_calculate_light( int light_index, \n"
6953 " vec3 halfview, vec3 co, vec3 normal )\n"
6955 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
6956 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
6957 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
6959 " vec3 light_delta = light_co.xyz-co;\n"
6960 " float dist2 = dot(light_delta,light_delta);\n"
6962 " light_delta = normalize( light_delta );\n"
6964 " float quadratic = dist2*100.0;\n"
6965 " float attenuation = 1.0/( 1.0 + quadratic );\n"
6966 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
6968 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
6970 " if( light_dir.w < 0.999999 ){\n"
6971 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
6972 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
6975 " return light_colour.rgb * attenuation * falloff \n"
6976 " * step( g_day_phase, light_colour.w );\n"
6979 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
6980 " vec3 halfview, vec3 co, vec3 normal )\n"
6982 " uint light_count = packed_index & 0x3u;\n"
6984 " vec3 l = vec3(0.0);\n"
6986 " if( light_count >= 1u ){\n"
6987 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
6988 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
6989 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
6991 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
6993 " if( light_count >= 2u ){\n"
6994 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
6996 " if( light_count >= 3u ){\n"
6997 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
7005 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
7006 " float light_mask )\n"
7008 " if( g_light_preview == 1 )\n"
7009 " diffuse = vec3(0.75);\n"
7012 " vec3 halfview = uCamera - co;\n"
7013 " float fdist = length(halfview);\n"
7014 " halfview /= fdist;\n"
7016 " float world_shadow = newlight_compute_sun_shadow( \n"
7017 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
7019 " vec3 total_light = clearskies_lighting( \n"
7020 " normal, min( light_mask, world_shadow ), halfview );\n"
7022 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
7023 " cube_coord = floor( cube_coord );\n"
7025 " if( g_debug_indices == 1 )\n"
7027 " return rand33(cube_coord);\n"
7030 " if( g_debug_complexity == 1 )\n"
7032 " ivec3 coord = ivec3( cube_coord );\n"
7033 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
7035 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
7036 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
7039 " // FIXME: this coord should absolutely must be clamped!\n"
7041 " ivec3 coord = ivec3( cube_coord );\n"
7042 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
7044 " total_light += \n"
7045 " scene_calculate_packed_light_patch( index_sample.x,\n"
7046 " halfview, co, normal ) \n"
7048 " total_light += \n"
7049 " scene_calculate_packed_light_patch( index_sample.y,\n"
7050 " halfview, co, normal )\n"
7053 " // Take a section of the sky function to give us a matching fog colour\n"
7055 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
7056 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
7057 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
7058 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
7060 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
7061 " sun_colour *= sun_shape;\n"
7063 " fog_colour += sun_colour;\n"
7064 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
7069 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
7071 " vec3 pa = p - a;\n"
7072 " vec3 ba = b - a;\n"
7074 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
7075 " return length( pa - ba*h );\n"
7078 "float compute_board_shadow()\n"
7080 " // player shadow\n"
7081 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
7082 " g_board_1.xyz )-0.1 );\n"
7083 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
7084 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
7086 " return 1.0 - player_shadow*0.8;\n"
7089 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
7091 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
7096 "const float k_motion_lerp_amount = 0.01;\n"
7100 "layout (location = 1) out vec2 oMotionVec;\n"
7102 "in vec3 aMotionVec0;\n"
7103 "in vec3 aMotionVec1;\n"
7105 "void compute_motion_vectors()\n"
7107 " // Write motion vectors\n"
7108 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
7109 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
7111 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
7118 " compute_motion_vectors();\n"
7120 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
7121 " vec4 vsamplemain = texture( uTexMain, aUv );\n"
7122 " vec3 qnorm = aNorm.xyz;\n"
7124 " vfrag = vsamplemain.rgb;\n"
7126 " if( g_light_preview == 1 )\n"
7128 " vfrag = vec3(0.5);\n"
7131 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
7132 " oColour = vec4( vfrag, 1.0 );\n"
7137 GLuint _uniform_scene_scoretext_uMdl
;
7138 GLuint _uniform_scene_scoretext_uPv
;
7139 GLuint _uniform_scene_scoretext_uPvmPrev
;
7140 GLuint _uniform_scene_scoretext_uInfo
;
7141 GLuint _uniform_scene_scoretext_uTexGarbage
;
7142 GLuint _uniform_scene_scoretext_uTexMain
;
7143 GLuint _uniform_scene_scoretext_uCamera
;
7144 GLuint _uniform_scene_scoretext_uPlane
;
7145 GLuint _uniform_scene_scoretext_g_world_depth
;
7146 GLuint _uniform_scene_scoretext_uLightsArray
;
7147 GLuint _uniform_scene_scoretext_uLightsIndex
;
7148 #include "shaders/scene_font.h"
7149 struct vg_shader _shader_scene_font
= {
7150 .name
= "scene_font",
7153 .orig_file
= "shaders/model_font.vs",
7155 "layout (location=0) in vec3 a_co;\n"
7156 "layout (location=1) in vec3 a_norm;\n"
7157 "layout (location=2) in vec2 a_uv;\n"
7160 "const float k_motion_lerp_amount = 0.01;\n"
7164 "out vec3 aMotionVec0;\n"
7165 "out vec3 aMotionVec1;\n"
7167 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
7169 " // This magically solves some artifacting errors!\n"
7171 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
7173 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
7174 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
7179 "uniform mat4x3 uMdl;\n"
7180 "uniform mat4 uPv;\n"
7181 "uniform mat4 uPvmPrev;\n"
7182 "uniform vec4 uOffset;\n"
7187 "out vec3 aWorldCo;\n"
7191 " vec3 co = a_co*uOffset.w+uOffset.xyz;\n"
7192 " vec3 world_pos0 = uMdl * vec4( co, 1.0 );\n"
7193 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
7194 " vec4 vproj1 = uPvmPrev * vec4( co, 1.0 );\n"
7196 " vs_motion_out( vproj0, vproj1 );\n"
7198 " gl_Position = vproj0;\n"
7201 " aNorm = vec4( mat3(uMdl) * a_norm, 0.0 );\n"
7203 " aWorldCo = world_pos0;\n"
7208 .orig_file
= "shaders/scene_font.fs",
7210 "uniform sampler2D uTexGarbage; // unused\n"
7211 "uniform sampler2D uTexMain; // unused\n"
7212 "uniform vec3 uCamera;\n"
7213 "uniform float uTime;\n"
7214 "uniform float uOpacity;\n"
7215 "uniform float uColourize;\n"
7219 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
7228 "in vec3 aWorldCo;\n"
7231 "layout (location = 0) out vec4 oColour;\n"
7233 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
7234 "layout (std140) uniform ub_world_lighting\n"
7236 " vec4 g_cube_min;\n"
7237 " vec4 g_cube_inv_range;\n"
7239 " vec4 g_water_plane;\n"
7240 " vec4 g_depth_bounds;\n"
7242 " vec4 g_daysky_colour;\n"
7243 " vec4 g_nightsky_colour;\n"
7244 " vec4 g_sunset_colour;\n"
7245 " vec4 g_ambient_colour;\n"
7246 " vec4 g_sunset_ambient;\n"
7247 " vec4 g_sun_colour;\n"
7248 " vec4 g_sun_dir;\n"
7249 " vec4 g_board_0;\n"
7250 " vec4 g_board_1;\n"
7252 " float g_water_fog;\n"
7254 " float g_realtime;\n"
7255 " float g_shadow_length;\n"
7256 " float g_shadow_spread;\n"
7258 " float g_time_of_day;\n"
7259 " float g_day_phase;\n"
7260 " float g_sunset_phase;\n"
7262 " int g_light_preview;\n"
7263 " int g_shadow_samples;\n"
7265 " int g_debug_indices;\n"
7266 " int g_debug_complexity;\n"
7269 "uniform sampler2D g_world_depth;\n"
7270 "uniform samplerBuffer uLightsArray;\n"
7271 "uniform usampler3D uLightsIndex;\n"
7274 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
7275 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
7276 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
7277 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
7278 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
7279 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
7281 "const float SUN_ANGLE = 0.0001;\n"
7282 "const float PI = 3.14159265358979323846264;\n"
7284 "//struct world_info\n"
7289 "// sunset_phase;\n"
7291 "// vec3 sun_dir;\n"
7294 "vec3 rand33(vec3 p3)\n"
7296 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
7297 " p3 += dot(p3, p3.yxz+33.33);\n"
7298 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
7301 "float stars( vec3 rd, float rr, float size ){\n"
7302 " vec3 co = rd * rr;\n"
7304 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
7306 " float spaces = 1.0 / rr;\n"
7307 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
7308 " a -= mod(a, spaces) - spaces * 0.5;\n"
7310 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
7312 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
7313 " plane = plane - mod(plane, PI / count);\n"
7315 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
7317 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
7318 " float ydist = sqrt(rr * rr - level * level);\n"
7319 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
7320 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
7321 " float star = smoothstep(size, 0.0, distance(center, co));\n"
7325 "float luminance( vec3 v )\n"
7327 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
7330 "vec3 clearskies_ambient( vec3 dir )\n"
7332 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
7333 " float sky_gradient = dir.y;\n"
7335 " /* Blend phase colours */\n"
7336 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
7337 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
7338 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
7340 " /* Add gradient */\n"
7341 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
7343 " return ambient;\n"
7346 "vec3 clearskies_sky( vec3 ray_dir )\n"
7348 " ray_dir.y = abs( ray_dir.y );\n"
7349 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
7352 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
7353 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
7354 " float sun_shape = pow( sun_size, 2000.0 );\n"
7355 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
7357 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
7358 " sun_colour *= sun_shape;\n"
7361 " float star = 0.0;\n"
7362 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
7364 " if( star_blend > 0.001 ){\n"
7365 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
7366 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
7367 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
7371 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
7372 " return composite;\n"
7375 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
7377 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
7379 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
7380 " g_sunset_phase );\n"
7382 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
7383 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
7384 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
7385 " ) * g_sun_colour.rgb * g_day_phase;\n"
7387 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
7388 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
7389 " g_sunset_phase );\n"
7391 " return ambient + (light_sun + sky_reflection) * shadow;\n"
7396 "float world_depth_sample( vec3 pos )\n"
7398 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
7399 " return texture( g_world_depth, depth_coord ).r;\n"
7402 "float world_water_depth( vec3 pos )\n"
7404 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
7405 " return world_depth_sample( pos ) - ref_depth;\n"
7408 "float shadow_sample( vec3 co ){\n"
7409 " float height_sample = world_depth_sample( co );\n"
7411 " float fdelta = height_sample - co.y;\n"
7412 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
7415 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
7416 " if( g_shadow_samples == 0 ){\n"
7420 " float fspread = g_shadow_spread;\n"
7421 " float flength = g_shadow_length;\n"
7423 " float famt = 0.0;\n"
7424 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
7425 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
7426 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
7427 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
7429 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
7430 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
7431 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
7432 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
7434 " return 1.0 - famt;\n"
7437 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
7439 " vec3 specdir = reflect( -dir, wnormal );\n"
7440 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
7443 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
7444 " float dist = pow(fdist*0.0010,0.78);\n"
7445 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
7448 "vec3 scene_calculate_light( int light_index, \n"
7449 " vec3 halfview, vec3 co, vec3 normal )\n"
7451 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
7452 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
7453 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
7455 " vec3 light_delta = light_co.xyz-co;\n"
7456 " float dist2 = dot(light_delta,light_delta);\n"
7458 " light_delta = normalize( light_delta );\n"
7460 " float quadratic = dist2*100.0;\n"
7461 " float attenuation = 1.0/( 1.0 + quadratic );\n"
7462 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
7464 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
7466 " if( light_dir.w < 0.999999 ){\n"
7467 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
7468 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
7471 " return light_colour.rgb * attenuation * falloff \n"
7472 " * step( g_day_phase, light_colour.w );\n"
7475 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
7476 " vec3 halfview, vec3 co, vec3 normal )\n"
7478 " uint light_count = packed_index & 0x3u;\n"
7480 " vec3 l = vec3(0.0);\n"
7482 " if( light_count >= 1u ){\n"
7483 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
7484 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
7485 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
7487 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
7489 " if( light_count >= 2u ){\n"
7490 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
7492 " if( light_count >= 3u ){\n"
7493 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
7501 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
7502 " float light_mask )\n"
7504 " if( g_light_preview == 1 )\n"
7505 " diffuse = vec3(0.75);\n"
7508 " vec3 halfview = uCamera - co;\n"
7509 " float fdist = length(halfview);\n"
7510 " halfview /= fdist;\n"
7512 " float world_shadow = newlight_compute_sun_shadow( \n"
7513 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
7515 " vec3 total_light = clearskies_lighting( \n"
7516 " normal, min( light_mask, world_shadow ), halfview );\n"
7518 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
7519 " cube_coord = floor( cube_coord );\n"
7521 " if( g_debug_indices == 1 )\n"
7523 " return rand33(cube_coord);\n"
7526 " if( g_debug_complexity == 1 )\n"
7528 " ivec3 coord = ivec3( cube_coord );\n"
7529 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
7531 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
7532 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
7535 " // FIXME: this coord should absolutely must be clamped!\n"
7537 " ivec3 coord = ivec3( cube_coord );\n"
7538 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
7540 " total_light += \n"
7541 " scene_calculate_packed_light_patch( index_sample.x,\n"
7542 " halfview, co, normal ) \n"
7544 " total_light += \n"
7545 " scene_calculate_packed_light_patch( index_sample.y,\n"
7546 " halfview, co, normal )\n"
7549 " // Take a section of the sky function to give us a matching fog colour\n"
7551 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
7552 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
7553 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
7554 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
7556 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
7557 " sun_colour *= sun_shape;\n"
7559 " fog_colour += sun_colour;\n"
7560 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
7565 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
7567 " vec3 pa = p - a;\n"
7568 " vec3 ba = b - a;\n"
7570 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
7571 " return length( pa - ba*h );\n"
7574 "float compute_board_shadow()\n"
7576 " // player shadow\n"
7577 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
7578 " g_board_1.xyz )-0.1 );\n"
7579 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
7580 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
7582 " return 1.0 - player_shadow*0.8;\n"
7585 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
7587 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
7592 "const float k_motion_lerp_amount = 0.01;\n"
7596 "layout (location = 1) out vec2 oMotionVec;\n"
7598 "in vec3 aMotionVec0;\n"
7599 "in vec3 aMotionVec1;\n"
7601 "void compute_motion_vectors()\n"
7603 " // Write motion vectors\n"
7604 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
7605 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
7607 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
7612 "vec3 pal( float t ){\n"
7613 " vec3 a = vec3(0.30,0.3,0.3);\n"
7614 " vec3 b = vec3(0.8);\n"
7615 " vec3 c = vec3(0.28,0.3,0.4);\n"
7616 " vec3 d = vec3(0.00,0.1,0.1);\n"
7617 " return a + b*cos( 6.28318*(c*t+d) );\n"
7621 " compute_motion_vectors();\n"
7622 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
7623 " vec3 qnorm = aNorm.xyz;\n"
7625 " //vec4 vsamplemain = texture( uTexMain, aUv );\n"
7626 " //vfrag = vsamplemain.rgb;\n"
7628 " vec4 spread0 = uTime*0.0002*vec4( 17.3,-19.6, 23.2,-47.7 );\n"
7629 " vec4 spread1 = uTime*0.0002*vec4( -13.3, 12.6,-28.2, 14.7 );\n"
7631 " vec2 p = aCo.xy + vec2(0.3);\n"
7632 " float a = atan( p.y/p.x );\n"
7633 " vec4 v0 = step( vec4(0.5), fract(vec4(a) + spread0) );\n"
7634 " vec4 v1 = step( vec4(0.5), fract(vec4(a) + spread1) );\n"
7636 " float d = ( v0.x+v0.y+v0.z+v0.w +\n"
7637 " v1.x+v1.y+v1.z+v1.w ) * 0.125;\n"
7639 " float dither = fract(dot(vec2(171.0,231.0),gl_FragCoord.xy)/71.0);\n"
7640 " float x = d*0.8+length(p)*0.3;\n"
7641 " x = (floor(x*8.0) + step(dither, fract(x * 8.0))) / 8.0;\n"
7643 " if( x + (uOpacity*2.0-1.0) < 0.5 ) \n"
7646 " vfrag = mix( vec3(x), pal( x ), uColourize );\n"
7648 " if( g_light_preview == 1 ){\n"
7649 " vfrag = vec3(0.5);\n"
7652 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
7653 " oColour = vec4( vfrag, 1.0 );\n"
7658 GLuint _uniform_scene_font_uMdl
;
7659 GLuint _uniform_scene_font_uPv
;
7660 GLuint _uniform_scene_font_uPvmPrev
;
7661 GLuint _uniform_scene_font_uOffset
;
7662 GLuint _uniform_scene_font_uTexGarbage
;
7663 GLuint _uniform_scene_font_uTexMain
;
7664 GLuint _uniform_scene_font_uCamera
;
7665 GLuint _uniform_scene_font_uTime
;
7666 GLuint _uniform_scene_font_uOpacity
;
7667 GLuint _uniform_scene_font_uColourize
;
7668 GLuint _uniform_scene_font_g_world_depth
;
7669 GLuint _uniform_scene_font_uLightsArray
;
7670 GLuint _uniform_scene_font_uLightsIndex
;
7671 #include "shaders/model_sky.h"
7672 struct vg_shader _shader_model_sky
= {
7673 .name
= "model_sky",
7676 .orig_file
= "shaders/model.vs",
7678 "layout (location=0) in vec3 a_co;\n"
7679 "layout (location=1) in vec3 a_norm;\n"
7680 "layout (location=2) in vec2 a_uv;\n"
7681 "layout (location=3) in vec4 a_colour;\n"
7682 "layout (location=4) in vec4 a_weights;\n"
7683 "layout (location=5) in ivec4 a_groups;\n"
7686 "const float k_motion_lerp_amount = 0.01;\n"
7690 "out vec3 aMotionVec0;\n"
7691 "out vec3 aMotionVec1;\n"
7693 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
7695 " // This magically solves some artifacting errors!\n"
7697 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
7699 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
7700 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
7705 "uniform mat4x3 uMdl;\n"
7706 "uniform mat4 uPv;\n"
7707 "uniform mat4 uPvmPrev;\n"
7709 "out vec4 aColour;\n"
7713 "out vec3 aWorldCo;\n"
7717 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
7718 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
7719 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
7721 " vs_motion_out( vproj0, vproj1 );\n"
7723 " gl_Position = vproj0;\n"
7724 " aWorldCo = world_pos0;\n"
7725 " aColour = a_colour;\n"
7727 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
7733 .orig_file
= "shaders/model_sky.fs",
7735 "uniform sampler2D uTexGarbage;\n"
7737 "in vec4 aColour;\n"
7741 "in vec3 aWorldCo;\n"
7744 "const vec3 uCamera = vec3(0.0);\n"
7748 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
7752 "layout (location = 0) out vec4 oColour;\n"
7754 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
7755 "layout (std140) uniform ub_world_lighting\n"
7757 " vec4 g_cube_min;\n"
7758 " vec4 g_cube_inv_range;\n"
7760 " vec4 g_water_plane;\n"
7761 " vec4 g_depth_bounds;\n"
7763 " vec4 g_daysky_colour;\n"
7764 " vec4 g_nightsky_colour;\n"
7765 " vec4 g_sunset_colour;\n"
7766 " vec4 g_ambient_colour;\n"
7767 " vec4 g_sunset_ambient;\n"
7768 " vec4 g_sun_colour;\n"
7769 " vec4 g_sun_dir;\n"
7770 " vec4 g_board_0;\n"
7771 " vec4 g_board_1;\n"
7773 " float g_water_fog;\n"
7775 " float g_realtime;\n"
7776 " float g_shadow_length;\n"
7777 " float g_shadow_spread;\n"
7779 " float g_time_of_day;\n"
7780 " float g_day_phase;\n"
7781 " float g_sunset_phase;\n"
7783 " int g_light_preview;\n"
7784 " int g_shadow_samples;\n"
7786 " int g_debug_indices;\n"
7787 " int g_debug_complexity;\n"
7790 "uniform sampler2D g_world_depth;\n"
7791 "uniform samplerBuffer uLightsArray;\n"
7792 "uniform usampler3D uLightsIndex;\n"
7795 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
7796 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
7797 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
7798 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
7799 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
7800 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
7802 "const float SUN_ANGLE = 0.0001;\n"
7803 "const float PI = 3.14159265358979323846264;\n"
7805 "//struct world_info\n"
7810 "// sunset_phase;\n"
7812 "// vec3 sun_dir;\n"
7815 "vec3 rand33(vec3 p3)\n"
7817 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
7818 " p3 += dot(p3, p3.yxz+33.33);\n"
7819 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
7822 "float stars( vec3 rd, float rr, float size ){\n"
7823 " vec3 co = rd * rr;\n"
7825 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
7827 " float spaces = 1.0 / rr;\n"
7828 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
7829 " a -= mod(a, spaces) - spaces * 0.5;\n"
7831 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
7833 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
7834 " plane = plane - mod(plane, PI / count);\n"
7836 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
7838 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
7839 " float ydist = sqrt(rr * rr - level * level);\n"
7840 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
7841 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
7842 " float star = smoothstep(size, 0.0, distance(center, co));\n"
7846 "float luminance( vec3 v )\n"
7848 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
7851 "vec3 clearskies_ambient( vec3 dir )\n"
7853 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
7854 " float sky_gradient = dir.y;\n"
7856 " /* Blend phase colours */\n"
7857 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
7858 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
7859 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
7861 " /* Add gradient */\n"
7862 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
7864 " return ambient;\n"
7867 "vec3 clearskies_sky( vec3 ray_dir )\n"
7869 " ray_dir.y = abs( ray_dir.y );\n"
7870 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
7873 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
7874 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
7875 " float sun_shape = pow( sun_size, 2000.0 );\n"
7876 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
7878 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
7879 " sun_colour *= sun_shape;\n"
7882 " float star = 0.0;\n"
7883 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
7885 " if( star_blend > 0.001 ){\n"
7886 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
7887 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
7888 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
7892 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
7893 " return composite;\n"
7896 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
7898 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
7900 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
7901 " g_sunset_phase );\n"
7903 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
7904 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
7905 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
7906 " ) * g_sun_colour.rgb * g_day_phase;\n"
7908 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
7909 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
7910 " g_sunset_phase );\n"
7912 " return ambient + (light_sun + sky_reflection) * shadow;\n"
7917 "float world_depth_sample( vec3 pos )\n"
7919 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
7920 " return texture( g_world_depth, depth_coord ).r;\n"
7923 "float world_water_depth( vec3 pos )\n"
7925 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
7926 " return world_depth_sample( pos ) - ref_depth;\n"
7929 "float shadow_sample( vec3 co ){\n"
7930 " float height_sample = world_depth_sample( co );\n"
7932 " float fdelta = height_sample - co.y;\n"
7933 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
7936 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
7937 " if( g_shadow_samples == 0 ){\n"
7941 " float fspread = g_shadow_spread;\n"
7942 " float flength = g_shadow_length;\n"
7944 " float famt = 0.0;\n"
7945 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
7946 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
7947 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
7948 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
7950 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
7951 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
7952 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
7953 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
7955 " return 1.0 - famt;\n"
7958 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
7960 " vec3 specdir = reflect( -dir, wnormal );\n"
7961 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
7964 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
7965 " float dist = pow(fdist*0.0010,0.78);\n"
7966 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
7969 "vec3 scene_calculate_light( int light_index, \n"
7970 " vec3 halfview, vec3 co, vec3 normal )\n"
7972 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
7973 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
7974 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
7976 " vec3 light_delta = light_co.xyz-co;\n"
7977 " float dist2 = dot(light_delta,light_delta);\n"
7979 " light_delta = normalize( light_delta );\n"
7981 " float quadratic = dist2*100.0;\n"
7982 " float attenuation = 1.0/( 1.0 + quadratic );\n"
7983 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
7985 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
7987 " if( light_dir.w < 0.999999 ){\n"
7988 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
7989 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
7992 " return light_colour.rgb * attenuation * falloff \n"
7993 " * step( g_day_phase, light_colour.w );\n"
7996 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
7997 " vec3 halfview, vec3 co, vec3 normal )\n"
7999 " uint light_count = packed_index & 0x3u;\n"
8001 " vec3 l = vec3(0.0);\n"
8003 " if( light_count >= 1u ){\n"
8004 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
8005 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
8006 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
8008 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
8010 " if( light_count >= 2u ){\n"
8011 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
8013 " if( light_count >= 3u ){\n"
8014 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
8022 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
8023 " float light_mask )\n"
8025 " if( g_light_preview == 1 )\n"
8026 " diffuse = vec3(0.75);\n"
8029 " vec3 halfview = uCamera - co;\n"
8030 " float fdist = length(halfview);\n"
8031 " halfview /= fdist;\n"
8033 " float world_shadow = newlight_compute_sun_shadow( \n"
8034 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
8036 " vec3 total_light = clearskies_lighting( \n"
8037 " normal, min( light_mask, world_shadow ), halfview );\n"
8039 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
8040 " cube_coord = floor( cube_coord );\n"
8042 " if( g_debug_indices == 1 )\n"
8044 " return rand33(cube_coord);\n"
8047 " if( g_debug_complexity == 1 )\n"
8049 " ivec3 coord = ivec3( cube_coord );\n"
8050 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
8052 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
8053 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
8056 " // FIXME: this coord should absolutely must be clamped!\n"
8058 " ivec3 coord = ivec3( cube_coord );\n"
8059 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
8061 " total_light += \n"
8062 " scene_calculate_packed_light_patch( index_sample.x,\n"
8063 " halfview, co, normal ) \n"
8065 " total_light += \n"
8066 " scene_calculate_packed_light_patch( index_sample.y,\n"
8067 " halfview, co, normal )\n"
8070 " // Take a section of the sky function to give us a matching fog colour\n"
8072 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
8073 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
8074 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
8075 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
8077 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
8078 " sun_colour *= sun_shape;\n"
8080 " fog_colour += sun_colour;\n"
8081 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
8086 "const float k_motion_lerp_amount = 0.01;\n"
8090 "layout (location = 1) out vec2 oMotionVec;\n"
8092 "in vec3 aMotionVec0;\n"
8093 "in vec3 aMotionVec1;\n"
8095 "void compute_motion_vectors()\n"
8097 " // Write motion vectors\n"
8098 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
8099 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
8101 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
8108 " compute_motion_vectors();\n"
8110 " vec3 rd = normalize(aNorm);\n"
8112 " float fmove = g_time * 5.0;\n"
8113 " vec2 cloudplane = (rd.xz / (rd.y*sign(rd.y))) * 0.025;\n"
8114 " vec4 clouds1 = texture( uTexGarbage, cloudplane + vec2(0.1,0.4)*fmove*2.0 );\n"
8115 " vec4 clouds2 = texture( uTexGarbage, cloudplane*2.0 + vec2(0.3,0.1)*fmove );\n"
8117 " float cloud_d = max(clouds1.b*clouds2.r -0.2 - clouds2.g*0.4,0.0);\n"
8118 " float cloud_e = pow(cloud_d,1.5)*pow(abs(rd.y),0.3)*2.0;\n"
8120 " oColour = vec4( clearskies_sky( -rd ) ,1.0);\n"
8122 " vec3 cloud_colour = mix( mix(g_nightsky_colour.rgb,vec3(1.0),g_day_phase), \n"
8123 " g_sunset_colour.rgb, g_sunset_phase );\n"
8125 " oColour.rgb = mix( oColour.rgb, cloud_colour, cloud_e );\n"
8130 GLuint _uniform_model_sky_uMdl
;
8131 GLuint _uniform_model_sky_uPv
;
8132 GLuint _uniform_model_sky_uPvmPrev
;
8133 GLuint _uniform_model_sky_uTexGarbage
;
8134 GLuint _uniform_model_sky_g_world_depth
;
8135 GLuint _uniform_model_sky_uLightsArray
;
8136 GLuint _uniform_model_sky_uLightsIndex
;
8137 #include "shaders/model_sky_space.h"
8138 struct vg_shader _shader_model_sky_space
= {
8139 .name
= "model_sky_space",
8142 .orig_file
= "shaders/model.vs",
8144 "layout (location=0) in vec3 a_co;\n"
8145 "layout (location=1) in vec3 a_norm;\n"
8146 "layout (location=2) in vec2 a_uv;\n"
8147 "layout (location=3) in vec4 a_colour;\n"
8148 "layout (location=4) in vec4 a_weights;\n"
8149 "layout (location=5) in ivec4 a_groups;\n"
8152 "const float k_motion_lerp_amount = 0.01;\n"
8156 "out vec3 aMotionVec0;\n"
8157 "out vec3 aMotionVec1;\n"
8159 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
8161 " // This magically solves some artifacting errors!\n"
8163 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
8165 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
8166 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
8171 "uniform mat4x3 uMdl;\n"
8172 "uniform mat4 uPv;\n"
8173 "uniform mat4 uPvmPrev;\n"
8175 "out vec4 aColour;\n"
8179 "out vec3 aWorldCo;\n"
8183 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
8184 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
8185 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
8187 " vs_motion_out( vproj0, vproj1 );\n"
8189 " gl_Position = vproj0;\n"
8190 " aWorldCo = world_pos0;\n"
8191 " aColour = a_colour;\n"
8193 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
8199 .orig_file
= "shaders/model_sky_space.fs",
8201 "uniform sampler2D uTexGarbage;\n"
8203 "in vec4 aColour;\n"
8207 "in vec3 aWorldCo;\n"
8210 "const vec3 uCamera = vec3(0.0);\n"
8214 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
8218 "layout (location = 0) out vec4 oColour;\n"
8220 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
8221 "layout (std140) uniform ub_world_lighting\n"
8223 " vec4 g_cube_min;\n"
8224 " vec4 g_cube_inv_range;\n"
8226 " vec4 g_water_plane;\n"
8227 " vec4 g_depth_bounds;\n"
8229 " vec4 g_daysky_colour;\n"
8230 " vec4 g_nightsky_colour;\n"
8231 " vec4 g_sunset_colour;\n"
8232 " vec4 g_ambient_colour;\n"
8233 " vec4 g_sunset_ambient;\n"
8234 " vec4 g_sun_colour;\n"
8235 " vec4 g_sun_dir;\n"
8236 " vec4 g_board_0;\n"
8237 " vec4 g_board_1;\n"
8239 " float g_water_fog;\n"
8241 " float g_realtime;\n"
8242 " float g_shadow_length;\n"
8243 " float g_shadow_spread;\n"
8245 " float g_time_of_day;\n"
8246 " float g_day_phase;\n"
8247 " float g_sunset_phase;\n"
8249 " int g_light_preview;\n"
8250 " int g_shadow_samples;\n"
8252 " int g_debug_indices;\n"
8253 " int g_debug_complexity;\n"
8256 "uniform sampler2D g_world_depth;\n"
8257 "uniform samplerBuffer uLightsArray;\n"
8258 "uniform usampler3D uLightsIndex;\n"
8261 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
8262 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
8263 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
8264 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
8265 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
8266 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
8268 "const float SUN_ANGLE = 0.0001;\n"
8269 "const float PI = 3.14159265358979323846264;\n"
8271 "//struct world_info\n"
8276 "// sunset_phase;\n"
8278 "// vec3 sun_dir;\n"
8281 "vec3 rand33(vec3 p3)\n"
8283 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
8284 " p3 += dot(p3, p3.yxz+33.33);\n"
8285 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
8288 "float stars( vec3 rd, float rr, float size ){\n"
8289 " vec3 co = rd * rr;\n"
8291 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
8293 " float spaces = 1.0 / rr;\n"
8294 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
8295 " a -= mod(a, spaces) - spaces * 0.5;\n"
8297 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
8299 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
8300 " plane = plane - mod(plane, PI / count);\n"
8302 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
8304 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
8305 " float ydist = sqrt(rr * rr - level * level);\n"
8306 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
8307 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
8308 " float star = smoothstep(size, 0.0, distance(center, co));\n"
8312 "float luminance( vec3 v )\n"
8314 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
8317 "vec3 clearskies_ambient( vec3 dir )\n"
8319 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
8320 " float sky_gradient = dir.y;\n"
8322 " /* Blend phase colours */\n"
8323 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
8324 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
8325 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
8327 " /* Add gradient */\n"
8328 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
8330 " return ambient;\n"
8333 "vec3 clearskies_sky( vec3 ray_dir )\n"
8335 " ray_dir.y = abs( ray_dir.y );\n"
8336 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
8339 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
8340 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
8341 " float sun_shape = pow( sun_size, 2000.0 );\n"
8342 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
8344 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
8345 " sun_colour *= sun_shape;\n"
8348 " float star = 0.0;\n"
8349 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
8351 " if( star_blend > 0.001 ){\n"
8352 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
8353 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
8354 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
8358 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
8359 " return composite;\n"
8362 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
8364 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
8366 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
8367 " g_sunset_phase );\n"
8369 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
8370 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
8371 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
8372 " ) * g_sun_colour.rgb * g_day_phase;\n"
8374 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
8375 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
8376 " g_sunset_phase );\n"
8378 " return ambient + (light_sun + sky_reflection) * shadow;\n"
8383 "float world_depth_sample( vec3 pos )\n"
8385 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
8386 " return texture( g_world_depth, depth_coord ).r;\n"
8389 "float world_water_depth( vec3 pos )\n"
8391 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
8392 " return world_depth_sample( pos ) - ref_depth;\n"
8395 "float shadow_sample( vec3 co ){\n"
8396 " float height_sample = world_depth_sample( co );\n"
8398 " float fdelta = height_sample - co.y;\n"
8399 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
8402 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
8403 " if( g_shadow_samples == 0 ){\n"
8407 " float fspread = g_shadow_spread;\n"
8408 " float flength = g_shadow_length;\n"
8410 " float famt = 0.0;\n"
8411 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
8412 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
8413 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
8414 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
8416 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
8417 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
8418 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
8419 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
8421 " return 1.0 - famt;\n"
8424 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
8426 " vec3 specdir = reflect( -dir, wnormal );\n"
8427 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
8430 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
8431 " float dist = pow(fdist*0.0010,0.78);\n"
8432 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
8435 "vec3 scene_calculate_light( int light_index, \n"
8436 " vec3 halfview, vec3 co, vec3 normal )\n"
8438 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
8439 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
8440 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
8442 " vec3 light_delta = light_co.xyz-co;\n"
8443 " float dist2 = dot(light_delta,light_delta);\n"
8445 " light_delta = normalize( light_delta );\n"
8447 " float quadratic = dist2*100.0;\n"
8448 " float attenuation = 1.0/( 1.0 + quadratic );\n"
8449 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
8451 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
8453 " if( light_dir.w < 0.999999 ){\n"
8454 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
8455 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
8458 " return light_colour.rgb * attenuation * falloff \n"
8459 " * step( g_day_phase, light_colour.w );\n"
8462 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
8463 " vec3 halfview, vec3 co, vec3 normal )\n"
8465 " uint light_count = packed_index & 0x3u;\n"
8467 " vec3 l = vec3(0.0);\n"
8469 " if( light_count >= 1u ){\n"
8470 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
8471 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
8472 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
8474 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
8476 " if( light_count >= 2u ){\n"
8477 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
8479 " if( light_count >= 3u ){\n"
8480 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
8488 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
8489 " float light_mask )\n"
8491 " if( g_light_preview == 1 )\n"
8492 " diffuse = vec3(0.75);\n"
8495 " vec3 halfview = uCamera - co;\n"
8496 " float fdist = length(halfview);\n"
8497 " halfview /= fdist;\n"
8499 " float world_shadow = newlight_compute_sun_shadow( \n"
8500 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
8502 " vec3 total_light = clearskies_lighting( \n"
8503 " normal, min( light_mask, world_shadow ), halfview );\n"
8505 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
8506 " cube_coord = floor( cube_coord );\n"
8508 " if( g_debug_indices == 1 )\n"
8510 " return rand33(cube_coord);\n"
8513 " if( g_debug_complexity == 1 )\n"
8515 " ivec3 coord = ivec3( cube_coord );\n"
8516 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
8518 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
8519 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
8522 " // FIXME: this coord should absolutely must be clamped!\n"
8524 " ivec3 coord = ivec3( cube_coord );\n"
8525 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
8527 " total_light += \n"
8528 " scene_calculate_packed_light_patch( index_sample.x,\n"
8529 " halfview, co, normal ) \n"
8531 " total_light += \n"
8532 " scene_calculate_packed_light_patch( index_sample.y,\n"
8533 " halfview, co, normal )\n"
8536 " // Take a section of the sky function to give us a matching fog colour\n"
8538 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
8539 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
8540 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
8541 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
8543 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
8544 " sun_colour *= sun_shape;\n"
8546 " fog_colour += sun_colour;\n"
8547 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
8552 "const float k_motion_lerp_amount = 0.01;\n"
8556 "layout (location = 1) out vec2 oMotionVec;\n"
8558 "in vec3 aMotionVec0;\n"
8559 "in vec3 aMotionVec1;\n"
8561 "void compute_motion_vectors()\n"
8563 " // Write motion vectors\n"
8564 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
8565 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
8567 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
8572 "float stars1( vec3 rd, float rr, float size ){\n"
8573 " vec3 co = rd * rr;\n"
8575 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
8577 " float spaces = 1.0 / rr;\n"
8578 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
8579 " a -= mod(a, spaces) - spaces * 0.5;\n"
8581 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
8583 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
8584 " plane = plane - mod(plane, PI / count);\n"
8586 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
8588 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
8589 " float ydist = sqrt(rr * rr - level * level);\n"
8590 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
8591 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
8592 " float star = smoothstep(size, 0.0, distance(center, co));\n"
8597 " compute_motion_vectors();\n"
8599 " vec3 rd = -normalize(aNorm);\n"
8601 " float star = 0.0;\n"
8602 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
8603 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
8604 " star += stars( rd, 1.94 * pow( 1.64, j ), m ) * (1.0 / pow(4.0, j));\n"
8607 " oColour = vec4( vec3(star*20.0), 1.0);\n"
8612 GLuint _uniform_model_sky_space_uMdl
;
8613 GLuint _uniform_model_sky_space_uPv
;
8614 GLuint _uniform_model_sky_space_uPvmPrev
;
8615 GLuint _uniform_model_sky_space_uTexGarbage
;
8616 GLuint _uniform_model_sky_space_g_world_depth
;
8617 GLuint _uniform_model_sky_space_uLightsArray
;
8618 GLuint _uniform_model_sky_space_uLightsIndex
;
8619 #include "shaders/model_menu.h"
8620 struct vg_shader _shader_model_menu
= {
8621 .name
= "model_menu",
8624 .orig_file
= "shaders/model.vs",
8626 "layout (location=0) in vec3 a_co;\n"
8627 "layout (location=1) in vec3 a_norm;\n"
8628 "layout (location=2) in vec2 a_uv;\n"
8629 "layout (location=3) in vec4 a_colour;\n"
8630 "layout (location=4) in vec4 a_weights;\n"
8631 "layout (location=5) in ivec4 a_groups;\n"
8634 "const float k_motion_lerp_amount = 0.01;\n"
8638 "out vec3 aMotionVec0;\n"
8639 "out vec3 aMotionVec1;\n"
8641 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
8643 " // This magically solves some artifacting errors!\n"
8645 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
8647 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
8648 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
8653 "uniform mat4x3 uMdl;\n"
8654 "uniform mat4 uPv;\n"
8655 "uniform mat4 uPvmPrev;\n"
8657 "out vec4 aColour;\n"
8661 "out vec3 aWorldCo;\n"
8665 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
8666 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
8667 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
8669 " vs_motion_out( vproj0, vproj1 );\n"
8671 " gl_Position = vproj0;\n"
8672 " aWorldCo = world_pos0;\n"
8673 " aColour = a_colour;\n"
8675 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
8681 .orig_file
= "shaders/model_menu.fs",
8683 "out vec4 FragColor;\n"
8685 "uniform sampler2D uTexMain;\n"
8686 "uniform vec4 uColour;\n"
8688 "in vec4 aColour;\n"
8695 " vec4 diffuse = texture( uTexMain, aUv );\n"
8697 " if( diffuse.a < 0.5 )\n"
8700 " FragColor = vec4( diffuse.rgb, 1.0 ) * uColour;\n"
8705 GLuint _uniform_model_menu_uMdl
;
8706 GLuint _uniform_model_menu_uPv
;
8707 GLuint _uniform_model_menu_uPvmPrev
;
8708 GLuint _uniform_model_menu_uTexMain
;
8709 GLuint _uniform_model_menu_uColour
;
8710 #include "shaders/model_character_view.h"
8711 struct vg_shader _shader_model_character_view
= {
8712 .name
= "model_character_view",
8715 .orig_file
= "shaders/model_skinned.vs",
8717 "layout (location=0) in vec3 a_co;\n"
8718 "layout (location=1) in vec3 a_norm;\n"
8719 "layout (location=2) in vec2 a_uv;\n"
8720 "layout (location=3) in vec4 a_colour;\n"
8721 "layout (location=4) in vec4 a_weights;\n"
8722 "layout (location=5) in ivec4 a_groups;\n"
8725 "const float k_motion_lerp_amount = 0.01;\n"
8729 "out vec3 aMotionVec0;\n"
8730 "out vec3 aMotionVec1;\n"
8732 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
8734 " // This magically solves some artifacting errors!\n"
8736 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
8738 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
8739 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
8744 "uniform mat4 uPv;\n"
8745 "uniform mat4x3 uTransforms[32];\n"
8747 "out vec4 aColour;\n"
8751 "out vec3 aWorldCo;\n"
8755 " vec4 co_local = vec4( a_co, 1.0 );\n"
8756 " vec3 co0 = uTransforms[ a_groups[0] ] * co_local;\n"
8757 " vec3 co1 = uTransforms[ a_groups[1] ] * co_local;\n"
8758 " vec3 co2 = uTransforms[ a_groups[2] ] * co_local;\n"
8759 " vec3 n0 = mat3(uTransforms[ a_groups[0] ]) * a_norm;\n"
8760 " vec3 n1 = mat3(uTransforms[ a_groups[1] ]) * a_norm;\n"
8761 " vec3 n2 = mat3(uTransforms[ a_groups[2] ]) * a_norm;\n"
8763 " vec3 world_pos = co0*a_weights[0] + co1*a_weights[1] + co2*a_weights[2];\n"
8764 " vec3 world_normal = n0*a_weights[0] + n1*a_weights[1] + n2*a_weights[2];\n"
8766 " gl_Position = uPv * vec4( world_pos, 1.0 );\n"
8767 " aColour = a_colour;\n"
8769 " aNorm = world_normal;\n"
8771 " aWorldCo = world_pos;\n"
8773 " // TODO: motion vectors\n"
8774 " aMotionVec0 = vec3(1.0);\n"
8775 " aMotionVec1 = vec3(1.0);\n"
8780 .orig_file
= "shaders/model_character_view.fs",
8782 "uniform sampler2D uTexMain;\n"
8783 "uniform vec3 uCamera;\n"
8785 "in vec4 aColour;\n"
8789 "in vec3 aWorldCo;\n"
8793 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
8797 "layout (location = 0) out vec4 oColour;\n"
8799 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
8800 "layout (std140) uniform ub_world_lighting\n"
8802 " vec4 g_cube_min;\n"
8803 " vec4 g_cube_inv_range;\n"
8805 " vec4 g_water_plane;\n"
8806 " vec4 g_depth_bounds;\n"
8808 " vec4 g_daysky_colour;\n"
8809 " vec4 g_nightsky_colour;\n"
8810 " vec4 g_sunset_colour;\n"
8811 " vec4 g_ambient_colour;\n"
8812 " vec4 g_sunset_ambient;\n"
8813 " vec4 g_sun_colour;\n"
8814 " vec4 g_sun_dir;\n"
8815 " vec4 g_board_0;\n"
8816 " vec4 g_board_1;\n"
8818 " float g_water_fog;\n"
8820 " float g_realtime;\n"
8821 " float g_shadow_length;\n"
8822 " float g_shadow_spread;\n"
8824 " float g_time_of_day;\n"
8825 " float g_day_phase;\n"
8826 " float g_sunset_phase;\n"
8828 " int g_light_preview;\n"
8829 " int g_shadow_samples;\n"
8831 " int g_debug_indices;\n"
8832 " int g_debug_complexity;\n"
8835 "uniform sampler2D g_world_depth;\n"
8836 "uniform samplerBuffer uLightsArray;\n"
8837 "uniform usampler3D uLightsIndex;\n"
8840 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
8841 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
8842 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
8843 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
8844 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
8845 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
8847 "const float SUN_ANGLE = 0.0001;\n"
8848 "const float PI = 3.14159265358979323846264;\n"
8850 "//struct world_info\n"
8855 "// sunset_phase;\n"
8857 "// vec3 sun_dir;\n"
8860 "vec3 rand33(vec3 p3)\n"
8862 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
8863 " p3 += dot(p3, p3.yxz+33.33);\n"
8864 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
8867 "float stars( vec3 rd, float rr, float size ){\n"
8868 " vec3 co = rd * rr;\n"
8870 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
8872 " float spaces = 1.0 / rr;\n"
8873 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
8874 " a -= mod(a, spaces) - spaces * 0.5;\n"
8876 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
8878 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
8879 " plane = plane - mod(plane, PI / count);\n"
8881 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
8883 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
8884 " float ydist = sqrt(rr * rr - level * level);\n"
8885 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
8886 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
8887 " float star = smoothstep(size, 0.0, distance(center, co));\n"
8891 "float luminance( vec3 v )\n"
8893 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
8896 "vec3 clearskies_ambient( vec3 dir )\n"
8898 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
8899 " float sky_gradient = dir.y;\n"
8901 " /* Blend phase colours */\n"
8902 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
8903 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
8904 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
8906 " /* Add gradient */\n"
8907 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
8909 " return ambient;\n"
8912 "vec3 clearskies_sky( vec3 ray_dir )\n"
8914 " ray_dir.y = abs( ray_dir.y );\n"
8915 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
8918 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
8919 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
8920 " float sun_shape = pow( sun_size, 2000.0 );\n"
8921 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
8923 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
8924 " sun_colour *= sun_shape;\n"
8927 " float star = 0.0;\n"
8928 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
8930 " if( star_blend > 0.001 ){\n"
8931 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
8932 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
8933 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
8937 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
8938 " return composite;\n"
8941 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
8943 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
8945 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
8946 " g_sunset_phase );\n"
8948 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
8949 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
8950 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
8951 " ) * g_sun_colour.rgb * g_day_phase;\n"
8953 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
8954 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
8955 " g_sunset_phase );\n"
8957 " return ambient + (light_sun + sky_reflection) * shadow;\n"
8962 "float world_depth_sample( vec3 pos )\n"
8964 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
8965 " return texture( g_world_depth, depth_coord ).r;\n"
8968 "float world_water_depth( vec3 pos )\n"
8970 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
8971 " return world_depth_sample( pos ) - ref_depth;\n"
8974 "float shadow_sample( vec3 co ){\n"
8975 " float height_sample = world_depth_sample( co );\n"
8977 " float fdelta = height_sample - co.y;\n"
8978 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
8981 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
8982 " if( g_shadow_samples == 0 ){\n"
8986 " float fspread = g_shadow_spread;\n"
8987 " float flength = g_shadow_length;\n"
8989 " float famt = 0.0;\n"
8990 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
8991 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
8992 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
8993 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
8995 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
8996 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
8997 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
8998 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
9000 " return 1.0 - famt;\n"
9003 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
9005 " vec3 specdir = reflect( -dir, wnormal );\n"
9006 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
9009 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
9010 " float dist = pow(fdist*0.0010,0.78);\n"
9011 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
9014 "vec3 scene_calculate_light( int light_index, \n"
9015 " vec3 halfview, vec3 co, vec3 normal )\n"
9017 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
9018 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
9019 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
9021 " vec3 light_delta = light_co.xyz-co;\n"
9022 " float dist2 = dot(light_delta,light_delta);\n"
9024 " light_delta = normalize( light_delta );\n"
9026 " float quadratic = dist2*100.0;\n"
9027 " float attenuation = 1.0/( 1.0 + quadratic );\n"
9028 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
9030 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
9032 " if( light_dir.w < 0.999999 ){\n"
9033 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
9034 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
9037 " return light_colour.rgb * attenuation * falloff \n"
9038 " * step( g_day_phase, light_colour.w );\n"
9041 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
9042 " vec3 halfview, vec3 co, vec3 normal )\n"
9044 " uint light_count = packed_index & 0x3u;\n"
9046 " vec3 l = vec3(0.0);\n"
9048 " if( light_count >= 1u ){\n"
9049 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
9050 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
9051 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
9053 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
9055 " if( light_count >= 2u ){\n"
9056 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
9058 " if( light_count >= 3u ){\n"
9059 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
9067 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
9068 " float light_mask )\n"
9070 " if( g_light_preview == 1 )\n"
9071 " diffuse = vec3(0.75);\n"
9074 " vec3 halfview = uCamera - co;\n"
9075 " float fdist = length(halfview);\n"
9076 " halfview /= fdist;\n"
9078 " float world_shadow = newlight_compute_sun_shadow( \n"
9079 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
9081 " vec3 total_light = clearskies_lighting( \n"
9082 " normal, min( light_mask, world_shadow ), halfview );\n"
9084 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
9085 " cube_coord = floor( cube_coord );\n"
9087 " if( g_debug_indices == 1 )\n"
9089 " return rand33(cube_coord);\n"
9092 " if( g_debug_complexity == 1 )\n"
9094 " ivec3 coord = ivec3( cube_coord );\n"
9095 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9097 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
9098 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
9101 " // FIXME: this coord should absolutely must be clamped!\n"
9103 " ivec3 coord = ivec3( cube_coord );\n"
9104 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9106 " total_light += \n"
9107 " scene_calculate_packed_light_patch( index_sample.x,\n"
9108 " halfview, co, normal ) \n"
9110 " total_light += \n"
9111 " scene_calculate_packed_light_patch( index_sample.y,\n"
9112 " halfview, co, normal )\n"
9115 " // Take a section of the sky function to give us a matching fog colour\n"
9117 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
9118 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
9119 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
9120 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9122 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9123 " sun_colour *= sun_shape;\n"
9125 " fog_colour += sun_colour;\n"
9126 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
9131 "const float k_motion_lerp_amount = 0.01;\n"
9135 "layout (location = 1) out vec2 oMotionVec;\n"
9137 "in vec3 aMotionVec0;\n"
9138 "in vec3 aMotionVec1;\n"
9140 "void compute_motion_vectors()\n"
9142 " // Write motion vectors\n"
9143 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
9144 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
9146 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
9151 "uniform sampler2D uTexSceneDepth;\n"
9152 "uniform vec3 uInverseRatioDepth;\n"
9153 "uniform vec3 uInverseRatioMain;\n"
9154 "uniform int uDepthMode;\n"
9155 "uniform float uDitherCutoff;\n"
9157 "float linear_depth( float depth, float near, float far ) {\n"
9158 " float z = depth * 2.0 - 1.0;\n"
9159 " return (2.0 * near * far) / (far + near - z * (far - near)); \n"
9162 "void depth_compare_dither()\n"
9164 " if( uDepthMode == 1 )\n"
9166 " vec2 back_coord = gl_FragCoord.xy * uInverseRatioMain.xy \n"
9167 " * uInverseRatioDepth.xy;\n"
9168 " float back_depth = texture( uTexSceneDepth, back_coord ).r;\n"
9169 " float front_depth = gl_FragCoord.z/gl_FragCoord.w;\n"
9171 " back_depth = linear_depth( back_depth, 0.1, 2100.0 );\n"
9172 " float diff = back_depth - front_depth;\n"
9174 " vec2 ssuv = gl_FragCoord.xy;\n"
9175 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
9176 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
9178 " if( step(0.0,diff)+dither<0.3 )\n"
9182 " if( uDepthMode == 2 )\n"
9184 " vec2 ssuv = gl_FragCoord.xy;\n"
9185 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
9186 " float dither = fract( vDither.g / 71.0 );\n"
9187 " if( dither<uDitherCutoff ) discard;\n"
9193 "vec3 character_clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
9195 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
9197 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
9198 " g_sunset_phase );\n"
9201 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
9202 " vec3 light_sun = max(0.0, dot(normal,g_sun_dir.xyz)*0.5+0.5) \n"
9203 " * g_sun_colour.rgb * g_day_phase;\n"
9205 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
9206 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
9207 " g_sunset_phase );\n"
9209 " return ambient + (light_sun + sky_reflection) * shadow;\n"
9212 "vec3 character_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
9213 " float light_mask )\n"
9215 " if( g_light_preview == 1 )\n"
9216 " diffuse = vec3(0.75);\n"
9219 " vec3 halfview = uCamera - co;\n"
9220 " float fdist = length(halfview);\n"
9221 " halfview /= fdist;\n"
9223 " float world_shadow = newlight_compute_sun_shadow( \n"
9224 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
9226 " vec3 total_light = character_clearskies_lighting( \n"
9227 " normal, min( light_mask, world_shadow ), halfview );\n"
9229 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
9230 " cube_coord = floor( cube_coord );\n"
9232 " if( g_debug_indices == 1 )\n"
9234 " return rand33(cube_coord);\n"
9237 " if( g_debug_complexity == 1 )\n"
9239 " ivec3 coord = ivec3( cube_coord );\n"
9240 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9242 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
9243 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
9246 " // FIXME: this coord should absolutely must be clamped!\n"
9248 " ivec3 coord = ivec3( cube_coord );\n"
9249 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9251 " total_light += \n"
9252 " scene_calculate_packed_light_patch( index_sample.x,\n"
9253 " halfview, co, normal ) \n"
9255 " total_light += \n"
9256 " scene_calculate_packed_light_patch( index_sample.y,\n"
9257 " halfview, co, normal )\n"
9260 " // Take a section of the sky function to give us a matching fog colour\n"
9262 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
9263 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
9264 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
9265 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9267 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9268 " sun_colour *= sun_shape;\n"
9270 " fog_colour += sun_colour;\n"
9271 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
9275 " depth_compare_dither();\n"
9276 " compute_motion_vectors();\n"
9278 " vec3 qnorm = aNorm;\n"
9279 " vec3 diffuse = texture( uTexMain, aUv ).rgb;\n"
9280 " vec3 composite = character_compute_lighting( diffuse, qnorm, aWorldCo, 1.0 );\n"
9282 " float dist = distance( aWorldCo, uCamera ) - 0.08;\n"
9283 " float opacity = clamp( dist*dist, 0.0, 1.0 );\n"
9285 " oColour = vec4( composite, opacity );\n"
9290 GLuint _uniform_model_character_view_uPv
;
9291 GLuint _uniform_model_character_view_uTransforms
;
9292 GLuint _uniform_model_character_view_uTexMain
;
9293 GLuint _uniform_model_character_view_uCamera
;
9294 GLuint _uniform_model_character_view_g_world_depth
;
9295 GLuint _uniform_model_character_view_uLightsArray
;
9296 GLuint _uniform_model_character_view_uLightsIndex
;
9297 GLuint _uniform_model_character_view_uTexSceneDepth
;
9298 GLuint _uniform_model_character_view_uInverseRatioDepth
;
9299 GLuint _uniform_model_character_view_uInverseRatioMain
;
9300 GLuint _uniform_model_character_view_uDepthMode
;
9301 GLuint _uniform_model_character_view_uDitherCutoff
;
9302 #include "shaders/model_board_view.h"
9303 struct vg_shader _shader_model_board_view
= {
9304 .name
= "model_board_view",
9307 .orig_file
= "shaders/model.vs",
9309 "layout (location=0) in vec3 a_co;\n"
9310 "layout (location=1) in vec3 a_norm;\n"
9311 "layout (location=2) in vec2 a_uv;\n"
9312 "layout (location=3) in vec4 a_colour;\n"
9313 "layout (location=4) in vec4 a_weights;\n"
9314 "layout (location=5) in ivec4 a_groups;\n"
9317 "const float k_motion_lerp_amount = 0.01;\n"
9321 "out vec3 aMotionVec0;\n"
9322 "out vec3 aMotionVec1;\n"
9324 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
9326 " // This magically solves some artifacting errors!\n"
9328 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
9330 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
9331 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
9336 "uniform mat4x3 uMdl;\n"
9337 "uniform mat4 uPv;\n"
9338 "uniform mat4 uPvmPrev;\n"
9340 "out vec4 aColour;\n"
9344 "out vec3 aWorldCo;\n"
9348 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
9349 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
9350 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
9352 " vs_motion_out( vproj0, vproj1 );\n"
9354 " gl_Position = vproj0;\n"
9355 " aWorldCo = world_pos0;\n"
9356 " aColour = a_colour;\n"
9358 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
9364 .orig_file
= "shaders/model_character_view.fs",
9366 "uniform sampler2D uTexMain;\n"
9367 "uniform vec3 uCamera;\n"
9369 "in vec4 aColour;\n"
9373 "in vec3 aWorldCo;\n"
9377 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
9381 "layout (location = 0) out vec4 oColour;\n"
9383 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
9384 "layout (std140) uniform ub_world_lighting\n"
9386 " vec4 g_cube_min;\n"
9387 " vec4 g_cube_inv_range;\n"
9389 " vec4 g_water_plane;\n"
9390 " vec4 g_depth_bounds;\n"
9392 " vec4 g_daysky_colour;\n"
9393 " vec4 g_nightsky_colour;\n"
9394 " vec4 g_sunset_colour;\n"
9395 " vec4 g_ambient_colour;\n"
9396 " vec4 g_sunset_ambient;\n"
9397 " vec4 g_sun_colour;\n"
9398 " vec4 g_sun_dir;\n"
9399 " vec4 g_board_0;\n"
9400 " vec4 g_board_1;\n"
9402 " float g_water_fog;\n"
9404 " float g_realtime;\n"
9405 " float g_shadow_length;\n"
9406 " float g_shadow_spread;\n"
9408 " float g_time_of_day;\n"
9409 " float g_day_phase;\n"
9410 " float g_sunset_phase;\n"
9412 " int g_light_preview;\n"
9413 " int g_shadow_samples;\n"
9415 " int g_debug_indices;\n"
9416 " int g_debug_complexity;\n"
9419 "uniform sampler2D g_world_depth;\n"
9420 "uniform samplerBuffer uLightsArray;\n"
9421 "uniform usampler3D uLightsIndex;\n"
9424 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
9425 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
9426 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
9427 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
9428 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
9429 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
9431 "const float SUN_ANGLE = 0.0001;\n"
9432 "const float PI = 3.14159265358979323846264;\n"
9434 "//struct world_info\n"
9439 "// sunset_phase;\n"
9441 "// vec3 sun_dir;\n"
9444 "vec3 rand33(vec3 p3)\n"
9446 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
9447 " p3 += dot(p3, p3.yxz+33.33);\n"
9448 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
9451 "float stars( vec3 rd, float rr, float size ){\n"
9452 " vec3 co = rd * rr;\n"
9454 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
9456 " float spaces = 1.0 / rr;\n"
9457 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
9458 " a -= mod(a, spaces) - spaces * 0.5;\n"
9460 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
9462 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
9463 " plane = plane - mod(plane, PI / count);\n"
9465 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
9467 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
9468 " float ydist = sqrt(rr * rr - level * level);\n"
9469 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
9470 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
9471 " float star = smoothstep(size, 0.0, distance(center, co));\n"
9475 "float luminance( vec3 v )\n"
9477 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
9480 "vec3 clearskies_ambient( vec3 dir )\n"
9482 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
9483 " float sky_gradient = dir.y;\n"
9485 " /* Blend phase colours */\n"
9486 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
9487 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
9488 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
9490 " /* Add gradient */\n"
9491 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
9493 " return ambient;\n"
9496 "vec3 clearskies_sky( vec3 ray_dir )\n"
9498 " ray_dir.y = abs( ray_dir.y );\n"
9499 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
9502 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
9503 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
9504 " float sun_shape = pow( sun_size, 2000.0 );\n"
9505 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9507 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9508 " sun_colour *= sun_shape;\n"
9511 " float star = 0.0;\n"
9512 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
9514 " if( star_blend > 0.001 ){\n"
9515 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
9516 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
9517 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
9521 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
9522 " return composite;\n"
9525 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
9527 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
9529 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
9530 " g_sunset_phase );\n"
9532 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
9533 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
9534 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
9535 " ) * g_sun_colour.rgb * g_day_phase;\n"
9537 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
9538 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
9539 " g_sunset_phase );\n"
9541 " return ambient + (light_sun + sky_reflection) * shadow;\n"
9546 "float world_depth_sample( vec3 pos )\n"
9548 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
9549 " return texture( g_world_depth, depth_coord ).r;\n"
9552 "float world_water_depth( vec3 pos )\n"
9554 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
9555 " return world_depth_sample( pos ) - ref_depth;\n"
9558 "float shadow_sample( vec3 co ){\n"
9559 " float height_sample = world_depth_sample( co );\n"
9561 " float fdelta = height_sample - co.y;\n"
9562 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
9565 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
9566 " if( g_shadow_samples == 0 ){\n"
9570 " float fspread = g_shadow_spread;\n"
9571 " float flength = g_shadow_length;\n"
9573 " float famt = 0.0;\n"
9574 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
9575 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
9576 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
9577 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
9579 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
9580 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
9581 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
9582 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
9584 " return 1.0 - famt;\n"
9587 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
9589 " vec3 specdir = reflect( -dir, wnormal );\n"
9590 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
9593 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
9594 " float dist = pow(fdist*0.0010,0.78);\n"
9595 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
9598 "vec3 scene_calculate_light( int light_index, \n"
9599 " vec3 halfview, vec3 co, vec3 normal )\n"
9601 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
9602 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
9603 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
9605 " vec3 light_delta = light_co.xyz-co;\n"
9606 " float dist2 = dot(light_delta,light_delta);\n"
9608 " light_delta = normalize( light_delta );\n"
9610 " float quadratic = dist2*100.0;\n"
9611 " float attenuation = 1.0/( 1.0 + quadratic );\n"
9612 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
9614 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
9616 " if( light_dir.w < 0.999999 ){\n"
9617 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
9618 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
9621 " return light_colour.rgb * attenuation * falloff \n"
9622 " * step( g_day_phase, light_colour.w );\n"
9625 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
9626 " vec3 halfview, vec3 co, vec3 normal )\n"
9628 " uint light_count = packed_index & 0x3u;\n"
9630 " vec3 l = vec3(0.0);\n"
9632 " if( light_count >= 1u ){\n"
9633 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
9634 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
9635 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
9637 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
9639 " if( light_count >= 2u ){\n"
9640 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
9642 " if( light_count >= 3u ){\n"
9643 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
9651 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
9652 " float light_mask )\n"
9654 " if( g_light_preview == 1 )\n"
9655 " diffuse = vec3(0.75);\n"
9658 " vec3 halfview = uCamera - co;\n"
9659 " float fdist = length(halfview);\n"
9660 " halfview /= fdist;\n"
9662 " float world_shadow = newlight_compute_sun_shadow( \n"
9663 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
9665 " vec3 total_light = clearskies_lighting( \n"
9666 " normal, min( light_mask, world_shadow ), halfview );\n"
9668 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
9669 " cube_coord = floor( cube_coord );\n"
9671 " if( g_debug_indices == 1 )\n"
9673 " return rand33(cube_coord);\n"
9676 " if( g_debug_complexity == 1 )\n"
9678 " ivec3 coord = ivec3( cube_coord );\n"
9679 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9681 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
9682 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
9685 " // FIXME: this coord should absolutely must be clamped!\n"
9687 " ivec3 coord = ivec3( cube_coord );\n"
9688 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9690 " total_light += \n"
9691 " scene_calculate_packed_light_patch( index_sample.x,\n"
9692 " halfview, co, normal ) \n"
9694 " total_light += \n"
9695 " scene_calculate_packed_light_patch( index_sample.y,\n"
9696 " halfview, co, normal )\n"
9699 " // Take a section of the sky function to give us a matching fog colour\n"
9701 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
9702 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
9703 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
9704 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9706 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9707 " sun_colour *= sun_shape;\n"
9709 " fog_colour += sun_colour;\n"
9710 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
9715 "const float k_motion_lerp_amount = 0.01;\n"
9719 "layout (location = 1) out vec2 oMotionVec;\n"
9721 "in vec3 aMotionVec0;\n"
9722 "in vec3 aMotionVec1;\n"
9724 "void compute_motion_vectors()\n"
9726 " // Write motion vectors\n"
9727 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
9728 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
9730 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
9735 "uniform sampler2D uTexSceneDepth;\n"
9736 "uniform vec3 uInverseRatioDepth;\n"
9737 "uniform vec3 uInverseRatioMain;\n"
9738 "uniform int uDepthMode;\n"
9739 "uniform float uDitherCutoff;\n"
9741 "float linear_depth( float depth, float near, float far ) {\n"
9742 " float z = depth * 2.0 - 1.0;\n"
9743 " return (2.0 * near * far) / (far + near - z * (far - near)); \n"
9746 "void depth_compare_dither()\n"
9748 " if( uDepthMode == 1 )\n"
9750 " vec2 back_coord = gl_FragCoord.xy * uInverseRatioMain.xy \n"
9751 " * uInverseRatioDepth.xy;\n"
9752 " float back_depth = texture( uTexSceneDepth, back_coord ).r;\n"
9753 " float front_depth = gl_FragCoord.z/gl_FragCoord.w;\n"
9755 " back_depth = linear_depth( back_depth, 0.1, 2100.0 );\n"
9756 " float diff = back_depth - front_depth;\n"
9758 " vec2 ssuv = gl_FragCoord.xy;\n"
9759 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
9760 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
9762 " if( step(0.0,diff)+dither<0.3 )\n"
9766 " if( uDepthMode == 2 )\n"
9768 " vec2 ssuv = gl_FragCoord.xy;\n"
9769 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
9770 " float dither = fract( vDither.g / 71.0 );\n"
9771 " if( dither<uDitherCutoff ) discard;\n"
9777 "vec3 character_clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
9779 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
9781 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
9782 " g_sunset_phase );\n"
9785 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
9786 " vec3 light_sun = max(0.0, dot(normal,g_sun_dir.xyz)*0.5+0.5) \n"
9787 " * g_sun_colour.rgb * g_day_phase;\n"
9789 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
9790 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
9791 " g_sunset_phase );\n"
9793 " return ambient + (light_sun + sky_reflection) * shadow;\n"
9796 "vec3 character_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
9797 " float light_mask )\n"
9799 " if( g_light_preview == 1 )\n"
9800 " diffuse = vec3(0.75);\n"
9803 " vec3 halfview = uCamera - co;\n"
9804 " float fdist = length(halfview);\n"
9805 " halfview /= fdist;\n"
9807 " float world_shadow = newlight_compute_sun_shadow( \n"
9808 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
9810 " vec3 total_light = character_clearskies_lighting( \n"
9811 " normal, min( light_mask, world_shadow ), halfview );\n"
9813 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
9814 " cube_coord = floor( cube_coord );\n"
9816 " if( g_debug_indices == 1 )\n"
9818 " return rand33(cube_coord);\n"
9821 " if( g_debug_complexity == 1 )\n"
9823 " ivec3 coord = ivec3( cube_coord );\n"
9824 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9826 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
9827 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
9830 " // FIXME: this coord should absolutely must be clamped!\n"
9832 " ivec3 coord = ivec3( cube_coord );\n"
9833 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9835 " total_light += \n"
9836 " scene_calculate_packed_light_patch( index_sample.x,\n"
9837 " halfview, co, normal ) \n"
9839 " total_light += \n"
9840 " scene_calculate_packed_light_patch( index_sample.y,\n"
9841 " halfview, co, normal )\n"
9844 " // Take a section of the sky function to give us a matching fog colour\n"
9846 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
9847 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
9848 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
9849 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9851 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9852 " sun_colour *= sun_shape;\n"
9854 " fog_colour += sun_colour;\n"
9855 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
9859 " depth_compare_dither();\n"
9860 " compute_motion_vectors();\n"
9862 " vec3 qnorm = aNorm;\n"
9863 " vec3 diffuse = texture( uTexMain, aUv ).rgb;\n"
9864 " vec3 composite = character_compute_lighting( diffuse, qnorm, aWorldCo, 1.0 );\n"
9866 " float dist = distance( aWorldCo, uCamera ) - 0.08;\n"
9867 " float opacity = clamp( dist*dist, 0.0, 1.0 );\n"
9869 " oColour = vec4( composite, opacity );\n"
9874 GLuint _uniform_model_board_view_uMdl
;
9875 GLuint _uniform_model_board_view_uPv
;
9876 GLuint _uniform_model_board_view_uPvmPrev
;
9877 GLuint _uniform_model_board_view_uTexMain
;
9878 GLuint _uniform_model_board_view_uCamera
;
9879 GLuint _uniform_model_board_view_g_world_depth
;
9880 GLuint _uniform_model_board_view_uLightsArray
;
9881 GLuint _uniform_model_board_view_uLightsIndex
;
9882 GLuint _uniform_model_board_view_uTexSceneDepth
;
9883 GLuint _uniform_model_board_view_uInverseRatioDepth
;
9884 GLuint _uniform_model_board_view_uInverseRatioMain
;
9885 GLuint _uniform_model_board_view_uDepthMode
;
9886 GLuint _uniform_model_board_view_uDitherCutoff
;
9887 #include "shaders/model_entity.h"
9888 struct vg_shader _shader_model_entity
= {
9889 .name
= "model_entity",
9892 .orig_file
= "shaders/model.vs",
9894 "layout (location=0) in vec3 a_co;\n"
9895 "layout (location=1) in vec3 a_norm;\n"
9896 "layout (location=2) in vec2 a_uv;\n"
9897 "layout (location=3) in vec4 a_colour;\n"
9898 "layout (location=4) in vec4 a_weights;\n"
9899 "layout (location=5) in ivec4 a_groups;\n"
9902 "const float k_motion_lerp_amount = 0.01;\n"
9906 "out vec3 aMotionVec0;\n"
9907 "out vec3 aMotionVec1;\n"
9909 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
9911 " // This magically solves some artifacting errors!\n"
9913 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
9915 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
9916 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
9921 "uniform mat4x3 uMdl;\n"
9922 "uniform mat4 uPv;\n"
9923 "uniform mat4 uPvmPrev;\n"
9925 "out vec4 aColour;\n"
9929 "out vec3 aWorldCo;\n"
9933 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
9934 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
9935 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
9937 " vs_motion_out( vproj0, vproj1 );\n"
9939 " gl_Position = vproj0;\n"
9940 " aWorldCo = world_pos0;\n"
9941 " aColour = a_colour;\n"
9943 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
9949 .orig_file
= "shaders/model_entity.fs",
9951 "uniform sampler2D uTexMain;\n"
9952 "uniform vec3 uCamera;\n"
9954 "in vec4 aColour;\n"
9958 "in vec3 aWorldCo;\n"
9962 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
9966 "layout (location = 0) out vec4 oColour;\n"
9968 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
9969 "layout (std140) uniform ub_world_lighting\n"
9971 " vec4 g_cube_min;\n"
9972 " vec4 g_cube_inv_range;\n"
9974 " vec4 g_water_plane;\n"
9975 " vec4 g_depth_bounds;\n"
9977 " vec4 g_daysky_colour;\n"
9978 " vec4 g_nightsky_colour;\n"
9979 " vec4 g_sunset_colour;\n"
9980 " vec4 g_ambient_colour;\n"
9981 " vec4 g_sunset_ambient;\n"
9982 " vec4 g_sun_colour;\n"
9983 " vec4 g_sun_dir;\n"
9984 " vec4 g_board_0;\n"
9985 " vec4 g_board_1;\n"
9987 " float g_water_fog;\n"
9989 " float g_realtime;\n"
9990 " float g_shadow_length;\n"
9991 " float g_shadow_spread;\n"
9993 " float g_time_of_day;\n"
9994 " float g_day_phase;\n"
9995 " float g_sunset_phase;\n"
9997 " int g_light_preview;\n"
9998 " int g_shadow_samples;\n"
10000 " int g_debug_indices;\n"
10001 " int g_debug_complexity;\n"
10004 "uniform sampler2D g_world_depth;\n"
10005 "uniform samplerBuffer uLightsArray;\n"
10006 "uniform usampler3D uLightsIndex;\n"
10009 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
10010 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
10011 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
10012 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
10013 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
10014 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
10016 "const float SUN_ANGLE = 0.0001;\n"
10017 "const float PI = 3.14159265358979323846264;\n"
10019 "//struct world_info\n"
10022 "// time_of_day,\n"
10024 "// sunset_phase;\n"
10026 "// vec3 sun_dir;\n"
10029 "vec3 rand33(vec3 p3)\n"
10031 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
10032 " p3 += dot(p3, p3.yxz+33.33);\n"
10033 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
10036 "float stars( vec3 rd, float rr, float size ){\n"
10037 " vec3 co = rd * rr;\n"
10039 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
10041 " float spaces = 1.0 / rr;\n"
10042 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
10043 " a -= mod(a, spaces) - spaces * 0.5;\n"
10045 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
10047 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
10048 " plane = plane - mod(plane, PI / count);\n"
10050 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
10052 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
10053 " float ydist = sqrt(rr * rr - level * level);\n"
10054 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
10055 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
10056 " float star = smoothstep(size, 0.0, distance(center, co));\n"
10060 "float luminance( vec3 v )\n"
10062 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
10065 "vec3 clearskies_ambient( vec3 dir )\n"
10067 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
10068 " float sky_gradient = dir.y;\n"
10070 " /* Blend phase colours */\n"
10071 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
10072 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
10073 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
10075 " /* Add gradient */\n"
10076 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
10078 " return ambient;\n"
10081 "vec3 clearskies_sky( vec3 ray_dir )\n"
10083 " ray_dir.y = abs( ray_dir.y );\n"
10084 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
10087 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
10088 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
10089 " float sun_shape = pow( sun_size, 2000.0 );\n"
10090 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
10092 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
10093 " sun_colour *= sun_shape;\n"
10096 " float star = 0.0;\n"
10097 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
10099 " if( star_blend > 0.001 ){\n"
10100 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
10101 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
10102 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
10106 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
10107 " return composite;\n"
10110 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
10112 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
10114 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
10115 " g_sunset_phase );\n"
10117 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
10118 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
10119 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
10120 " ) * g_sun_colour.rgb * g_day_phase;\n"
10122 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
10123 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
10124 " g_sunset_phase );\n"
10126 " return ambient + (light_sun + sky_reflection) * shadow;\n"
10131 "float world_depth_sample( vec3 pos )\n"
10133 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
10134 " return texture( g_world_depth, depth_coord ).r;\n"
10137 "float world_water_depth( vec3 pos )\n"
10139 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
10140 " return world_depth_sample( pos ) - ref_depth;\n"
10143 "float shadow_sample( vec3 co ){\n"
10144 " float height_sample = world_depth_sample( co );\n"
10146 " float fdelta = height_sample - co.y;\n"
10147 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
10150 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
10151 " if( g_shadow_samples == 0 ){\n"
10155 " float fspread = g_shadow_spread;\n"
10156 " float flength = g_shadow_length;\n"
10158 " float famt = 0.0;\n"
10159 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
10160 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
10161 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
10162 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
10164 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
10165 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
10166 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
10167 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
10169 " return 1.0 - famt;\n"
10172 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
10174 " vec3 specdir = reflect( -dir, wnormal );\n"
10175 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
10178 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
10179 " float dist = pow(fdist*0.0010,0.78);\n"
10180 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
10183 "vec3 scene_calculate_light( int light_index, \n"
10184 " vec3 halfview, vec3 co, vec3 normal )\n"
10186 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
10187 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
10188 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
10190 " vec3 light_delta = light_co.xyz-co;\n"
10191 " float dist2 = dot(light_delta,light_delta);\n"
10193 " light_delta = normalize( light_delta );\n"
10195 " float quadratic = dist2*100.0;\n"
10196 " float attenuation = 1.0/( 1.0 + quadratic );\n"
10197 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
10199 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
10201 " if( light_dir.w < 0.999999 ){\n"
10202 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
10203 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
10206 " return light_colour.rgb * attenuation * falloff \n"
10207 " * step( g_day_phase, light_colour.w );\n"
10210 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
10211 " vec3 halfview, vec3 co, vec3 normal )\n"
10213 " uint light_count = packed_index & 0x3u;\n"
10215 " vec3 l = vec3(0.0);\n"
10217 " if( light_count >= 1u ){\n"
10218 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
10219 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
10220 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
10222 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
10224 " if( light_count >= 2u ){\n"
10225 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
10227 " if( light_count >= 3u ){\n"
10228 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
10236 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
10237 " float light_mask )\n"
10239 " if( g_light_preview == 1 )\n"
10240 " diffuse = vec3(0.75);\n"
10243 " vec3 halfview = uCamera - co;\n"
10244 " float fdist = length(halfview);\n"
10245 " halfview /= fdist;\n"
10247 " float world_shadow = newlight_compute_sun_shadow( \n"
10248 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
10250 " vec3 total_light = clearskies_lighting( \n"
10251 " normal, min( light_mask, world_shadow ), halfview );\n"
10253 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
10254 " cube_coord = floor( cube_coord );\n"
10256 " if( g_debug_indices == 1 )\n"
10258 " return rand33(cube_coord);\n"
10261 " if( g_debug_complexity == 1 )\n"
10263 " ivec3 coord = ivec3( cube_coord );\n"
10264 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
10266 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
10267 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
10270 " // FIXME: this coord should absolutely must be clamped!\n"
10272 " ivec3 coord = ivec3( cube_coord );\n"
10273 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
10275 " total_light += \n"
10276 " scene_calculate_packed_light_patch( index_sample.x,\n"
10277 " halfview, co, normal ) \n"
10279 " total_light += \n"
10280 " scene_calculate_packed_light_patch( index_sample.y,\n"
10281 " halfview, co, normal )\n"
10284 " // Take a section of the sky function to give us a matching fog colour\n"
10286 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
10287 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
10288 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
10289 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
10291 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
10292 " sun_colour *= sun_shape;\n"
10294 " fog_colour += sun_colour;\n"
10295 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
10300 "const float k_motion_lerp_amount = 0.01;\n"
10304 "layout (location = 1) out vec2 oMotionVec;\n"
10306 "in vec3 aMotionVec0;\n"
10307 "in vec3 aMotionVec1;\n"
10309 "void compute_motion_vectors()\n"
10311 " // Write motion vectors\n"
10312 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10313 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10315 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10322 " compute_motion_vectors();\n"
10324 " vec3 qnorm = normalize(floor(aNorm*2.0)*0.5) + vec3(0.001,0.0,0.0);\n"
10325 " vec3 diffuse = texture( uTexMain, aUv ).rgb;\n"
10326 " vec3 composite = world_compute_lighting( diffuse, qnorm, aWorldCo, 1.0 );\n"
10328 " oColour = vec4( composite, 1.0 );\n"
10333 GLuint _uniform_model_entity_uMdl
;
10334 GLuint _uniform_model_entity_uPv
;
10335 GLuint _uniform_model_entity_uPvmPrev
;
10336 GLuint _uniform_model_entity_uTexMain
;
10337 GLuint _uniform_model_entity_uCamera
;
10338 GLuint _uniform_model_entity_g_world_depth
;
10339 GLuint _uniform_model_entity_uLightsArray
;
10340 GLuint _uniform_model_entity_uLightsIndex
;
10341 #include "shaders/model_gate.h"
10342 struct vg_shader _shader_model_gate
= {
10343 .name
= "model_gate",
10346 .orig_file
= "shaders/model.vs",
10348 "layout (location=0) in vec3 a_co;\n"
10349 "layout (location=1) in vec3 a_norm;\n"
10350 "layout (location=2) in vec2 a_uv;\n"
10351 "layout (location=3) in vec4 a_colour;\n"
10352 "layout (location=4) in vec4 a_weights;\n"
10353 "layout (location=5) in ivec4 a_groups;\n"
10356 "const float k_motion_lerp_amount = 0.01;\n"
10360 "out vec3 aMotionVec0;\n"
10361 "out vec3 aMotionVec1;\n"
10363 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10365 " // This magically solves some artifacting errors!\n"
10367 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10369 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10370 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10375 "uniform mat4x3 uMdl;\n"
10376 "uniform mat4 uPv;\n"
10377 "uniform mat4 uPvmPrev;\n"
10379 "out vec4 aColour;\n"
10381 "out vec3 aNorm;\n"
10383 "out vec3 aWorldCo;\n"
10387 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
10388 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
10389 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
10391 " vs_motion_out( vproj0, vproj1 );\n"
10393 " gl_Position = vproj0;\n"
10394 " aWorldCo = world_pos0;\n"
10395 " aColour = a_colour;\n"
10397 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
10403 .orig_file
= "shaders/model_gate_lq.fs",
10405 "out vec4 FragColor;\n"
10407 "uniform float uTime;\n"
10408 "uniform vec3 uCam;\n"
10409 "uniform vec2 uInvRes;\n"
10410 "uniform vec4 uColour;\n"
10418 " vec2 ssuv = gl_FragCoord.xy;\n"
10419 " float opacity = 1.0-smoothstep(0.0,1.0,aUv.y+uColour.a);\n"
10421 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10422 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10424 " if( opacity+dither<0.5 )\n"
10427 " FragColor = uColour;\n"
10432 GLuint _uniform_model_gate_uMdl
;
10433 GLuint _uniform_model_gate_uPv
;
10434 GLuint _uniform_model_gate_uPvmPrev
;
10435 GLuint _uniform_model_gate_uTime
;
10436 GLuint _uniform_model_gate_uCam
;
10437 GLuint _uniform_model_gate_uInvRes
;
10438 GLuint _uniform_model_gate_uColour
;
10439 #include "shaders/model_gate_unlinked.h"
10440 struct vg_shader _shader_model_gate_unlinked
= {
10441 .name
= "model_gate_unlinked",
10444 .orig_file
= "shaders/model.vs",
10446 "layout (location=0) in vec3 a_co;\n"
10447 "layout (location=1) in vec3 a_norm;\n"
10448 "layout (location=2) in vec2 a_uv;\n"
10449 "layout (location=3) in vec4 a_colour;\n"
10450 "layout (location=4) in vec4 a_weights;\n"
10451 "layout (location=5) in ivec4 a_groups;\n"
10454 "const float k_motion_lerp_amount = 0.01;\n"
10458 "out vec3 aMotionVec0;\n"
10459 "out vec3 aMotionVec1;\n"
10461 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10463 " // This magically solves some artifacting errors!\n"
10465 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10467 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10468 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10473 "uniform mat4x3 uMdl;\n"
10474 "uniform mat4 uPv;\n"
10475 "uniform mat4 uPvmPrev;\n"
10477 "out vec4 aColour;\n"
10479 "out vec3 aNorm;\n"
10481 "out vec3 aWorldCo;\n"
10485 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
10486 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
10487 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
10489 " vs_motion_out( vproj0, vproj1 );\n"
10491 " gl_Position = vproj0;\n"
10492 " aWorldCo = world_pos0;\n"
10493 " aColour = a_colour;\n"
10495 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
10501 .orig_file
= "shaders/model_gate_unlinked.fs",
10503 "out vec4 FragColor;\n"
10505 "uniform float uTime;\n"
10506 "uniform vec3 uCam;\n"
10507 "uniform vec4 uColour;\n"
10514 "const float k_motion_lerp_amount = 0.01;\n"
10518 "layout (location = 1) out vec2 oMotionVec;\n"
10520 "in vec3 aMotionVec0;\n"
10521 "in vec3 aMotionVec1;\n"
10523 "void compute_motion_vectors()\n"
10525 " // Write motion vectors\n"
10526 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10527 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10529 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10534 "const int NOISE_LOOP = 3;\n"
10535 "vec3 digital_noise( uvec3 iuv ){\n"
10536 " iuv *=uvec3(8,2524,7552);\n"
10537 " for( int i=0; i<NOISE_LOOP; i++ )\n"
10538 " iuv += (iuv.yzx<<2) ^ (iuv.yxz)+iuv.z;\n"
10539 " return vec3(iuv)*(1.0/float(0xffffffffU));\n"
10542 "vec2 rand_hash22( vec2 p ){\n"
10543 " vec3 p3 = fract(vec3(p.xyx) * 213.8976123);\n"
10544 " p3 += dot(p3, p3.yzx+19.19);\n"
10545 " return fract(vec2((p3.x + p3.y)*p3.z, (p3.x+p3.z)*p3.y));\n"
10549 " compute_motion_vectors();\n"
10551 " vec2 ssuv = gl_FragCoord.xy;\n"
10552 " float grad = 1.0-aUv.y*0.1;\n"
10553 " float opacity = rand_hash22( vec2(floor(aUv.y*100.0),floor(aCo.z*10.0+uTime*40.0)) ).r*grad;\n"
10555 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10556 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10558 " if( opacity<0.9 )\n"
10561 " FragColor = vec4(0.7,0.5,0.5,1.0);\n"
10566 GLuint _uniform_model_gate_unlinked_uMdl
;
10567 GLuint _uniform_model_gate_unlinked_uPv
;
10568 GLuint _uniform_model_gate_unlinked_uPvmPrev
;
10569 GLuint _uniform_model_gate_unlinked_uTime
;
10570 GLuint _uniform_model_gate_unlinked_uCam
;
10571 GLuint _uniform_model_gate_unlinked_uColour
;
10572 #include "shaders/model_font.h"
10573 struct vg_shader _shader_model_font
= {
10574 .name
= "model_font",
10577 .orig_file
= "shaders/model_font.vs",
10579 "layout (location=0) in vec3 a_co;\n"
10580 "layout (location=1) in vec3 a_norm;\n"
10581 "layout (location=2) in vec2 a_uv;\n"
10584 "const float k_motion_lerp_amount = 0.01;\n"
10588 "out vec3 aMotionVec0;\n"
10589 "out vec3 aMotionVec1;\n"
10591 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10593 " // This magically solves some artifacting errors!\n"
10595 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10597 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10598 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10603 "uniform mat4x3 uMdl;\n"
10604 "uniform mat4 uPv;\n"
10605 "uniform mat4 uPvmPrev;\n"
10606 "uniform vec4 uOffset;\n"
10609 "out vec4 aNorm;\n"
10611 "out vec3 aWorldCo;\n"
10615 " vec3 co = a_co*uOffset.w+uOffset.xyz;\n"
10616 " vec3 world_pos0 = uMdl * vec4( co, 1.0 );\n"
10617 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
10618 " vec4 vproj1 = uPvmPrev * vec4( co, 1.0 );\n"
10620 " vs_motion_out( vproj0, vproj1 );\n"
10622 " gl_Position = vproj0;\n"
10625 " aNorm = vec4( mat3(uMdl) * a_norm, 0.0 );\n"
10627 " aWorldCo = world_pos0;\n"
10632 .orig_file
= "shaders/model_font.fs",
10634 "layout (location = 0) out vec4 oColour;\n"
10636 "uniform sampler2D uTexMain;\n"
10637 "uniform vec4 uColour;\n"
10644 "const float k_motion_lerp_amount = 0.01;\n"
10648 "layout (location = 1) out vec2 oMotionVec;\n"
10650 "in vec3 aMotionVec0;\n"
10651 "in vec3 aMotionVec1;\n"
10653 "void compute_motion_vectors()\n"
10655 " // Write motion vectors\n"
10656 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10657 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10659 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10664 "uniform sampler2D uTexSceneDepth;\n"
10665 "uniform vec3 uInverseRatioDepth;\n"
10666 "uniform vec3 uInverseRatioMain;\n"
10667 "uniform int uDepthMode;\n"
10668 "uniform float uDitherCutoff;\n"
10670 "float linear_depth( float depth, float near, float far ) {\n"
10671 " float z = depth * 2.0 - 1.0;\n"
10672 " return (2.0 * near * far) / (far + near - z * (far - near)); \n"
10675 "void depth_compare_dither()\n"
10677 " if( uDepthMode == 1 )\n"
10679 " vec2 back_coord = gl_FragCoord.xy * uInverseRatioMain.xy \n"
10680 " * uInverseRatioDepth.xy;\n"
10681 " float back_depth = texture( uTexSceneDepth, back_coord ).r;\n"
10682 " float front_depth = gl_FragCoord.z/gl_FragCoord.w;\n"
10684 " back_depth = linear_depth( back_depth, 0.1, 2100.0 );\n"
10685 " float diff = back_depth - front_depth;\n"
10687 " vec2 ssuv = gl_FragCoord.xy;\n"
10688 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10689 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10691 " if( step(0.0,diff)+dither<0.3 )\n"
10695 " if( uDepthMode == 2 )\n"
10697 " vec2 ssuv = gl_FragCoord.xy;\n"
10698 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10699 " float dither = fract( vDither.g / 71.0 );\n"
10700 " if( dither<uDitherCutoff ) discard;\n"
10707 " depth_compare_dither();\n"
10708 " compute_motion_vectors();\n"
10709 " oColour = texture( uTexMain, aUv ) * uColour;\n"
10714 GLuint _uniform_model_font_uMdl
;
10715 GLuint _uniform_model_font_uPv
;
10716 GLuint _uniform_model_font_uPvmPrev
;
10717 GLuint _uniform_model_font_uOffset
;
10718 GLuint _uniform_model_font_uTexMain
;
10719 GLuint _uniform_model_font_uColour
;
10720 GLuint _uniform_model_font_uTexSceneDepth
;
10721 GLuint _uniform_model_font_uInverseRatioDepth
;
10722 GLuint _uniform_model_font_uInverseRatioMain
;
10723 GLuint _uniform_model_font_uDepthMode
;
10724 GLuint _uniform_model_font_uDitherCutoff
;
10725 #include "shaders/particle.h"
10726 struct vg_shader _shader_particle
= {
10727 .name
= "particle",
10730 .orig_file
= "shaders/particle.vs",
10732 "layout (location=0) in vec3 a_co;\n"
10733 "layout (location=1) in vec4 a_colour;\n"
10736 "const float k_motion_lerp_amount = 0.01;\n"
10740 "out vec3 aMotionVec0;\n"
10741 "out vec3 aMotionVec1;\n"
10743 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10745 " // This magically solves some artifacting errors!\n"
10747 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10749 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10750 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10755 "uniform mat4 uPv;\n"
10756 "uniform mat4 uPvPrev;\n"
10758 "out vec4 aColour;\n"
10761 " vec4 vproj0 = uPv * vec4( a_co, 1.0 );\n"
10762 " vec4 vproj1 = uPvPrev * vec4( a_co, 1.0 );\n"
10763 " vs_motion_out( vproj0, vproj1 );\n"
10765 " gl_Position = vproj0;\n"
10766 " aColour = a_colour;\n"
10771 .orig_file
= "shaders/particle.fs",
10773 "layout (location = 0) out vec4 oColour;\n"
10774 "in vec4 aColour;\n"
10777 "const float k_motion_lerp_amount = 0.01;\n"
10781 "layout (location = 1) out vec2 oMotionVec;\n"
10783 "in vec3 aMotionVec0;\n"
10784 "in vec3 aMotionVec1;\n"
10786 "void compute_motion_vectors()\n"
10788 " // Write motion vectors\n"
10789 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10790 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10792 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10798 " compute_motion_vectors();\n"
10800 " //vec2 ssuv = gl_FragCoord.xy;\n"
10801 " //vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10802 " //float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10804 " //if( vsamplemain.a+dither<0.5 )\n"
10807 " oColour = aColour;\n"
10812 GLuint _uniform_particle_uPv
;
10813 GLuint _uniform_particle_uPvPrev
;
10814 #include "shaders/trail.h"
10815 struct vg_shader _shader_trail
= {
10819 .orig_file
= "shaders/trail.vs",
10821 "layout (location=0) in vec4 a_co;\n"
10824 "const float k_motion_lerp_amount = 0.01;\n"
10828 "out vec3 aMotionVec0;\n"
10829 "out vec3 aMotionVec1;\n"
10831 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10833 " // This magically solves some artifacting errors!\n"
10835 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10837 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10838 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10843 "uniform mat4 uPv;\n"
10844 "uniform mat4 uPvPrev;\n"
10846 "out float aAlpha;\n"
10849 " vec4 vproj0 = uPv * vec4( a_co.xyz, 1.0 );\n"
10850 " vec4 vproj1 = uPvPrev * vec4( a_co.xyz, 1.0 );\n"
10851 " vs_motion_out( vproj0, vproj1 );\n"
10853 " gl_Position = vproj0;\n"
10854 " aAlpha = a_co.w;\n"
10859 .orig_file
= "shaders/trail.fs",
10861 "layout (location = 0) out vec4 oColour;\n"
10862 "in float aAlpha;\n"
10863 "uniform vec4 uColour;\n"
10866 "const float k_motion_lerp_amount = 0.01;\n"
10870 "layout (location = 1) out vec2 oMotionVec;\n"
10872 "in vec3 aMotionVec0;\n"
10873 "in vec3 aMotionVec1;\n"
10875 "void compute_motion_vectors()\n"
10877 " // Write motion vectors\n"
10878 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10879 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10881 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10887 " compute_motion_vectors();\n"
10889 " vec2 ssuv = gl_FragCoord.xy;\n"
10890 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10891 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10893 " if( aAlpha+dither<0.5 )\n"
10896 " oColour = vec4( uColour.rgb, uColour.a * aAlpha );\n"
10901 GLuint _uniform_trail_uPv
;
10902 GLuint _uniform_trail_uPvPrev
;
10903 GLuint _uniform_trail_uColour
;
10904 #include "shaders/blit.h"
10905 struct vg_shader _shader_blit
= {
10909 .orig_file
= "shaders/blit.vs",
10911 "layout (location=0) in vec2 a_co;\n"
10914 "uniform vec2 uInverseRatio;\n"
10918 " gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
10919 " aUv = a_co * uInverseRatio;\n"
10924 .orig_file
= "shaders/blit.fs",
10926 "out vec4 FragColor;\n"
10927 "uniform sampler2D uTexMain;\n"
10931 "float kPi = 3.14159265358979;\n"
10933 "vec2 fisheye_distort(vec2 xy)\n"
10935 " float aperture = 1350.0;\n"
10936 " float apertureHalf = 0.5 * aperture * (kPi / 180.0);\n"
10937 " float maxFactor = sin(apertureHalf);\n"
10940 " float d = length(xy);\n"
10941 " if(d < (2.0-maxFactor))\n"
10943 " d = length(xy * maxFactor);\n"
10944 " float z = sqrt(1.0 - d * d);\n"
10945 " float r = atan(d, z) / kPi;\n"
10946 " float phi = atan(xy.y, xy.x);\n"
10948 " uv.x = r * cos(phi) + 0.5;\n"
10949 " uv.y = r * sin(phi) + 0.5;\n"
10953 " uv = 0.5*xy + 0.5;\n"
10962 " vec2 vwarp = 2.0*aUv - 1.0;\n"
10963 " vwarp = fisheye_distort( vwarp );\n"
10965 " FragColor = texture( uTexMain, aUv );\n"
10970 GLuint _uniform_blit_uInverseRatio
;
10971 GLuint _uniform_blit_uTexMain
;
10972 #include "shaders/blitblur.h"
10973 struct vg_shader _shader_blitblur
= {
10974 .name
= "blitblur",
10977 .orig_file
= "shaders/blit.vs",
10979 "layout (location=0) in vec2 a_co;\n"
10982 "uniform vec2 uInverseRatio;\n"
10986 " gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
10987 " aUv = a_co * uInverseRatio;\n"
10992 .orig_file
= "shaders/blitblur.fs",
10994 "out vec4 FragColor;\n"
10995 "uniform sampler2D uTexMain;\n"
10996 "uniform sampler2D uTexMotion;\n"
10997 "uniform float uBlurStrength;\n"
10998 "uniform vec2 uOverrideDir;\n"
10999 "uniform float uTime;\n"
11000 "uniform float uGlitchStrength;\n"
11001 "uniform vec2 uClampUv;\n"
11005 "vec2 rand_hash22( vec2 p ){\n"
11006 " vec3 p3 = fract(vec3(p.xyx) * 213.8976123);\n"
11007 " p3 += dot(p3, p3.yzx+19.19);\n"
11008 " return fract(vec2((p3.x + p3.y)*p3.z, (p3.x+p3.z)*p3.y));\n"
11011 "const int NOISE_LOOP = 3;\n"
11012 "vec3 digital_noise( uvec3 iuv ){\n"
11013 " iuv *=uvec3(8,2524,7552);\n"
11014 " for( int i=0; i<NOISE_LOOP; i++ )\n"
11015 " iuv += (iuv.yzx<<2) ^ (iuv.yxz)+iuv.z;\n"
11016 " return vec3(iuv)*(1.0/float(0xffffffffU));\n"
11020 " vec2 vuv = aUv; \n"
11022 " //if( uGlitchStrength > 0.0 ){\n"
11023 " // uvec3 p = uvec3( gl_FragCoord.xy, uint(uTime*30.0) );\n"
11024 " // vec2 g = digital_noise(p).xy;\n"
11025 " // vuv = aUv + g.xy*uGlitchStrength - uGlitchStrength*0.5;\n"
11028 " vec2 vrand = rand_hash22( vuv ) * 2.0 - vec2(1.0);\n"
11029 " vec2 vrand1 = rand_hash22( vrand ) * 2.0 - vec2(1.0);\n"
11031 " vec2 vdir = texture( uTexMotion, vuv ).xy * uBlurStrength + uOverrideDir;\n"
11033 " vec4 vcolour0 = texture( uTexMain, min(vuv + vdir*vrand.x,uClampUv) );\n"
11034 " vec4 vcolour1 = texture( uTexMain, min(vuv + vdir*vrand.y,uClampUv) );\n"
11035 " vec4 vcolour2 = texture( uTexMain, min(vuv + vdir*vrand1.x,uClampUv) );\n"
11036 " vec4 vcolour3 = texture( uTexMain, min(vuv + vdir*vrand1.y,uClampUv) );\n"
11038 " FragColor = ( vcolour0 + vcolour1 + vcolour2 + vcolour3 ) * 0.25;\n"
11043 GLuint _uniform_blitblur_uInverseRatio
;
11044 GLuint _uniform_blitblur_uTexMain
;
11045 GLuint _uniform_blitblur_uTexMotion
;
11046 GLuint _uniform_blitblur_uBlurStrength
;
11047 GLuint _uniform_blitblur_uOverrideDir
;
11048 GLuint _uniform_blitblur_uTime
;
11049 GLuint _uniform_blitblur_uGlitchStrength
;
11050 GLuint _uniform_blitblur_uClampUv
;
11051 #include "shaders/blitcolour.h"
11052 struct vg_shader _shader_blitcolour
= {
11053 .name
= "blitcolour",
11056 .orig_file
= "shaders/blit.vs",
11058 "layout (location=0) in vec2 a_co;\n"
11061 "uniform vec2 uInverseRatio;\n"
11065 " gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
11066 " aUv = a_co * uInverseRatio;\n"
11071 .orig_file
= "shaders/colour.fs",
11073 "out vec4 FragColor;\n"
11074 "uniform vec4 uColour;\n"
11080 " FragColor = uColour;\n"
11085 GLuint _uniform_blitcolour_uInverseRatio
;
11086 GLuint _uniform_blitcolour_uColour
;
11087 #include "shaders/blit_transition.h"
11088 struct vg_shader _shader_blit_transition
= {
11089 .name
= "blit_transition",
11092 .orig_file
= "shaders/blit.vs",
11094 "layout (location=0) in vec2 a_co;\n"
11097 "uniform vec2 uInverseRatio;\n"
11101 " gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
11102 " aUv = a_co * uInverseRatio;\n"
11107 .orig_file
= "shaders/blit_transition.fs",
11109 "out vec4 FragColor;\n"
11111 "uniform float uT;\n"
11114 " float d = uT + distance( aUv, vec2(0.5,0.5) );\n"
11116 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), gl_FragCoord.xy) );\n"
11117 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
11119 " if( d+dither < -0.5 )\n"
11122 " FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n"
11127 GLuint _uniform_blit_transition_uInverseRatio
;
11128 GLuint _uniform_blit_transition_uT
;
11129 #include "shaders/routeui.h"
11130 struct vg_shader _shader_routeui
= {
11134 .orig_file
= "shaders/routeui.vs",
11136 "layout (location=0) in vec2 a_co;\n"
11138 "uniform vec4 uOffset;\n"
11142 " vec2 vpos = a_co * uOffset.zw + uOffset.xy;\n"
11143 " gl_Position = vec4(vpos,0.0,1.0);\n"
11148 .orig_file
= "shaders/routeui.fs",
11150 "out vec4 FragColor;\n"
11152 "uniform vec4 uColour;\n"
11156 " FragColor = uColour;\n"
11161 GLuint _uniform_routeui_uOffset
;
11162 GLuint _uniform_routeui_uColour
;
11165 void vg_auto_shader_link(void)
11167 _uniform_scene_standard_uMdl
= glGetUniformLocation( _shader_scene_standard
.id
, "uMdl" );
11168 _uniform_scene_standard_uPv
= glGetUniformLocation( _shader_scene_standard
.id
, "uPv" );
11169 _uniform_scene_standard_uPvmPrev
= glGetUniformLocation( _shader_scene_standard
.id
, "uPvmPrev" );
11170 _uniform_scene_standard_uTexGarbage
= glGetUniformLocation( _shader_scene_standard
.id
, "uTexGarbage" );
11171 _uniform_scene_standard_uTexMain
= glGetUniformLocation( _shader_scene_standard
.id
, "uTexMain" );
11172 _uniform_scene_standard_uCamera
= glGetUniformLocation( _shader_scene_standard
.id
, "uCamera" );
11173 _uniform_scene_standard_uPlane
= glGetUniformLocation( _shader_scene_standard
.id
, "uPlane" );
11174 _uniform_scene_standard_g_world_depth
= glGetUniformLocation( _shader_scene_standard
.id
, "g_world_depth" );
11175 _uniform_scene_standard_uLightsArray
= glGetUniformLocation( _shader_scene_standard
.id
, "uLightsArray" );
11176 _uniform_scene_standard_uLightsIndex
= glGetUniformLocation( _shader_scene_standard
.id
, "uLightsIndex" );
11177 _uniform_scene_standard_alphatest_uMdl
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uMdl" );
11178 _uniform_scene_standard_alphatest_uPv
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uPv" );
11179 _uniform_scene_standard_alphatest_uPvmPrev
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uPvmPrev" );
11180 _uniform_scene_standard_alphatest_uTexGarbage
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uTexGarbage" );
11181 _uniform_scene_standard_alphatest_uTexMain
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uTexMain" );
11182 _uniform_scene_standard_alphatest_uCamera
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uCamera" );
11183 _uniform_scene_standard_alphatest_uPlane
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uPlane" );
11184 _uniform_scene_standard_alphatest_g_world_depth
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "g_world_depth" );
11185 _uniform_scene_standard_alphatest_uLightsArray
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uLightsArray" );
11186 _uniform_scene_standard_alphatest_uLightsIndex
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uLightsIndex" );
11187 _uniform_scene_foliage_uMdl
= glGetUniformLocation( _shader_scene_foliage
.id
, "uMdl" );
11188 _uniform_scene_foliage_uPv
= glGetUniformLocation( _shader_scene_foliage
.id
, "uPv" );
11189 _uniform_scene_foliage_uPvmPrev
= glGetUniformLocation( _shader_scene_foliage
.id
, "uPvmPrev" );
11190 _uniform_scene_foliage_uTime
= glGetUniformLocation( _shader_scene_foliage
.id
, "uTime" );
11191 _uniform_scene_foliage_uTexGarbage
= glGetUniformLocation( _shader_scene_foliage
.id
, "uTexGarbage" );
11192 _uniform_scene_foliage_uTexMain
= glGetUniformLocation( _shader_scene_foliage
.id
, "uTexMain" );
11193 _uniform_scene_foliage_uCamera
= glGetUniformLocation( _shader_scene_foliage
.id
, "uCamera" );
11194 _uniform_scene_foliage_uPlane
= glGetUniformLocation( _shader_scene_foliage
.id
, "uPlane" );
11195 _uniform_scene_foliage_g_world_depth
= glGetUniformLocation( _shader_scene_foliage
.id
, "g_world_depth" );
11196 _uniform_scene_foliage_uLightsArray
= glGetUniformLocation( _shader_scene_foliage
.id
, "uLightsArray" );
11197 _uniform_scene_foliage_uLightsIndex
= glGetUniformLocation( _shader_scene_foliage
.id
, "uLightsIndex" );
11198 _uniform_scene_override_uMdl
= glGetUniformLocation( _shader_scene_override
.id
, "uMdl" );
11199 _uniform_scene_override_uPv
= glGetUniformLocation( _shader_scene_override
.id
, "uPv" );
11200 _uniform_scene_override_uPvmPrev
= glGetUniformLocation( _shader_scene_override
.id
, "uPvmPrev" );
11201 _uniform_scene_override_uNormalMtx
= glGetUniformLocation( _shader_scene_override
.id
, "uNormalMtx" );
11202 _uniform_scene_override_uTexGarbage
= glGetUniformLocation( _shader_scene_override
.id
, "uTexGarbage" );
11203 _uniform_scene_override_uTexMain
= glGetUniformLocation( _shader_scene_override
.id
, "uTexMain" );
11204 _uniform_scene_override_uCamera
= glGetUniformLocation( _shader_scene_override
.id
, "uCamera" );
11205 _uniform_scene_override_uPlane
= glGetUniformLocation( _shader_scene_override
.id
, "uPlane" );
11206 _uniform_scene_override_uPlayerPos
= glGetUniformLocation( _shader_scene_override
.id
, "uPlayerPos" );
11207 _uniform_scene_override_uSpawnPos
= glGetUniformLocation( _shader_scene_override
.id
, "uSpawnPos" );
11208 _uniform_scene_override_uAlphatest
= glGetUniformLocation( _shader_scene_override
.id
, "uAlphatest" );
11209 _uniform_scene_override_uMapInfo
= glGetUniformLocation( _shader_scene_override
.id
, "uMapInfo" );
11210 _uniform_scene_override_g_world_depth
= glGetUniformLocation( _shader_scene_override
.id
, "g_world_depth" );
11211 _uniform_scene_override_uLightsArray
= glGetUniformLocation( _shader_scene_override
.id
, "uLightsArray" );
11212 _uniform_scene_override_uLightsIndex
= glGetUniformLocation( _shader_scene_override
.id
, "uLightsIndex" );
11213 _uniform_scene_fxglow_uMdl
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uMdl" );
11214 _uniform_scene_fxglow_uPv
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uPv" );
11215 _uniform_scene_fxglow_uPvmPrev
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uPvmPrev" );
11216 _uniform_scene_fxglow_uUvOffset
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uUvOffset" );
11217 _uniform_scene_fxglow_uTexMain
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uTexMain" );
11218 _uniform_scene_fxglow_uCamera
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uCamera" );
11219 _uniform_scene_fxglow_g_world_depth
= glGetUniformLocation( _shader_scene_fxglow
.id
, "g_world_depth" );
11220 _uniform_scene_fxglow_uLightsArray
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uLightsArray" );
11221 _uniform_scene_fxglow_uLightsIndex
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uLightsIndex" );
11222 _uniform_scene_vertex_blend_uMdl
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uMdl" );
11223 _uniform_scene_vertex_blend_uPv
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uPv" );
11224 _uniform_scene_vertex_blend_uPvmPrev
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uPvmPrev" );
11225 _uniform_scene_vertex_blend_uTexGarbage
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uTexGarbage" );
11226 _uniform_scene_vertex_blend_uTexGradients
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uTexGradients" );
11227 _uniform_scene_vertex_blend_uCamera
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uCamera" );
11228 _uniform_scene_vertex_blend_g_world_depth
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "g_world_depth" );
11229 _uniform_scene_vertex_blend_uLightsArray
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uLightsArray" );
11230 _uniform_scene_vertex_blend_uLightsIndex
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uLightsIndex" );
11231 _uniform_scene_terrain_uMdl
= glGetUniformLocation( _shader_scene_terrain
.id
, "uMdl" );
11232 _uniform_scene_terrain_uPv
= glGetUniformLocation( _shader_scene_terrain
.id
, "uPv" );
11233 _uniform_scene_terrain_uPvmPrev
= glGetUniformLocation( _shader_scene_terrain
.id
, "uPvmPrev" );
11234 _uniform_scene_terrain_uTexGarbage
= glGetUniformLocation( _shader_scene_terrain
.id
, "uTexGarbage" );
11235 _uniform_scene_terrain_uTexGradients
= glGetUniformLocation( _shader_scene_terrain
.id
, "uTexGradients" );
11236 _uniform_scene_terrain_uCamera
= glGetUniformLocation( _shader_scene_terrain
.id
, "uCamera" );
11237 _uniform_scene_terrain_uSandColour
= glGetUniformLocation( _shader_scene_terrain
.id
, "uSandColour" );
11238 _uniform_scene_terrain_uBlendOffset
= glGetUniformLocation( _shader_scene_terrain
.id
, "uBlendOffset" );
11239 _uniform_scene_terrain_g_world_depth
= glGetUniformLocation( _shader_scene_terrain
.id
, "g_world_depth" );
11240 _uniform_scene_terrain_uLightsArray
= glGetUniformLocation( _shader_scene_terrain
.id
, "uLightsArray" );
11241 _uniform_scene_terrain_uLightsIndex
= glGetUniformLocation( _shader_scene_terrain
.id
, "uLightsIndex" );
11242 _uniform_scene_route_uMdl
= glGetUniformLocation( _shader_scene_route
.id
, "uMdl" );
11243 _uniform_scene_route_uPv
= glGetUniformLocation( _shader_scene_route
.id
, "uPv" );
11244 _uniform_scene_route_uPvmPrev
= glGetUniformLocation( _shader_scene_route
.id
, "uPvmPrev" );
11245 _uniform_scene_route_uNormalMtx
= glGetUniformLocation( _shader_scene_route
.id
, "uNormalMtx" );
11246 _uniform_scene_route_uTexGarbage
= glGetUniformLocation( _shader_scene_route
.id
, "uTexGarbage" );
11247 _uniform_scene_route_uTexGradients
= glGetUniformLocation( _shader_scene_route
.id
, "uTexGradients" );
11248 _uniform_scene_route_uCamera
= glGetUniformLocation( _shader_scene_route
.id
, "uCamera" );
11249 _uniform_scene_route_uColour
= glGetUniformLocation( _shader_scene_route
.id
, "uColour" );
11250 _uniform_scene_route_g_world_depth
= glGetUniformLocation( _shader_scene_route
.id
, "g_world_depth" );
11251 _uniform_scene_route_uLightsArray
= glGetUniformLocation( _shader_scene_route
.id
, "uLightsArray" );
11252 _uniform_scene_route_uLightsIndex
= glGetUniformLocation( _shader_scene_route
.id
, "uLightsIndex" );
11253 _uniform_scene_depth_uMdl
= glGetUniformLocation( _shader_scene_depth
.id
, "uMdl" );
11254 _uniform_scene_depth_uPv
= glGetUniformLocation( _shader_scene_depth
.id
, "uPv" );
11255 _uniform_scene_depth_uPvmPrev
= glGetUniformLocation( _shader_scene_depth
.id
, "uPvmPrev" );
11256 _uniform_scene_depth_uCamera
= glGetUniformLocation( _shader_scene_depth
.id
, "uCamera" );
11257 _uniform_scene_depth_uBoard0
= glGetUniformLocation( _shader_scene_depth
.id
, "uBoard0" );
11258 _uniform_scene_depth_uBoard1
= glGetUniformLocation( _shader_scene_depth
.id
, "uBoard1" );
11259 _uniform_scene_depth_g_world_depth
= glGetUniformLocation( _shader_scene_depth
.id
, "g_world_depth" );
11260 _uniform_scene_depth_uLightsArray
= glGetUniformLocation( _shader_scene_depth
.id
, "uLightsArray" );
11261 _uniform_scene_depth_uLightsIndex
= glGetUniformLocation( _shader_scene_depth
.id
, "uLightsIndex" );
11262 _uniform_scene_position_uMdl
= glGetUniformLocation( _shader_scene_position
.id
, "uMdl" );
11263 _uniform_scene_position_uPv
= glGetUniformLocation( _shader_scene_position
.id
, "uPv" );
11264 _uniform_scene_position_uPvmPrev
= glGetUniformLocation( _shader_scene_position
.id
, "uPvmPrev" );
11265 _uniform_scene_position_uCamera
= glGetUniformLocation( _shader_scene_position
.id
, "uCamera" );
11266 _uniform_scene_position_uBoard0
= glGetUniformLocation( _shader_scene_position
.id
, "uBoard0" );
11267 _uniform_scene_position_uBoard1
= glGetUniformLocation( _shader_scene_position
.id
, "uBoard1" );
11268 _uniform_scene_position_g_world_depth
= glGetUniformLocation( _shader_scene_position
.id
, "g_world_depth" );
11269 _uniform_scene_position_uLightsArray
= glGetUniformLocation( _shader_scene_position
.id
, "uLightsArray" );
11270 _uniform_scene_position_uLightsIndex
= glGetUniformLocation( _shader_scene_position
.id
, "uLightsIndex" );
11271 _uniform_scene_cubemapped_uMdl
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uMdl" );
11272 _uniform_scene_cubemapped_uPv
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uPv" );
11273 _uniform_scene_cubemapped_uPvmPrev
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uPvmPrev" );
11274 _uniform_scene_cubemapped_uTexGarbage
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uTexGarbage" );
11275 _uniform_scene_cubemapped_uTexMain
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uTexMain" );
11276 _uniform_scene_cubemapped_uTexCubemap
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uTexCubemap" );
11277 _uniform_scene_cubemapped_uCamera
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uCamera" );
11278 _uniform_scene_cubemapped_uPlane
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uPlane" );
11279 _uniform_scene_cubemapped_uColour
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uColour" );
11280 _uniform_scene_cubemapped_g_world_depth
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "g_world_depth" );
11281 _uniform_scene_cubemapped_uLightsArray
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uLightsArray" );
11282 _uniform_scene_cubemapped_uLightsIndex
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uLightsIndex" );
11283 _uniform_scene_water_uMdl
= glGetUniformLocation( _shader_scene_water
.id
, "uMdl" );
11284 _uniform_scene_water_uPv
= glGetUniformLocation( _shader_scene_water
.id
, "uPv" );
11285 _uniform_scene_water_uPvmPrev
= glGetUniformLocation( _shader_scene_water
.id
, "uPvmPrev" );
11286 _uniform_scene_water_uTexMain
= glGetUniformLocation( _shader_scene_water
.id
, "uTexMain" );
11287 _uniform_scene_water_uTexDudv
= glGetUniformLocation( _shader_scene_water
.id
, "uTexDudv" );
11288 _uniform_scene_water_uTexBack
= glGetUniformLocation( _shader_scene_water
.id
, "uTexBack" );
11289 _uniform_scene_water_uInvRes
= glGetUniformLocation( _shader_scene_water
.id
, "uInvRes" );
11290 _uniform_scene_water_uTime
= glGetUniformLocation( _shader_scene_water
.id
, "uTime" );
11291 _uniform_scene_water_uCamera
= glGetUniformLocation( _shader_scene_water
.id
, "uCamera" );
11292 _uniform_scene_water_uSurfaceY
= glGetUniformLocation( _shader_scene_water
.id
, "uSurfaceY" );
11293 _uniform_scene_water_uBoard0
= glGetUniformLocation( _shader_scene_water
.id
, "uBoard0" );
11294 _uniform_scene_water_uBoard1
= glGetUniformLocation( _shader_scene_water
.id
, "uBoard1" );
11295 _uniform_scene_water_uShoreColour
= glGetUniformLocation( _shader_scene_water
.id
, "uShoreColour" );
11296 _uniform_scene_water_uOceanColour
= glGetUniformLocation( _shader_scene_water
.id
, "uOceanColour" );
11297 _uniform_scene_water_g_world_depth
= glGetUniformLocation( _shader_scene_water
.id
, "g_world_depth" );
11298 _uniform_scene_water_uLightsArray
= glGetUniformLocation( _shader_scene_water
.id
, "uLightsArray" );
11299 _uniform_scene_water_uLightsIndex
= glGetUniformLocation( _shader_scene_water
.id
, "uLightsIndex" );
11300 _uniform_scene_water_fast_uMdl
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uMdl" );
11301 _uniform_scene_water_fast_uPv
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uPv" );
11302 _uniform_scene_water_fast_uPvmPrev
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uPvmPrev" );
11303 _uniform_scene_water_fast_uTexDudv
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uTexDudv" );
11304 _uniform_scene_water_fast_uTime
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uTime" );
11305 _uniform_scene_water_fast_uCamera
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uCamera" );
11306 _uniform_scene_water_fast_uSurfaceY
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uSurfaceY" );
11307 _uniform_scene_water_fast_uBoard0
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uBoard0" );
11308 _uniform_scene_water_fast_uBoard1
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uBoard1" );
11309 _uniform_scene_water_fast_uShoreColour
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uShoreColour" );
11310 _uniform_scene_water_fast_uOceanColour
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uOceanColour" );
11311 _uniform_scene_water_fast_g_world_depth
= glGetUniformLocation( _shader_scene_water_fast
.id
, "g_world_depth" );
11312 _uniform_scene_water_fast_uLightsArray
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uLightsArray" );
11313 _uniform_scene_water_fast_uLightsIndex
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uLightsIndex" );
11314 _uniform_scene_scoretext_uMdl
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uMdl" );
11315 _uniform_scene_scoretext_uPv
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uPv" );
11316 _uniform_scene_scoretext_uPvmPrev
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uPvmPrev" );
11317 _uniform_scene_scoretext_uInfo
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uInfo" );
11318 _uniform_scene_scoretext_uTexGarbage
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uTexGarbage" );
11319 _uniform_scene_scoretext_uTexMain
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uTexMain" );
11320 _uniform_scene_scoretext_uCamera
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uCamera" );
11321 _uniform_scene_scoretext_uPlane
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uPlane" );
11322 _uniform_scene_scoretext_g_world_depth
= glGetUniformLocation( _shader_scene_scoretext
.id
, "g_world_depth" );
11323 _uniform_scene_scoretext_uLightsArray
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uLightsArray" );
11324 _uniform_scene_scoretext_uLightsIndex
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uLightsIndex" );
11325 _uniform_scene_font_uMdl
= glGetUniformLocation( _shader_scene_font
.id
, "uMdl" );
11326 _uniform_scene_font_uPv
= glGetUniformLocation( _shader_scene_font
.id
, "uPv" );
11327 _uniform_scene_font_uPvmPrev
= glGetUniformLocation( _shader_scene_font
.id
, "uPvmPrev" );
11328 _uniform_scene_font_uOffset
= glGetUniformLocation( _shader_scene_font
.id
, "uOffset" );
11329 _uniform_scene_font_uTexGarbage
= glGetUniformLocation( _shader_scene_font
.id
, "uTexGarbage" );
11330 _uniform_scene_font_uTexMain
= glGetUniformLocation( _shader_scene_font
.id
, "uTexMain" );
11331 _uniform_scene_font_uCamera
= glGetUniformLocation( _shader_scene_font
.id
, "uCamera" );
11332 _uniform_scene_font_uTime
= glGetUniformLocation( _shader_scene_font
.id
, "uTime" );
11333 _uniform_scene_font_uOpacity
= glGetUniformLocation( _shader_scene_font
.id
, "uOpacity" );
11334 _uniform_scene_font_uColourize
= glGetUniformLocation( _shader_scene_font
.id
, "uColourize" );
11335 _uniform_scene_font_g_world_depth
= glGetUniformLocation( _shader_scene_font
.id
, "g_world_depth" );
11336 _uniform_scene_font_uLightsArray
= glGetUniformLocation( _shader_scene_font
.id
, "uLightsArray" );
11337 _uniform_scene_font_uLightsIndex
= glGetUniformLocation( _shader_scene_font
.id
, "uLightsIndex" );
11338 _uniform_model_sky_uMdl
= glGetUniformLocation( _shader_model_sky
.id
, "uMdl" );
11339 _uniform_model_sky_uPv
= glGetUniformLocation( _shader_model_sky
.id
, "uPv" );
11340 _uniform_model_sky_uPvmPrev
= glGetUniformLocation( _shader_model_sky
.id
, "uPvmPrev" );
11341 _uniform_model_sky_uTexGarbage
= glGetUniformLocation( _shader_model_sky
.id
, "uTexGarbage" );
11342 _uniform_model_sky_g_world_depth
= glGetUniformLocation( _shader_model_sky
.id
, "g_world_depth" );
11343 _uniform_model_sky_uLightsArray
= glGetUniformLocation( _shader_model_sky
.id
, "uLightsArray" );
11344 _uniform_model_sky_uLightsIndex
= glGetUniformLocation( _shader_model_sky
.id
, "uLightsIndex" );
11345 _uniform_model_sky_space_uMdl
= glGetUniformLocation( _shader_model_sky_space
.id
, "uMdl" );
11346 _uniform_model_sky_space_uPv
= glGetUniformLocation( _shader_model_sky_space
.id
, "uPv" );
11347 _uniform_model_sky_space_uPvmPrev
= glGetUniformLocation( _shader_model_sky_space
.id
, "uPvmPrev" );
11348 _uniform_model_sky_space_uTexGarbage
= glGetUniformLocation( _shader_model_sky_space
.id
, "uTexGarbage" );
11349 _uniform_model_sky_space_g_world_depth
= glGetUniformLocation( _shader_model_sky_space
.id
, "g_world_depth" );
11350 _uniform_model_sky_space_uLightsArray
= glGetUniformLocation( _shader_model_sky_space
.id
, "uLightsArray" );
11351 _uniform_model_sky_space_uLightsIndex
= glGetUniformLocation( _shader_model_sky_space
.id
, "uLightsIndex" );
11352 _uniform_model_menu_uMdl
= glGetUniformLocation( _shader_model_menu
.id
, "uMdl" );
11353 _uniform_model_menu_uPv
= glGetUniformLocation( _shader_model_menu
.id
, "uPv" );
11354 _uniform_model_menu_uPvmPrev
= glGetUniformLocation( _shader_model_menu
.id
, "uPvmPrev" );
11355 _uniform_model_menu_uTexMain
= glGetUniformLocation( _shader_model_menu
.id
, "uTexMain" );
11356 _uniform_model_menu_uColour
= glGetUniformLocation( _shader_model_menu
.id
, "uColour" );
11357 _uniform_model_character_view_uPv
= glGetUniformLocation( _shader_model_character_view
.id
, "uPv" );
11358 _uniform_model_character_view_uTransforms
= glGetUniformLocation( _shader_model_character_view
.id
, "uTransforms" );
11359 _uniform_model_character_view_uTexMain
= glGetUniformLocation( _shader_model_character_view
.id
, "uTexMain" );
11360 _uniform_model_character_view_uCamera
= glGetUniformLocation( _shader_model_character_view
.id
, "uCamera" );
11361 _uniform_model_character_view_g_world_depth
= glGetUniformLocation( _shader_model_character_view
.id
, "g_world_depth" );
11362 _uniform_model_character_view_uLightsArray
= glGetUniformLocation( _shader_model_character_view
.id
, "uLightsArray" );
11363 _uniform_model_character_view_uLightsIndex
= glGetUniformLocation( _shader_model_character_view
.id
, "uLightsIndex" );
11364 _uniform_model_character_view_uTexSceneDepth
= glGetUniformLocation( _shader_model_character_view
.id
, "uTexSceneDepth" );
11365 _uniform_model_character_view_uInverseRatioDepth
= glGetUniformLocation( _shader_model_character_view
.id
, "uInverseRatioDepth" );
11366 _uniform_model_character_view_uInverseRatioMain
= glGetUniformLocation( _shader_model_character_view
.id
, "uInverseRatioMain" );
11367 _uniform_model_character_view_uDepthMode
= glGetUniformLocation( _shader_model_character_view
.id
, "uDepthMode" );
11368 _uniform_model_character_view_uDitherCutoff
= glGetUniformLocation( _shader_model_character_view
.id
, "uDitherCutoff" );
11369 _uniform_model_board_view_uMdl
= glGetUniformLocation( _shader_model_board_view
.id
, "uMdl" );
11370 _uniform_model_board_view_uPv
= glGetUniformLocation( _shader_model_board_view
.id
, "uPv" );
11371 _uniform_model_board_view_uPvmPrev
= glGetUniformLocation( _shader_model_board_view
.id
, "uPvmPrev" );
11372 _uniform_model_board_view_uTexMain
= glGetUniformLocation( _shader_model_board_view
.id
, "uTexMain" );
11373 _uniform_model_board_view_uCamera
= glGetUniformLocation( _shader_model_board_view
.id
, "uCamera" );
11374 _uniform_model_board_view_g_world_depth
= glGetUniformLocation( _shader_model_board_view
.id
, "g_world_depth" );
11375 _uniform_model_board_view_uLightsArray
= glGetUniformLocation( _shader_model_board_view
.id
, "uLightsArray" );
11376 _uniform_model_board_view_uLightsIndex
= glGetUniformLocation( _shader_model_board_view
.id
, "uLightsIndex" );
11377 _uniform_model_board_view_uTexSceneDepth
= glGetUniformLocation( _shader_model_board_view
.id
, "uTexSceneDepth" );
11378 _uniform_model_board_view_uInverseRatioDepth
= glGetUniformLocation( _shader_model_board_view
.id
, "uInverseRatioDepth" );
11379 _uniform_model_board_view_uInverseRatioMain
= glGetUniformLocation( _shader_model_board_view
.id
, "uInverseRatioMain" );
11380 _uniform_model_board_view_uDepthMode
= glGetUniformLocation( _shader_model_board_view
.id
, "uDepthMode" );
11381 _uniform_model_board_view_uDitherCutoff
= glGetUniformLocation( _shader_model_board_view
.id
, "uDitherCutoff" );
11382 _uniform_model_entity_uMdl
= glGetUniformLocation( _shader_model_entity
.id
, "uMdl" );
11383 _uniform_model_entity_uPv
= glGetUniformLocation( _shader_model_entity
.id
, "uPv" );
11384 _uniform_model_entity_uPvmPrev
= glGetUniformLocation( _shader_model_entity
.id
, "uPvmPrev" );
11385 _uniform_model_entity_uTexMain
= glGetUniformLocation( _shader_model_entity
.id
, "uTexMain" );
11386 _uniform_model_entity_uCamera
= glGetUniformLocation( _shader_model_entity
.id
, "uCamera" );
11387 _uniform_model_entity_g_world_depth
= glGetUniformLocation( _shader_model_entity
.id
, "g_world_depth" );
11388 _uniform_model_entity_uLightsArray
= glGetUniformLocation( _shader_model_entity
.id
, "uLightsArray" );
11389 _uniform_model_entity_uLightsIndex
= glGetUniformLocation( _shader_model_entity
.id
, "uLightsIndex" );
11390 _uniform_model_gate_uMdl
= glGetUniformLocation( _shader_model_gate
.id
, "uMdl" );
11391 _uniform_model_gate_uPv
= glGetUniformLocation( _shader_model_gate
.id
, "uPv" );
11392 _uniform_model_gate_uPvmPrev
= glGetUniformLocation( _shader_model_gate
.id
, "uPvmPrev" );
11393 _uniform_model_gate_uTime
= glGetUniformLocation( _shader_model_gate
.id
, "uTime" );
11394 _uniform_model_gate_uCam
= glGetUniformLocation( _shader_model_gate
.id
, "uCam" );
11395 _uniform_model_gate_uInvRes
= glGetUniformLocation( _shader_model_gate
.id
, "uInvRes" );
11396 _uniform_model_gate_uColour
= glGetUniformLocation( _shader_model_gate
.id
, "uColour" );
11397 _uniform_model_gate_unlinked_uMdl
= glGetUniformLocation( _shader_model_gate_unlinked
.id
, "uMdl" );
11398 _uniform_model_gate_unlinked_uPv
= glGetUniformLocation( _shader_model_gate_unlinked
.id
, "uPv" );
11399 _uniform_model_gate_unlinked_uPvmPrev
= glGetUniformLocation( _shader_model_gate_unlinked
.id
, "uPvmPrev" );
11400 _uniform_model_gate_unlinked_uTime
= glGetUniformLocation( _shader_model_gate_unlinked
.id
, "uTime" );
11401 _uniform_model_gate_unlinked_uCam
= glGetUniformLocation( _shader_model_gate_unlinked
.id
, "uCam" );
11402 _uniform_model_gate_unlinked_uColour
= glGetUniformLocation( _shader_model_gate_unlinked
.id
, "uColour" );
11403 _uniform_model_font_uMdl
= glGetUniformLocation( _shader_model_font
.id
, "uMdl" );
11404 _uniform_model_font_uPv
= glGetUniformLocation( _shader_model_font
.id
, "uPv" );
11405 _uniform_model_font_uPvmPrev
= glGetUniformLocation( _shader_model_font
.id
, "uPvmPrev" );
11406 _uniform_model_font_uOffset
= glGetUniformLocation( _shader_model_font
.id
, "uOffset" );
11407 _uniform_model_font_uTexMain
= glGetUniformLocation( _shader_model_font
.id
, "uTexMain" );
11408 _uniform_model_font_uColour
= glGetUniformLocation( _shader_model_font
.id
, "uColour" );
11409 _uniform_model_font_uTexSceneDepth
= glGetUniformLocation( _shader_model_font
.id
, "uTexSceneDepth" );
11410 _uniform_model_font_uInverseRatioDepth
= glGetUniformLocation( _shader_model_font
.id
, "uInverseRatioDepth" );
11411 _uniform_model_font_uInverseRatioMain
= glGetUniformLocation( _shader_model_font
.id
, "uInverseRatioMain" );
11412 _uniform_model_font_uDepthMode
= glGetUniformLocation( _shader_model_font
.id
, "uDepthMode" );
11413 _uniform_model_font_uDitherCutoff
= glGetUniformLocation( _shader_model_font
.id
, "uDitherCutoff" );
11414 _uniform_particle_uPv
= glGetUniformLocation( _shader_particle
.id
, "uPv" );
11415 _uniform_particle_uPvPrev
= glGetUniformLocation( _shader_particle
.id
, "uPvPrev" );
11416 _uniform_trail_uPv
= glGetUniformLocation( _shader_trail
.id
, "uPv" );
11417 _uniform_trail_uPvPrev
= glGetUniformLocation( _shader_trail
.id
, "uPvPrev" );
11418 _uniform_trail_uColour
= glGetUniformLocation( _shader_trail
.id
, "uColour" );
11419 _uniform_blit_uInverseRatio
= glGetUniformLocation( _shader_blit
.id
, "uInverseRatio" );
11420 _uniform_blit_uTexMain
= glGetUniformLocation( _shader_blit
.id
, "uTexMain" );
11421 _uniform_blitblur_uInverseRatio
= glGetUniformLocation( _shader_blitblur
.id
, "uInverseRatio" );
11422 _uniform_blitblur_uTexMain
= glGetUniformLocation( _shader_blitblur
.id
, "uTexMain" );
11423 _uniform_blitblur_uTexMotion
= glGetUniformLocation( _shader_blitblur
.id
, "uTexMotion" );
11424 _uniform_blitblur_uBlurStrength
= glGetUniformLocation( _shader_blitblur
.id
, "uBlurStrength" );
11425 _uniform_blitblur_uOverrideDir
= glGetUniformLocation( _shader_blitblur
.id
, "uOverrideDir" );
11426 _uniform_blitblur_uTime
= glGetUniformLocation( _shader_blitblur
.id
, "uTime" );
11427 _uniform_blitblur_uGlitchStrength
= glGetUniformLocation( _shader_blitblur
.id
, "uGlitchStrength" );
11428 _uniform_blitblur_uClampUv
= glGetUniformLocation( _shader_blitblur
.id
, "uClampUv" );
11429 _uniform_blitcolour_uInverseRatio
= glGetUniformLocation( _shader_blitcolour
.id
, "uInverseRatio" );
11430 _uniform_blitcolour_uColour
= glGetUniformLocation( _shader_blitcolour
.id
, "uColour" );
11431 _uniform_blit_transition_uInverseRatio
= glGetUniformLocation( _shader_blit_transition
.id
, "uInverseRatio" );
11432 _uniform_blit_transition_uT
= glGetUniformLocation( _shader_blit_transition
.id
, "uT" );
11433 _uniform_routeui_uOffset
= glGetUniformLocation( _shader_routeui
.id
, "uOffset" );
11434 _uniform_routeui_uColour
= glGetUniformLocation( _shader_routeui
.id
, "uColour" );
11437 void vg_auto_shader_register(void)
11439 vg_shader_register( &_shader_scene_standard
);
11440 vg_shader_register( &_shader_scene_standard_alphatest
);
11441 vg_shader_register( &_shader_scene_foliage
);
11442 vg_shader_register( &_shader_scene_override
);
11443 vg_shader_register( &_shader_scene_fxglow
);
11444 vg_shader_register( &_shader_scene_vertex_blend
);
11445 vg_shader_register( &_shader_scene_terrain
);
11446 vg_shader_register( &_shader_scene_route
);
11447 vg_shader_register( &_shader_scene_depth
);
11448 vg_shader_register( &_shader_scene_position
);
11449 vg_shader_register( &_shader_scene_cubemapped
);
11450 vg_shader_register( &_shader_scene_water
);
11451 vg_shader_register( &_shader_scene_water_fast
);
11452 vg_shader_register( &_shader_scene_scoretext
);
11453 vg_shader_register( &_shader_scene_font
);
11454 vg_shader_register( &_shader_model_sky
);
11455 vg_shader_register( &_shader_model_sky_space
);
11456 vg_shader_register( &_shader_model_menu
);
11457 vg_shader_register( &_shader_model_character_view
);
11458 vg_shader_register( &_shader_model_board_view
);
11459 vg_shader_register( &_shader_model_entity
);
11460 vg_shader_register( &_shader_model_gate
);
11461 vg_shader_register( &_shader_model_gate_unlinked
);
11462 vg_shader_register( &_shader_model_font
);
11463 vg_shader_register( &_shader_particle
);
11464 vg_shader_register( &_shader_trail
);
11465 vg_shader_register( &_shader_blit
);
11466 vg_shader_register( &_shader_blitblur
);
11467 vg_shader_register( &_shader_blitcolour
);
11468 vg_shader_register( &_shader_blit_transition
);
11469 vg_shader_register( &_shader_routeui
);