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"
4511 " // TODO: Make g_water_fog a material param\n"
4512 " return t * 0.3;//g_water_fog;\n"
4517 " vec3 halfview = normalize( uCamera - aWorldCo );\n"
4518 " float depth = water_depth( aWorldCo, halfview );\n"
4519 " FragColor = vec4( depth, 0.0, 0.0, 0.0 );\n"
4524 GLuint _uniform_scene_depth_uMdl
;
4525 GLuint _uniform_scene_depth_uPv
;
4526 GLuint _uniform_scene_depth_uPvmPrev
;
4527 GLuint _uniform_scene_depth_uCamera
;
4528 GLuint _uniform_scene_depth_uBoard0
;
4529 GLuint _uniform_scene_depth_uBoard1
;
4530 GLuint _uniform_scene_depth_g_world_depth
;
4531 GLuint _uniform_scene_depth_uLightsArray
;
4532 GLuint _uniform_scene_depth_uLightsIndex
;
4533 #include "shaders/scene_position.h"
4534 struct vg_shader _shader_scene_position
= {
4535 .name
= "scene_position",
4538 .orig_file
= "shaders/scene.vs",
4540 "layout (location=0) in vec3 a_co;\n"
4541 "layout (location=1) in vec4 a_norm;\n"
4542 "layout (location=2) in vec2 a_uv;\n"
4545 "const float k_motion_lerp_amount = 0.01;\n"
4549 "out vec3 aMotionVec0;\n"
4550 "out vec3 aMotionVec1;\n"
4552 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
4554 " // This magically solves some artifacting errors!\n"
4556 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
4558 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
4559 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
4564 "uniform mat4x3 uMdl;\n"
4565 "uniform mat4 uPv;\n"
4566 "uniform mat4 uPvmPrev;\n"
4571 "out vec3 aWorldCo;\n"
4575 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
4576 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
4577 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
4579 " vs_motion_out( vproj0, vproj1 );\n"
4581 " gl_Position = vproj0;\n"
4584 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
4586 " aWorldCo = world_pos0;\n"
4591 .orig_file
= "shaders/scene_position.fs",
4593 "out vec4 FragColor;\n"
4595 "uniform vec3 uCamera;\n"
4596 "uniform vec3 uBoard0;\n"
4597 "uniform vec3 uBoard1;\n"
4601 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
4610 "in vec3 aWorldCo;\n"
4613 "layout (location = 0) out vec4 oColour;\n"
4615 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
4616 "layout (std140) uniform ub_world_lighting\n"
4618 " vec4 g_cube_min;\n"
4619 " vec4 g_cube_inv_range;\n"
4621 " vec4 g_water_plane;\n"
4622 " vec4 g_depth_bounds;\n"
4624 " vec4 g_daysky_colour;\n"
4625 " vec4 g_nightsky_colour;\n"
4626 " vec4 g_sunset_colour;\n"
4627 " vec4 g_ambient_colour;\n"
4628 " vec4 g_sunset_ambient;\n"
4629 " vec4 g_sun_colour;\n"
4630 " vec4 g_sun_dir;\n"
4631 " vec4 g_board_0;\n"
4632 " vec4 g_board_1;\n"
4634 " float g_water_fog;\n"
4636 " float g_realtime;\n"
4637 " float g_shadow_length;\n"
4638 " float g_shadow_spread;\n"
4640 " float g_time_of_day;\n"
4641 " float g_day_phase;\n"
4642 " float g_sunset_phase;\n"
4644 " int g_light_preview;\n"
4645 " int g_shadow_samples;\n"
4647 " int g_debug_indices;\n"
4648 " int g_debug_complexity;\n"
4651 "uniform sampler2D g_world_depth;\n"
4652 "uniform samplerBuffer uLightsArray;\n"
4653 "uniform usampler3D uLightsIndex;\n"
4656 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
4657 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
4658 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
4659 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
4660 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
4661 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
4663 "const float SUN_ANGLE = 0.0001;\n"
4664 "const float PI = 3.14159265358979323846264;\n"
4666 "//struct world_info\n"
4671 "// sunset_phase;\n"
4673 "// vec3 sun_dir;\n"
4676 "vec3 rand33(vec3 p3)\n"
4678 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
4679 " p3 += dot(p3, p3.yxz+33.33);\n"
4680 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
4683 "float stars( vec3 rd, float rr, float size ){\n"
4684 " vec3 co = rd * rr;\n"
4686 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
4688 " float spaces = 1.0 / rr;\n"
4689 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
4690 " a -= mod(a, spaces) - spaces * 0.5;\n"
4692 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
4694 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
4695 " plane = plane - mod(plane, PI / count);\n"
4697 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
4699 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
4700 " float ydist = sqrt(rr * rr - level * level);\n"
4701 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
4702 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
4703 " float star = smoothstep(size, 0.0, distance(center, co));\n"
4707 "float luminance( vec3 v )\n"
4709 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
4712 "vec3 clearskies_ambient( vec3 dir )\n"
4714 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
4715 " float sky_gradient = dir.y;\n"
4717 " /* Blend phase colours */\n"
4718 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
4719 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
4720 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
4722 " /* Add gradient */\n"
4723 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
4725 " return ambient;\n"
4728 "vec3 clearskies_sky( vec3 ray_dir )\n"
4730 " ray_dir.y = abs( ray_dir.y );\n"
4731 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
4734 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
4735 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
4736 " float sun_shape = pow( sun_size, 2000.0 );\n"
4737 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
4739 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
4740 " sun_colour *= sun_shape;\n"
4743 " float star = 0.0;\n"
4744 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
4746 " if( star_blend > 0.001 ){\n"
4747 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
4748 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
4749 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
4753 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
4754 " return composite;\n"
4757 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
4759 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
4761 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
4762 " g_sunset_phase );\n"
4764 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
4765 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
4766 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
4767 " ) * g_sun_colour.rgb * g_day_phase;\n"
4769 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
4770 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
4771 " g_sunset_phase );\n"
4773 " return ambient + (light_sun + sky_reflection) * shadow;\n"
4778 "float world_depth_sample( vec3 pos )\n"
4780 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
4781 " return texture( g_world_depth, depth_coord ).r;\n"
4784 "float world_water_depth( vec3 pos )\n"
4786 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
4787 " return world_depth_sample( pos ) - ref_depth;\n"
4790 "float shadow_sample( vec3 co ){\n"
4791 " float height_sample = world_depth_sample( co );\n"
4793 " float fdelta = height_sample - co.y;\n"
4794 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
4797 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
4798 " if( g_shadow_samples == 0 ){\n"
4802 " float fspread = g_shadow_spread;\n"
4803 " float flength = g_shadow_length;\n"
4805 " float famt = 0.0;\n"
4806 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
4807 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
4808 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
4809 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
4811 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
4812 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
4813 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
4814 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
4816 " return 1.0 - famt;\n"
4819 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
4821 " vec3 specdir = reflect( -dir, wnormal );\n"
4822 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
4825 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
4826 " float dist = pow(fdist*0.0010,0.78);\n"
4827 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
4830 "vec3 scene_calculate_light( int light_index, \n"
4831 " vec3 halfview, vec3 co, vec3 normal )\n"
4833 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
4834 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
4835 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
4837 " vec3 light_delta = light_co.xyz-co;\n"
4838 " float dist2 = dot(light_delta,light_delta);\n"
4840 " light_delta = normalize( light_delta );\n"
4842 " float quadratic = dist2*100.0;\n"
4843 " float attenuation = 1.0/( 1.0 + quadratic );\n"
4844 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
4846 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
4848 " if( light_dir.w < 0.999999 ){\n"
4849 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
4850 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
4853 " return light_colour.rgb * attenuation * falloff \n"
4854 " * step( g_day_phase, light_colour.w );\n"
4857 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
4858 " vec3 halfview, vec3 co, vec3 normal )\n"
4860 " uint light_count = packed_index & 0x3u;\n"
4862 " vec3 l = vec3(0.0);\n"
4864 " if( light_count >= 1u ){\n"
4865 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
4866 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
4867 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
4869 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
4871 " if( light_count >= 2u ){\n"
4872 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
4874 " if( light_count >= 3u ){\n"
4875 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
4883 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
4884 " float light_mask )\n"
4886 " if( g_light_preview == 1 )\n"
4887 " diffuse = vec3(0.75);\n"
4890 " vec3 halfview = uCamera - co;\n"
4891 " float fdist = length(halfview);\n"
4892 " halfview /= fdist;\n"
4894 " float world_shadow = newlight_compute_sun_shadow( \n"
4895 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
4897 " vec3 total_light = clearskies_lighting( \n"
4898 " normal, min( light_mask, world_shadow ), halfview );\n"
4900 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
4901 " cube_coord = floor( cube_coord );\n"
4903 " if( g_debug_indices == 1 )\n"
4905 " return rand33(cube_coord);\n"
4908 " if( g_debug_complexity == 1 )\n"
4910 " ivec3 coord = ivec3( cube_coord );\n"
4911 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
4913 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
4914 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
4917 " // FIXME: this coord should absolutely must be clamped!\n"
4919 " ivec3 coord = ivec3( cube_coord );\n"
4920 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
4922 " total_light += \n"
4923 " scene_calculate_packed_light_patch( index_sample.x,\n"
4924 " halfview, co, normal ) \n"
4926 " total_light += \n"
4927 " scene_calculate_packed_light_patch( index_sample.y,\n"
4928 " halfview, co, normal )\n"
4931 " // Take a section of the sky function to give us a matching fog colour\n"
4933 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
4934 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
4935 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
4936 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
4938 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
4939 " sun_colour *= sun_shape;\n"
4941 " fog_colour += sun_colour;\n"
4942 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
4947 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
4949 " vec3 pa = p - a;\n"
4950 " vec3 ba = b - a;\n"
4952 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
4953 " return length( pa - ba*h );\n"
4956 "float compute_board_shadow()\n"
4958 " // player shadow\n"
4959 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
4960 " g_board_1.xyz )-0.1 );\n"
4961 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
4962 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
4964 " return 1.0 - player_shadow*0.8;\n"
4967 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
4969 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
4976 " float height_full = aWorldCo.y;\n"
4977 " float height_water = height_full;\n"
4979 " if( height_water > (g_water_plane.y * g_water_plane.w) + 2.0 )\n"
4980 " height_water = -99999.9;\n"
4982 " FragColor = vec4( height_full, height_water, 0.0, 0.0 );\n"
4987 GLuint _uniform_scene_position_uMdl
;
4988 GLuint _uniform_scene_position_uPv
;
4989 GLuint _uniform_scene_position_uPvmPrev
;
4990 GLuint _uniform_scene_position_uCamera
;
4991 GLuint _uniform_scene_position_uBoard0
;
4992 GLuint _uniform_scene_position_uBoard1
;
4993 GLuint _uniform_scene_position_g_world_depth
;
4994 GLuint _uniform_scene_position_uLightsArray
;
4995 GLuint _uniform_scene_position_uLightsIndex
;
4996 #include "shaders/scene_cubemapped.h"
4997 struct vg_shader _shader_scene_cubemapped
= {
4998 .name
= "scene_cubemapped",
5001 .orig_file
= "shaders/scene.vs",
5003 "layout (location=0) in vec3 a_co;\n"
5004 "layout (location=1) in vec4 a_norm;\n"
5005 "layout (location=2) in vec2 a_uv;\n"
5008 "const float k_motion_lerp_amount = 0.01;\n"
5012 "out vec3 aMotionVec0;\n"
5013 "out vec3 aMotionVec1;\n"
5015 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
5017 " // This magically solves some artifacting errors!\n"
5019 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
5021 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
5022 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
5027 "uniform mat4x3 uMdl;\n"
5028 "uniform mat4 uPv;\n"
5029 "uniform mat4 uPvmPrev;\n"
5034 "out vec3 aWorldCo;\n"
5038 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
5039 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
5040 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
5042 " vs_motion_out( vproj0, vproj1 );\n"
5044 " gl_Position = vproj0;\n"
5047 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
5049 " aWorldCo = world_pos0;\n"
5054 .orig_file
= "shaders/scene_cubemapped.fs",
5056 "uniform sampler2D uTexGarbage;\n"
5057 "uniform sampler2D uTexMain;\n"
5058 "uniform samplerCube uTexCubemap;\n"
5059 "uniform vec3 uCamera;\n"
5060 "uniform vec4 uPlane;\n"
5061 "uniform vec4 uColour;\n"
5065 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
5074 "in vec3 aWorldCo;\n"
5077 "layout (location = 0) out vec4 oColour;\n"
5079 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
5080 "layout (std140) uniform ub_world_lighting\n"
5082 " vec4 g_cube_min;\n"
5083 " vec4 g_cube_inv_range;\n"
5085 " vec4 g_water_plane;\n"
5086 " vec4 g_depth_bounds;\n"
5088 " vec4 g_daysky_colour;\n"
5089 " vec4 g_nightsky_colour;\n"
5090 " vec4 g_sunset_colour;\n"
5091 " vec4 g_ambient_colour;\n"
5092 " vec4 g_sunset_ambient;\n"
5093 " vec4 g_sun_colour;\n"
5094 " vec4 g_sun_dir;\n"
5095 " vec4 g_board_0;\n"
5096 " vec4 g_board_1;\n"
5098 " float g_water_fog;\n"
5100 " float g_realtime;\n"
5101 " float g_shadow_length;\n"
5102 " float g_shadow_spread;\n"
5104 " float g_time_of_day;\n"
5105 " float g_day_phase;\n"
5106 " float g_sunset_phase;\n"
5108 " int g_light_preview;\n"
5109 " int g_shadow_samples;\n"
5111 " int g_debug_indices;\n"
5112 " int g_debug_complexity;\n"
5115 "uniform sampler2D g_world_depth;\n"
5116 "uniform samplerBuffer uLightsArray;\n"
5117 "uniform usampler3D uLightsIndex;\n"
5120 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
5121 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
5122 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
5123 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
5124 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
5125 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
5127 "const float SUN_ANGLE = 0.0001;\n"
5128 "const float PI = 3.14159265358979323846264;\n"
5130 "//struct world_info\n"
5135 "// sunset_phase;\n"
5137 "// vec3 sun_dir;\n"
5140 "vec3 rand33(vec3 p3)\n"
5142 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
5143 " p3 += dot(p3, p3.yxz+33.33);\n"
5144 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
5147 "float stars( vec3 rd, float rr, float size ){\n"
5148 " vec3 co = rd * rr;\n"
5150 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
5152 " float spaces = 1.0 / rr;\n"
5153 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
5154 " a -= mod(a, spaces) - spaces * 0.5;\n"
5156 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
5158 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
5159 " plane = plane - mod(plane, PI / count);\n"
5161 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
5163 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
5164 " float ydist = sqrt(rr * rr - level * level);\n"
5165 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
5166 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
5167 " float star = smoothstep(size, 0.0, distance(center, co));\n"
5171 "float luminance( vec3 v )\n"
5173 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
5176 "vec3 clearskies_ambient( vec3 dir )\n"
5178 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
5179 " float sky_gradient = dir.y;\n"
5181 " /* Blend phase colours */\n"
5182 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
5183 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
5184 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
5186 " /* Add gradient */\n"
5187 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
5189 " return ambient;\n"
5192 "vec3 clearskies_sky( vec3 ray_dir )\n"
5194 " ray_dir.y = abs( ray_dir.y );\n"
5195 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
5198 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
5199 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
5200 " float sun_shape = pow( sun_size, 2000.0 );\n"
5201 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
5203 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
5204 " sun_colour *= sun_shape;\n"
5207 " float star = 0.0;\n"
5208 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
5210 " if( star_blend > 0.001 ){\n"
5211 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
5212 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
5213 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
5217 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
5218 " return composite;\n"
5221 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
5223 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
5225 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
5226 " g_sunset_phase );\n"
5228 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
5229 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
5230 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
5231 " ) * g_sun_colour.rgb * g_day_phase;\n"
5233 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
5234 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
5235 " g_sunset_phase );\n"
5237 " return ambient + (light_sun + sky_reflection) * shadow;\n"
5242 "float world_depth_sample( vec3 pos )\n"
5244 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
5245 " return texture( g_world_depth, depth_coord ).r;\n"
5248 "float world_water_depth( vec3 pos )\n"
5250 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
5251 " return world_depth_sample( pos ) - ref_depth;\n"
5254 "float shadow_sample( vec3 co ){\n"
5255 " float height_sample = world_depth_sample( co );\n"
5257 " float fdelta = height_sample - co.y;\n"
5258 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
5261 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
5262 " if( g_shadow_samples == 0 ){\n"
5266 " float fspread = g_shadow_spread;\n"
5267 " float flength = g_shadow_length;\n"
5269 " float famt = 0.0;\n"
5270 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
5271 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
5272 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
5273 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
5275 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
5276 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
5277 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
5278 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
5280 " return 1.0 - famt;\n"
5283 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
5285 " vec3 specdir = reflect( -dir, wnormal );\n"
5286 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
5289 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
5290 " float dist = pow(fdist*0.0010,0.78);\n"
5291 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
5294 "vec3 scene_calculate_light( int light_index, \n"
5295 " vec3 halfview, vec3 co, vec3 normal )\n"
5297 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
5298 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
5299 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
5301 " vec3 light_delta = light_co.xyz-co;\n"
5302 " float dist2 = dot(light_delta,light_delta);\n"
5304 " light_delta = normalize( light_delta );\n"
5306 " float quadratic = dist2*100.0;\n"
5307 " float attenuation = 1.0/( 1.0 + quadratic );\n"
5308 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
5310 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
5312 " if( light_dir.w < 0.999999 ){\n"
5313 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
5314 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
5317 " return light_colour.rgb * attenuation * falloff \n"
5318 " * step( g_day_phase, light_colour.w );\n"
5321 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
5322 " vec3 halfview, vec3 co, vec3 normal )\n"
5324 " uint light_count = packed_index & 0x3u;\n"
5326 " vec3 l = vec3(0.0);\n"
5328 " if( light_count >= 1u ){\n"
5329 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
5330 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
5331 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
5333 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
5335 " if( light_count >= 2u ){\n"
5336 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
5338 " if( light_count >= 3u ){\n"
5339 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
5347 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
5348 " float light_mask )\n"
5350 " if( g_light_preview == 1 )\n"
5351 " diffuse = vec3(0.75);\n"
5354 " vec3 halfview = uCamera - co;\n"
5355 " float fdist = length(halfview);\n"
5356 " halfview /= fdist;\n"
5358 " float world_shadow = newlight_compute_sun_shadow( \n"
5359 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
5361 " vec3 total_light = clearskies_lighting( \n"
5362 " normal, min( light_mask, world_shadow ), halfview );\n"
5364 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
5365 " cube_coord = floor( cube_coord );\n"
5367 " if( g_debug_indices == 1 )\n"
5369 " return rand33(cube_coord);\n"
5372 " if( g_debug_complexity == 1 )\n"
5374 " ivec3 coord = ivec3( cube_coord );\n"
5375 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
5377 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
5378 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
5381 " // FIXME: this coord should absolutely must be clamped!\n"
5383 " ivec3 coord = ivec3( cube_coord );\n"
5384 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
5386 " total_light += \n"
5387 " scene_calculate_packed_light_patch( index_sample.x,\n"
5388 " halfview, co, normal ) \n"
5390 " total_light += \n"
5391 " scene_calculate_packed_light_patch( index_sample.y,\n"
5392 " halfview, co, normal )\n"
5395 " // Take a section of the sky function to give us a matching fog colour\n"
5397 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
5398 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
5399 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
5400 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
5402 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
5403 " sun_colour *= sun_shape;\n"
5405 " fog_colour += sun_colour;\n"
5406 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
5411 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
5413 " vec3 pa = p - a;\n"
5414 " vec3 ba = b - a;\n"
5416 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
5417 " return length( pa - ba*h );\n"
5420 "float compute_board_shadow()\n"
5422 " // player shadow\n"
5423 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
5424 " g_board_1.xyz )-0.1 );\n"
5425 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
5426 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
5428 " return 1.0 - player_shadow*0.8;\n"
5431 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
5433 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
5438 "const float k_motion_lerp_amount = 0.01;\n"
5442 "layout (location = 1) out vec2 oMotionVec;\n"
5444 "in vec3 aMotionVec0;\n"
5445 "in vec3 aMotionVec1;\n"
5447 "void compute_motion_vectors()\n"
5449 " // Write motion vectors\n"
5450 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
5451 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
5453 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
5460 " compute_motion_vectors();\n"
5462 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
5463 " vec4 vsamplemain = texture( uTexMain, aUv );\n"
5464 " vec4 wgarbage = texture( uTexGarbage, aCo.xz * 0.0015 + aCo.yx*0.002 );\n"
5465 " vec3 qnorm = aNorm.xyz;\n"
5466 " vfrag = vsamplemain.rgb;\n"
5468 " if( g_light_preview == 1 ){\n"
5469 " vfrag = vec3(0.5);\n"
5472 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
5473 " oColour = vec4( vfrag, 1.0 );\n"
5475 " vec3 halfdir = normalize( aWorldCo - uCamera );\n"
5476 " vec3 reflectdir = reflect( halfdir, qnorm );\n"
5477 " oColour = mix( oColour, \n"
5478 " vec4(texture(uTexCubemap,reflectdir).rgb * uColour.rgb, 1.0),\n"
5479 " uColour.a*wgarbage.b );\n"
5484 GLuint _uniform_scene_cubemapped_uMdl
;
5485 GLuint _uniform_scene_cubemapped_uPv
;
5486 GLuint _uniform_scene_cubemapped_uPvmPrev
;
5487 GLuint _uniform_scene_cubemapped_uTexGarbage
;
5488 GLuint _uniform_scene_cubemapped_uTexMain
;
5489 GLuint _uniform_scene_cubemapped_uTexCubemap
;
5490 GLuint _uniform_scene_cubemapped_uCamera
;
5491 GLuint _uniform_scene_cubemapped_uPlane
;
5492 GLuint _uniform_scene_cubemapped_uColour
;
5493 GLuint _uniform_scene_cubemapped_g_world_depth
;
5494 GLuint _uniform_scene_cubemapped_uLightsArray
;
5495 GLuint _uniform_scene_cubemapped_uLightsIndex
;
5496 #include "shaders/scene_water.h"
5497 struct vg_shader _shader_scene_water
= {
5498 .name
= "scene_water",
5501 .orig_file
= "shaders/scene.vs",
5503 "layout (location=0) in vec3 a_co;\n"
5504 "layout (location=1) in vec4 a_norm;\n"
5505 "layout (location=2) in vec2 a_uv;\n"
5508 "const float k_motion_lerp_amount = 0.01;\n"
5512 "out vec3 aMotionVec0;\n"
5513 "out vec3 aMotionVec1;\n"
5515 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
5517 " // This magically solves some artifacting errors!\n"
5519 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
5521 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
5522 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
5527 "uniform mat4x3 uMdl;\n"
5528 "uniform mat4 uPv;\n"
5529 "uniform mat4 uPvmPrev;\n"
5534 "out vec3 aWorldCo;\n"
5538 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
5539 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
5540 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
5542 " vs_motion_out( vproj0, vproj1 );\n"
5544 " gl_Position = vproj0;\n"
5547 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
5549 " aWorldCo = world_pos0;\n"
5554 .orig_file
= "shaders/scene_water.fs",
5556 "uniform sampler2D uTexMain;\n"
5557 "uniform sampler2D uTexDudv;\n"
5558 "uniform sampler2D uTexBack;\n"
5560 "uniform vec2 uInvRes;\n"
5561 "uniform float uTime;\n"
5562 "uniform vec3 uCamera;\n"
5563 "uniform float uSurfaceY;\n"
5564 "uniform vec3 uBoard0;\n"
5565 "uniform vec3 uBoard1;\n"
5567 "uniform vec3 uShoreColour;\n"
5568 "uniform vec3 uOceanColour;\n"
5569 "uniform float uFresnel;\n"
5570 "uniform float uWaterScale;\n"
5571 "uniform vec4 uWaveSpeed;\n"
5575 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
5584 "in vec3 aWorldCo;\n"
5587 "layout (location = 0) out vec4 oColour;\n"
5589 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
5590 "layout (std140) uniform ub_world_lighting\n"
5592 " vec4 g_cube_min;\n"
5593 " vec4 g_cube_inv_range;\n"
5595 " vec4 g_water_plane;\n"
5596 " vec4 g_depth_bounds;\n"
5598 " vec4 g_daysky_colour;\n"
5599 " vec4 g_nightsky_colour;\n"
5600 " vec4 g_sunset_colour;\n"
5601 " vec4 g_ambient_colour;\n"
5602 " vec4 g_sunset_ambient;\n"
5603 " vec4 g_sun_colour;\n"
5604 " vec4 g_sun_dir;\n"
5605 " vec4 g_board_0;\n"
5606 " vec4 g_board_1;\n"
5608 " float g_water_fog;\n"
5610 " float g_realtime;\n"
5611 " float g_shadow_length;\n"
5612 " float g_shadow_spread;\n"
5614 " float g_time_of_day;\n"
5615 " float g_day_phase;\n"
5616 " float g_sunset_phase;\n"
5618 " int g_light_preview;\n"
5619 " int g_shadow_samples;\n"
5621 " int g_debug_indices;\n"
5622 " int g_debug_complexity;\n"
5625 "uniform sampler2D g_world_depth;\n"
5626 "uniform samplerBuffer uLightsArray;\n"
5627 "uniform usampler3D uLightsIndex;\n"
5630 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
5631 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
5632 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
5633 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
5634 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
5635 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
5637 "const float SUN_ANGLE = 0.0001;\n"
5638 "const float PI = 3.14159265358979323846264;\n"
5640 "//struct world_info\n"
5645 "// sunset_phase;\n"
5647 "// vec3 sun_dir;\n"
5650 "vec3 rand33(vec3 p3)\n"
5652 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
5653 " p3 += dot(p3, p3.yxz+33.33);\n"
5654 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
5657 "float stars( vec3 rd, float rr, float size ){\n"
5658 " vec3 co = rd * rr;\n"
5660 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
5662 " float spaces = 1.0 / rr;\n"
5663 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
5664 " a -= mod(a, spaces) - spaces * 0.5;\n"
5666 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
5668 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
5669 " plane = plane - mod(plane, PI / count);\n"
5671 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
5673 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
5674 " float ydist = sqrt(rr * rr - level * level);\n"
5675 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
5676 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
5677 " float star = smoothstep(size, 0.0, distance(center, co));\n"
5681 "float luminance( vec3 v )\n"
5683 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
5686 "vec3 clearskies_ambient( vec3 dir )\n"
5688 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
5689 " float sky_gradient = dir.y;\n"
5691 " /* Blend phase colours */\n"
5692 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
5693 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
5694 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
5696 " /* Add gradient */\n"
5697 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
5699 " return ambient;\n"
5702 "vec3 clearskies_sky( vec3 ray_dir )\n"
5704 " ray_dir.y = abs( ray_dir.y );\n"
5705 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
5708 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
5709 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
5710 " float sun_shape = pow( sun_size, 2000.0 );\n"
5711 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
5713 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
5714 " sun_colour *= sun_shape;\n"
5717 " float star = 0.0;\n"
5718 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
5720 " if( star_blend > 0.001 ){\n"
5721 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
5722 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
5723 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
5727 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
5728 " return composite;\n"
5731 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
5733 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
5735 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
5736 " g_sunset_phase );\n"
5738 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
5739 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
5740 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
5741 " ) * g_sun_colour.rgb * g_day_phase;\n"
5743 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
5744 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
5745 " g_sunset_phase );\n"
5747 " return ambient + (light_sun + sky_reflection) * shadow;\n"
5752 "float world_depth_sample( vec3 pos )\n"
5754 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
5755 " return texture( g_world_depth, depth_coord ).r;\n"
5758 "float world_water_depth( vec3 pos )\n"
5760 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
5761 " return world_depth_sample( pos ) - ref_depth;\n"
5764 "float shadow_sample( vec3 co ){\n"
5765 " float height_sample = world_depth_sample( co );\n"
5767 " float fdelta = height_sample - co.y;\n"
5768 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
5771 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
5772 " if( g_shadow_samples == 0 ){\n"
5776 " float fspread = g_shadow_spread;\n"
5777 " float flength = g_shadow_length;\n"
5779 " float famt = 0.0;\n"
5780 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
5781 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
5782 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
5783 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
5785 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
5786 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
5787 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
5788 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
5790 " return 1.0 - famt;\n"
5793 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
5795 " vec3 specdir = reflect( -dir, wnormal );\n"
5796 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
5799 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
5800 " float dist = pow(fdist*0.0010,0.78);\n"
5801 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
5804 "vec3 scene_calculate_light( int light_index, \n"
5805 " vec3 halfview, vec3 co, vec3 normal )\n"
5807 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
5808 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
5809 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
5811 " vec3 light_delta = light_co.xyz-co;\n"
5812 " float dist2 = dot(light_delta,light_delta);\n"
5814 " light_delta = normalize( light_delta );\n"
5816 " float quadratic = dist2*100.0;\n"
5817 " float attenuation = 1.0/( 1.0 + quadratic );\n"
5818 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
5820 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
5822 " if( light_dir.w < 0.999999 ){\n"
5823 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
5824 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
5827 " return light_colour.rgb * attenuation * falloff \n"
5828 " * step( g_day_phase, light_colour.w );\n"
5831 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
5832 " vec3 halfview, vec3 co, vec3 normal )\n"
5834 " uint light_count = packed_index & 0x3u;\n"
5836 " vec3 l = vec3(0.0);\n"
5838 " if( light_count >= 1u ){\n"
5839 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
5840 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
5841 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
5843 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
5845 " if( light_count >= 2u ){\n"
5846 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
5848 " if( light_count >= 3u ){\n"
5849 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
5857 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
5858 " float light_mask )\n"
5860 " if( g_light_preview == 1 )\n"
5861 " diffuse = vec3(0.75);\n"
5864 " vec3 halfview = uCamera - co;\n"
5865 " float fdist = length(halfview);\n"
5866 " halfview /= fdist;\n"
5868 " float world_shadow = newlight_compute_sun_shadow( \n"
5869 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
5871 " vec3 total_light = clearskies_lighting( \n"
5872 " normal, min( light_mask, world_shadow ), halfview );\n"
5874 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
5875 " cube_coord = floor( cube_coord );\n"
5877 " if( g_debug_indices == 1 )\n"
5879 " return rand33(cube_coord);\n"
5882 " if( g_debug_complexity == 1 )\n"
5884 " ivec3 coord = ivec3( cube_coord );\n"
5885 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
5887 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
5888 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
5891 " // FIXME: this coord should absolutely must be clamped!\n"
5893 " ivec3 coord = ivec3( cube_coord );\n"
5894 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
5896 " total_light += \n"
5897 " scene_calculate_packed_light_patch( index_sample.x,\n"
5898 " halfview, co, normal ) \n"
5900 " total_light += \n"
5901 " scene_calculate_packed_light_patch( index_sample.y,\n"
5902 " halfview, co, normal )\n"
5905 " // Take a section of the sky function to give us a matching fog colour\n"
5907 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
5908 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
5909 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
5910 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
5912 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
5913 " sun_colour *= sun_shape;\n"
5915 " fog_colour += sun_colour;\n"
5916 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
5921 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
5923 " vec3 pa = p - a;\n"
5924 " vec3 ba = b - a;\n"
5926 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
5927 " return length( pa - ba*h );\n"
5930 "float compute_board_shadow()\n"
5932 " // player shadow\n"
5933 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
5934 " g_board_1.xyz )-0.1 );\n"
5935 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
5936 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
5938 " return 1.0 - player_shadow*0.8;\n"
5941 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
5943 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
5948 "const float k_motion_lerp_amount = 0.01;\n"
5952 "layout (location = 1) out vec2 oMotionVec;\n"
5954 "in vec3 aMotionVec0;\n"
5955 "in vec3 aMotionVec1;\n"
5957 "void compute_motion_vectors()\n"
5959 " // Write motion vectors\n"
5960 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
5961 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
5963 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
5968 "// Pasted from common_world.glsl\n"
5969 "vec3 water_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
5971 " float light_mask = compute_board_shadow();\n"
5973 " if( g_light_preview == 1 )\n"
5974 " diffuse = vec3(0.75);\n"
5977 " vec3 halfview = uCamera - co;\n"
5978 " float fdist = length(halfview);\n"
5979 " halfview /= fdist;\n"
5981 " float world_shadow = newlight_compute_sun_shadow( \n"
5982 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
5984 " vec3 total_light = clearskies_lighting( \n"
5985 " normal, min( light_mask, world_shadow ), halfview );\n"
5987 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
5988 " cube_coord = floor( cube_coord );\n"
5990 " if( g_debug_indices == 1 )\n"
5992 " return rand33(cube_coord);\n"
5995 " if( g_debug_complexity == 1 )\n"
5997 " ivec3 coord = ivec3( cube_coord );\n"
5998 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
6000 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
6001 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
6004 " // FIXME: this coord should absolutely must be clamped!\n"
6006 " ivec3 coord = ivec3( cube_coord );\n"
6007 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
6009 " total_light += \n"
6010 " scene_calculate_packed_light_patch( index_sample.x,\n"
6011 " halfview, co, normal ) \n"
6013 " total_light += \n"
6014 " scene_calculate_packed_light_patch( index_sample.y,\n"
6015 " halfview, co, normal )\n"
6018 " return diffuse * total_light;\n"
6021 "vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue, \n"
6022 " vec4 beneath, vec4 above, vec4 dudva )\n"
6024 " vec3 surface_tint = mix(uShoreColour, uOceanColour, depthvalue);\n"
6026 " float ffresnel = pow(1.0-dot( vnorm, halfview ),uFresnel);\n"
6028 " vec3 lightdir = vec3(0.95,0.0,-0.3);\n"
6029 " vec3 specdir = reflect( -lightdir, vnorm );\n"
6030 " float spec = pow(max(dot(halfview,specdir),0.0),20.0)*0.3;\n"
6033 " float depthblend = pow( beneath.r, 0.8 );\n"
6036 " float fband = fract( aCo.z*0.02+uTime*0.1+depthvalue*10.0 );\n"
6037 " fband = step( fband+dudva.a*0.8, 0.3 ) * max((1.0-depthvalue*4.0),0.0);\n"
6039 " vec4 surf = mix( vec4(surface_tint,depthblend), \n"
6040 " vec4(1.0,1.0,1.0,0.5), fband );\n"
6041 " surf.rgb = water_compute_lighting( surf.rgb, aNorm.xyz, aWorldCo );\n"
6042 " surf.rgb = mix(surf.rgb, above.rgb, ffresnel );\n"
6044 " // Take a section of the sky function to give us a matching fog colour\n"
6045 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
6046 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
6047 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
6048 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
6050 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
6051 " sun_colour *= sun_shape;\n"
6053 " fog_colour += sun_colour;\n"
6054 " surf.rgb = scene_apply_fog( surf.rgb, fog_colour, \n"
6055 " distance(uCamera, aWorldCo) );\n"
6062 " compute_motion_vectors();\n"
6064 " // Create texture coords\n"
6065 " vec2 ssuv = gl_FragCoord.xy*uInvRes;\n"
6067 " // Surface colour composite\n"
6068 " float depthvalue = clamp( -world_water_depth(aCo)*(1.0/25.0), 0.0,1.0 );\n"
6070 " vec2 world_coord = aCo.xz * uWaterScale;\n"
6071 " //TODO: Material param ( 0.008, 0.006, 0.003, 0.03 );\n"
6072 " vec4 time_offsets = vec4( uTime ) * vec4( 0.08, -0.08, -0.03, -0.01 );\n"
6073 " vec4 dudva = texture( uTexDudv, world_coord + time_offsets.xy )-0.5;\n"
6074 " vec4 dudvb = texture( uTexDudv, world_coord *7.0 - time_offsets.zw )-0.5;\n"
6076 " vec3 surfnorm = dudva.rgb + dudvb.rgb;\n"
6077 " surfnorm = normalize(vec3(0.0,1.0,0.0) + dudva.xyz*0.4 + dudvb.xyz*0.1);\n"
6080 " vec3 halfview = -normalize( aCo-uCamera );\n"
6082 " // Sample textures\n"
6083 " vec4 above = texture( uTexMain, ssuv+ surfnorm.xz*0.2 );\n"
6084 " vec4 beneath = texture( uTexBack, ssuv );\n"
6087 " float fdist = pow(length( aCo.xz-uCamera.xz ) * 0.00047, 2.6);\n"
6090 " vec4 vsurface = water_surf( halfview, surfnorm, depthvalue, beneath, above, dudva );\n"
6091 " vsurface.a -= fdist;\n"
6093 " oColour = vsurface;\n"
6098 GLuint _uniform_scene_water_uMdl
;
6099 GLuint _uniform_scene_water_uPv
;
6100 GLuint _uniform_scene_water_uPvmPrev
;
6101 GLuint _uniform_scene_water_uTexMain
;
6102 GLuint _uniform_scene_water_uTexDudv
;
6103 GLuint _uniform_scene_water_uTexBack
;
6104 GLuint _uniform_scene_water_uInvRes
;
6105 GLuint _uniform_scene_water_uTime
;
6106 GLuint _uniform_scene_water_uCamera
;
6107 GLuint _uniform_scene_water_uSurfaceY
;
6108 GLuint _uniform_scene_water_uBoard0
;
6109 GLuint _uniform_scene_water_uBoard1
;
6110 GLuint _uniform_scene_water_uShoreColour
;
6111 GLuint _uniform_scene_water_uOceanColour
;
6112 GLuint _uniform_scene_water_uFresnel
;
6113 GLuint _uniform_scene_water_uWaterScale
;
6114 GLuint _uniform_scene_water_uWaveSpeed
;
6115 GLuint _uniform_scene_water_g_world_depth
;
6116 GLuint _uniform_scene_water_uLightsArray
;
6117 GLuint _uniform_scene_water_uLightsIndex
;
6118 #include "shaders/scene_water_fast.h"
6119 struct vg_shader _shader_scene_water_fast
= {
6120 .name
= "scene_water_fast",
6123 .orig_file
= "shaders/scene.vs",
6125 "layout (location=0) in vec3 a_co;\n"
6126 "layout (location=1) in vec4 a_norm;\n"
6127 "layout (location=2) in vec2 a_uv;\n"
6130 "const float k_motion_lerp_amount = 0.01;\n"
6134 "out vec3 aMotionVec0;\n"
6135 "out vec3 aMotionVec1;\n"
6137 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
6139 " // This magically solves some artifacting errors!\n"
6141 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
6143 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
6144 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
6149 "uniform mat4x3 uMdl;\n"
6150 "uniform mat4 uPv;\n"
6151 "uniform mat4 uPvmPrev;\n"
6156 "out vec3 aWorldCo;\n"
6160 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
6161 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
6162 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
6164 " vs_motion_out( vproj0, vproj1 );\n"
6166 " gl_Position = vproj0;\n"
6169 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
6171 " aWorldCo = world_pos0;\n"
6176 .orig_file
= "shaders/scene_water_fast.fs",
6178 "uniform sampler2D uTexDudv;\n"
6180 "uniform float uTime;\n"
6181 "uniform vec3 uCamera;\n"
6182 "uniform float uSurfaceY;\n"
6183 "uniform vec3 uBoard0;\n"
6184 "uniform vec3 uBoard1;\n"
6186 "uniform vec3 uShoreColour;\n"
6187 "uniform vec3 uOceanColour;\n"
6191 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
6200 "in vec3 aWorldCo;\n"
6203 "layout (location = 0) out vec4 oColour;\n"
6205 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
6206 "layout (std140) uniform ub_world_lighting\n"
6208 " vec4 g_cube_min;\n"
6209 " vec4 g_cube_inv_range;\n"
6211 " vec4 g_water_plane;\n"
6212 " vec4 g_depth_bounds;\n"
6214 " vec4 g_daysky_colour;\n"
6215 " vec4 g_nightsky_colour;\n"
6216 " vec4 g_sunset_colour;\n"
6217 " vec4 g_ambient_colour;\n"
6218 " vec4 g_sunset_ambient;\n"
6219 " vec4 g_sun_colour;\n"
6220 " vec4 g_sun_dir;\n"
6221 " vec4 g_board_0;\n"
6222 " vec4 g_board_1;\n"
6224 " float g_water_fog;\n"
6226 " float g_realtime;\n"
6227 " float g_shadow_length;\n"
6228 " float g_shadow_spread;\n"
6230 " float g_time_of_day;\n"
6231 " float g_day_phase;\n"
6232 " float g_sunset_phase;\n"
6234 " int g_light_preview;\n"
6235 " int g_shadow_samples;\n"
6237 " int g_debug_indices;\n"
6238 " int g_debug_complexity;\n"
6241 "uniform sampler2D g_world_depth;\n"
6242 "uniform samplerBuffer uLightsArray;\n"
6243 "uniform usampler3D uLightsIndex;\n"
6246 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
6247 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
6248 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
6249 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
6250 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
6251 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
6253 "const float SUN_ANGLE = 0.0001;\n"
6254 "const float PI = 3.14159265358979323846264;\n"
6256 "//struct world_info\n"
6261 "// sunset_phase;\n"
6263 "// vec3 sun_dir;\n"
6266 "vec3 rand33(vec3 p3)\n"
6268 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
6269 " p3 += dot(p3, p3.yxz+33.33);\n"
6270 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
6273 "float stars( vec3 rd, float rr, float size ){\n"
6274 " vec3 co = rd * rr;\n"
6276 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
6278 " float spaces = 1.0 / rr;\n"
6279 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
6280 " a -= mod(a, spaces) - spaces * 0.5;\n"
6282 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
6284 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
6285 " plane = plane - mod(plane, PI / count);\n"
6287 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
6289 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
6290 " float ydist = sqrt(rr * rr - level * level);\n"
6291 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
6292 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
6293 " float star = smoothstep(size, 0.0, distance(center, co));\n"
6297 "float luminance( vec3 v )\n"
6299 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
6302 "vec3 clearskies_ambient( vec3 dir )\n"
6304 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
6305 " float sky_gradient = dir.y;\n"
6307 " /* Blend phase colours */\n"
6308 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
6309 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
6310 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
6312 " /* Add gradient */\n"
6313 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
6315 " return ambient;\n"
6318 "vec3 clearskies_sky( vec3 ray_dir )\n"
6320 " ray_dir.y = abs( ray_dir.y );\n"
6321 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
6324 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
6325 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
6326 " float sun_shape = pow( sun_size, 2000.0 );\n"
6327 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
6329 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
6330 " sun_colour *= sun_shape;\n"
6333 " float star = 0.0;\n"
6334 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
6336 " if( star_blend > 0.001 ){\n"
6337 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
6338 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
6339 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
6343 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
6344 " return composite;\n"
6347 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
6349 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
6351 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
6352 " g_sunset_phase );\n"
6354 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
6355 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
6356 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
6357 " ) * g_sun_colour.rgb * g_day_phase;\n"
6359 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
6360 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
6361 " g_sunset_phase );\n"
6363 " return ambient + (light_sun + sky_reflection) * shadow;\n"
6368 "float world_depth_sample( vec3 pos )\n"
6370 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
6371 " return texture( g_world_depth, depth_coord ).r;\n"
6374 "float world_water_depth( vec3 pos )\n"
6376 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
6377 " return world_depth_sample( pos ) - ref_depth;\n"
6380 "float shadow_sample( vec3 co ){\n"
6381 " float height_sample = world_depth_sample( co );\n"
6383 " float fdelta = height_sample - co.y;\n"
6384 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
6387 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
6388 " if( g_shadow_samples == 0 ){\n"
6392 " float fspread = g_shadow_spread;\n"
6393 " float flength = g_shadow_length;\n"
6395 " float famt = 0.0;\n"
6396 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
6397 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
6398 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
6399 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
6401 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
6402 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
6403 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
6404 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
6406 " return 1.0 - famt;\n"
6409 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
6411 " vec3 specdir = reflect( -dir, wnormal );\n"
6412 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
6415 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
6416 " float dist = pow(fdist*0.0010,0.78);\n"
6417 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
6420 "vec3 scene_calculate_light( int light_index, \n"
6421 " vec3 halfview, vec3 co, vec3 normal )\n"
6423 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
6424 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
6425 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
6427 " vec3 light_delta = light_co.xyz-co;\n"
6428 " float dist2 = dot(light_delta,light_delta);\n"
6430 " light_delta = normalize( light_delta );\n"
6432 " float quadratic = dist2*100.0;\n"
6433 " float attenuation = 1.0/( 1.0 + quadratic );\n"
6434 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
6436 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
6438 " if( light_dir.w < 0.999999 ){\n"
6439 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
6440 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
6443 " return light_colour.rgb * attenuation * falloff \n"
6444 " * step( g_day_phase, light_colour.w );\n"
6447 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
6448 " vec3 halfview, vec3 co, vec3 normal )\n"
6450 " uint light_count = packed_index & 0x3u;\n"
6452 " vec3 l = vec3(0.0);\n"
6454 " if( light_count >= 1u ){\n"
6455 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
6456 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
6457 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
6459 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
6461 " if( light_count >= 2u ){\n"
6462 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
6464 " if( light_count >= 3u ){\n"
6465 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
6473 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
6474 " float light_mask )\n"
6476 " if( g_light_preview == 1 )\n"
6477 " diffuse = vec3(0.75);\n"
6480 " vec3 halfview = uCamera - co;\n"
6481 " float fdist = length(halfview);\n"
6482 " halfview /= fdist;\n"
6484 " float world_shadow = newlight_compute_sun_shadow( \n"
6485 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
6487 " vec3 total_light = clearskies_lighting( \n"
6488 " normal, min( light_mask, world_shadow ), halfview );\n"
6490 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
6491 " cube_coord = floor( cube_coord );\n"
6493 " if( g_debug_indices == 1 )\n"
6495 " return rand33(cube_coord);\n"
6498 " if( g_debug_complexity == 1 )\n"
6500 " ivec3 coord = ivec3( cube_coord );\n"
6501 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
6503 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
6504 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
6507 " // FIXME: this coord should absolutely must be clamped!\n"
6509 " ivec3 coord = ivec3( cube_coord );\n"
6510 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
6512 " total_light += \n"
6513 " scene_calculate_packed_light_patch( index_sample.x,\n"
6514 " halfview, co, normal ) \n"
6516 " total_light += \n"
6517 " scene_calculate_packed_light_patch( index_sample.y,\n"
6518 " halfview, co, normal )\n"
6521 " // Take a section of the sky function to give us a matching fog colour\n"
6523 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
6524 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
6525 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
6526 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
6528 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
6529 " sun_colour *= sun_shape;\n"
6531 " fog_colour += sun_colour;\n"
6532 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
6537 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
6539 " vec3 pa = p - a;\n"
6540 " vec3 ba = b - a;\n"
6542 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
6543 " return length( pa - ba*h );\n"
6546 "float compute_board_shadow()\n"
6548 " // player shadow\n"
6549 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
6550 " g_board_1.xyz )-0.1 );\n"
6551 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
6552 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
6554 " return 1.0 - player_shadow*0.8;\n"
6557 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
6559 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
6564 "const float k_motion_lerp_amount = 0.01;\n"
6568 "layout (location = 1) out vec2 oMotionVec;\n"
6570 "in vec3 aMotionVec0;\n"
6571 "in vec3 aMotionVec1;\n"
6573 "void compute_motion_vectors()\n"
6575 " // Write motion vectors\n"
6576 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
6577 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
6579 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
6584 "vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue )\n"
6586 " vec3 surface_tint = mix(uShoreColour, uOceanColour, depthvalue);\n"
6588 " float ffresnel = pow(1.0-dot( vnorm, halfview ),5.0);\n"
6590 " vec3 lightdir = vec3(0.95,0.0,-0.3);\n"
6591 " vec3 specdir = reflect( -lightdir, vnorm );\n"
6592 " float spec = pow(max(dot(halfview,specdir),0.0),20.0)*0.3;\n"
6594 " return vec4( surface_tint + spec, max(min(depthvalue*4.0, 1.0),0.0) );\n"
6599 " compute_motion_vectors();\n"
6601 " // Surface colour composite\n"
6602 " float depthvalue = clamp( -world_water_depth( aCo )*(1.0/25.0), 0.0, 1.0 );\n"
6604 " vec2 world_coord = aCo.xz * 0.008;\n"
6605 " vec4 time_offsets = vec4( uTime ) * vec4( 0.008, 0.006, 0.003, 0.03 );\n"
6606 " vec4 dudva = texture( uTexDudv, world_coord + time_offsets.xy )-0.5;\n"
6607 " vec4 dudvb = texture( uTexDudv, world_coord *7.0 - time_offsets.zw )-0.5;\n"
6609 " vec3 surfnorm = dudva.rgb + dudvb.rgb;\n"
6610 " surfnorm = normalize(vec3(0.0,1.0,0.0) + dudva.xyz*0.4 + dudvb.xyz*0.1);\n"
6613 " float fband = fract( aCo.z*0.02+uTime*0.1+depthvalue*10.0 );\n"
6614 " fband = step( fband+dudva.a*0.8, 0.3 ) * max((1.0-depthvalue*4.0),0.0);\n"
6617 " vec3 halfview = -normalize( aCo-uCamera );\n"
6620 " float fdist = pow(length( aCo.xz-uCamera.xz ) * 0.00047, 2.6);\n"
6623 " vec4 vsurface = water_surf( halfview, surfnorm, depthvalue );\n"
6624 " vsurface.a -= fdist;\n"
6625 " oColour = mix( vsurface, vec4(1.0,1.0,1.0,0.5), fband );\n"
6626 " oColour.rgb = scene_compute_lighting( oColour.rgb, aNorm.xyz, aWorldCo );\n"
6631 GLuint _uniform_scene_water_fast_uMdl
;
6632 GLuint _uniform_scene_water_fast_uPv
;
6633 GLuint _uniform_scene_water_fast_uPvmPrev
;
6634 GLuint _uniform_scene_water_fast_uTexDudv
;
6635 GLuint _uniform_scene_water_fast_uTime
;
6636 GLuint _uniform_scene_water_fast_uCamera
;
6637 GLuint _uniform_scene_water_fast_uSurfaceY
;
6638 GLuint _uniform_scene_water_fast_uBoard0
;
6639 GLuint _uniform_scene_water_fast_uBoard1
;
6640 GLuint _uniform_scene_water_fast_uShoreColour
;
6641 GLuint _uniform_scene_water_fast_uOceanColour
;
6642 GLuint _uniform_scene_water_fast_g_world_depth
;
6643 GLuint _uniform_scene_water_fast_uLightsArray
;
6644 GLuint _uniform_scene_water_fast_uLightsIndex
;
6645 #include "shaders/scene_scoretext.h"
6646 struct vg_shader _shader_scene_scoretext
= {
6647 .name
= "scene_scoretext",
6650 .orig_file
= "shaders/scene_sfd.vs",
6652 "layout (location=0) in vec3 a_co;\n"
6653 "layout (location=1) in vec4 a_norm;\n"
6654 "layout (location=2) in vec2 a_uv;\n"
6657 "const float k_motion_lerp_amount = 0.01;\n"
6661 "out vec3 aMotionVec0;\n"
6662 "out vec3 aMotionVec1;\n"
6664 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
6666 " // This magically solves some artifacting errors!\n"
6668 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
6670 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
6671 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
6676 "uniform mat4x3 uMdl;\n"
6677 "uniform mat4 uPv;\n"
6678 "uniform mat4 uPvmPrev;\n"
6679 "uniform vec3 uInfo;\n"
6684 "out vec3 aWorldCo;\n"
6688 " float w = ((a_norm.w)-0.5)*2.0 + fract(uInfo.z) - 0.0;\n"
6689 " float c = -cos(w*0.6);\n"
6690 " float s = -sin(w*0.6);\n"
6693 " float w1 = clamp( w*4.0 - a_co.y*10.0, -1.0, 1.0 ) * (3.14159265*0.5);\n"
6694 " float c1 = cos(w1);\n"
6695 " float s1 = sin(w1);\n"
6697 " float yoff = step(0.01,fract(uInfo.z))*-0.5;\n"
6700 " mlocal[0] = vec3(c1, s1,0.0);\n"
6701 " mlocal[1] = vec3(-s1,c1,0.0);\n"
6702 " mlocal[2] = vec3(0.0,0.0,1.0);\n"
6703 " mlocal[3] = vec3(c*r,uInfo.y*0.875 + s*r,uInfo.x*0.5);\n"
6705 " vec3 local_pos0 = mlocal * vec4( a_co, 1.0 );\n"
6706 " vec3 world_pos0 = uMdl * vec4( local_pos0, 1.0 );\n"
6708 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
6709 " vec4 vproj1 = uPvmPrev * vec4( local_pos0, 1.0 );\n"
6711 " vs_motion_out( vproj0, vproj1 );\n"
6713 " gl_Position = vproj0;\n"
6715 " aUv = a_uv + vec2( floor(uInfo.z+0.5)*(1.0/64.0), yoff );\n"
6716 " aNorm = vec4( mat3(uMdl) * mat3(mlocal) * a_norm.xyz, a_norm.w );\n"
6718 " aWorldCo = world_pos0;\n"
6723 .orig_file
= "shaders/scene_standard.fs",
6725 "uniform sampler2D uTexGarbage;\n"
6726 "uniform sampler2D uTexMain;\n"
6727 "uniform vec3 uCamera;\n"
6728 "uniform vec4 uPlane;\n"
6732 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
6741 "in vec3 aWorldCo;\n"
6744 "layout (location = 0) out vec4 oColour;\n"
6746 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
6747 "layout (std140) uniform ub_world_lighting\n"
6749 " vec4 g_cube_min;\n"
6750 " vec4 g_cube_inv_range;\n"
6752 " vec4 g_water_plane;\n"
6753 " vec4 g_depth_bounds;\n"
6755 " vec4 g_daysky_colour;\n"
6756 " vec4 g_nightsky_colour;\n"
6757 " vec4 g_sunset_colour;\n"
6758 " vec4 g_ambient_colour;\n"
6759 " vec4 g_sunset_ambient;\n"
6760 " vec4 g_sun_colour;\n"
6761 " vec4 g_sun_dir;\n"
6762 " vec4 g_board_0;\n"
6763 " vec4 g_board_1;\n"
6765 " float g_water_fog;\n"
6767 " float g_realtime;\n"
6768 " float g_shadow_length;\n"
6769 " float g_shadow_spread;\n"
6771 " float g_time_of_day;\n"
6772 " float g_day_phase;\n"
6773 " float g_sunset_phase;\n"
6775 " int g_light_preview;\n"
6776 " int g_shadow_samples;\n"
6778 " int g_debug_indices;\n"
6779 " int g_debug_complexity;\n"
6782 "uniform sampler2D g_world_depth;\n"
6783 "uniform samplerBuffer uLightsArray;\n"
6784 "uniform usampler3D uLightsIndex;\n"
6787 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
6788 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
6789 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
6790 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
6791 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
6792 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
6794 "const float SUN_ANGLE = 0.0001;\n"
6795 "const float PI = 3.14159265358979323846264;\n"
6797 "//struct world_info\n"
6802 "// sunset_phase;\n"
6804 "// vec3 sun_dir;\n"
6807 "vec3 rand33(vec3 p3)\n"
6809 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
6810 " p3 += dot(p3, p3.yxz+33.33);\n"
6811 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
6814 "float stars( vec3 rd, float rr, float size ){\n"
6815 " vec3 co = rd * rr;\n"
6817 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
6819 " float spaces = 1.0 / rr;\n"
6820 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
6821 " a -= mod(a, spaces) - spaces * 0.5;\n"
6823 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
6825 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
6826 " plane = plane - mod(plane, PI / count);\n"
6828 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
6830 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
6831 " float ydist = sqrt(rr * rr - level * level);\n"
6832 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
6833 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
6834 " float star = smoothstep(size, 0.0, distance(center, co));\n"
6838 "float luminance( vec3 v )\n"
6840 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
6843 "vec3 clearskies_ambient( vec3 dir )\n"
6845 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
6846 " float sky_gradient = dir.y;\n"
6848 " /* Blend phase colours */\n"
6849 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
6850 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
6851 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
6853 " /* Add gradient */\n"
6854 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
6856 " return ambient;\n"
6859 "vec3 clearskies_sky( vec3 ray_dir )\n"
6861 " ray_dir.y = abs( ray_dir.y );\n"
6862 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
6865 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
6866 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
6867 " float sun_shape = pow( sun_size, 2000.0 );\n"
6868 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
6870 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
6871 " sun_colour *= sun_shape;\n"
6874 " float star = 0.0;\n"
6875 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
6877 " if( star_blend > 0.001 ){\n"
6878 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
6879 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
6880 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
6884 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
6885 " return composite;\n"
6888 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
6890 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
6892 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
6893 " g_sunset_phase );\n"
6895 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
6896 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
6897 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
6898 " ) * g_sun_colour.rgb * g_day_phase;\n"
6900 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
6901 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
6902 " g_sunset_phase );\n"
6904 " return ambient + (light_sun + sky_reflection) * shadow;\n"
6909 "float world_depth_sample( vec3 pos )\n"
6911 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
6912 " return texture( g_world_depth, depth_coord ).r;\n"
6915 "float world_water_depth( vec3 pos )\n"
6917 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
6918 " return world_depth_sample( pos ) - ref_depth;\n"
6921 "float shadow_sample( vec3 co ){\n"
6922 " float height_sample = world_depth_sample( co );\n"
6924 " float fdelta = height_sample - co.y;\n"
6925 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
6928 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
6929 " if( g_shadow_samples == 0 ){\n"
6933 " float fspread = g_shadow_spread;\n"
6934 " float flength = g_shadow_length;\n"
6936 " float famt = 0.0;\n"
6937 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
6938 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
6939 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
6940 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
6942 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
6943 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
6944 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
6945 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
6947 " return 1.0 - famt;\n"
6950 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
6952 " vec3 specdir = reflect( -dir, wnormal );\n"
6953 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
6956 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
6957 " float dist = pow(fdist*0.0010,0.78);\n"
6958 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
6961 "vec3 scene_calculate_light( int light_index, \n"
6962 " vec3 halfview, vec3 co, vec3 normal )\n"
6964 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
6965 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
6966 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
6968 " vec3 light_delta = light_co.xyz-co;\n"
6969 " float dist2 = dot(light_delta,light_delta);\n"
6971 " light_delta = normalize( light_delta );\n"
6973 " float quadratic = dist2*100.0;\n"
6974 " float attenuation = 1.0/( 1.0 + quadratic );\n"
6975 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
6977 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
6979 " if( light_dir.w < 0.999999 ){\n"
6980 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
6981 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
6984 " return light_colour.rgb * attenuation * falloff \n"
6985 " * step( g_day_phase, light_colour.w );\n"
6988 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
6989 " vec3 halfview, vec3 co, vec3 normal )\n"
6991 " uint light_count = packed_index & 0x3u;\n"
6993 " vec3 l = vec3(0.0);\n"
6995 " if( light_count >= 1u ){\n"
6996 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
6997 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
6998 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
7000 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
7002 " if( light_count >= 2u ){\n"
7003 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
7005 " if( light_count >= 3u ){\n"
7006 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
7014 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
7015 " float light_mask )\n"
7017 " if( g_light_preview == 1 )\n"
7018 " diffuse = vec3(0.75);\n"
7021 " vec3 halfview = uCamera - co;\n"
7022 " float fdist = length(halfview);\n"
7023 " halfview /= fdist;\n"
7025 " float world_shadow = newlight_compute_sun_shadow( \n"
7026 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
7028 " vec3 total_light = clearskies_lighting( \n"
7029 " normal, min( light_mask, world_shadow ), halfview );\n"
7031 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
7032 " cube_coord = floor( cube_coord );\n"
7034 " if( g_debug_indices == 1 )\n"
7036 " return rand33(cube_coord);\n"
7039 " if( g_debug_complexity == 1 )\n"
7041 " ivec3 coord = ivec3( cube_coord );\n"
7042 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
7044 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
7045 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
7048 " // FIXME: this coord should absolutely must be clamped!\n"
7050 " ivec3 coord = ivec3( cube_coord );\n"
7051 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
7053 " total_light += \n"
7054 " scene_calculate_packed_light_patch( index_sample.x,\n"
7055 " halfview, co, normal ) \n"
7057 " total_light += \n"
7058 " scene_calculate_packed_light_patch( index_sample.y,\n"
7059 " halfview, co, normal )\n"
7062 " // Take a section of the sky function to give us a matching fog colour\n"
7064 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
7065 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
7066 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
7067 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
7069 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
7070 " sun_colour *= sun_shape;\n"
7072 " fog_colour += sun_colour;\n"
7073 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
7078 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
7080 " vec3 pa = p - a;\n"
7081 " vec3 ba = b - a;\n"
7083 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
7084 " return length( pa - ba*h );\n"
7087 "float compute_board_shadow()\n"
7089 " // player shadow\n"
7090 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
7091 " g_board_1.xyz )-0.1 );\n"
7092 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
7093 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
7095 " return 1.0 - player_shadow*0.8;\n"
7098 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
7100 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
7105 "const float k_motion_lerp_amount = 0.01;\n"
7109 "layout (location = 1) out vec2 oMotionVec;\n"
7111 "in vec3 aMotionVec0;\n"
7112 "in vec3 aMotionVec1;\n"
7114 "void compute_motion_vectors()\n"
7116 " // Write motion vectors\n"
7117 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
7118 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
7120 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
7127 " compute_motion_vectors();\n"
7129 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
7130 " vec4 vsamplemain = texture( uTexMain, aUv );\n"
7131 " vec3 qnorm = aNorm.xyz;\n"
7133 " vfrag = vsamplemain.rgb;\n"
7135 " if( g_light_preview == 1 )\n"
7137 " vfrag = vec3(0.5);\n"
7140 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
7141 " oColour = vec4( vfrag, 1.0 );\n"
7146 GLuint _uniform_scene_scoretext_uMdl
;
7147 GLuint _uniform_scene_scoretext_uPv
;
7148 GLuint _uniform_scene_scoretext_uPvmPrev
;
7149 GLuint _uniform_scene_scoretext_uInfo
;
7150 GLuint _uniform_scene_scoretext_uTexGarbage
;
7151 GLuint _uniform_scene_scoretext_uTexMain
;
7152 GLuint _uniform_scene_scoretext_uCamera
;
7153 GLuint _uniform_scene_scoretext_uPlane
;
7154 GLuint _uniform_scene_scoretext_g_world_depth
;
7155 GLuint _uniform_scene_scoretext_uLightsArray
;
7156 GLuint _uniform_scene_scoretext_uLightsIndex
;
7157 #include "shaders/scene_font.h"
7158 struct vg_shader _shader_scene_font
= {
7159 .name
= "scene_font",
7162 .orig_file
= "shaders/model_font.vs",
7164 "layout (location=0) in vec3 a_co;\n"
7165 "layout (location=1) in vec3 a_norm;\n"
7166 "layout (location=2) in vec2 a_uv;\n"
7169 "const float k_motion_lerp_amount = 0.01;\n"
7173 "out vec3 aMotionVec0;\n"
7174 "out vec3 aMotionVec1;\n"
7176 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
7178 " // This magically solves some artifacting errors!\n"
7180 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
7182 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
7183 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
7188 "uniform mat4x3 uMdl;\n"
7189 "uniform mat4 uPv;\n"
7190 "uniform mat4 uPvmPrev;\n"
7191 "uniform vec4 uOffset;\n"
7196 "out vec3 aWorldCo;\n"
7200 " vec3 co = a_co*uOffset.w+uOffset.xyz;\n"
7201 " vec3 world_pos0 = uMdl * vec4( co, 1.0 );\n"
7202 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
7203 " vec4 vproj1 = uPvmPrev * vec4( co, 1.0 );\n"
7205 " vs_motion_out( vproj0, vproj1 );\n"
7207 " gl_Position = vproj0;\n"
7210 " aNorm = vec4( mat3(uMdl) * a_norm, 0.0 );\n"
7212 " aWorldCo = world_pos0;\n"
7217 .orig_file
= "shaders/scene_font.fs",
7219 "uniform sampler2D uTexGarbage; // unused\n"
7220 "uniform sampler2D uTexMain; // unused\n"
7221 "uniform vec3 uCamera;\n"
7222 "uniform float uTime;\n"
7223 "uniform float uOpacity;\n"
7224 "uniform float uColourize;\n"
7228 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
7237 "in vec3 aWorldCo;\n"
7240 "layout (location = 0) out vec4 oColour;\n"
7242 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
7243 "layout (std140) uniform ub_world_lighting\n"
7245 " vec4 g_cube_min;\n"
7246 " vec4 g_cube_inv_range;\n"
7248 " vec4 g_water_plane;\n"
7249 " vec4 g_depth_bounds;\n"
7251 " vec4 g_daysky_colour;\n"
7252 " vec4 g_nightsky_colour;\n"
7253 " vec4 g_sunset_colour;\n"
7254 " vec4 g_ambient_colour;\n"
7255 " vec4 g_sunset_ambient;\n"
7256 " vec4 g_sun_colour;\n"
7257 " vec4 g_sun_dir;\n"
7258 " vec4 g_board_0;\n"
7259 " vec4 g_board_1;\n"
7261 " float g_water_fog;\n"
7263 " float g_realtime;\n"
7264 " float g_shadow_length;\n"
7265 " float g_shadow_spread;\n"
7267 " float g_time_of_day;\n"
7268 " float g_day_phase;\n"
7269 " float g_sunset_phase;\n"
7271 " int g_light_preview;\n"
7272 " int g_shadow_samples;\n"
7274 " int g_debug_indices;\n"
7275 " int g_debug_complexity;\n"
7278 "uniform sampler2D g_world_depth;\n"
7279 "uniform samplerBuffer uLightsArray;\n"
7280 "uniform usampler3D uLightsIndex;\n"
7283 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
7284 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
7285 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
7286 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
7287 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
7288 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
7290 "const float SUN_ANGLE = 0.0001;\n"
7291 "const float PI = 3.14159265358979323846264;\n"
7293 "//struct world_info\n"
7298 "// sunset_phase;\n"
7300 "// vec3 sun_dir;\n"
7303 "vec3 rand33(vec3 p3)\n"
7305 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
7306 " p3 += dot(p3, p3.yxz+33.33);\n"
7307 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
7310 "float stars( vec3 rd, float rr, float size ){\n"
7311 " vec3 co = rd * rr;\n"
7313 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
7315 " float spaces = 1.0 / rr;\n"
7316 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
7317 " a -= mod(a, spaces) - spaces * 0.5;\n"
7319 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
7321 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
7322 " plane = plane - mod(plane, PI / count);\n"
7324 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
7326 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
7327 " float ydist = sqrt(rr * rr - level * level);\n"
7328 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
7329 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
7330 " float star = smoothstep(size, 0.0, distance(center, co));\n"
7334 "float luminance( vec3 v )\n"
7336 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
7339 "vec3 clearskies_ambient( vec3 dir )\n"
7341 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
7342 " float sky_gradient = dir.y;\n"
7344 " /* Blend phase colours */\n"
7345 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
7346 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
7347 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
7349 " /* Add gradient */\n"
7350 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
7352 " return ambient;\n"
7355 "vec3 clearskies_sky( vec3 ray_dir )\n"
7357 " ray_dir.y = abs( ray_dir.y );\n"
7358 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
7361 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
7362 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
7363 " float sun_shape = pow( sun_size, 2000.0 );\n"
7364 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
7366 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
7367 " sun_colour *= sun_shape;\n"
7370 " float star = 0.0;\n"
7371 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
7373 " if( star_blend > 0.001 ){\n"
7374 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
7375 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
7376 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
7380 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
7381 " return composite;\n"
7384 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
7386 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
7388 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
7389 " g_sunset_phase );\n"
7391 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
7392 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
7393 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
7394 " ) * g_sun_colour.rgb * g_day_phase;\n"
7396 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
7397 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
7398 " g_sunset_phase );\n"
7400 " return ambient + (light_sun + sky_reflection) * shadow;\n"
7405 "float world_depth_sample( vec3 pos )\n"
7407 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
7408 " return texture( g_world_depth, depth_coord ).r;\n"
7411 "float world_water_depth( vec3 pos )\n"
7413 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
7414 " return world_depth_sample( pos ) - ref_depth;\n"
7417 "float shadow_sample( vec3 co ){\n"
7418 " float height_sample = world_depth_sample( co );\n"
7420 " float fdelta = height_sample - co.y;\n"
7421 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
7424 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
7425 " if( g_shadow_samples == 0 ){\n"
7429 " float fspread = g_shadow_spread;\n"
7430 " float flength = g_shadow_length;\n"
7432 " float famt = 0.0;\n"
7433 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
7434 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
7435 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
7436 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
7438 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
7439 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
7440 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
7441 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
7443 " return 1.0 - famt;\n"
7446 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
7448 " vec3 specdir = reflect( -dir, wnormal );\n"
7449 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
7452 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
7453 " float dist = pow(fdist*0.0010,0.78);\n"
7454 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
7457 "vec3 scene_calculate_light( int light_index, \n"
7458 " vec3 halfview, vec3 co, vec3 normal )\n"
7460 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
7461 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
7462 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
7464 " vec3 light_delta = light_co.xyz-co;\n"
7465 " float dist2 = dot(light_delta,light_delta);\n"
7467 " light_delta = normalize( light_delta );\n"
7469 " float quadratic = dist2*100.0;\n"
7470 " float attenuation = 1.0/( 1.0 + quadratic );\n"
7471 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
7473 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
7475 " if( light_dir.w < 0.999999 ){\n"
7476 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
7477 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
7480 " return light_colour.rgb * attenuation * falloff \n"
7481 " * step( g_day_phase, light_colour.w );\n"
7484 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
7485 " vec3 halfview, vec3 co, vec3 normal )\n"
7487 " uint light_count = packed_index & 0x3u;\n"
7489 " vec3 l = vec3(0.0);\n"
7491 " if( light_count >= 1u ){\n"
7492 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
7493 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
7494 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
7496 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
7498 " if( light_count >= 2u ){\n"
7499 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
7501 " if( light_count >= 3u ){\n"
7502 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
7510 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
7511 " float light_mask )\n"
7513 " if( g_light_preview == 1 )\n"
7514 " diffuse = vec3(0.75);\n"
7517 " vec3 halfview = uCamera - co;\n"
7518 " float fdist = length(halfview);\n"
7519 " halfview /= fdist;\n"
7521 " float world_shadow = newlight_compute_sun_shadow( \n"
7522 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
7524 " vec3 total_light = clearskies_lighting( \n"
7525 " normal, min( light_mask, world_shadow ), halfview );\n"
7527 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
7528 " cube_coord = floor( cube_coord );\n"
7530 " if( g_debug_indices == 1 )\n"
7532 " return rand33(cube_coord);\n"
7535 " if( g_debug_complexity == 1 )\n"
7537 " ivec3 coord = ivec3( cube_coord );\n"
7538 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
7540 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
7541 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
7544 " // FIXME: this coord should absolutely must be clamped!\n"
7546 " ivec3 coord = ivec3( cube_coord );\n"
7547 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
7549 " total_light += \n"
7550 " scene_calculate_packed_light_patch( index_sample.x,\n"
7551 " halfview, co, normal ) \n"
7553 " total_light += \n"
7554 " scene_calculate_packed_light_patch( index_sample.y,\n"
7555 " halfview, co, normal )\n"
7558 " // Take a section of the sky function to give us a matching fog colour\n"
7560 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
7561 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
7562 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
7563 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
7565 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
7566 " sun_colour *= sun_shape;\n"
7568 " fog_colour += sun_colour;\n"
7569 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
7574 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
7576 " vec3 pa = p - a;\n"
7577 " vec3 ba = b - a;\n"
7579 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
7580 " return length( pa - ba*h );\n"
7583 "float compute_board_shadow()\n"
7585 " // player shadow\n"
7586 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
7587 " g_board_1.xyz )-0.1 );\n"
7588 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
7589 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
7591 " return 1.0 - player_shadow*0.8;\n"
7594 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
7596 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
7601 "const float k_motion_lerp_amount = 0.01;\n"
7605 "layout (location = 1) out vec2 oMotionVec;\n"
7607 "in vec3 aMotionVec0;\n"
7608 "in vec3 aMotionVec1;\n"
7610 "void compute_motion_vectors()\n"
7612 " // Write motion vectors\n"
7613 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
7614 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
7616 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
7621 "vec3 pal( float t ){\n"
7622 " vec3 a = vec3(0.30,0.3,0.3);\n"
7623 " vec3 b = vec3(0.8);\n"
7624 " vec3 c = vec3(0.28,0.3,0.4);\n"
7625 " vec3 d = vec3(0.00,0.1,0.1);\n"
7626 " return a + b*cos( 6.28318*(c*t+d) );\n"
7630 " compute_motion_vectors();\n"
7631 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
7632 " vec3 qnorm = aNorm.xyz;\n"
7634 " //vec4 vsamplemain = texture( uTexMain, aUv );\n"
7635 " //vfrag = vsamplemain.rgb;\n"
7637 " vec4 spread0 = uTime*0.0002*vec4( 17.3,-19.6, 23.2,-47.7 );\n"
7638 " vec4 spread1 = uTime*0.0002*vec4( -13.3, 12.6,-28.2, 14.7 );\n"
7640 " vec2 p = aCo.xy + vec2(0.3);\n"
7641 " float a = atan( p.y/p.x );\n"
7642 " vec4 v0 = step( vec4(0.5), fract(vec4(a) + spread0) );\n"
7643 " vec4 v1 = step( vec4(0.5), fract(vec4(a) + spread1) );\n"
7645 " float d = ( v0.x+v0.y+v0.z+v0.w +\n"
7646 " v1.x+v1.y+v1.z+v1.w ) * 0.125;\n"
7648 " float dither = fract(dot(vec2(171.0,231.0),gl_FragCoord.xy)/71.0);\n"
7649 " float x = d*0.8+length(p)*0.3;\n"
7650 " x = (floor(x*8.0) + step(dither, fract(x * 8.0))) / 8.0;\n"
7652 " if( x + (uOpacity*2.0-1.0) < 0.5 ) \n"
7655 " vfrag = mix( vec3(x), pal( x ), uColourize );\n"
7657 " if( g_light_preview == 1 ){\n"
7658 " vfrag = vec3(0.5);\n"
7661 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
7662 " oColour = vec4( vfrag, 1.0 );\n"
7667 GLuint _uniform_scene_font_uMdl
;
7668 GLuint _uniform_scene_font_uPv
;
7669 GLuint _uniform_scene_font_uPvmPrev
;
7670 GLuint _uniform_scene_font_uOffset
;
7671 GLuint _uniform_scene_font_uTexGarbage
;
7672 GLuint _uniform_scene_font_uTexMain
;
7673 GLuint _uniform_scene_font_uCamera
;
7674 GLuint _uniform_scene_font_uTime
;
7675 GLuint _uniform_scene_font_uOpacity
;
7676 GLuint _uniform_scene_font_uColourize
;
7677 GLuint _uniform_scene_font_g_world_depth
;
7678 GLuint _uniform_scene_font_uLightsArray
;
7679 GLuint _uniform_scene_font_uLightsIndex
;
7680 #include "shaders/model_sky.h"
7681 struct vg_shader _shader_model_sky
= {
7682 .name
= "model_sky",
7685 .orig_file
= "shaders/model.vs",
7687 "layout (location=0) in vec3 a_co;\n"
7688 "layout (location=1) in vec3 a_norm;\n"
7689 "layout (location=2) in vec2 a_uv;\n"
7690 "layout (location=3) in vec4 a_colour;\n"
7691 "layout (location=4) in vec4 a_weights;\n"
7692 "layout (location=5) in ivec4 a_groups;\n"
7695 "const float k_motion_lerp_amount = 0.01;\n"
7699 "out vec3 aMotionVec0;\n"
7700 "out vec3 aMotionVec1;\n"
7702 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
7704 " // This magically solves some artifacting errors!\n"
7706 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
7708 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
7709 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
7714 "uniform mat4x3 uMdl;\n"
7715 "uniform mat4 uPv;\n"
7716 "uniform mat4 uPvmPrev;\n"
7718 "out vec4 aColour;\n"
7722 "out vec3 aWorldCo;\n"
7726 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
7727 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
7728 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
7730 " vs_motion_out( vproj0, vproj1 );\n"
7732 " gl_Position = vproj0;\n"
7733 " aWorldCo = world_pos0;\n"
7734 " aColour = a_colour;\n"
7736 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
7742 .orig_file
= "shaders/model_sky.fs",
7744 "uniform sampler2D uTexGarbage;\n"
7746 "in vec4 aColour;\n"
7750 "in vec3 aWorldCo;\n"
7753 "const vec3 uCamera = vec3(0.0);\n"
7757 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
7761 "layout (location = 0) out vec4 oColour;\n"
7763 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
7764 "layout (std140) uniform ub_world_lighting\n"
7766 " vec4 g_cube_min;\n"
7767 " vec4 g_cube_inv_range;\n"
7769 " vec4 g_water_plane;\n"
7770 " vec4 g_depth_bounds;\n"
7772 " vec4 g_daysky_colour;\n"
7773 " vec4 g_nightsky_colour;\n"
7774 " vec4 g_sunset_colour;\n"
7775 " vec4 g_ambient_colour;\n"
7776 " vec4 g_sunset_ambient;\n"
7777 " vec4 g_sun_colour;\n"
7778 " vec4 g_sun_dir;\n"
7779 " vec4 g_board_0;\n"
7780 " vec4 g_board_1;\n"
7782 " float g_water_fog;\n"
7784 " float g_realtime;\n"
7785 " float g_shadow_length;\n"
7786 " float g_shadow_spread;\n"
7788 " float g_time_of_day;\n"
7789 " float g_day_phase;\n"
7790 " float g_sunset_phase;\n"
7792 " int g_light_preview;\n"
7793 " int g_shadow_samples;\n"
7795 " int g_debug_indices;\n"
7796 " int g_debug_complexity;\n"
7799 "uniform sampler2D g_world_depth;\n"
7800 "uniform samplerBuffer uLightsArray;\n"
7801 "uniform usampler3D uLightsIndex;\n"
7804 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
7805 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
7806 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
7807 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
7808 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
7809 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
7811 "const float SUN_ANGLE = 0.0001;\n"
7812 "const float PI = 3.14159265358979323846264;\n"
7814 "//struct world_info\n"
7819 "// sunset_phase;\n"
7821 "// vec3 sun_dir;\n"
7824 "vec3 rand33(vec3 p3)\n"
7826 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
7827 " p3 += dot(p3, p3.yxz+33.33);\n"
7828 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
7831 "float stars( vec3 rd, float rr, float size ){\n"
7832 " vec3 co = rd * rr;\n"
7834 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
7836 " float spaces = 1.0 / rr;\n"
7837 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
7838 " a -= mod(a, spaces) - spaces * 0.5;\n"
7840 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
7842 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
7843 " plane = plane - mod(plane, PI / count);\n"
7845 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
7847 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
7848 " float ydist = sqrt(rr * rr - level * level);\n"
7849 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
7850 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
7851 " float star = smoothstep(size, 0.0, distance(center, co));\n"
7855 "float luminance( vec3 v )\n"
7857 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
7860 "vec3 clearskies_ambient( vec3 dir )\n"
7862 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
7863 " float sky_gradient = dir.y;\n"
7865 " /* Blend phase colours */\n"
7866 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
7867 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
7868 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
7870 " /* Add gradient */\n"
7871 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
7873 " return ambient;\n"
7876 "vec3 clearskies_sky( vec3 ray_dir )\n"
7878 " ray_dir.y = abs( ray_dir.y );\n"
7879 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
7882 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
7883 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
7884 " float sun_shape = pow( sun_size, 2000.0 );\n"
7885 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
7887 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
7888 " sun_colour *= sun_shape;\n"
7891 " float star = 0.0;\n"
7892 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
7894 " if( star_blend > 0.001 ){\n"
7895 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
7896 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
7897 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
7901 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
7902 " return composite;\n"
7905 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
7907 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
7909 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
7910 " g_sunset_phase );\n"
7912 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
7913 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
7914 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
7915 " ) * g_sun_colour.rgb * g_day_phase;\n"
7917 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
7918 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
7919 " g_sunset_phase );\n"
7921 " return ambient + (light_sun + sky_reflection) * shadow;\n"
7926 "float world_depth_sample( vec3 pos )\n"
7928 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
7929 " return texture( g_world_depth, depth_coord ).r;\n"
7932 "float world_water_depth( vec3 pos )\n"
7934 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
7935 " return world_depth_sample( pos ) - ref_depth;\n"
7938 "float shadow_sample( vec3 co ){\n"
7939 " float height_sample = world_depth_sample( co );\n"
7941 " float fdelta = height_sample - co.y;\n"
7942 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
7945 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
7946 " if( g_shadow_samples == 0 ){\n"
7950 " float fspread = g_shadow_spread;\n"
7951 " float flength = g_shadow_length;\n"
7953 " float famt = 0.0;\n"
7954 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
7955 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
7956 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
7957 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
7959 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
7960 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
7961 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
7962 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
7964 " return 1.0 - famt;\n"
7967 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
7969 " vec3 specdir = reflect( -dir, wnormal );\n"
7970 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
7973 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
7974 " float dist = pow(fdist*0.0010,0.78);\n"
7975 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
7978 "vec3 scene_calculate_light( int light_index, \n"
7979 " vec3 halfview, vec3 co, vec3 normal )\n"
7981 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
7982 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
7983 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
7985 " vec3 light_delta = light_co.xyz-co;\n"
7986 " float dist2 = dot(light_delta,light_delta);\n"
7988 " light_delta = normalize( light_delta );\n"
7990 " float quadratic = dist2*100.0;\n"
7991 " float attenuation = 1.0/( 1.0 + quadratic );\n"
7992 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
7994 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
7996 " if( light_dir.w < 0.999999 ){\n"
7997 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
7998 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
8001 " return light_colour.rgb * attenuation * falloff \n"
8002 " * step( g_day_phase, light_colour.w );\n"
8005 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
8006 " vec3 halfview, vec3 co, vec3 normal )\n"
8008 " uint light_count = packed_index & 0x3u;\n"
8010 " vec3 l = vec3(0.0);\n"
8012 " if( light_count >= 1u ){\n"
8013 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
8014 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
8015 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
8017 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
8019 " if( light_count >= 2u ){\n"
8020 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
8022 " if( light_count >= 3u ){\n"
8023 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
8031 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
8032 " float light_mask )\n"
8034 " if( g_light_preview == 1 )\n"
8035 " diffuse = vec3(0.75);\n"
8038 " vec3 halfview = uCamera - co;\n"
8039 " float fdist = length(halfview);\n"
8040 " halfview /= fdist;\n"
8042 " float world_shadow = newlight_compute_sun_shadow( \n"
8043 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
8045 " vec3 total_light = clearskies_lighting( \n"
8046 " normal, min( light_mask, world_shadow ), halfview );\n"
8048 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
8049 " cube_coord = floor( cube_coord );\n"
8051 " if( g_debug_indices == 1 )\n"
8053 " return rand33(cube_coord);\n"
8056 " if( g_debug_complexity == 1 )\n"
8058 " ivec3 coord = ivec3( cube_coord );\n"
8059 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
8061 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
8062 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
8065 " // FIXME: this coord should absolutely must be clamped!\n"
8067 " ivec3 coord = ivec3( cube_coord );\n"
8068 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
8070 " total_light += \n"
8071 " scene_calculate_packed_light_patch( index_sample.x,\n"
8072 " halfview, co, normal ) \n"
8074 " total_light += \n"
8075 " scene_calculate_packed_light_patch( index_sample.y,\n"
8076 " halfview, co, normal )\n"
8079 " // Take a section of the sky function to give us a matching fog colour\n"
8081 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
8082 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
8083 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
8084 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
8086 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
8087 " sun_colour *= sun_shape;\n"
8089 " fog_colour += sun_colour;\n"
8090 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
8095 "const float k_motion_lerp_amount = 0.01;\n"
8099 "layout (location = 1) out vec2 oMotionVec;\n"
8101 "in vec3 aMotionVec0;\n"
8102 "in vec3 aMotionVec1;\n"
8104 "void compute_motion_vectors()\n"
8106 " // Write motion vectors\n"
8107 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
8108 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
8110 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
8117 " compute_motion_vectors();\n"
8119 " vec3 rd = normalize(aNorm);\n"
8121 " float fmove = g_time * 5.0;\n"
8122 " vec2 cloudplane = (rd.xz / (rd.y*sign(rd.y))) * 0.025;\n"
8123 " vec4 clouds1 = texture( uTexGarbage, cloudplane + vec2(0.1,0.4)*fmove*2.0 );\n"
8124 " vec4 clouds2 = texture( uTexGarbage, cloudplane*2.0 + vec2(0.3,0.1)*fmove );\n"
8126 " float cloud_d = max(clouds1.b*clouds2.r -0.2 - clouds2.g*0.4,0.0);\n"
8127 " float cloud_e = pow(cloud_d,1.5)*pow(abs(rd.y),0.3)*2.0;\n"
8129 " oColour = vec4( clearskies_sky( -rd ) ,1.0);\n"
8131 " vec3 cloud_colour = mix( mix(g_nightsky_colour.rgb,vec3(1.0),g_day_phase), \n"
8132 " g_sunset_colour.rgb, g_sunset_phase );\n"
8134 " oColour.rgb = mix( oColour.rgb, cloud_colour, cloud_e );\n"
8139 GLuint _uniform_model_sky_uMdl
;
8140 GLuint _uniform_model_sky_uPv
;
8141 GLuint _uniform_model_sky_uPvmPrev
;
8142 GLuint _uniform_model_sky_uTexGarbage
;
8143 GLuint _uniform_model_sky_g_world_depth
;
8144 GLuint _uniform_model_sky_uLightsArray
;
8145 GLuint _uniform_model_sky_uLightsIndex
;
8146 #include "shaders/model_sky_space.h"
8147 struct vg_shader _shader_model_sky_space
= {
8148 .name
= "model_sky_space",
8151 .orig_file
= "shaders/model.vs",
8153 "layout (location=0) in vec3 a_co;\n"
8154 "layout (location=1) in vec3 a_norm;\n"
8155 "layout (location=2) in vec2 a_uv;\n"
8156 "layout (location=3) in vec4 a_colour;\n"
8157 "layout (location=4) in vec4 a_weights;\n"
8158 "layout (location=5) in ivec4 a_groups;\n"
8161 "const float k_motion_lerp_amount = 0.01;\n"
8165 "out vec3 aMotionVec0;\n"
8166 "out vec3 aMotionVec1;\n"
8168 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
8170 " // This magically solves some artifacting errors!\n"
8172 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
8174 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
8175 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
8180 "uniform mat4x3 uMdl;\n"
8181 "uniform mat4 uPv;\n"
8182 "uniform mat4 uPvmPrev;\n"
8184 "out vec4 aColour;\n"
8188 "out vec3 aWorldCo;\n"
8192 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
8193 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
8194 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
8196 " vs_motion_out( vproj0, vproj1 );\n"
8198 " gl_Position = vproj0;\n"
8199 " aWorldCo = world_pos0;\n"
8200 " aColour = a_colour;\n"
8202 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
8208 .orig_file
= "shaders/model_sky_space.fs",
8210 "uniform sampler2D uTexGarbage;\n"
8212 "in vec4 aColour;\n"
8216 "in vec3 aWorldCo;\n"
8219 "const vec3 uCamera = vec3(0.0);\n"
8223 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
8227 "layout (location = 0) out vec4 oColour;\n"
8229 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
8230 "layout (std140) uniform ub_world_lighting\n"
8232 " vec4 g_cube_min;\n"
8233 " vec4 g_cube_inv_range;\n"
8235 " vec4 g_water_plane;\n"
8236 " vec4 g_depth_bounds;\n"
8238 " vec4 g_daysky_colour;\n"
8239 " vec4 g_nightsky_colour;\n"
8240 " vec4 g_sunset_colour;\n"
8241 " vec4 g_ambient_colour;\n"
8242 " vec4 g_sunset_ambient;\n"
8243 " vec4 g_sun_colour;\n"
8244 " vec4 g_sun_dir;\n"
8245 " vec4 g_board_0;\n"
8246 " vec4 g_board_1;\n"
8248 " float g_water_fog;\n"
8250 " float g_realtime;\n"
8251 " float g_shadow_length;\n"
8252 " float g_shadow_spread;\n"
8254 " float g_time_of_day;\n"
8255 " float g_day_phase;\n"
8256 " float g_sunset_phase;\n"
8258 " int g_light_preview;\n"
8259 " int g_shadow_samples;\n"
8261 " int g_debug_indices;\n"
8262 " int g_debug_complexity;\n"
8265 "uniform sampler2D g_world_depth;\n"
8266 "uniform samplerBuffer uLightsArray;\n"
8267 "uniform usampler3D uLightsIndex;\n"
8270 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
8271 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
8272 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
8273 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
8274 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
8275 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
8277 "const float SUN_ANGLE = 0.0001;\n"
8278 "const float PI = 3.14159265358979323846264;\n"
8280 "//struct world_info\n"
8285 "// sunset_phase;\n"
8287 "// vec3 sun_dir;\n"
8290 "vec3 rand33(vec3 p3)\n"
8292 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
8293 " p3 += dot(p3, p3.yxz+33.33);\n"
8294 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
8297 "float stars( vec3 rd, float rr, float size ){\n"
8298 " vec3 co = rd * rr;\n"
8300 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
8302 " float spaces = 1.0 / rr;\n"
8303 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
8304 " a -= mod(a, spaces) - spaces * 0.5;\n"
8306 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
8308 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
8309 " plane = plane - mod(plane, PI / count);\n"
8311 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
8313 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
8314 " float ydist = sqrt(rr * rr - level * level);\n"
8315 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
8316 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
8317 " float star = smoothstep(size, 0.0, distance(center, co));\n"
8321 "float luminance( vec3 v )\n"
8323 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
8326 "vec3 clearskies_ambient( vec3 dir )\n"
8328 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
8329 " float sky_gradient = dir.y;\n"
8331 " /* Blend phase colours */\n"
8332 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
8333 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
8334 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
8336 " /* Add gradient */\n"
8337 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
8339 " return ambient;\n"
8342 "vec3 clearskies_sky( vec3 ray_dir )\n"
8344 " ray_dir.y = abs( ray_dir.y );\n"
8345 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
8348 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
8349 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
8350 " float sun_shape = pow( sun_size, 2000.0 );\n"
8351 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
8353 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
8354 " sun_colour *= sun_shape;\n"
8357 " float star = 0.0;\n"
8358 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
8360 " if( star_blend > 0.001 ){\n"
8361 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
8362 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
8363 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
8367 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
8368 " return composite;\n"
8371 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
8373 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
8375 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
8376 " g_sunset_phase );\n"
8378 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
8379 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
8380 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
8381 " ) * g_sun_colour.rgb * g_day_phase;\n"
8383 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
8384 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
8385 " g_sunset_phase );\n"
8387 " return ambient + (light_sun + sky_reflection) * shadow;\n"
8392 "float world_depth_sample( vec3 pos )\n"
8394 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
8395 " return texture( g_world_depth, depth_coord ).r;\n"
8398 "float world_water_depth( vec3 pos )\n"
8400 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
8401 " return world_depth_sample( pos ) - ref_depth;\n"
8404 "float shadow_sample( vec3 co ){\n"
8405 " float height_sample = world_depth_sample( co );\n"
8407 " float fdelta = height_sample - co.y;\n"
8408 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
8411 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
8412 " if( g_shadow_samples == 0 ){\n"
8416 " float fspread = g_shadow_spread;\n"
8417 " float flength = g_shadow_length;\n"
8419 " float famt = 0.0;\n"
8420 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
8421 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
8422 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
8423 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
8425 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
8426 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
8427 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
8428 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
8430 " return 1.0 - famt;\n"
8433 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
8435 " vec3 specdir = reflect( -dir, wnormal );\n"
8436 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
8439 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
8440 " float dist = pow(fdist*0.0010,0.78);\n"
8441 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
8444 "vec3 scene_calculate_light( int light_index, \n"
8445 " vec3 halfview, vec3 co, vec3 normal )\n"
8447 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
8448 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
8449 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
8451 " vec3 light_delta = light_co.xyz-co;\n"
8452 " float dist2 = dot(light_delta,light_delta);\n"
8454 " light_delta = normalize( light_delta );\n"
8456 " float quadratic = dist2*100.0;\n"
8457 " float attenuation = 1.0/( 1.0 + quadratic );\n"
8458 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
8460 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
8462 " if( light_dir.w < 0.999999 ){\n"
8463 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
8464 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
8467 " return light_colour.rgb * attenuation * falloff \n"
8468 " * step( g_day_phase, light_colour.w );\n"
8471 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
8472 " vec3 halfview, vec3 co, vec3 normal )\n"
8474 " uint light_count = packed_index & 0x3u;\n"
8476 " vec3 l = vec3(0.0);\n"
8478 " if( light_count >= 1u ){\n"
8479 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
8480 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
8481 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
8483 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
8485 " if( light_count >= 2u ){\n"
8486 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
8488 " if( light_count >= 3u ){\n"
8489 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
8497 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
8498 " float light_mask )\n"
8500 " if( g_light_preview == 1 )\n"
8501 " diffuse = vec3(0.75);\n"
8504 " vec3 halfview = uCamera - co;\n"
8505 " float fdist = length(halfview);\n"
8506 " halfview /= fdist;\n"
8508 " float world_shadow = newlight_compute_sun_shadow( \n"
8509 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
8511 " vec3 total_light = clearskies_lighting( \n"
8512 " normal, min( light_mask, world_shadow ), halfview );\n"
8514 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
8515 " cube_coord = floor( cube_coord );\n"
8517 " if( g_debug_indices == 1 )\n"
8519 " return rand33(cube_coord);\n"
8522 " if( g_debug_complexity == 1 )\n"
8524 " ivec3 coord = ivec3( cube_coord );\n"
8525 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
8527 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
8528 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
8531 " // FIXME: this coord should absolutely must be clamped!\n"
8533 " ivec3 coord = ivec3( cube_coord );\n"
8534 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
8536 " total_light += \n"
8537 " scene_calculate_packed_light_patch( index_sample.x,\n"
8538 " halfview, co, normal ) \n"
8540 " total_light += \n"
8541 " scene_calculate_packed_light_patch( index_sample.y,\n"
8542 " halfview, co, normal )\n"
8545 " // Take a section of the sky function to give us a matching fog colour\n"
8547 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
8548 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
8549 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
8550 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
8552 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
8553 " sun_colour *= sun_shape;\n"
8555 " fog_colour += sun_colour;\n"
8556 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
8561 "const float k_motion_lerp_amount = 0.01;\n"
8565 "layout (location = 1) out vec2 oMotionVec;\n"
8567 "in vec3 aMotionVec0;\n"
8568 "in vec3 aMotionVec1;\n"
8570 "void compute_motion_vectors()\n"
8572 " // Write motion vectors\n"
8573 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
8574 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
8576 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
8581 "float stars1( vec3 rd, float rr, float size ){\n"
8582 " vec3 co = rd * rr;\n"
8584 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
8586 " float spaces = 1.0 / rr;\n"
8587 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
8588 " a -= mod(a, spaces) - spaces * 0.5;\n"
8590 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
8592 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
8593 " plane = plane - mod(plane, PI / count);\n"
8595 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
8597 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
8598 " float ydist = sqrt(rr * rr - level * level);\n"
8599 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
8600 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
8601 " float star = smoothstep(size, 0.0, distance(center, co));\n"
8606 " compute_motion_vectors();\n"
8608 " vec3 rd = -normalize(aNorm);\n"
8610 " float star = 0.0;\n"
8611 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
8612 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
8613 " star += stars( rd, 1.94 * pow( 1.64, j ), m ) * (1.0 / pow(4.0, j));\n"
8616 " oColour = vec4( vec3(star*20.0), 1.0);\n"
8621 GLuint _uniform_model_sky_space_uMdl
;
8622 GLuint _uniform_model_sky_space_uPv
;
8623 GLuint _uniform_model_sky_space_uPvmPrev
;
8624 GLuint _uniform_model_sky_space_uTexGarbage
;
8625 GLuint _uniform_model_sky_space_g_world_depth
;
8626 GLuint _uniform_model_sky_space_uLightsArray
;
8627 GLuint _uniform_model_sky_space_uLightsIndex
;
8628 #include "shaders/model_menu.h"
8629 struct vg_shader _shader_model_menu
= {
8630 .name
= "model_menu",
8633 .orig_file
= "shaders/model.vs",
8635 "layout (location=0) in vec3 a_co;\n"
8636 "layout (location=1) in vec3 a_norm;\n"
8637 "layout (location=2) in vec2 a_uv;\n"
8638 "layout (location=3) in vec4 a_colour;\n"
8639 "layout (location=4) in vec4 a_weights;\n"
8640 "layout (location=5) in ivec4 a_groups;\n"
8643 "const float k_motion_lerp_amount = 0.01;\n"
8647 "out vec3 aMotionVec0;\n"
8648 "out vec3 aMotionVec1;\n"
8650 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
8652 " // This magically solves some artifacting errors!\n"
8654 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
8656 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
8657 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
8662 "uniform mat4x3 uMdl;\n"
8663 "uniform mat4 uPv;\n"
8664 "uniform mat4 uPvmPrev;\n"
8666 "out vec4 aColour;\n"
8670 "out vec3 aWorldCo;\n"
8674 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
8675 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
8676 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
8678 " vs_motion_out( vproj0, vproj1 );\n"
8680 " gl_Position = vproj0;\n"
8681 " aWorldCo = world_pos0;\n"
8682 " aColour = a_colour;\n"
8684 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
8690 .orig_file
= "shaders/model_menu.fs",
8692 "out vec4 FragColor;\n"
8694 "uniform sampler2D uTexMain;\n"
8695 "uniform vec4 uColour;\n"
8697 "in vec4 aColour;\n"
8704 " vec4 diffuse = texture( uTexMain, aUv );\n"
8706 " if( diffuse.a < 0.5 )\n"
8709 " FragColor = vec4( diffuse.rgb, 1.0 ) * uColour;\n"
8714 GLuint _uniform_model_menu_uMdl
;
8715 GLuint _uniform_model_menu_uPv
;
8716 GLuint _uniform_model_menu_uPvmPrev
;
8717 GLuint _uniform_model_menu_uTexMain
;
8718 GLuint _uniform_model_menu_uColour
;
8719 #include "shaders/model_character_view.h"
8720 struct vg_shader _shader_model_character_view
= {
8721 .name
= "model_character_view",
8724 .orig_file
= "shaders/model_skinned.vs",
8726 "layout (location=0) in vec3 a_co;\n"
8727 "layout (location=1) in vec3 a_norm;\n"
8728 "layout (location=2) in vec2 a_uv;\n"
8729 "layout (location=3) in vec4 a_colour;\n"
8730 "layout (location=4) in vec4 a_weights;\n"
8731 "layout (location=5) in ivec4 a_groups;\n"
8734 "const float k_motion_lerp_amount = 0.01;\n"
8738 "out vec3 aMotionVec0;\n"
8739 "out vec3 aMotionVec1;\n"
8741 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
8743 " // This magically solves some artifacting errors!\n"
8745 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
8747 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
8748 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
8753 "uniform mat4 uPv;\n"
8754 "uniform mat4x3 uTransforms[32];\n"
8756 "out vec4 aColour;\n"
8760 "out vec3 aWorldCo;\n"
8764 " vec4 co_local = vec4( a_co, 1.0 );\n"
8765 " vec3 co0 = uTransforms[ a_groups[0] ] * co_local;\n"
8766 " vec3 co1 = uTransforms[ a_groups[1] ] * co_local;\n"
8767 " vec3 co2 = uTransforms[ a_groups[2] ] * co_local;\n"
8768 " vec3 n0 = mat3(uTransforms[ a_groups[0] ]) * a_norm;\n"
8769 " vec3 n1 = mat3(uTransforms[ a_groups[1] ]) * a_norm;\n"
8770 " vec3 n2 = mat3(uTransforms[ a_groups[2] ]) * a_norm;\n"
8772 " vec3 world_pos = co0*a_weights[0] + co1*a_weights[1] + co2*a_weights[2];\n"
8773 " vec3 world_normal = n0*a_weights[0] + n1*a_weights[1] + n2*a_weights[2];\n"
8775 " gl_Position = uPv * vec4( world_pos, 1.0 );\n"
8776 " aColour = a_colour;\n"
8778 " aNorm = world_normal;\n"
8780 " aWorldCo = world_pos;\n"
8782 " // TODO: motion vectors\n"
8783 " aMotionVec0 = vec3(1.0);\n"
8784 " aMotionVec1 = vec3(1.0);\n"
8789 .orig_file
= "shaders/model_character_view.fs",
8791 "uniform sampler2D uTexMain;\n"
8792 "uniform vec3 uCamera;\n"
8794 "in vec4 aColour;\n"
8798 "in vec3 aWorldCo;\n"
8802 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
8806 "layout (location = 0) out vec4 oColour;\n"
8808 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
8809 "layout (std140) uniform ub_world_lighting\n"
8811 " vec4 g_cube_min;\n"
8812 " vec4 g_cube_inv_range;\n"
8814 " vec4 g_water_plane;\n"
8815 " vec4 g_depth_bounds;\n"
8817 " vec4 g_daysky_colour;\n"
8818 " vec4 g_nightsky_colour;\n"
8819 " vec4 g_sunset_colour;\n"
8820 " vec4 g_ambient_colour;\n"
8821 " vec4 g_sunset_ambient;\n"
8822 " vec4 g_sun_colour;\n"
8823 " vec4 g_sun_dir;\n"
8824 " vec4 g_board_0;\n"
8825 " vec4 g_board_1;\n"
8827 " float g_water_fog;\n"
8829 " float g_realtime;\n"
8830 " float g_shadow_length;\n"
8831 " float g_shadow_spread;\n"
8833 " float g_time_of_day;\n"
8834 " float g_day_phase;\n"
8835 " float g_sunset_phase;\n"
8837 " int g_light_preview;\n"
8838 " int g_shadow_samples;\n"
8840 " int g_debug_indices;\n"
8841 " int g_debug_complexity;\n"
8844 "uniform sampler2D g_world_depth;\n"
8845 "uniform samplerBuffer uLightsArray;\n"
8846 "uniform usampler3D uLightsIndex;\n"
8849 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
8850 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
8851 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
8852 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
8853 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
8854 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
8856 "const float SUN_ANGLE = 0.0001;\n"
8857 "const float PI = 3.14159265358979323846264;\n"
8859 "//struct world_info\n"
8864 "// sunset_phase;\n"
8866 "// vec3 sun_dir;\n"
8869 "vec3 rand33(vec3 p3)\n"
8871 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
8872 " p3 += dot(p3, p3.yxz+33.33);\n"
8873 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
8876 "float stars( vec3 rd, float rr, float size ){\n"
8877 " vec3 co = rd * rr;\n"
8879 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
8881 " float spaces = 1.0 / rr;\n"
8882 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
8883 " a -= mod(a, spaces) - spaces * 0.5;\n"
8885 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
8887 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
8888 " plane = plane - mod(plane, PI / count);\n"
8890 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
8892 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
8893 " float ydist = sqrt(rr * rr - level * level);\n"
8894 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
8895 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
8896 " float star = smoothstep(size, 0.0, distance(center, co));\n"
8900 "float luminance( vec3 v )\n"
8902 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
8905 "vec3 clearskies_ambient( vec3 dir )\n"
8907 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
8908 " float sky_gradient = dir.y;\n"
8910 " /* Blend phase colours */\n"
8911 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
8912 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
8913 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
8915 " /* Add gradient */\n"
8916 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
8918 " return ambient;\n"
8921 "vec3 clearskies_sky( vec3 ray_dir )\n"
8923 " ray_dir.y = abs( ray_dir.y );\n"
8924 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
8927 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
8928 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
8929 " float sun_shape = pow( sun_size, 2000.0 );\n"
8930 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
8932 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
8933 " sun_colour *= sun_shape;\n"
8936 " float star = 0.0;\n"
8937 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
8939 " if( star_blend > 0.001 ){\n"
8940 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
8941 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
8942 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
8946 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
8947 " return composite;\n"
8950 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
8952 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
8954 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
8955 " g_sunset_phase );\n"
8957 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
8958 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
8959 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
8960 " ) * g_sun_colour.rgb * g_day_phase;\n"
8962 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
8963 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
8964 " g_sunset_phase );\n"
8966 " return ambient + (light_sun + sky_reflection) * shadow;\n"
8971 "float world_depth_sample( vec3 pos )\n"
8973 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
8974 " return texture( g_world_depth, depth_coord ).r;\n"
8977 "float world_water_depth( vec3 pos )\n"
8979 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
8980 " return world_depth_sample( pos ) - ref_depth;\n"
8983 "float shadow_sample( vec3 co ){\n"
8984 " float height_sample = world_depth_sample( co );\n"
8986 " float fdelta = height_sample - co.y;\n"
8987 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
8990 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
8991 " if( g_shadow_samples == 0 ){\n"
8995 " float fspread = g_shadow_spread;\n"
8996 " float flength = g_shadow_length;\n"
8998 " float famt = 0.0;\n"
8999 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
9000 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
9001 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
9002 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
9004 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
9005 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
9006 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
9007 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
9009 " return 1.0 - famt;\n"
9012 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
9014 " vec3 specdir = reflect( -dir, wnormal );\n"
9015 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
9018 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
9019 " float dist = pow(fdist*0.0010,0.78);\n"
9020 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
9023 "vec3 scene_calculate_light( int light_index, \n"
9024 " vec3 halfview, vec3 co, vec3 normal )\n"
9026 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
9027 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
9028 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
9030 " vec3 light_delta = light_co.xyz-co;\n"
9031 " float dist2 = dot(light_delta,light_delta);\n"
9033 " light_delta = normalize( light_delta );\n"
9035 " float quadratic = dist2*100.0;\n"
9036 " float attenuation = 1.0/( 1.0 + quadratic );\n"
9037 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
9039 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
9041 " if( light_dir.w < 0.999999 ){\n"
9042 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
9043 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
9046 " return light_colour.rgb * attenuation * falloff \n"
9047 " * step( g_day_phase, light_colour.w );\n"
9050 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
9051 " vec3 halfview, vec3 co, vec3 normal )\n"
9053 " uint light_count = packed_index & 0x3u;\n"
9055 " vec3 l = vec3(0.0);\n"
9057 " if( light_count >= 1u ){\n"
9058 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
9059 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
9060 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
9062 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
9064 " if( light_count >= 2u ){\n"
9065 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
9067 " if( light_count >= 3u ){\n"
9068 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
9076 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
9077 " float light_mask )\n"
9079 " if( g_light_preview == 1 )\n"
9080 " diffuse = vec3(0.75);\n"
9083 " vec3 halfview = uCamera - co;\n"
9084 " float fdist = length(halfview);\n"
9085 " halfview /= fdist;\n"
9087 " float world_shadow = newlight_compute_sun_shadow( \n"
9088 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
9090 " vec3 total_light = clearskies_lighting( \n"
9091 " normal, min( light_mask, world_shadow ), halfview );\n"
9093 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
9094 " cube_coord = floor( cube_coord );\n"
9096 " if( g_debug_indices == 1 )\n"
9098 " return rand33(cube_coord);\n"
9101 " if( g_debug_complexity == 1 )\n"
9103 " ivec3 coord = ivec3( cube_coord );\n"
9104 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9106 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
9107 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
9110 " // FIXME: this coord should absolutely must be clamped!\n"
9112 " ivec3 coord = ivec3( cube_coord );\n"
9113 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9115 " total_light += \n"
9116 " scene_calculate_packed_light_patch( index_sample.x,\n"
9117 " halfview, co, normal ) \n"
9119 " total_light += \n"
9120 " scene_calculate_packed_light_patch( index_sample.y,\n"
9121 " halfview, co, normal )\n"
9124 " // Take a section of the sky function to give us a matching fog colour\n"
9126 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
9127 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
9128 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
9129 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9131 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9132 " sun_colour *= sun_shape;\n"
9134 " fog_colour += sun_colour;\n"
9135 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
9140 "const float k_motion_lerp_amount = 0.01;\n"
9144 "layout (location = 1) out vec2 oMotionVec;\n"
9146 "in vec3 aMotionVec0;\n"
9147 "in vec3 aMotionVec1;\n"
9149 "void compute_motion_vectors()\n"
9151 " // Write motion vectors\n"
9152 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
9153 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
9155 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
9160 "uniform sampler2D uTexSceneDepth;\n"
9161 "uniform vec3 uInverseRatioDepth;\n"
9162 "uniform vec3 uInverseRatioMain;\n"
9163 "uniform int uDepthMode;\n"
9164 "uniform float uDitherCutoff;\n"
9166 "float linear_depth( float depth, float near, float far ) {\n"
9167 " float z = depth * 2.0 - 1.0;\n"
9168 " return (2.0 * near * far) / (far + near - z * (far - near)); \n"
9171 "void depth_compare_dither()\n"
9173 " if( uDepthMode == 1 )\n"
9175 " vec2 back_coord = gl_FragCoord.xy * uInverseRatioMain.xy \n"
9176 " * uInverseRatioDepth.xy;\n"
9177 " float back_depth = texture( uTexSceneDepth, back_coord ).r;\n"
9178 " float front_depth = gl_FragCoord.z/gl_FragCoord.w;\n"
9180 " back_depth = linear_depth( back_depth, 0.1, 2100.0 );\n"
9181 " float diff = back_depth - front_depth;\n"
9183 " vec2 ssuv = gl_FragCoord.xy;\n"
9184 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
9185 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
9187 " if( step(0.0,diff)+dither<0.3 )\n"
9191 " if( uDepthMode == 2 )\n"
9193 " vec2 ssuv = gl_FragCoord.xy;\n"
9194 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
9195 " float dither = fract( vDither.g / 71.0 );\n"
9196 " if( dither<uDitherCutoff ) discard;\n"
9202 "vec3 character_clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
9204 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
9206 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
9207 " g_sunset_phase );\n"
9210 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
9211 " vec3 light_sun = max(0.0, dot(normal,g_sun_dir.xyz)*0.5+0.5) \n"
9212 " * g_sun_colour.rgb * g_day_phase;\n"
9214 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
9215 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
9216 " g_sunset_phase );\n"
9218 " return ambient + (light_sun + sky_reflection) * shadow;\n"
9221 "vec3 character_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
9222 " float light_mask )\n"
9224 " if( g_light_preview == 1 )\n"
9225 " diffuse = vec3(0.75);\n"
9228 " vec3 halfview = uCamera - co;\n"
9229 " float fdist = length(halfview);\n"
9230 " halfview /= fdist;\n"
9232 " float world_shadow = newlight_compute_sun_shadow( \n"
9233 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
9235 " vec3 total_light = character_clearskies_lighting( \n"
9236 " normal, min( light_mask, world_shadow ), halfview );\n"
9238 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
9239 " cube_coord = floor( cube_coord );\n"
9241 " if( g_debug_indices == 1 )\n"
9243 " return rand33(cube_coord);\n"
9246 " if( g_debug_complexity == 1 )\n"
9248 " ivec3 coord = ivec3( cube_coord );\n"
9249 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9251 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
9252 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
9255 " // FIXME: this coord should absolutely must be clamped!\n"
9257 " ivec3 coord = ivec3( cube_coord );\n"
9258 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9260 " total_light += \n"
9261 " scene_calculate_packed_light_patch( index_sample.x,\n"
9262 " halfview, co, normal ) \n"
9264 " total_light += \n"
9265 " scene_calculate_packed_light_patch( index_sample.y,\n"
9266 " halfview, co, normal )\n"
9269 " // Take a section of the sky function to give us a matching fog colour\n"
9271 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
9272 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
9273 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
9274 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9276 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9277 " sun_colour *= sun_shape;\n"
9279 " fog_colour += sun_colour;\n"
9280 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
9284 " depth_compare_dither();\n"
9285 " compute_motion_vectors();\n"
9287 " vec3 qnorm = aNorm;\n"
9288 " vec3 diffuse = texture( uTexMain, aUv ).rgb;\n"
9289 " vec3 composite = character_compute_lighting( diffuse, qnorm, aWorldCo, 1.0 );\n"
9291 " float dist = distance( aWorldCo, uCamera ) - 0.08;\n"
9292 " float opacity = clamp( dist*dist, 0.0, 1.0 );\n"
9294 " oColour = vec4( composite, opacity );\n"
9299 GLuint _uniform_model_character_view_uPv
;
9300 GLuint _uniform_model_character_view_uTransforms
;
9301 GLuint _uniform_model_character_view_uTexMain
;
9302 GLuint _uniform_model_character_view_uCamera
;
9303 GLuint _uniform_model_character_view_g_world_depth
;
9304 GLuint _uniform_model_character_view_uLightsArray
;
9305 GLuint _uniform_model_character_view_uLightsIndex
;
9306 GLuint _uniform_model_character_view_uTexSceneDepth
;
9307 GLuint _uniform_model_character_view_uInverseRatioDepth
;
9308 GLuint _uniform_model_character_view_uInverseRatioMain
;
9309 GLuint _uniform_model_character_view_uDepthMode
;
9310 GLuint _uniform_model_character_view_uDitherCutoff
;
9311 #include "shaders/model_board_view.h"
9312 struct vg_shader _shader_model_board_view
= {
9313 .name
= "model_board_view",
9316 .orig_file
= "shaders/model.vs",
9318 "layout (location=0) in vec3 a_co;\n"
9319 "layout (location=1) in vec3 a_norm;\n"
9320 "layout (location=2) in vec2 a_uv;\n"
9321 "layout (location=3) in vec4 a_colour;\n"
9322 "layout (location=4) in vec4 a_weights;\n"
9323 "layout (location=5) in ivec4 a_groups;\n"
9326 "const float k_motion_lerp_amount = 0.01;\n"
9330 "out vec3 aMotionVec0;\n"
9331 "out vec3 aMotionVec1;\n"
9333 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
9335 " // This magically solves some artifacting errors!\n"
9337 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
9339 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
9340 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
9345 "uniform mat4x3 uMdl;\n"
9346 "uniform mat4 uPv;\n"
9347 "uniform mat4 uPvmPrev;\n"
9349 "out vec4 aColour;\n"
9353 "out vec3 aWorldCo;\n"
9357 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
9358 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
9359 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
9361 " vs_motion_out( vproj0, vproj1 );\n"
9363 " gl_Position = vproj0;\n"
9364 " aWorldCo = world_pos0;\n"
9365 " aColour = a_colour;\n"
9367 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
9373 .orig_file
= "shaders/model_character_view.fs",
9375 "uniform sampler2D uTexMain;\n"
9376 "uniform vec3 uCamera;\n"
9378 "in vec4 aColour;\n"
9382 "in vec3 aWorldCo;\n"
9386 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
9390 "layout (location = 0) out vec4 oColour;\n"
9392 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
9393 "layout (std140) uniform ub_world_lighting\n"
9395 " vec4 g_cube_min;\n"
9396 " vec4 g_cube_inv_range;\n"
9398 " vec4 g_water_plane;\n"
9399 " vec4 g_depth_bounds;\n"
9401 " vec4 g_daysky_colour;\n"
9402 " vec4 g_nightsky_colour;\n"
9403 " vec4 g_sunset_colour;\n"
9404 " vec4 g_ambient_colour;\n"
9405 " vec4 g_sunset_ambient;\n"
9406 " vec4 g_sun_colour;\n"
9407 " vec4 g_sun_dir;\n"
9408 " vec4 g_board_0;\n"
9409 " vec4 g_board_1;\n"
9411 " float g_water_fog;\n"
9413 " float g_realtime;\n"
9414 " float g_shadow_length;\n"
9415 " float g_shadow_spread;\n"
9417 " float g_time_of_day;\n"
9418 " float g_day_phase;\n"
9419 " float g_sunset_phase;\n"
9421 " int g_light_preview;\n"
9422 " int g_shadow_samples;\n"
9424 " int g_debug_indices;\n"
9425 " int g_debug_complexity;\n"
9428 "uniform sampler2D g_world_depth;\n"
9429 "uniform samplerBuffer uLightsArray;\n"
9430 "uniform usampler3D uLightsIndex;\n"
9433 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
9434 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
9435 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
9436 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
9437 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
9438 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
9440 "const float SUN_ANGLE = 0.0001;\n"
9441 "const float PI = 3.14159265358979323846264;\n"
9443 "//struct world_info\n"
9448 "// sunset_phase;\n"
9450 "// vec3 sun_dir;\n"
9453 "vec3 rand33(vec3 p3)\n"
9455 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
9456 " p3 += dot(p3, p3.yxz+33.33);\n"
9457 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
9460 "float stars( vec3 rd, float rr, float size ){\n"
9461 " vec3 co = rd * rr;\n"
9463 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
9465 " float spaces = 1.0 / rr;\n"
9466 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
9467 " a -= mod(a, spaces) - spaces * 0.5;\n"
9469 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
9471 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
9472 " plane = plane - mod(plane, PI / count);\n"
9474 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
9476 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
9477 " float ydist = sqrt(rr * rr - level * level);\n"
9478 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
9479 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
9480 " float star = smoothstep(size, 0.0, distance(center, co));\n"
9484 "float luminance( vec3 v )\n"
9486 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
9489 "vec3 clearskies_ambient( vec3 dir )\n"
9491 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
9492 " float sky_gradient = dir.y;\n"
9494 " /* Blend phase colours */\n"
9495 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
9496 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
9497 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
9499 " /* Add gradient */\n"
9500 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
9502 " return ambient;\n"
9505 "vec3 clearskies_sky( vec3 ray_dir )\n"
9507 " ray_dir.y = abs( ray_dir.y );\n"
9508 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
9511 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
9512 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
9513 " float sun_shape = pow( sun_size, 2000.0 );\n"
9514 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9516 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9517 " sun_colour *= sun_shape;\n"
9520 " float star = 0.0;\n"
9521 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
9523 " if( star_blend > 0.001 ){\n"
9524 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
9525 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
9526 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
9530 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
9531 " return composite;\n"
9534 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
9536 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
9538 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
9539 " g_sunset_phase );\n"
9541 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
9542 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
9543 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
9544 " ) * g_sun_colour.rgb * g_day_phase;\n"
9546 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
9547 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
9548 " g_sunset_phase );\n"
9550 " return ambient + (light_sun + sky_reflection) * shadow;\n"
9555 "float world_depth_sample( vec3 pos )\n"
9557 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
9558 " return texture( g_world_depth, depth_coord ).r;\n"
9561 "float world_water_depth( vec3 pos )\n"
9563 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
9564 " return world_depth_sample( pos ) - ref_depth;\n"
9567 "float shadow_sample( vec3 co ){\n"
9568 " float height_sample = world_depth_sample( co );\n"
9570 " float fdelta = height_sample - co.y;\n"
9571 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
9574 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
9575 " if( g_shadow_samples == 0 ){\n"
9579 " float fspread = g_shadow_spread;\n"
9580 " float flength = g_shadow_length;\n"
9582 " float famt = 0.0;\n"
9583 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
9584 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
9585 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
9586 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
9588 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
9589 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
9590 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
9591 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
9593 " return 1.0 - famt;\n"
9596 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
9598 " vec3 specdir = reflect( -dir, wnormal );\n"
9599 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
9602 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
9603 " float dist = pow(fdist*0.0010,0.78);\n"
9604 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
9607 "vec3 scene_calculate_light( int light_index, \n"
9608 " vec3 halfview, vec3 co, vec3 normal )\n"
9610 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
9611 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
9612 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
9614 " vec3 light_delta = light_co.xyz-co;\n"
9615 " float dist2 = dot(light_delta,light_delta);\n"
9617 " light_delta = normalize( light_delta );\n"
9619 " float quadratic = dist2*100.0;\n"
9620 " float attenuation = 1.0/( 1.0 + quadratic );\n"
9621 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
9623 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
9625 " if( light_dir.w < 0.999999 ){\n"
9626 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
9627 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
9630 " return light_colour.rgb * attenuation * falloff \n"
9631 " * step( g_day_phase, light_colour.w );\n"
9634 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
9635 " vec3 halfview, vec3 co, vec3 normal )\n"
9637 " uint light_count = packed_index & 0x3u;\n"
9639 " vec3 l = vec3(0.0);\n"
9641 " if( light_count >= 1u ){\n"
9642 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
9643 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
9644 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
9646 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
9648 " if( light_count >= 2u ){\n"
9649 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
9651 " if( light_count >= 3u ){\n"
9652 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
9660 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
9661 " float light_mask )\n"
9663 " if( g_light_preview == 1 )\n"
9664 " diffuse = vec3(0.75);\n"
9667 " vec3 halfview = uCamera - co;\n"
9668 " float fdist = length(halfview);\n"
9669 " halfview /= fdist;\n"
9671 " float world_shadow = newlight_compute_sun_shadow( \n"
9672 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
9674 " vec3 total_light = clearskies_lighting( \n"
9675 " normal, min( light_mask, world_shadow ), halfview );\n"
9677 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
9678 " cube_coord = floor( cube_coord );\n"
9680 " if( g_debug_indices == 1 )\n"
9682 " return rand33(cube_coord);\n"
9685 " if( g_debug_complexity == 1 )\n"
9687 " ivec3 coord = ivec3( cube_coord );\n"
9688 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9690 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
9691 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
9694 " // FIXME: this coord should absolutely must be clamped!\n"
9696 " ivec3 coord = ivec3( cube_coord );\n"
9697 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9699 " total_light += \n"
9700 " scene_calculate_packed_light_patch( index_sample.x,\n"
9701 " halfview, co, normal ) \n"
9703 " total_light += \n"
9704 " scene_calculate_packed_light_patch( index_sample.y,\n"
9705 " halfview, co, normal )\n"
9708 " // Take a section of the sky function to give us a matching fog colour\n"
9710 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
9711 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
9712 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
9713 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9715 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9716 " sun_colour *= sun_shape;\n"
9718 " fog_colour += sun_colour;\n"
9719 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
9724 "const float k_motion_lerp_amount = 0.01;\n"
9728 "layout (location = 1) out vec2 oMotionVec;\n"
9730 "in vec3 aMotionVec0;\n"
9731 "in vec3 aMotionVec1;\n"
9733 "void compute_motion_vectors()\n"
9735 " // Write motion vectors\n"
9736 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
9737 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
9739 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
9744 "uniform sampler2D uTexSceneDepth;\n"
9745 "uniform vec3 uInverseRatioDepth;\n"
9746 "uniform vec3 uInverseRatioMain;\n"
9747 "uniform int uDepthMode;\n"
9748 "uniform float uDitherCutoff;\n"
9750 "float linear_depth( float depth, float near, float far ) {\n"
9751 " float z = depth * 2.0 - 1.0;\n"
9752 " return (2.0 * near * far) / (far + near - z * (far - near)); \n"
9755 "void depth_compare_dither()\n"
9757 " if( uDepthMode == 1 )\n"
9759 " vec2 back_coord = gl_FragCoord.xy * uInverseRatioMain.xy \n"
9760 " * uInverseRatioDepth.xy;\n"
9761 " float back_depth = texture( uTexSceneDepth, back_coord ).r;\n"
9762 " float front_depth = gl_FragCoord.z/gl_FragCoord.w;\n"
9764 " back_depth = linear_depth( back_depth, 0.1, 2100.0 );\n"
9765 " float diff = back_depth - front_depth;\n"
9767 " vec2 ssuv = gl_FragCoord.xy;\n"
9768 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
9769 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
9771 " if( step(0.0,diff)+dither<0.3 )\n"
9775 " if( uDepthMode == 2 )\n"
9777 " vec2 ssuv = gl_FragCoord.xy;\n"
9778 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
9779 " float dither = fract( vDither.g / 71.0 );\n"
9780 " if( dither<uDitherCutoff ) discard;\n"
9786 "vec3 character_clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
9788 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
9790 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
9791 " g_sunset_phase );\n"
9794 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
9795 " vec3 light_sun = max(0.0, dot(normal,g_sun_dir.xyz)*0.5+0.5) \n"
9796 " * g_sun_colour.rgb * g_day_phase;\n"
9798 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
9799 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
9800 " g_sunset_phase );\n"
9802 " return ambient + (light_sun + sky_reflection) * shadow;\n"
9805 "vec3 character_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
9806 " float light_mask )\n"
9808 " if( g_light_preview == 1 )\n"
9809 " diffuse = vec3(0.75);\n"
9812 " vec3 halfview = uCamera - co;\n"
9813 " float fdist = length(halfview);\n"
9814 " halfview /= fdist;\n"
9816 " float world_shadow = newlight_compute_sun_shadow( \n"
9817 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
9819 " vec3 total_light = character_clearskies_lighting( \n"
9820 " normal, min( light_mask, world_shadow ), halfview );\n"
9822 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
9823 " cube_coord = floor( cube_coord );\n"
9825 " if( g_debug_indices == 1 )\n"
9827 " return rand33(cube_coord);\n"
9830 " if( g_debug_complexity == 1 )\n"
9832 " ivec3 coord = ivec3( cube_coord );\n"
9833 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9835 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
9836 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
9839 " // FIXME: this coord should absolutely must be clamped!\n"
9841 " ivec3 coord = ivec3( cube_coord );\n"
9842 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9844 " total_light += \n"
9845 " scene_calculate_packed_light_patch( index_sample.x,\n"
9846 " halfview, co, normal ) \n"
9848 " total_light += \n"
9849 " scene_calculate_packed_light_patch( index_sample.y,\n"
9850 " halfview, co, normal )\n"
9853 " // Take a section of the sky function to give us a matching fog colour\n"
9855 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
9856 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
9857 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
9858 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9860 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9861 " sun_colour *= sun_shape;\n"
9863 " fog_colour += sun_colour;\n"
9864 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
9868 " depth_compare_dither();\n"
9869 " compute_motion_vectors();\n"
9871 " vec3 qnorm = aNorm;\n"
9872 " vec3 diffuse = texture( uTexMain, aUv ).rgb;\n"
9873 " vec3 composite = character_compute_lighting( diffuse, qnorm, aWorldCo, 1.0 );\n"
9875 " float dist = distance( aWorldCo, uCamera ) - 0.08;\n"
9876 " float opacity = clamp( dist*dist, 0.0, 1.0 );\n"
9878 " oColour = vec4( composite, opacity );\n"
9883 GLuint _uniform_model_board_view_uMdl
;
9884 GLuint _uniform_model_board_view_uPv
;
9885 GLuint _uniform_model_board_view_uPvmPrev
;
9886 GLuint _uniform_model_board_view_uTexMain
;
9887 GLuint _uniform_model_board_view_uCamera
;
9888 GLuint _uniform_model_board_view_g_world_depth
;
9889 GLuint _uniform_model_board_view_uLightsArray
;
9890 GLuint _uniform_model_board_view_uLightsIndex
;
9891 GLuint _uniform_model_board_view_uTexSceneDepth
;
9892 GLuint _uniform_model_board_view_uInverseRatioDepth
;
9893 GLuint _uniform_model_board_view_uInverseRatioMain
;
9894 GLuint _uniform_model_board_view_uDepthMode
;
9895 GLuint _uniform_model_board_view_uDitherCutoff
;
9896 #include "shaders/model_entity.h"
9897 struct vg_shader _shader_model_entity
= {
9898 .name
= "model_entity",
9901 .orig_file
= "shaders/model.vs",
9903 "layout (location=0) in vec3 a_co;\n"
9904 "layout (location=1) in vec3 a_norm;\n"
9905 "layout (location=2) in vec2 a_uv;\n"
9906 "layout (location=3) in vec4 a_colour;\n"
9907 "layout (location=4) in vec4 a_weights;\n"
9908 "layout (location=5) in ivec4 a_groups;\n"
9911 "const float k_motion_lerp_amount = 0.01;\n"
9915 "out vec3 aMotionVec0;\n"
9916 "out vec3 aMotionVec1;\n"
9918 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
9920 " // This magically solves some artifacting errors!\n"
9922 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
9924 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
9925 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
9930 "uniform mat4x3 uMdl;\n"
9931 "uniform mat4 uPv;\n"
9932 "uniform mat4 uPvmPrev;\n"
9934 "out vec4 aColour;\n"
9938 "out vec3 aWorldCo;\n"
9942 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
9943 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
9944 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
9946 " vs_motion_out( vproj0, vproj1 );\n"
9948 " gl_Position = vproj0;\n"
9949 " aWorldCo = world_pos0;\n"
9950 " aColour = a_colour;\n"
9952 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
9958 .orig_file
= "shaders/model_entity.fs",
9960 "uniform sampler2D uTexMain;\n"
9961 "uniform vec3 uCamera;\n"
9963 "in vec4 aColour;\n"
9967 "in vec3 aWorldCo;\n"
9971 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
9975 "layout (location = 0) out vec4 oColour;\n"
9977 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
9978 "layout (std140) uniform ub_world_lighting\n"
9980 " vec4 g_cube_min;\n"
9981 " vec4 g_cube_inv_range;\n"
9983 " vec4 g_water_plane;\n"
9984 " vec4 g_depth_bounds;\n"
9986 " vec4 g_daysky_colour;\n"
9987 " vec4 g_nightsky_colour;\n"
9988 " vec4 g_sunset_colour;\n"
9989 " vec4 g_ambient_colour;\n"
9990 " vec4 g_sunset_ambient;\n"
9991 " vec4 g_sun_colour;\n"
9992 " vec4 g_sun_dir;\n"
9993 " vec4 g_board_0;\n"
9994 " vec4 g_board_1;\n"
9996 " float g_water_fog;\n"
9998 " float g_realtime;\n"
9999 " float g_shadow_length;\n"
10000 " float g_shadow_spread;\n"
10002 " float g_time_of_day;\n"
10003 " float g_day_phase;\n"
10004 " float g_sunset_phase;\n"
10006 " int g_light_preview;\n"
10007 " int g_shadow_samples;\n"
10009 " int g_debug_indices;\n"
10010 " int g_debug_complexity;\n"
10013 "uniform sampler2D g_world_depth;\n"
10014 "uniform samplerBuffer uLightsArray;\n"
10015 "uniform usampler3D uLightsIndex;\n"
10018 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
10019 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
10020 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
10021 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
10022 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
10023 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
10025 "const float SUN_ANGLE = 0.0001;\n"
10026 "const float PI = 3.14159265358979323846264;\n"
10028 "//struct world_info\n"
10031 "// time_of_day,\n"
10033 "// sunset_phase;\n"
10035 "// vec3 sun_dir;\n"
10038 "vec3 rand33(vec3 p3)\n"
10040 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
10041 " p3 += dot(p3, p3.yxz+33.33);\n"
10042 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
10045 "float stars( vec3 rd, float rr, float size ){\n"
10046 " vec3 co = rd * rr;\n"
10048 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
10050 " float spaces = 1.0 / rr;\n"
10051 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
10052 " a -= mod(a, spaces) - spaces * 0.5;\n"
10054 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
10056 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
10057 " plane = plane - mod(plane, PI / count);\n"
10059 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
10061 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
10062 " float ydist = sqrt(rr * rr - level * level);\n"
10063 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
10064 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
10065 " float star = smoothstep(size, 0.0, distance(center, co));\n"
10069 "float luminance( vec3 v )\n"
10071 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
10074 "vec3 clearskies_ambient( vec3 dir )\n"
10076 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
10077 " float sky_gradient = dir.y;\n"
10079 " /* Blend phase colours */\n"
10080 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
10081 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
10082 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
10084 " /* Add gradient */\n"
10085 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
10087 " return ambient;\n"
10090 "vec3 clearskies_sky( vec3 ray_dir )\n"
10092 " ray_dir.y = abs( ray_dir.y );\n"
10093 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
10096 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
10097 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
10098 " float sun_shape = pow( sun_size, 2000.0 );\n"
10099 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
10101 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
10102 " sun_colour *= sun_shape;\n"
10105 " float star = 0.0;\n"
10106 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
10108 " if( star_blend > 0.001 ){\n"
10109 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
10110 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
10111 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
10115 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
10116 " return composite;\n"
10119 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
10121 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
10123 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
10124 " g_sunset_phase );\n"
10126 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
10127 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
10128 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
10129 " ) * g_sun_colour.rgb * g_day_phase;\n"
10131 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
10132 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
10133 " g_sunset_phase );\n"
10135 " return ambient + (light_sun + sky_reflection) * shadow;\n"
10140 "float world_depth_sample( vec3 pos )\n"
10142 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
10143 " return texture( g_world_depth, depth_coord ).r;\n"
10146 "float world_water_depth( vec3 pos )\n"
10148 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
10149 " return world_depth_sample( pos ) - ref_depth;\n"
10152 "float shadow_sample( vec3 co ){\n"
10153 " float height_sample = world_depth_sample( co );\n"
10155 " float fdelta = height_sample - co.y;\n"
10156 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
10159 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
10160 " if( g_shadow_samples == 0 ){\n"
10164 " float fspread = g_shadow_spread;\n"
10165 " float flength = g_shadow_length;\n"
10167 " float famt = 0.0;\n"
10168 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
10169 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
10170 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
10171 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
10173 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
10174 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
10175 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
10176 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
10178 " return 1.0 - famt;\n"
10181 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
10183 " vec3 specdir = reflect( -dir, wnormal );\n"
10184 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
10187 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
10188 " float dist = pow(fdist*0.0010,0.78);\n"
10189 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
10192 "vec3 scene_calculate_light( int light_index, \n"
10193 " vec3 halfview, vec3 co, vec3 normal )\n"
10195 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
10196 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
10197 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
10199 " vec3 light_delta = light_co.xyz-co;\n"
10200 " float dist2 = dot(light_delta,light_delta);\n"
10202 " light_delta = normalize( light_delta );\n"
10204 " float quadratic = dist2*100.0;\n"
10205 " float attenuation = 1.0/( 1.0 + quadratic );\n"
10206 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
10208 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
10210 " if( light_dir.w < 0.999999 ){\n"
10211 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
10212 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
10215 " return light_colour.rgb * attenuation * falloff \n"
10216 " * step( g_day_phase, light_colour.w );\n"
10219 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
10220 " vec3 halfview, vec3 co, vec3 normal )\n"
10222 " uint light_count = packed_index & 0x3u;\n"
10224 " vec3 l = vec3(0.0);\n"
10226 " if( light_count >= 1u ){\n"
10227 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
10228 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
10229 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
10231 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
10233 " if( light_count >= 2u ){\n"
10234 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
10236 " if( light_count >= 3u ){\n"
10237 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
10245 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
10246 " float light_mask )\n"
10248 " if( g_light_preview == 1 )\n"
10249 " diffuse = vec3(0.75);\n"
10252 " vec3 halfview = uCamera - co;\n"
10253 " float fdist = length(halfview);\n"
10254 " halfview /= fdist;\n"
10256 " float world_shadow = newlight_compute_sun_shadow( \n"
10257 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
10259 " vec3 total_light = clearskies_lighting( \n"
10260 " normal, min( light_mask, world_shadow ), halfview );\n"
10262 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
10263 " cube_coord = floor( cube_coord );\n"
10265 " if( g_debug_indices == 1 )\n"
10267 " return rand33(cube_coord);\n"
10270 " if( g_debug_complexity == 1 )\n"
10272 " ivec3 coord = ivec3( cube_coord );\n"
10273 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
10275 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
10276 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
10279 " // FIXME: this coord should absolutely must be clamped!\n"
10281 " ivec3 coord = ivec3( cube_coord );\n"
10282 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
10284 " total_light += \n"
10285 " scene_calculate_packed_light_patch( index_sample.x,\n"
10286 " halfview, co, normal ) \n"
10288 " total_light += \n"
10289 " scene_calculate_packed_light_patch( index_sample.y,\n"
10290 " halfview, co, normal )\n"
10293 " // Take a section of the sky function to give us a matching fog colour\n"
10295 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
10296 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
10297 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
10298 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
10300 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
10301 " sun_colour *= sun_shape;\n"
10303 " fog_colour += sun_colour;\n"
10304 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
10309 "const float k_motion_lerp_amount = 0.01;\n"
10313 "layout (location = 1) out vec2 oMotionVec;\n"
10315 "in vec3 aMotionVec0;\n"
10316 "in vec3 aMotionVec1;\n"
10318 "void compute_motion_vectors()\n"
10320 " // Write motion vectors\n"
10321 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10322 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10324 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10331 " compute_motion_vectors();\n"
10333 " vec3 qnorm = normalize(floor(aNorm*2.0)*0.5) + vec3(0.001,0.0,0.0);\n"
10334 " vec3 diffuse = texture( uTexMain, aUv ).rgb;\n"
10335 " vec3 composite = world_compute_lighting( diffuse, qnorm, aWorldCo, 1.0 );\n"
10337 " oColour = vec4( composite, 1.0 );\n"
10342 GLuint _uniform_model_entity_uMdl
;
10343 GLuint _uniform_model_entity_uPv
;
10344 GLuint _uniform_model_entity_uPvmPrev
;
10345 GLuint _uniform_model_entity_uTexMain
;
10346 GLuint _uniform_model_entity_uCamera
;
10347 GLuint _uniform_model_entity_g_world_depth
;
10348 GLuint _uniform_model_entity_uLightsArray
;
10349 GLuint _uniform_model_entity_uLightsIndex
;
10350 #include "shaders/model_gate.h"
10351 struct vg_shader _shader_model_gate
= {
10352 .name
= "model_gate",
10355 .orig_file
= "shaders/model.vs",
10357 "layout (location=0) in vec3 a_co;\n"
10358 "layout (location=1) in vec3 a_norm;\n"
10359 "layout (location=2) in vec2 a_uv;\n"
10360 "layout (location=3) in vec4 a_colour;\n"
10361 "layout (location=4) in vec4 a_weights;\n"
10362 "layout (location=5) in ivec4 a_groups;\n"
10365 "const float k_motion_lerp_amount = 0.01;\n"
10369 "out vec3 aMotionVec0;\n"
10370 "out vec3 aMotionVec1;\n"
10372 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10374 " // This magically solves some artifacting errors!\n"
10376 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10378 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10379 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10384 "uniform mat4x3 uMdl;\n"
10385 "uniform mat4 uPv;\n"
10386 "uniform mat4 uPvmPrev;\n"
10388 "out vec4 aColour;\n"
10390 "out vec3 aNorm;\n"
10392 "out vec3 aWorldCo;\n"
10396 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
10397 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
10398 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
10400 " vs_motion_out( vproj0, vproj1 );\n"
10402 " gl_Position = vproj0;\n"
10403 " aWorldCo = world_pos0;\n"
10404 " aColour = a_colour;\n"
10406 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
10412 .orig_file
= "shaders/model_gate_lq.fs",
10414 "out vec4 FragColor;\n"
10416 "uniform float uTime;\n"
10417 "uniform vec3 uCam;\n"
10418 "uniform vec2 uInvRes;\n"
10419 "uniform vec4 uColour;\n"
10427 " vec2 ssuv = gl_FragCoord.xy;\n"
10428 " float opacity = 1.0-smoothstep(0.0,1.0,aUv.y+uColour.a);\n"
10430 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10431 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10433 " if( opacity+dither<0.5 )\n"
10436 " FragColor = uColour;\n"
10441 GLuint _uniform_model_gate_uMdl
;
10442 GLuint _uniform_model_gate_uPv
;
10443 GLuint _uniform_model_gate_uPvmPrev
;
10444 GLuint _uniform_model_gate_uTime
;
10445 GLuint _uniform_model_gate_uCam
;
10446 GLuint _uniform_model_gate_uInvRes
;
10447 GLuint _uniform_model_gate_uColour
;
10448 #include "shaders/model_gate_unlinked.h"
10449 struct vg_shader _shader_model_gate_unlinked
= {
10450 .name
= "model_gate_unlinked",
10453 .orig_file
= "shaders/model.vs",
10455 "layout (location=0) in vec3 a_co;\n"
10456 "layout (location=1) in vec3 a_norm;\n"
10457 "layout (location=2) in vec2 a_uv;\n"
10458 "layout (location=3) in vec4 a_colour;\n"
10459 "layout (location=4) in vec4 a_weights;\n"
10460 "layout (location=5) in ivec4 a_groups;\n"
10463 "const float k_motion_lerp_amount = 0.01;\n"
10467 "out vec3 aMotionVec0;\n"
10468 "out vec3 aMotionVec1;\n"
10470 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10472 " // This magically solves some artifacting errors!\n"
10474 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10476 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10477 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10482 "uniform mat4x3 uMdl;\n"
10483 "uniform mat4 uPv;\n"
10484 "uniform mat4 uPvmPrev;\n"
10486 "out vec4 aColour;\n"
10488 "out vec3 aNorm;\n"
10490 "out vec3 aWorldCo;\n"
10494 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
10495 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
10496 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
10498 " vs_motion_out( vproj0, vproj1 );\n"
10500 " gl_Position = vproj0;\n"
10501 " aWorldCo = world_pos0;\n"
10502 " aColour = a_colour;\n"
10504 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
10510 .orig_file
= "shaders/model_gate_unlinked.fs",
10512 "out vec4 FragColor;\n"
10514 "uniform float uTime;\n"
10515 "uniform vec3 uCam;\n"
10516 "uniform vec4 uColour;\n"
10523 "const float k_motion_lerp_amount = 0.01;\n"
10527 "layout (location = 1) out vec2 oMotionVec;\n"
10529 "in vec3 aMotionVec0;\n"
10530 "in vec3 aMotionVec1;\n"
10532 "void compute_motion_vectors()\n"
10534 " // Write motion vectors\n"
10535 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10536 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10538 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10543 "const int NOISE_LOOP = 3;\n"
10544 "vec3 digital_noise( uvec3 iuv ){\n"
10545 " iuv *=uvec3(8,2524,7552);\n"
10546 " for( int i=0; i<NOISE_LOOP; i++ )\n"
10547 " iuv += (iuv.yzx<<2) ^ (iuv.yxz)+iuv.z;\n"
10548 " return vec3(iuv)*(1.0/float(0xffffffffU));\n"
10551 "vec2 rand_hash22( vec2 p ){\n"
10552 " vec3 p3 = fract(vec3(p.xyx) * 213.8976123);\n"
10553 " p3 += dot(p3, p3.yzx+19.19);\n"
10554 " return fract(vec2((p3.x + p3.y)*p3.z, (p3.x+p3.z)*p3.y));\n"
10558 " compute_motion_vectors();\n"
10560 " vec2 ssuv = gl_FragCoord.xy;\n"
10561 " float grad = 1.0-aUv.y*0.1;\n"
10562 " float opacity = rand_hash22( vec2(floor(aUv.y*100.0),floor(aCo.z*10.0+uTime*40.0)) ).r*grad;\n"
10564 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10565 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10567 " if( opacity<0.9 )\n"
10570 " FragColor = vec4(0.7,0.5,0.5,1.0);\n"
10575 GLuint _uniform_model_gate_unlinked_uMdl
;
10576 GLuint _uniform_model_gate_unlinked_uPv
;
10577 GLuint _uniform_model_gate_unlinked_uPvmPrev
;
10578 GLuint _uniform_model_gate_unlinked_uTime
;
10579 GLuint _uniform_model_gate_unlinked_uCam
;
10580 GLuint _uniform_model_gate_unlinked_uColour
;
10581 #include "shaders/model_font.h"
10582 struct vg_shader _shader_model_font
= {
10583 .name
= "model_font",
10586 .orig_file
= "shaders/model_font.vs",
10588 "layout (location=0) in vec3 a_co;\n"
10589 "layout (location=1) in vec3 a_norm;\n"
10590 "layout (location=2) in vec2 a_uv;\n"
10593 "const float k_motion_lerp_amount = 0.01;\n"
10597 "out vec3 aMotionVec0;\n"
10598 "out vec3 aMotionVec1;\n"
10600 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10602 " // This magically solves some artifacting errors!\n"
10604 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10606 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10607 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10612 "uniform mat4x3 uMdl;\n"
10613 "uniform mat4 uPv;\n"
10614 "uniform mat4 uPvmPrev;\n"
10615 "uniform vec4 uOffset;\n"
10618 "out vec4 aNorm;\n"
10620 "out vec3 aWorldCo;\n"
10624 " vec3 co = a_co*uOffset.w+uOffset.xyz;\n"
10625 " vec3 world_pos0 = uMdl * vec4( co, 1.0 );\n"
10626 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
10627 " vec4 vproj1 = uPvmPrev * vec4( co, 1.0 );\n"
10629 " vs_motion_out( vproj0, vproj1 );\n"
10631 " gl_Position = vproj0;\n"
10634 " aNorm = vec4( mat3(uMdl) * a_norm, 0.0 );\n"
10636 " aWorldCo = world_pos0;\n"
10641 .orig_file
= "shaders/model_font.fs",
10643 "layout (location = 0) out vec4 oColour;\n"
10645 "uniform sampler2D uTexMain;\n"
10646 "uniform vec4 uColour;\n"
10653 "const float k_motion_lerp_amount = 0.01;\n"
10657 "layout (location = 1) out vec2 oMotionVec;\n"
10659 "in vec3 aMotionVec0;\n"
10660 "in vec3 aMotionVec1;\n"
10662 "void compute_motion_vectors()\n"
10664 " // Write motion vectors\n"
10665 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10666 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10668 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10673 "uniform sampler2D uTexSceneDepth;\n"
10674 "uniform vec3 uInverseRatioDepth;\n"
10675 "uniform vec3 uInverseRatioMain;\n"
10676 "uniform int uDepthMode;\n"
10677 "uniform float uDitherCutoff;\n"
10679 "float linear_depth( float depth, float near, float far ) {\n"
10680 " float z = depth * 2.0 - 1.0;\n"
10681 " return (2.0 * near * far) / (far + near - z * (far - near)); \n"
10684 "void depth_compare_dither()\n"
10686 " if( uDepthMode == 1 )\n"
10688 " vec2 back_coord = gl_FragCoord.xy * uInverseRatioMain.xy \n"
10689 " * uInverseRatioDepth.xy;\n"
10690 " float back_depth = texture( uTexSceneDepth, back_coord ).r;\n"
10691 " float front_depth = gl_FragCoord.z/gl_FragCoord.w;\n"
10693 " back_depth = linear_depth( back_depth, 0.1, 2100.0 );\n"
10694 " float diff = back_depth - front_depth;\n"
10696 " vec2 ssuv = gl_FragCoord.xy;\n"
10697 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10698 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10700 " if( step(0.0,diff)+dither<0.3 )\n"
10704 " if( uDepthMode == 2 )\n"
10706 " vec2 ssuv = gl_FragCoord.xy;\n"
10707 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10708 " float dither = fract( vDither.g / 71.0 );\n"
10709 " if( dither<uDitherCutoff ) discard;\n"
10716 " depth_compare_dither();\n"
10717 " compute_motion_vectors();\n"
10718 " oColour = texture( uTexMain, aUv ) * uColour;\n"
10723 GLuint _uniform_model_font_uMdl
;
10724 GLuint _uniform_model_font_uPv
;
10725 GLuint _uniform_model_font_uPvmPrev
;
10726 GLuint _uniform_model_font_uOffset
;
10727 GLuint _uniform_model_font_uTexMain
;
10728 GLuint _uniform_model_font_uColour
;
10729 GLuint _uniform_model_font_uTexSceneDepth
;
10730 GLuint _uniform_model_font_uInverseRatioDepth
;
10731 GLuint _uniform_model_font_uInverseRatioMain
;
10732 GLuint _uniform_model_font_uDepthMode
;
10733 GLuint _uniform_model_font_uDitherCutoff
;
10734 #include "shaders/particle.h"
10735 struct vg_shader _shader_particle
= {
10736 .name
= "particle",
10739 .orig_file
= "shaders/particle.vs",
10741 "layout (location=0) in vec3 a_co;\n"
10742 "layout (location=1) in vec4 a_colour;\n"
10745 "const float k_motion_lerp_amount = 0.01;\n"
10749 "out vec3 aMotionVec0;\n"
10750 "out vec3 aMotionVec1;\n"
10752 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10754 " // This magically solves some artifacting errors!\n"
10756 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10758 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10759 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10764 "uniform mat4 uPv;\n"
10765 "uniform mat4 uPvPrev;\n"
10767 "out vec4 aColour;\n"
10770 " vec4 vproj0 = uPv * vec4( a_co, 1.0 );\n"
10771 " vec4 vproj1 = uPvPrev * vec4( a_co, 1.0 );\n"
10772 " vs_motion_out( vproj0, vproj1 );\n"
10774 " gl_Position = vproj0;\n"
10775 " aColour = a_colour;\n"
10780 .orig_file
= "shaders/particle.fs",
10782 "layout (location = 0) out vec4 oColour;\n"
10783 "in vec4 aColour;\n"
10786 "const float k_motion_lerp_amount = 0.01;\n"
10790 "layout (location = 1) out vec2 oMotionVec;\n"
10792 "in vec3 aMotionVec0;\n"
10793 "in vec3 aMotionVec1;\n"
10795 "void compute_motion_vectors()\n"
10797 " // Write motion vectors\n"
10798 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10799 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10801 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10807 " compute_motion_vectors();\n"
10809 " //vec2 ssuv = gl_FragCoord.xy;\n"
10810 " //vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10811 " //float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10813 " //if( vsamplemain.a+dither<0.5 )\n"
10816 " oColour = aColour;\n"
10821 GLuint _uniform_particle_uPv
;
10822 GLuint _uniform_particle_uPvPrev
;
10823 #include "shaders/trail.h"
10824 struct vg_shader _shader_trail
= {
10828 .orig_file
= "shaders/trail.vs",
10830 "layout (location=0) in vec4 a_co;\n"
10833 "const float k_motion_lerp_amount = 0.01;\n"
10837 "out vec3 aMotionVec0;\n"
10838 "out vec3 aMotionVec1;\n"
10840 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10842 " // This magically solves some artifacting errors!\n"
10844 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10846 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10847 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10852 "uniform mat4 uPv;\n"
10853 "uniform mat4 uPvPrev;\n"
10855 "out float aAlpha;\n"
10858 " vec4 vproj0 = uPv * vec4( a_co.xyz, 1.0 );\n"
10859 " vec4 vproj1 = uPvPrev * vec4( a_co.xyz, 1.0 );\n"
10860 " vs_motion_out( vproj0, vproj1 );\n"
10862 " gl_Position = vproj0;\n"
10863 " aAlpha = a_co.w;\n"
10868 .orig_file
= "shaders/trail.fs",
10870 "layout (location = 0) out vec4 oColour;\n"
10871 "in float aAlpha;\n"
10872 "uniform vec4 uColour;\n"
10875 "const float k_motion_lerp_amount = 0.01;\n"
10879 "layout (location = 1) out vec2 oMotionVec;\n"
10881 "in vec3 aMotionVec0;\n"
10882 "in vec3 aMotionVec1;\n"
10884 "void compute_motion_vectors()\n"
10886 " // Write motion vectors\n"
10887 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10888 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10890 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10896 " compute_motion_vectors();\n"
10898 " vec2 ssuv = gl_FragCoord.xy;\n"
10899 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10900 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10902 " if( aAlpha+dither<0.5 )\n"
10905 " oColour = vec4( uColour.rgb, uColour.a * aAlpha );\n"
10910 GLuint _uniform_trail_uPv
;
10911 GLuint _uniform_trail_uPvPrev
;
10912 GLuint _uniform_trail_uColour
;
10913 #include "shaders/blit.h"
10914 struct vg_shader _shader_blit
= {
10918 .orig_file
= "shaders/blit.vs",
10920 "layout (location=0) in vec2 a_co;\n"
10923 "uniform vec2 uInverseRatio;\n"
10927 " gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
10928 " aUv = a_co * uInverseRatio;\n"
10933 .orig_file
= "shaders/blit.fs",
10935 "out vec4 FragColor;\n"
10936 "uniform sampler2D uTexMain;\n"
10940 "float kPi = 3.14159265358979;\n"
10942 "vec2 fisheye_distort(vec2 xy)\n"
10944 " float aperture = 1350.0;\n"
10945 " float apertureHalf = 0.5 * aperture * (kPi / 180.0);\n"
10946 " float maxFactor = sin(apertureHalf);\n"
10949 " float d = length(xy);\n"
10950 " if(d < (2.0-maxFactor))\n"
10952 " d = length(xy * maxFactor);\n"
10953 " float z = sqrt(1.0 - d * d);\n"
10954 " float r = atan(d, z) / kPi;\n"
10955 " float phi = atan(xy.y, xy.x);\n"
10957 " uv.x = r * cos(phi) + 0.5;\n"
10958 " uv.y = r * sin(phi) + 0.5;\n"
10962 " uv = 0.5*xy + 0.5;\n"
10971 " vec2 vwarp = 2.0*aUv - 1.0;\n"
10972 " vwarp = fisheye_distort( vwarp );\n"
10974 " FragColor = texture( uTexMain, aUv );\n"
10979 GLuint _uniform_blit_uInverseRatio
;
10980 GLuint _uniform_blit_uTexMain
;
10981 #include "shaders/blitblur.h"
10982 struct vg_shader _shader_blitblur
= {
10983 .name
= "blitblur",
10986 .orig_file
= "shaders/blit.vs",
10988 "layout (location=0) in vec2 a_co;\n"
10991 "uniform vec2 uInverseRatio;\n"
10995 " gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
10996 " aUv = a_co * uInverseRatio;\n"
11001 .orig_file
= "shaders/blitblur.fs",
11003 "out vec4 FragColor;\n"
11004 "uniform sampler2D uTexMain;\n"
11005 "uniform sampler2D uTexMotion;\n"
11006 "uniform float uBlurStrength;\n"
11007 "uniform vec2 uOverrideDir;\n"
11008 "uniform float uTime;\n"
11009 "uniform float uGlitchStrength;\n"
11010 "uniform vec2 uClampUv;\n"
11014 "vec2 rand_hash22( vec2 p ){\n"
11015 " vec3 p3 = fract(vec3(p.xyx) * 213.8976123);\n"
11016 " p3 += dot(p3, p3.yzx+19.19);\n"
11017 " return fract(vec2((p3.x + p3.y)*p3.z, (p3.x+p3.z)*p3.y));\n"
11020 "const int NOISE_LOOP = 3;\n"
11021 "vec3 digital_noise( uvec3 iuv ){\n"
11022 " iuv *=uvec3(8,2524,7552);\n"
11023 " for( int i=0; i<NOISE_LOOP; i++ )\n"
11024 " iuv += (iuv.yzx<<2) ^ (iuv.yxz)+iuv.z;\n"
11025 " return vec3(iuv)*(1.0/float(0xffffffffU));\n"
11029 " vec2 vuv = aUv; \n"
11031 " //if( uGlitchStrength > 0.0 ){\n"
11032 " // uvec3 p = uvec3( gl_FragCoord.xy, uint(uTime*30.0) );\n"
11033 " // vec2 g = digital_noise(p).xy;\n"
11034 " // vuv = aUv + g.xy*uGlitchStrength - uGlitchStrength*0.5;\n"
11037 " vec2 vrand = rand_hash22( vuv ) * 2.0 - vec2(1.0);\n"
11038 " vec2 vrand1 = rand_hash22( vrand ) * 2.0 - vec2(1.0);\n"
11040 " vec2 vdir = texture( uTexMotion, vuv ).xy * uBlurStrength + uOverrideDir;\n"
11042 " vec4 vcolour0 = texture( uTexMain, min(vuv + vdir*vrand.x,uClampUv) );\n"
11043 " vec4 vcolour1 = texture( uTexMain, min(vuv + vdir*vrand.y,uClampUv) );\n"
11044 " vec4 vcolour2 = texture( uTexMain, min(vuv + vdir*vrand1.x,uClampUv) );\n"
11045 " vec4 vcolour3 = texture( uTexMain, min(vuv + vdir*vrand1.y,uClampUv) );\n"
11047 " FragColor = ( vcolour0 + vcolour1 + vcolour2 + vcolour3 ) * 0.25;\n"
11052 GLuint _uniform_blitblur_uInverseRatio
;
11053 GLuint _uniform_blitblur_uTexMain
;
11054 GLuint _uniform_blitblur_uTexMotion
;
11055 GLuint _uniform_blitblur_uBlurStrength
;
11056 GLuint _uniform_blitblur_uOverrideDir
;
11057 GLuint _uniform_blitblur_uTime
;
11058 GLuint _uniform_blitblur_uGlitchStrength
;
11059 GLuint _uniform_blitblur_uClampUv
;
11060 #include "shaders/blitcolour.h"
11061 struct vg_shader _shader_blitcolour
= {
11062 .name
= "blitcolour",
11065 .orig_file
= "shaders/blit.vs",
11067 "layout (location=0) in vec2 a_co;\n"
11070 "uniform vec2 uInverseRatio;\n"
11074 " gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
11075 " aUv = a_co * uInverseRatio;\n"
11080 .orig_file
= "shaders/colour.fs",
11082 "out vec4 FragColor;\n"
11083 "uniform vec4 uColour;\n"
11089 " FragColor = uColour;\n"
11094 GLuint _uniform_blitcolour_uInverseRatio
;
11095 GLuint _uniform_blitcolour_uColour
;
11096 #include "shaders/blit_transition.h"
11097 struct vg_shader _shader_blit_transition
= {
11098 .name
= "blit_transition",
11101 .orig_file
= "shaders/blit.vs",
11103 "layout (location=0) in vec2 a_co;\n"
11106 "uniform vec2 uInverseRatio;\n"
11110 " gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
11111 " aUv = a_co * uInverseRatio;\n"
11116 .orig_file
= "shaders/blit_transition.fs",
11118 "out vec4 FragColor;\n"
11120 "uniform float uT;\n"
11123 " float d = uT + distance( aUv, vec2(0.5,0.5) );\n"
11125 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), gl_FragCoord.xy) );\n"
11126 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
11128 " if( d+dither < -0.5 )\n"
11131 " FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n"
11136 GLuint _uniform_blit_transition_uInverseRatio
;
11137 GLuint _uniform_blit_transition_uT
;
11138 #include "shaders/routeui.h"
11139 struct vg_shader _shader_routeui
= {
11143 .orig_file
= "shaders/routeui.vs",
11145 "layout (location=0) in vec2 a_co;\n"
11147 "uniform vec4 uOffset;\n"
11151 " vec2 vpos = a_co * uOffset.zw + uOffset.xy;\n"
11152 " gl_Position = vec4(vpos,0.0,1.0);\n"
11157 .orig_file
= "shaders/routeui.fs",
11159 "out vec4 FragColor;\n"
11161 "uniform vec4 uColour;\n"
11165 " FragColor = uColour;\n"
11170 GLuint _uniform_routeui_uOffset
;
11171 GLuint _uniform_routeui_uColour
;
11174 void vg_auto_shader_link(void)
11176 _uniform_scene_standard_uMdl
= glGetUniformLocation( _shader_scene_standard
.id
, "uMdl" );
11177 _uniform_scene_standard_uPv
= glGetUniformLocation( _shader_scene_standard
.id
, "uPv" );
11178 _uniform_scene_standard_uPvmPrev
= glGetUniformLocation( _shader_scene_standard
.id
, "uPvmPrev" );
11179 _uniform_scene_standard_uTexGarbage
= glGetUniformLocation( _shader_scene_standard
.id
, "uTexGarbage" );
11180 _uniform_scene_standard_uTexMain
= glGetUniformLocation( _shader_scene_standard
.id
, "uTexMain" );
11181 _uniform_scene_standard_uCamera
= glGetUniformLocation( _shader_scene_standard
.id
, "uCamera" );
11182 _uniform_scene_standard_uPlane
= glGetUniformLocation( _shader_scene_standard
.id
, "uPlane" );
11183 _uniform_scene_standard_g_world_depth
= glGetUniformLocation( _shader_scene_standard
.id
, "g_world_depth" );
11184 _uniform_scene_standard_uLightsArray
= glGetUniformLocation( _shader_scene_standard
.id
, "uLightsArray" );
11185 _uniform_scene_standard_uLightsIndex
= glGetUniformLocation( _shader_scene_standard
.id
, "uLightsIndex" );
11186 _uniform_scene_standard_alphatest_uMdl
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uMdl" );
11187 _uniform_scene_standard_alphatest_uPv
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uPv" );
11188 _uniform_scene_standard_alphatest_uPvmPrev
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uPvmPrev" );
11189 _uniform_scene_standard_alphatest_uTexGarbage
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uTexGarbage" );
11190 _uniform_scene_standard_alphatest_uTexMain
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uTexMain" );
11191 _uniform_scene_standard_alphatest_uCamera
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uCamera" );
11192 _uniform_scene_standard_alphatest_uPlane
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uPlane" );
11193 _uniform_scene_standard_alphatest_g_world_depth
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "g_world_depth" );
11194 _uniform_scene_standard_alphatest_uLightsArray
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uLightsArray" );
11195 _uniform_scene_standard_alphatest_uLightsIndex
= glGetUniformLocation( _shader_scene_standard_alphatest
.id
, "uLightsIndex" );
11196 _uniform_scene_foliage_uMdl
= glGetUniformLocation( _shader_scene_foliage
.id
, "uMdl" );
11197 _uniform_scene_foliage_uPv
= glGetUniformLocation( _shader_scene_foliage
.id
, "uPv" );
11198 _uniform_scene_foliage_uPvmPrev
= glGetUniformLocation( _shader_scene_foliage
.id
, "uPvmPrev" );
11199 _uniform_scene_foliage_uTime
= glGetUniformLocation( _shader_scene_foliage
.id
, "uTime" );
11200 _uniform_scene_foliage_uTexGarbage
= glGetUniformLocation( _shader_scene_foliage
.id
, "uTexGarbage" );
11201 _uniform_scene_foliage_uTexMain
= glGetUniformLocation( _shader_scene_foliage
.id
, "uTexMain" );
11202 _uniform_scene_foliage_uCamera
= glGetUniformLocation( _shader_scene_foliage
.id
, "uCamera" );
11203 _uniform_scene_foliage_uPlane
= glGetUniformLocation( _shader_scene_foliage
.id
, "uPlane" );
11204 _uniform_scene_foliage_g_world_depth
= glGetUniformLocation( _shader_scene_foliage
.id
, "g_world_depth" );
11205 _uniform_scene_foliage_uLightsArray
= glGetUniformLocation( _shader_scene_foliage
.id
, "uLightsArray" );
11206 _uniform_scene_foliage_uLightsIndex
= glGetUniformLocation( _shader_scene_foliage
.id
, "uLightsIndex" );
11207 _uniform_scene_override_uMdl
= glGetUniformLocation( _shader_scene_override
.id
, "uMdl" );
11208 _uniform_scene_override_uPv
= glGetUniformLocation( _shader_scene_override
.id
, "uPv" );
11209 _uniform_scene_override_uPvmPrev
= glGetUniformLocation( _shader_scene_override
.id
, "uPvmPrev" );
11210 _uniform_scene_override_uNormalMtx
= glGetUniformLocation( _shader_scene_override
.id
, "uNormalMtx" );
11211 _uniform_scene_override_uTexGarbage
= glGetUniformLocation( _shader_scene_override
.id
, "uTexGarbage" );
11212 _uniform_scene_override_uTexMain
= glGetUniformLocation( _shader_scene_override
.id
, "uTexMain" );
11213 _uniform_scene_override_uCamera
= glGetUniformLocation( _shader_scene_override
.id
, "uCamera" );
11214 _uniform_scene_override_uPlane
= glGetUniformLocation( _shader_scene_override
.id
, "uPlane" );
11215 _uniform_scene_override_uPlayerPos
= glGetUniformLocation( _shader_scene_override
.id
, "uPlayerPos" );
11216 _uniform_scene_override_uSpawnPos
= glGetUniformLocation( _shader_scene_override
.id
, "uSpawnPos" );
11217 _uniform_scene_override_uAlphatest
= glGetUniformLocation( _shader_scene_override
.id
, "uAlphatest" );
11218 _uniform_scene_override_uMapInfo
= glGetUniformLocation( _shader_scene_override
.id
, "uMapInfo" );
11219 _uniform_scene_override_g_world_depth
= glGetUniformLocation( _shader_scene_override
.id
, "g_world_depth" );
11220 _uniform_scene_override_uLightsArray
= glGetUniformLocation( _shader_scene_override
.id
, "uLightsArray" );
11221 _uniform_scene_override_uLightsIndex
= glGetUniformLocation( _shader_scene_override
.id
, "uLightsIndex" );
11222 _uniform_scene_fxglow_uMdl
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uMdl" );
11223 _uniform_scene_fxglow_uPv
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uPv" );
11224 _uniform_scene_fxglow_uPvmPrev
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uPvmPrev" );
11225 _uniform_scene_fxglow_uUvOffset
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uUvOffset" );
11226 _uniform_scene_fxglow_uTexMain
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uTexMain" );
11227 _uniform_scene_fxglow_uCamera
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uCamera" );
11228 _uniform_scene_fxglow_g_world_depth
= glGetUniformLocation( _shader_scene_fxglow
.id
, "g_world_depth" );
11229 _uniform_scene_fxglow_uLightsArray
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uLightsArray" );
11230 _uniform_scene_fxglow_uLightsIndex
= glGetUniformLocation( _shader_scene_fxglow
.id
, "uLightsIndex" );
11231 _uniform_scene_vertex_blend_uMdl
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uMdl" );
11232 _uniform_scene_vertex_blend_uPv
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uPv" );
11233 _uniform_scene_vertex_blend_uPvmPrev
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uPvmPrev" );
11234 _uniform_scene_vertex_blend_uTexGarbage
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uTexGarbage" );
11235 _uniform_scene_vertex_blend_uTexGradients
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uTexGradients" );
11236 _uniform_scene_vertex_blend_uCamera
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uCamera" );
11237 _uniform_scene_vertex_blend_g_world_depth
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "g_world_depth" );
11238 _uniform_scene_vertex_blend_uLightsArray
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uLightsArray" );
11239 _uniform_scene_vertex_blend_uLightsIndex
= glGetUniformLocation( _shader_scene_vertex_blend
.id
, "uLightsIndex" );
11240 _uniform_scene_terrain_uMdl
= glGetUniformLocation( _shader_scene_terrain
.id
, "uMdl" );
11241 _uniform_scene_terrain_uPv
= glGetUniformLocation( _shader_scene_terrain
.id
, "uPv" );
11242 _uniform_scene_terrain_uPvmPrev
= glGetUniformLocation( _shader_scene_terrain
.id
, "uPvmPrev" );
11243 _uniform_scene_terrain_uTexGarbage
= glGetUniformLocation( _shader_scene_terrain
.id
, "uTexGarbage" );
11244 _uniform_scene_terrain_uTexGradients
= glGetUniformLocation( _shader_scene_terrain
.id
, "uTexGradients" );
11245 _uniform_scene_terrain_uCamera
= glGetUniformLocation( _shader_scene_terrain
.id
, "uCamera" );
11246 _uniform_scene_terrain_uSandColour
= glGetUniformLocation( _shader_scene_terrain
.id
, "uSandColour" );
11247 _uniform_scene_terrain_uBlendOffset
= glGetUniformLocation( _shader_scene_terrain
.id
, "uBlendOffset" );
11248 _uniform_scene_terrain_g_world_depth
= glGetUniformLocation( _shader_scene_terrain
.id
, "g_world_depth" );
11249 _uniform_scene_terrain_uLightsArray
= glGetUniformLocation( _shader_scene_terrain
.id
, "uLightsArray" );
11250 _uniform_scene_terrain_uLightsIndex
= glGetUniformLocation( _shader_scene_terrain
.id
, "uLightsIndex" );
11251 _uniform_scene_route_uMdl
= glGetUniformLocation( _shader_scene_route
.id
, "uMdl" );
11252 _uniform_scene_route_uPv
= glGetUniformLocation( _shader_scene_route
.id
, "uPv" );
11253 _uniform_scene_route_uPvmPrev
= glGetUniformLocation( _shader_scene_route
.id
, "uPvmPrev" );
11254 _uniform_scene_route_uNormalMtx
= glGetUniformLocation( _shader_scene_route
.id
, "uNormalMtx" );
11255 _uniform_scene_route_uTexGarbage
= glGetUniformLocation( _shader_scene_route
.id
, "uTexGarbage" );
11256 _uniform_scene_route_uTexGradients
= glGetUniformLocation( _shader_scene_route
.id
, "uTexGradients" );
11257 _uniform_scene_route_uCamera
= glGetUniformLocation( _shader_scene_route
.id
, "uCamera" );
11258 _uniform_scene_route_uColour
= glGetUniformLocation( _shader_scene_route
.id
, "uColour" );
11259 _uniform_scene_route_g_world_depth
= glGetUniformLocation( _shader_scene_route
.id
, "g_world_depth" );
11260 _uniform_scene_route_uLightsArray
= glGetUniformLocation( _shader_scene_route
.id
, "uLightsArray" );
11261 _uniform_scene_route_uLightsIndex
= glGetUniformLocation( _shader_scene_route
.id
, "uLightsIndex" );
11262 _uniform_scene_depth_uMdl
= glGetUniformLocation( _shader_scene_depth
.id
, "uMdl" );
11263 _uniform_scene_depth_uPv
= glGetUniformLocation( _shader_scene_depth
.id
, "uPv" );
11264 _uniform_scene_depth_uPvmPrev
= glGetUniformLocation( _shader_scene_depth
.id
, "uPvmPrev" );
11265 _uniform_scene_depth_uCamera
= glGetUniformLocation( _shader_scene_depth
.id
, "uCamera" );
11266 _uniform_scene_depth_uBoard0
= glGetUniformLocation( _shader_scene_depth
.id
, "uBoard0" );
11267 _uniform_scene_depth_uBoard1
= glGetUniformLocation( _shader_scene_depth
.id
, "uBoard1" );
11268 _uniform_scene_depth_g_world_depth
= glGetUniformLocation( _shader_scene_depth
.id
, "g_world_depth" );
11269 _uniform_scene_depth_uLightsArray
= glGetUniformLocation( _shader_scene_depth
.id
, "uLightsArray" );
11270 _uniform_scene_depth_uLightsIndex
= glGetUniformLocation( _shader_scene_depth
.id
, "uLightsIndex" );
11271 _uniform_scene_position_uMdl
= glGetUniformLocation( _shader_scene_position
.id
, "uMdl" );
11272 _uniform_scene_position_uPv
= glGetUniformLocation( _shader_scene_position
.id
, "uPv" );
11273 _uniform_scene_position_uPvmPrev
= glGetUniformLocation( _shader_scene_position
.id
, "uPvmPrev" );
11274 _uniform_scene_position_uCamera
= glGetUniformLocation( _shader_scene_position
.id
, "uCamera" );
11275 _uniform_scene_position_uBoard0
= glGetUniformLocation( _shader_scene_position
.id
, "uBoard0" );
11276 _uniform_scene_position_uBoard1
= glGetUniformLocation( _shader_scene_position
.id
, "uBoard1" );
11277 _uniform_scene_position_g_world_depth
= glGetUniformLocation( _shader_scene_position
.id
, "g_world_depth" );
11278 _uniform_scene_position_uLightsArray
= glGetUniformLocation( _shader_scene_position
.id
, "uLightsArray" );
11279 _uniform_scene_position_uLightsIndex
= glGetUniformLocation( _shader_scene_position
.id
, "uLightsIndex" );
11280 _uniform_scene_cubemapped_uMdl
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uMdl" );
11281 _uniform_scene_cubemapped_uPv
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uPv" );
11282 _uniform_scene_cubemapped_uPvmPrev
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uPvmPrev" );
11283 _uniform_scene_cubemapped_uTexGarbage
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uTexGarbage" );
11284 _uniform_scene_cubemapped_uTexMain
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uTexMain" );
11285 _uniform_scene_cubemapped_uTexCubemap
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uTexCubemap" );
11286 _uniform_scene_cubemapped_uCamera
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uCamera" );
11287 _uniform_scene_cubemapped_uPlane
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uPlane" );
11288 _uniform_scene_cubemapped_uColour
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uColour" );
11289 _uniform_scene_cubemapped_g_world_depth
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "g_world_depth" );
11290 _uniform_scene_cubemapped_uLightsArray
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uLightsArray" );
11291 _uniform_scene_cubemapped_uLightsIndex
= glGetUniformLocation( _shader_scene_cubemapped
.id
, "uLightsIndex" );
11292 _uniform_scene_water_uMdl
= glGetUniformLocation( _shader_scene_water
.id
, "uMdl" );
11293 _uniform_scene_water_uPv
= glGetUniformLocation( _shader_scene_water
.id
, "uPv" );
11294 _uniform_scene_water_uPvmPrev
= glGetUniformLocation( _shader_scene_water
.id
, "uPvmPrev" );
11295 _uniform_scene_water_uTexMain
= glGetUniformLocation( _shader_scene_water
.id
, "uTexMain" );
11296 _uniform_scene_water_uTexDudv
= glGetUniformLocation( _shader_scene_water
.id
, "uTexDudv" );
11297 _uniform_scene_water_uTexBack
= glGetUniformLocation( _shader_scene_water
.id
, "uTexBack" );
11298 _uniform_scene_water_uInvRes
= glGetUniformLocation( _shader_scene_water
.id
, "uInvRes" );
11299 _uniform_scene_water_uTime
= glGetUniformLocation( _shader_scene_water
.id
, "uTime" );
11300 _uniform_scene_water_uCamera
= glGetUniformLocation( _shader_scene_water
.id
, "uCamera" );
11301 _uniform_scene_water_uSurfaceY
= glGetUniformLocation( _shader_scene_water
.id
, "uSurfaceY" );
11302 _uniform_scene_water_uBoard0
= glGetUniformLocation( _shader_scene_water
.id
, "uBoard0" );
11303 _uniform_scene_water_uBoard1
= glGetUniformLocation( _shader_scene_water
.id
, "uBoard1" );
11304 _uniform_scene_water_uShoreColour
= glGetUniformLocation( _shader_scene_water
.id
, "uShoreColour" );
11305 _uniform_scene_water_uOceanColour
= glGetUniformLocation( _shader_scene_water
.id
, "uOceanColour" );
11306 _uniform_scene_water_uFresnel
= glGetUniformLocation( _shader_scene_water
.id
, "uFresnel" );
11307 _uniform_scene_water_uWaterScale
= glGetUniformLocation( _shader_scene_water
.id
, "uWaterScale" );
11308 _uniform_scene_water_uWaveSpeed
= glGetUniformLocation( _shader_scene_water
.id
, "uWaveSpeed" );
11309 _uniform_scene_water_g_world_depth
= glGetUniformLocation( _shader_scene_water
.id
, "g_world_depth" );
11310 _uniform_scene_water_uLightsArray
= glGetUniformLocation( _shader_scene_water
.id
, "uLightsArray" );
11311 _uniform_scene_water_uLightsIndex
= glGetUniformLocation( _shader_scene_water
.id
, "uLightsIndex" );
11312 _uniform_scene_water_fast_uMdl
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uMdl" );
11313 _uniform_scene_water_fast_uPv
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uPv" );
11314 _uniform_scene_water_fast_uPvmPrev
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uPvmPrev" );
11315 _uniform_scene_water_fast_uTexDudv
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uTexDudv" );
11316 _uniform_scene_water_fast_uTime
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uTime" );
11317 _uniform_scene_water_fast_uCamera
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uCamera" );
11318 _uniform_scene_water_fast_uSurfaceY
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uSurfaceY" );
11319 _uniform_scene_water_fast_uBoard0
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uBoard0" );
11320 _uniform_scene_water_fast_uBoard1
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uBoard1" );
11321 _uniform_scene_water_fast_uShoreColour
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uShoreColour" );
11322 _uniform_scene_water_fast_uOceanColour
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uOceanColour" );
11323 _uniform_scene_water_fast_g_world_depth
= glGetUniformLocation( _shader_scene_water_fast
.id
, "g_world_depth" );
11324 _uniform_scene_water_fast_uLightsArray
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uLightsArray" );
11325 _uniform_scene_water_fast_uLightsIndex
= glGetUniformLocation( _shader_scene_water_fast
.id
, "uLightsIndex" );
11326 _uniform_scene_scoretext_uMdl
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uMdl" );
11327 _uniform_scene_scoretext_uPv
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uPv" );
11328 _uniform_scene_scoretext_uPvmPrev
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uPvmPrev" );
11329 _uniform_scene_scoretext_uInfo
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uInfo" );
11330 _uniform_scene_scoretext_uTexGarbage
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uTexGarbage" );
11331 _uniform_scene_scoretext_uTexMain
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uTexMain" );
11332 _uniform_scene_scoretext_uCamera
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uCamera" );
11333 _uniform_scene_scoretext_uPlane
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uPlane" );
11334 _uniform_scene_scoretext_g_world_depth
= glGetUniformLocation( _shader_scene_scoretext
.id
, "g_world_depth" );
11335 _uniform_scene_scoretext_uLightsArray
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uLightsArray" );
11336 _uniform_scene_scoretext_uLightsIndex
= glGetUniformLocation( _shader_scene_scoretext
.id
, "uLightsIndex" );
11337 _uniform_scene_font_uMdl
= glGetUniformLocation( _shader_scene_font
.id
, "uMdl" );
11338 _uniform_scene_font_uPv
= glGetUniformLocation( _shader_scene_font
.id
, "uPv" );
11339 _uniform_scene_font_uPvmPrev
= glGetUniformLocation( _shader_scene_font
.id
, "uPvmPrev" );
11340 _uniform_scene_font_uOffset
= glGetUniformLocation( _shader_scene_font
.id
, "uOffset" );
11341 _uniform_scene_font_uTexGarbage
= glGetUniformLocation( _shader_scene_font
.id
, "uTexGarbage" );
11342 _uniform_scene_font_uTexMain
= glGetUniformLocation( _shader_scene_font
.id
, "uTexMain" );
11343 _uniform_scene_font_uCamera
= glGetUniformLocation( _shader_scene_font
.id
, "uCamera" );
11344 _uniform_scene_font_uTime
= glGetUniformLocation( _shader_scene_font
.id
, "uTime" );
11345 _uniform_scene_font_uOpacity
= glGetUniformLocation( _shader_scene_font
.id
, "uOpacity" );
11346 _uniform_scene_font_uColourize
= glGetUniformLocation( _shader_scene_font
.id
, "uColourize" );
11347 _uniform_scene_font_g_world_depth
= glGetUniformLocation( _shader_scene_font
.id
, "g_world_depth" );
11348 _uniform_scene_font_uLightsArray
= glGetUniformLocation( _shader_scene_font
.id
, "uLightsArray" );
11349 _uniform_scene_font_uLightsIndex
= glGetUniformLocation( _shader_scene_font
.id
, "uLightsIndex" );
11350 _uniform_model_sky_uMdl
= glGetUniformLocation( _shader_model_sky
.id
, "uMdl" );
11351 _uniform_model_sky_uPv
= glGetUniformLocation( _shader_model_sky
.id
, "uPv" );
11352 _uniform_model_sky_uPvmPrev
= glGetUniformLocation( _shader_model_sky
.id
, "uPvmPrev" );
11353 _uniform_model_sky_uTexGarbage
= glGetUniformLocation( _shader_model_sky
.id
, "uTexGarbage" );
11354 _uniform_model_sky_g_world_depth
= glGetUniformLocation( _shader_model_sky
.id
, "g_world_depth" );
11355 _uniform_model_sky_uLightsArray
= glGetUniformLocation( _shader_model_sky
.id
, "uLightsArray" );
11356 _uniform_model_sky_uLightsIndex
= glGetUniformLocation( _shader_model_sky
.id
, "uLightsIndex" );
11357 _uniform_model_sky_space_uMdl
= glGetUniformLocation( _shader_model_sky_space
.id
, "uMdl" );
11358 _uniform_model_sky_space_uPv
= glGetUniformLocation( _shader_model_sky_space
.id
, "uPv" );
11359 _uniform_model_sky_space_uPvmPrev
= glGetUniformLocation( _shader_model_sky_space
.id
, "uPvmPrev" );
11360 _uniform_model_sky_space_uTexGarbage
= glGetUniformLocation( _shader_model_sky_space
.id
, "uTexGarbage" );
11361 _uniform_model_sky_space_g_world_depth
= glGetUniformLocation( _shader_model_sky_space
.id
, "g_world_depth" );
11362 _uniform_model_sky_space_uLightsArray
= glGetUniformLocation( _shader_model_sky_space
.id
, "uLightsArray" );
11363 _uniform_model_sky_space_uLightsIndex
= glGetUniformLocation( _shader_model_sky_space
.id
, "uLightsIndex" );
11364 _uniform_model_menu_uMdl
= glGetUniformLocation( _shader_model_menu
.id
, "uMdl" );
11365 _uniform_model_menu_uPv
= glGetUniformLocation( _shader_model_menu
.id
, "uPv" );
11366 _uniform_model_menu_uPvmPrev
= glGetUniformLocation( _shader_model_menu
.id
, "uPvmPrev" );
11367 _uniform_model_menu_uTexMain
= glGetUniformLocation( _shader_model_menu
.id
, "uTexMain" );
11368 _uniform_model_menu_uColour
= glGetUniformLocation( _shader_model_menu
.id
, "uColour" );
11369 _uniform_model_character_view_uPv
= glGetUniformLocation( _shader_model_character_view
.id
, "uPv" );
11370 _uniform_model_character_view_uTransforms
= glGetUniformLocation( _shader_model_character_view
.id
, "uTransforms" );
11371 _uniform_model_character_view_uTexMain
= glGetUniformLocation( _shader_model_character_view
.id
, "uTexMain" );
11372 _uniform_model_character_view_uCamera
= glGetUniformLocation( _shader_model_character_view
.id
, "uCamera" );
11373 _uniform_model_character_view_g_world_depth
= glGetUniformLocation( _shader_model_character_view
.id
, "g_world_depth" );
11374 _uniform_model_character_view_uLightsArray
= glGetUniformLocation( _shader_model_character_view
.id
, "uLightsArray" );
11375 _uniform_model_character_view_uLightsIndex
= glGetUniformLocation( _shader_model_character_view
.id
, "uLightsIndex" );
11376 _uniform_model_character_view_uTexSceneDepth
= glGetUniformLocation( _shader_model_character_view
.id
, "uTexSceneDepth" );
11377 _uniform_model_character_view_uInverseRatioDepth
= glGetUniformLocation( _shader_model_character_view
.id
, "uInverseRatioDepth" );
11378 _uniform_model_character_view_uInverseRatioMain
= glGetUniformLocation( _shader_model_character_view
.id
, "uInverseRatioMain" );
11379 _uniform_model_character_view_uDepthMode
= glGetUniformLocation( _shader_model_character_view
.id
, "uDepthMode" );
11380 _uniform_model_character_view_uDitherCutoff
= glGetUniformLocation( _shader_model_character_view
.id
, "uDitherCutoff" );
11381 _uniform_model_board_view_uMdl
= glGetUniformLocation( _shader_model_board_view
.id
, "uMdl" );
11382 _uniform_model_board_view_uPv
= glGetUniformLocation( _shader_model_board_view
.id
, "uPv" );
11383 _uniform_model_board_view_uPvmPrev
= glGetUniformLocation( _shader_model_board_view
.id
, "uPvmPrev" );
11384 _uniform_model_board_view_uTexMain
= glGetUniformLocation( _shader_model_board_view
.id
, "uTexMain" );
11385 _uniform_model_board_view_uCamera
= glGetUniformLocation( _shader_model_board_view
.id
, "uCamera" );
11386 _uniform_model_board_view_g_world_depth
= glGetUniformLocation( _shader_model_board_view
.id
, "g_world_depth" );
11387 _uniform_model_board_view_uLightsArray
= glGetUniformLocation( _shader_model_board_view
.id
, "uLightsArray" );
11388 _uniform_model_board_view_uLightsIndex
= glGetUniformLocation( _shader_model_board_view
.id
, "uLightsIndex" );
11389 _uniform_model_board_view_uTexSceneDepth
= glGetUniformLocation( _shader_model_board_view
.id
, "uTexSceneDepth" );
11390 _uniform_model_board_view_uInverseRatioDepth
= glGetUniformLocation( _shader_model_board_view
.id
, "uInverseRatioDepth" );
11391 _uniform_model_board_view_uInverseRatioMain
= glGetUniformLocation( _shader_model_board_view
.id
, "uInverseRatioMain" );
11392 _uniform_model_board_view_uDepthMode
= glGetUniformLocation( _shader_model_board_view
.id
, "uDepthMode" );
11393 _uniform_model_board_view_uDitherCutoff
= glGetUniformLocation( _shader_model_board_view
.id
, "uDitherCutoff" );
11394 _uniform_model_entity_uMdl
= glGetUniformLocation( _shader_model_entity
.id
, "uMdl" );
11395 _uniform_model_entity_uPv
= glGetUniformLocation( _shader_model_entity
.id
, "uPv" );
11396 _uniform_model_entity_uPvmPrev
= glGetUniformLocation( _shader_model_entity
.id
, "uPvmPrev" );
11397 _uniform_model_entity_uTexMain
= glGetUniformLocation( _shader_model_entity
.id
, "uTexMain" );
11398 _uniform_model_entity_uCamera
= glGetUniformLocation( _shader_model_entity
.id
, "uCamera" );
11399 _uniform_model_entity_g_world_depth
= glGetUniformLocation( _shader_model_entity
.id
, "g_world_depth" );
11400 _uniform_model_entity_uLightsArray
= glGetUniformLocation( _shader_model_entity
.id
, "uLightsArray" );
11401 _uniform_model_entity_uLightsIndex
= glGetUniformLocation( _shader_model_entity
.id
, "uLightsIndex" );
11402 _uniform_model_gate_uMdl
= glGetUniformLocation( _shader_model_gate
.id
, "uMdl" );
11403 _uniform_model_gate_uPv
= glGetUniformLocation( _shader_model_gate
.id
, "uPv" );
11404 _uniform_model_gate_uPvmPrev
= glGetUniformLocation( _shader_model_gate
.id
, "uPvmPrev" );
11405 _uniform_model_gate_uTime
= glGetUniformLocation( _shader_model_gate
.id
, "uTime" );
11406 _uniform_model_gate_uCam
= glGetUniformLocation( _shader_model_gate
.id
, "uCam" );
11407 _uniform_model_gate_uInvRes
= glGetUniformLocation( _shader_model_gate
.id
, "uInvRes" );
11408 _uniform_model_gate_uColour
= glGetUniformLocation( _shader_model_gate
.id
, "uColour" );
11409 _uniform_model_gate_unlinked_uMdl
= glGetUniformLocation( _shader_model_gate_unlinked
.id
, "uMdl" );
11410 _uniform_model_gate_unlinked_uPv
= glGetUniformLocation( _shader_model_gate_unlinked
.id
, "uPv" );
11411 _uniform_model_gate_unlinked_uPvmPrev
= glGetUniformLocation( _shader_model_gate_unlinked
.id
, "uPvmPrev" );
11412 _uniform_model_gate_unlinked_uTime
= glGetUniformLocation( _shader_model_gate_unlinked
.id
, "uTime" );
11413 _uniform_model_gate_unlinked_uCam
= glGetUniformLocation( _shader_model_gate_unlinked
.id
, "uCam" );
11414 _uniform_model_gate_unlinked_uColour
= glGetUniformLocation( _shader_model_gate_unlinked
.id
, "uColour" );
11415 _uniform_model_font_uMdl
= glGetUniformLocation( _shader_model_font
.id
, "uMdl" );
11416 _uniform_model_font_uPv
= glGetUniformLocation( _shader_model_font
.id
, "uPv" );
11417 _uniform_model_font_uPvmPrev
= glGetUniformLocation( _shader_model_font
.id
, "uPvmPrev" );
11418 _uniform_model_font_uOffset
= glGetUniformLocation( _shader_model_font
.id
, "uOffset" );
11419 _uniform_model_font_uTexMain
= glGetUniformLocation( _shader_model_font
.id
, "uTexMain" );
11420 _uniform_model_font_uColour
= glGetUniformLocation( _shader_model_font
.id
, "uColour" );
11421 _uniform_model_font_uTexSceneDepth
= glGetUniformLocation( _shader_model_font
.id
, "uTexSceneDepth" );
11422 _uniform_model_font_uInverseRatioDepth
= glGetUniformLocation( _shader_model_font
.id
, "uInverseRatioDepth" );
11423 _uniform_model_font_uInverseRatioMain
= glGetUniformLocation( _shader_model_font
.id
, "uInverseRatioMain" );
11424 _uniform_model_font_uDepthMode
= glGetUniformLocation( _shader_model_font
.id
, "uDepthMode" );
11425 _uniform_model_font_uDitherCutoff
= glGetUniformLocation( _shader_model_font
.id
, "uDitherCutoff" );
11426 _uniform_particle_uPv
= glGetUniformLocation( _shader_particle
.id
, "uPv" );
11427 _uniform_particle_uPvPrev
= glGetUniformLocation( _shader_particle
.id
, "uPvPrev" );
11428 _uniform_trail_uPv
= glGetUniformLocation( _shader_trail
.id
, "uPv" );
11429 _uniform_trail_uPvPrev
= glGetUniformLocation( _shader_trail
.id
, "uPvPrev" );
11430 _uniform_trail_uColour
= glGetUniformLocation( _shader_trail
.id
, "uColour" );
11431 _uniform_blit_uInverseRatio
= glGetUniformLocation( _shader_blit
.id
, "uInverseRatio" );
11432 _uniform_blit_uTexMain
= glGetUniformLocation( _shader_blit
.id
, "uTexMain" );
11433 _uniform_blitblur_uInverseRatio
= glGetUniformLocation( _shader_blitblur
.id
, "uInverseRatio" );
11434 _uniform_blitblur_uTexMain
= glGetUniformLocation( _shader_blitblur
.id
, "uTexMain" );
11435 _uniform_blitblur_uTexMotion
= glGetUniformLocation( _shader_blitblur
.id
, "uTexMotion" );
11436 _uniform_blitblur_uBlurStrength
= glGetUniformLocation( _shader_blitblur
.id
, "uBlurStrength" );
11437 _uniform_blitblur_uOverrideDir
= glGetUniformLocation( _shader_blitblur
.id
, "uOverrideDir" );
11438 _uniform_blitblur_uTime
= glGetUniformLocation( _shader_blitblur
.id
, "uTime" );
11439 _uniform_blitblur_uGlitchStrength
= glGetUniformLocation( _shader_blitblur
.id
, "uGlitchStrength" );
11440 _uniform_blitblur_uClampUv
= glGetUniformLocation( _shader_blitblur
.id
, "uClampUv" );
11441 _uniform_blitcolour_uInverseRatio
= glGetUniformLocation( _shader_blitcolour
.id
, "uInverseRatio" );
11442 _uniform_blitcolour_uColour
= glGetUniformLocation( _shader_blitcolour
.id
, "uColour" );
11443 _uniform_blit_transition_uInverseRatio
= glGetUniformLocation( _shader_blit_transition
.id
, "uInverseRatio" );
11444 _uniform_blit_transition_uT
= glGetUniformLocation( _shader_blit_transition
.id
, "uT" );
11445 _uniform_routeui_uOffset
= glGetUniformLocation( _shader_routeui
.id
, "uOffset" );
11446 _uniform_routeui_uColour
= glGetUniformLocation( _shader_routeui
.id
, "uColour" );
11449 void vg_auto_shader_register(void)
11451 vg_shader_register( &_shader_scene_standard
);
11452 vg_shader_register( &_shader_scene_standard_alphatest
);
11453 vg_shader_register( &_shader_scene_foliage
);
11454 vg_shader_register( &_shader_scene_override
);
11455 vg_shader_register( &_shader_scene_fxglow
);
11456 vg_shader_register( &_shader_scene_vertex_blend
);
11457 vg_shader_register( &_shader_scene_terrain
);
11458 vg_shader_register( &_shader_scene_route
);
11459 vg_shader_register( &_shader_scene_depth
);
11460 vg_shader_register( &_shader_scene_position
);
11461 vg_shader_register( &_shader_scene_cubemapped
);
11462 vg_shader_register( &_shader_scene_water
);
11463 vg_shader_register( &_shader_scene_water_fast
);
11464 vg_shader_register( &_shader_scene_scoretext
);
11465 vg_shader_register( &_shader_scene_font
);
11466 vg_shader_register( &_shader_model_sky
);
11467 vg_shader_register( &_shader_model_sky_space
);
11468 vg_shader_register( &_shader_model_menu
);
11469 vg_shader_register( &_shader_model_character_view
);
11470 vg_shader_register( &_shader_model_board_view
);
11471 vg_shader_register( &_shader_model_entity
);
11472 vg_shader_register( &_shader_model_gate
);
11473 vg_shader_register( &_shader_model_gate_unlinked
);
11474 vg_shader_register( &_shader_model_font
);
11475 vg_shader_register( &_shader_particle
);
11476 vg_shader_register( &_shader_trail
);
11477 vg_shader_register( &_shader_blit
);
11478 vg_shader_register( &_shader_blitblur
);
11479 vg_shader_register( &_shader_blitcolour
);
11480 vg_shader_register( &_shader_blit_transition
);
11481 vg_shader_register( &_shader_routeui
);