fix wwater fog
[carveJwlIkooP6JGAAIwe30JlM.git] / shaders / impl.c
1 #include "shaders/scene_standard.h"
2 struct vg_shader _shader_scene_standard = {
3 .name = "scene_standard",
4 .vs =
5 {
6 .orig_file = "shaders/scene.vs",
7 .static_src =
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"
11 "\n"
12 "#line 1 1 \n"
13 "const float k_motion_lerp_amount = 0.01;\n"
14 "\n"
15 "#line 2 0 \n"
16 "\n"
17 "out vec3 aMotionVec0;\n"
18 "out vec3 aMotionVec1;\n"
19 "\n"
20 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
21 "{\n"
22 " // This magically solves some artifacting errors!\n"
23 " //\n"
24 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
25 "\n"
26 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
27 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
28 "}\n"
29 "\n"
30 "#line 6 0 \n"
31 "\n"
32 "uniform mat4x3 uMdl;\n"
33 "uniform mat4 uPv;\n"
34 "uniform mat4 uPvmPrev;\n"
35 "\n"
36 "out vec2 aUv;\n"
37 "out vec4 aNorm;\n"
38 "out vec3 aCo;\n"
39 "out vec3 aWorldCo;\n"
40 "\n"
41 "void main()\n"
42 "{\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"
46 "\n"
47 " vs_motion_out( vproj0, vproj1 );\n"
48 "\n"
49 " gl_Position = vproj0;\n"
50 "\n"
51 " aUv = a_uv;\n"
52 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
53 " aCo = a_co;\n"
54 " aWorldCo = world_pos0;\n"
55 "}\n"
56 ""},
57 .fs =
58 {
59 .orig_file = "shaders/scene_standard.fs",
60 .static_src =
61 "uniform sampler2D uTexGarbage;\n"
62 "uniform sampler2D uTexMain;\n"
63 "uniform vec3 uCamera;\n"
64 "uniform vec4 uPlane;\n"
65 "\n"
66 "#line 1 1 \n"
67 "// :D\n"
68 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
69 "\n"
70 "#line 7 0 \n"
71 "#line 1 2 \n"
72 "// :D\n"
73 "\n"
74 "in vec2 aUv;\n"
75 "in vec4 aNorm;\n"
76 "in vec3 aCo;\n"
77 "in vec3 aWorldCo;\n"
78 "\n"
79 "#line 1 1 \n"
80 "layout (location = 0) out vec4 oColour;\n"
81 "\n"
82 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
83 "layout (std140) uniform ub_world_lighting\n"
84 "{\n"
85 " vec4 g_cube_min;\n"
86 " vec4 g_cube_inv_range;\n"
87 "\n"
88 " vec4 g_water_plane;\n"
89 " vec4 g_depth_bounds;\n"
90 "\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"
97 " vec4 g_sun_dir;\n"
98 " vec4 g_board_0;\n"
99 " vec4 g_board_1;\n"
100 "\n"
101 " float g_water_fog;\n"
102 " float g_time;\n"
103 " float g_realtime;\n"
104 " float g_shadow_length;\n"
105 " float g_shadow_spread;\n"
106 "\n"
107 " float g_time_of_day;\n"
108 " float g_day_phase;\n"
109 " float g_sunset_phase;\n"
110 "\n"
111 " int g_light_preview;\n"
112 " int g_shadow_samples;\n"
113 "\n"
114 " int g_debug_indices;\n"
115 " int g_debug_complexity;\n"
116 "};\n"
117 "\n"
118 "uniform sampler2D g_world_depth;\n"
119 "uniform samplerBuffer uLightsArray;\n"
120 "uniform usampler3D uLightsIndex;\n"
121 "\n"
122 "#line 1 1 \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"
129 "\n"
130 "const float SUN_ANGLE = 0.0001;\n"
131 "const float PI = 3.14159265358979323846264;\n"
132 "\n"
133 "//struct world_info\n"
134 "//{\n"
135 "// float time,\n"
136 "// time_of_day,\n"
137 "// day_phase,\n"
138 "// sunset_phase;\n"
139 "// \n"
140 "// vec3 sun_dir;\n"
141 "//};\n"
142 "\n"
143 "vec3 rand33(vec3 p3)\n"
144 "{\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"
148 "}\n"
149 "\n"
150 "float stars( vec3 rd, float rr, float size ){\n"
151 " vec3 co = rd * rr;\n"
152 "\n"
153 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
154 "\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"
158 "\n"
159 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
160 " \n"
161 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
162 " plane = plane - mod(plane, PI / count);\n"
163 "\n"
164 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
165 "\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"
171 " return star;\n"
172 "}\n"
173 "\n"
174 "float luminance( vec3 v )\n"
175 "{\n"
176 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
177 "}\n"
178 "\n"
179 "vec3 clearskies_ambient( vec3 dir )\n"
180 "{\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"
183 " \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"
188 " \n"
189 " /* Add gradient */\n"
190 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
191 " \n"
192 " return ambient;\n"
193 "}\n"
194 "\n"
195 "vec3 clearskies_sky( vec3 ray_dir )\n"
196 "{\n"
197 " ray_dir.y = abs( ray_dir.y );\n"
198 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
199 " \n"
200 " /* Sun */\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"
205 " \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"
208 "\n"
209 " \n"
210 " float star = 0.0;\n"
211 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
212 "\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"
217 " }\n"
218 " }\n"
219 " \n"
220 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
221 " return composite;\n"
222 "}\n"
223 "\n"
224 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
225 "{\n"
226 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
227 "\n"
228 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
229 " g_sunset_phase );\n"
230 "\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"
235 "\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"
239 "\n"
240 " return ambient + (light_sun + sky_reflection) * shadow;\n"
241 "}\n"
242 "\n"
243 "#line 44 0 \n"
244 "\n"
245 "float world_depth_sample( vec3 pos )\n"
246 "{\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"
249 "}\n"
250 "\n"
251 "float world_water_depth( vec3 pos )\n"
252 "{\n"
253 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
254 " return world_depth_sample( pos ) - ref_depth;\n"
255 "}\n"
256 "\n"
257 "float shadow_sample( vec3 co ){\n"
258 " float height_sample = world_depth_sample( co );\n"
259 "\n"
260 " float fdelta = height_sample - co.y;\n"
261 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
262 "}\n"
263 "\n"
264 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
265 " if( g_shadow_samples == 0 ){\n"
266 " return 1.0;\n"
267 " }\n"
268 "\n"
269 " float fspread = g_shadow_spread;\n"
270 " float flength = g_shadow_length;\n"
271 "\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"
277 "\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"
282 "\n"
283 " return 1.0 - famt;\n"
284 "}\n"
285 "\n"
286 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
287 "{\n"
288 " vec3 specdir = reflect( -dir, wnormal );\n"
289 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
290 "}\n"
291 "\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"
295 "}\n"
296 "\n"
297 "vec3 scene_calculate_light( int light_index, \n"
298 " vec3 halfview, vec3 co, vec3 normal )\n"
299 "{\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"
303 "\n"
304 " vec3 light_delta = light_co.xyz-co;\n"
305 " float dist2 = dot(light_delta,light_delta);\n"
306 "\n"
307 " light_delta = normalize( light_delta );\n"
308 "\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"
312 "\n"
313 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
314 "\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"
318 " }\n"
319 "\n"
320 " return light_colour.rgb * attenuation * falloff \n"
321 " * step( g_day_phase, light_colour.w );\n"
322 "}\n"
323 "\n"
324 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
325 " vec3 halfview, vec3 co, vec3 normal )\n"
326 "{\n"
327 " uint light_count = packed_index & 0x3u;\n"
328 "\n"
329 " vec3 l = vec3(0.0);\n"
330 "\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"
335 "\n"
336 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
337 "\n"
338 " if( light_count >= 2u ){\n"
339 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
340 "\n"
341 " if( light_count >= 3u ){\n"
342 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
343 " }\n"
344 " }\n"
345 " }\n"
346 "\n"
347 " return l;\n"
348 "}\n"
349 "\n"
350 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
351 " float light_mask )\n"
352 "{\n"
353 " if( g_light_preview == 1 )\n"
354 " diffuse = vec3(0.75);\n"
355 "\n"
356 " // Lighting\n"
357 " vec3 halfview = uCamera - co;\n"
358 " float fdist = length(halfview);\n"
359 " halfview /= fdist;\n"
360 "\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"
363 "\n"
364 " vec3 total_light = clearskies_lighting( \n"
365 " normal, min( light_mask, world_shadow ), halfview );\n"
366 "\n"
367 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
368 " cube_coord = floor( cube_coord );\n"
369 "\n"
370 " if( g_debug_indices == 1 )\n"
371 " {\n"
372 " return rand33(cube_coord);\n"
373 " }\n"
374 "\n"
375 " if( g_debug_complexity == 1 )\n"
376 " {\n"
377 " ivec3 coord = ivec3( cube_coord );\n"
378 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
379 "\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"
382 " }\n"
383 "\n"
384 " // FIXME: this coord should absolutely must be clamped!\n"
385 " \n"
386 " ivec3 coord = ivec3( cube_coord );\n"
387 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
388 "\n"
389 " total_light += \n"
390 " scene_calculate_packed_light_patch( index_sample.x,\n"
391 " halfview, co, normal ) \n"
392 " * light_mask;\n"
393 " total_light += \n"
394 " scene_calculate_packed_light_patch( index_sample.y,\n"
395 " halfview, co, normal )\n"
396 " * light_mask;\n"
397 "\n"
398 " // Take a section of the sky function to give us a matching fog colour\n"
399 "\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"
404 " \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"
407 "\n"
408 " fog_colour += sun_colour;\n"
409 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
410 "}\n"
411 "\n"
412 "#line 9 0 \n"
413 "\n"
414 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
415 "{\n"
416 " vec3 pa = p - a;\n"
417 " vec3 ba = b - a;\n"
418 "\n"
419 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
420 " return length( pa - ba*h );\n"
421 "}\n"
422 "\n"
423 "float compute_board_shadow()\n"
424 "{\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"
430 "\n"
431 " return 1.0 - player_shadow*0.8;\n"
432 "}\n"
433 "\n"
434 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
435 "{\n"
436 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
437 "}\n"
438 "\n"
439 "#line 8 0 \n"
440 "#line 1 3 \n"
441 "const float k_motion_lerp_amount = 0.01;\n"
442 "\n"
443 "#line 2 0 \n"
444 "\n"
445 "layout (location = 1) out vec2 oMotionVec;\n"
446 "\n"
447 "in vec3 aMotionVec0;\n"
448 "in vec3 aMotionVec1;\n"
449 "\n"
450 "void compute_motion_vectors()\n"
451 "{\n"
452 " // Write motion vectors\n"
453 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
454 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
455 "\n"
456 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
457 "}\n"
458 "\n"
459 "#line 9 0 \n"
460 "\n"
461 "void main()\n"
462 "{\n"
463 " compute_motion_vectors();\n"
464 "\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"
468 "\n"
469 " vfrag = vsamplemain.rgb;\n"
470 "\n"
471 " if( g_light_preview == 1 )\n"
472 " {\n"
473 " vfrag = vec3(0.5);\n"
474 " }\n"
475 "\n"
476 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
477 " oColour = vec4( vfrag, 1.0 );\n"
478 "}\n"
479 ""},
480 };
481
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",
495 .vs =
496 {
497 .orig_file = "shaders/scene.vs",
498 .static_src =
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"
502 "\n"
503 "#line 1 1 \n"
504 "const float k_motion_lerp_amount = 0.01;\n"
505 "\n"
506 "#line 2 0 \n"
507 "\n"
508 "out vec3 aMotionVec0;\n"
509 "out vec3 aMotionVec1;\n"
510 "\n"
511 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
512 "{\n"
513 " // This magically solves some artifacting errors!\n"
514 " //\n"
515 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
516 "\n"
517 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
518 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
519 "}\n"
520 "\n"
521 "#line 6 0 \n"
522 "\n"
523 "uniform mat4x3 uMdl;\n"
524 "uniform mat4 uPv;\n"
525 "uniform mat4 uPvmPrev;\n"
526 "\n"
527 "out vec2 aUv;\n"
528 "out vec4 aNorm;\n"
529 "out vec3 aCo;\n"
530 "out vec3 aWorldCo;\n"
531 "\n"
532 "void main()\n"
533 "{\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"
537 "\n"
538 " vs_motion_out( vproj0, vproj1 );\n"
539 "\n"
540 " gl_Position = vproj0;\n"
541 "\n"
542 " aUv = a_uv;\n"
543 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
544 " aCo = a_co;\n"
545 " aWorldCo = world_pos0;\n"
546 "}\n"
547 ""},
548 .fs =
549 {
550 .orig_file = "shaders/scene_standard_alphatest.fs",
551 .static_src =
552 "uniform sampler2D uTexGarbage;\n"
553 "uniform sampler2D uTexMain;\n"
554 "uniform vec3 uCamera;\n"
555 "uniform vec4 uPlane;\n"
556 "\n"
557 "#line 1 1 \n"
558 "// :D\n"
559 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
560 "\n"
561 "#line 7 0 \n"
562 "#line 1 2 \n"
563 "// :D\n"
564 "\n"
565 "in vec2 aUv;\n"
566 "in vec4 aNorm;\n"
567 "in vec3 aCo;\n"
568 "in vec3 aWorldCo;\n"
569 "\n"
570 "#line 1 1 \n"
571 "layout (location = 0) out vec4 oColour;\n"
572 "\n"
573 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
574 "layout (std140) uniform ub_world_lighting\n"
575 "{\n"
576 " vec4 g_cube_min;\n"
577 " vec4 g_cube_inv_range;\n"
578 "\n"
579 " vec4 g_water_plane;\n"
580 " vec4 g_depth_bounds;\n"
581 "\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"
588 " vec4 g_sun_dir;\n"
589 " vec4 g_board_0;\n"
590 " vec4 g_board_1;\n"
591 "\n"
592 " float g_water_fog;\n"
593 " float g_time;\n"
594 " float g_realtime;\n"
595 " float g_shadow_length;\n"
596 " float g_shadow_spread;\n"
597 "\n"
598 " float g_time_of_day;\n"
599 " float g_day_phase;\n"
600 " float g_sunset_phase;\n"
601 "\n"
602 " int g_light_preview;\n"
603 " int g_shadow_samples;\n"
604 "\n"
605 " int g_debug_indices;\n"
606 " int g_debug_complexity;\n"
607 "};\n"
608 "\n"
609 "uniform sampler2D g_world_depth;\n"
610 "uniform samplerBuffer uLightsArray;\n"
611 "uniform usampler3D uLightsIndex;\n"
612 "\n"
613 "#line 1 1 \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"
620 "\n"
621 "const float SUN_ANGLE = 0.0001;\n"
622 "const float PI = 3.14159265358979323846264;\n"
623 "\n"
624 "//struct world_info\n"
625 "//{\n"
626 "// float time,\n"
627 "// time_of_day,\n"
628 "// day_phase,\n"
629 "// sunset_phase;\n"
630 "// \n"
631 "// vec3 sun_dir;\n"
632 "//};\n"
633 "\n"
634 "vec3 rand33(vec3 p3)\n"
635 "{\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"
639 "}\n"
640 "\n"
641 "float stars( vec3 rd, float rr, float size ){\n"
642 " vec3 co = rd * rr;\n"
643 "\n"
644 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
645 "\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"
649 "\n"
650 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
651 " \n"
652 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
653 " plane = plane - mod(plane, PI / count);\n"
654 "\n"
655 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
656 "\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"
662 " return star;\n"
663 "}\n"
664 "\n"
665 "float luminance( vec3 v )\n"
666 "{\n"
667 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
668 "}\n"
669 "\n"
670 "vec3 clearskies_ambient( vec3 dir )\n"
671 "{\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"
674 " \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"
679 " \n"
680 " /* Add gradient */\n"
681 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
682 " \n"
683 " return ambient;\n"
684 "}\n"
685 "\n"
686 "vec3 clearskies_sky( vec3 ray_dir )\n"
687 "{\n"
688 " ray_dir.y = abs( ray_dir.y );\n"
689 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
690 " \n"
691 " /* Sun */\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"
696 " \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"
699 "\n"
700 " \n"
701 " float star = 0.0;\n"
702 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
703 "\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"
708 " }\n"
709 " }\n"
710 " \n"
711 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
712 " return composite;\n"
713 "}\n"
714 "\n"
715 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
716 "{\n"
717 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
718 "\n"
719 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
720 " g_sunset_phase );\n"
721 "\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"
726 "\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"
730 "\n"
731 " return ambient + (light_sun + sky_reflection) * shadow;\n"
732 "}\n"
733 "\n"
734 "#line 44 0 \n"
735 "\n"
736 "float world_depth_sample( vec3 pos )\n"
737 "{\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"
740 "}\n"
741 "\n"
742 "float world_water_depth( vec3 pos )\n"
743 "{\n"
744 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
745 " return world_depth_sample( pos ) - ref_depth;\n"
746 "}\n"
747 "\n"
748 "float shadow_sample( vec3 co ){\n"
749 " float height_sample = world_depth_sample( co );\n"
750 "\n"
751 " float fdelta = height_sample - co.y;\n"
752 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
753 "}\n"
754 "\n"
755 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
756 " if( g_shadow_samples == 0 ){\n"
757 " return 1.0;\n"
758 " }\n"
759 "\n"
760 " float fspread = g_shadow_spread;\n"
761 " float flength = g_shadow_length;\n"
762 "\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"
768 "\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"
773 "\n"
774 " return 1.0 - famt;\n"
775 "}\n"
776 "\n"
777 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
778 "{\n"
779 " vec3 specdir = reflect( -dir, wnormal );\n"
780 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
781 "}\n"
782 "\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"
786 "}\n"
787 "\n"
788 "vec3 scene_calculate_light( int light_index, \n"
789 " vec3 halfview, vec3 co, vec3 normal )\n"
790 "{\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"
794 "\n"
795 " vec3 light_delta = light_co.xyz-co;\n"
796 " float dist2 = dot(light_delta,light_delta);\n"
797 "\n"
798 " light_delta = normalize( light_delta );\n"
799 "\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"
803 "\n"
804 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
805 "\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"
809 " }\n"
810 "\n"
811 " return light_colour.rgb * attenuation * falloff \n"
812 " * step( g_day_phase, light_colour.w );\n"
813 "}\n"
814 "\n"
815 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
816 " vec3 halfview, vec3 co, vec3 normal )\n"
817 "{\n"
818 " uint light_count = packed_index & 0x3u;\n"
819 "\n"
820 " vec3 l = vec3(0.0);\n"
821 "\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"
826 "\n"
827 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
828 "\n"
829 " if( light_count >= 2u ){\n"
830 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
831 "\n"
832 " if( light_count >= 3u ){\n"
833 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
834 " }\n"
835 " }\n"
836 " }\n"
837 "\n"
838 " return l;\n"
839 "}\n"
840 "\n"
841 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
842 " float light_mask )\n"
843 "{\n"
844 " if( g_light_preview == 1 )\n"
845 " diffuse = vec3(0.75);\n"
846 "\n"
847 " // Lighting\n"
848 " vec3 halfview = uCamera - co;\n"
849 " float fdist = length(halfview);\n"
850 " halfview /= fdist;\n"
851 "\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"
854 "\n"
855 " vec3 total_light = clearskies_lighting( \n"
856 " normal, min( light_mask, world_shadow ), halfview );\n"
857 "\n"
858 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
859 " cube_coord = floor( cube_coord );\n"
860 "\n"
861 " if( g_debug_indices == 1 )\n"
862 " {\n"
863 " return rand33(cube_coord);\n"
864 " }\n"
865 "\n"
866 " if( g_debug_complexity == 1 )\n"
867 " {\n"
868 " ivec3 coord = ivec3( cube_coord );\n"
869 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
870 "\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"
873 " }\n"
874 "\n"
875 " // FIXME: this coord should absolutely must be clamped!\n"
876 " \n"
877 " ivec3 coord = ivec3( cube_coord );\n"
878 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
879 "\n"
880 " total_light += \n"
881 " scene_calculate_packed_light_patch( index_sample.x,\n"
882 " halfview, co, normal ) \n"
883 " * light_mask;\n"
884 " total_light += \n"
885 " scene_calculate_packed_light_patch( index_sample.y,\n"
886 " halfview, co, normal )\n"
887 " * light_mask;\n"
888 "\n"
889 " // Take a section of the sky function to give us a matching fog colour\n"
890 "\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"
895 " \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"
898 "\n"
899 " fog_colour += sun_colour;\n"
900 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
901 "}\n"
902 "\n"
903 "#line 9 0 \n"
904 "\n"
905 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
906 "{\n"
907 " vec3 pa = p - a;\n"
908 " vec3 ba = b - a;\n"
909 "\n"
910 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
911 " return length( pa - ba*h );\n"
912 "}\n"
913 "\n"
914 "float compute_board_shadow()\n"
915 "{\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"
921 "\n"
922 " return 1.0 - player_shadow*0.8;\n"
923 "}\n"
924 "\n"
925 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
926 "{\n"
927 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
928 "}\n"
929 "\n"
930 "#line 8 0 \n"
931 "#line 1 3 \n"
932 "const float k_motion_lerp_amount = 0.01;\n"
933 "\n"
934 "#line 2 0 \n"
935 "\n"
936 "layout (location = 1) out vec2 oMotionVec;\n"
937 "\n"
938 "in vec3 aMotionVec0;\n"
939 "in vec3 aMotionVec1;\n"
940 "\n"
941 "void compute_motion_vectors()\n"
942 "{\n"
943 " // Write motion vectors\n"
944 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
945 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
946 "\n"
947 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
948 "}\n"
949 "\n"
950 "#line 9 0 \n"
951 "\n"
952 "void main()\n"
953 "{\n"
954 " compute_motion_vectors();\n"
955 "\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"
959 "\n"
960 " if( vsamplemain.a < 0.15 )\n"
961 " discard;\n"
962 "\n"
963 " vfrag = vsamplemain.rgb;\n"
964 "\n"
965 " if( g_light_preview == 1 )\n"
966 " {\n"
967 " vfrag = vec3(0.5);\n"
968 " }\n"
969 "\n"
970 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
971 " oColour = vec4(vfrag, 1.0);\n"
972 "}\n"
973 ""},
974 };
975
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",
989 .vs =
990 {
991 .orig_file = "shaders/scene_foliage.vs",
992 .static_src =
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"
996 "\n"
997 "#line 1 1 \n"
998 "const float k_motion_lerp_amount = 0.01;\n"
999 "\n"
1000 "#line 2 0 \n"
1001 "\n"
1002 "out vec3 aMotionVec0;\n"
1003 "out vec3 aMotionVec1;\n"
1004 "\n"
1005 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
1006 "{\n"
1007 " // This magically solves some artifacting errors!\n"
1008 " //\n"
1009 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
1010 "\n"
1011 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
1012 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
1013 "}\n"
1014 "\n"
1015 "#line 6 0 \n"
1016 "\n"
1017 "uniform mat4x3 uMdl;\n"
1018 "uniform mat4 uPv;\n"
1019 "uniform mat4 uPvmPrev;\n"
1020 "uniform float uTime;\n"
1021 "\n"
1022 "out vec2 aUv;\n"
1023 "out vec4 aNorm;\n"
1024 "out vec3 aCo;\n"
1025 "out vec3 aWorldCo;\n"
1026 "\n"
1027 "void main(){\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"
1030 " \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"
1034 "\n"
1035 " vs_motion_out( vproj0, vproj1 );\n"
1036 "\n"
1037 " gl_Position = vproj0;\n"
1038 "\n"
1039 " aUv = a_uv;\n"
1040 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
1041 " aCo = a_co;\n"
1042 " aWorldCo = world_pos0;\n"
1043 "}\n"
1044 ""},
1045 .fs =
1046 {
1047 .orig_file = "shaders/scene_foliage.fs",
1048 .static_src =
1049 "uniform sampler2D uTexGarbage;\n"
1050 "uniform sampler2D uTexMain;\n"
1051 "uniform vec3 uCamera;\n"
1052 "uniform vec4 uPlane;\n"
1053 "\n"
1054 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.4;\n"
1055 "#line 1 1 \n"
1056 "// :D\n"
1057 "\n"
1058 "in vec2 aUv;\n"
1059 "in vec4 aNorm;\n"
1060 "in vec3 aCo;\n"
1061 "in vec3 aWorldCo;\n"
1062 "\n"
1063 "#line 1 1 \n"
1064 "layout (location = 0) out vec4 oColour;\n"
1065 "\n"
1066 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
1067 "layout (std140) uniform ub_world_lighting\n"
1068 "{\n"
1069 " vec4 g_cube_min;\n"
1070 " vec4 g_cube_inv_range;\n"
1071 "\n"
1072 " vec4 g_water_plane;\n"
1073 " vec4 g_depth_bounds;\n"
1074 "\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"
1084 "\n"
1085 " float g_water_fog;\n"
1086 " float g_time;\n"
1087 " float g_realtime;\n"
1088 " float g_shadow_length;\n"
1089 " float g_shadow_spread;\n"
1090 "\n"
1091 " float g_time_of_day;\n"
1092 " float g_day_phase;\n"
1093 " float g_sunset_phase;\n"
1094 "\n"
1095 " int g_light_preview;\n"
1096 " int g_shadow_samples;\n"
1097 "\n"
1098 " int g_debug_indices;\n"
1099 " int g_debug_complexity;\n"
1100 "};\n"
1101 "\n"
1102 "uniform sampler2D g_world_depth;\n"
1103 "uniform samplerBuffer uLightsArray;\n"
1104 "uniform usampler3D uLightsIndex;\n"
1105 "\n"
1106 "#line 1 1 \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"
1113 "\n"
1114 "const float SUN_ANGLE = 0.0001;\n"
1115 "const float PI = 3.14159265358979323846264;\n"
1116 "\n"
1117 "//struct world_info\n"
1118 "//{\n"
1119 "// float time,\n"
1120 "// time_of_day,\n"
1121 "// day_phase,\n"
1122 "// sunset_phase;\n"
1123 "// \n"
1124 "// vec3 sun_dir;\n"
1125 "//};\n"
1126 "\n"
1127 "vec3 rand33(vec3 p3)\n"
1128 "{\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"
1132 "}\n"
1133 "\n"
1134 "float stars( vec3 rd, float rr, float size ){\n"
1135 " vec3 co = rd * rr;\n"
1136 "\n"
1137 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
1138 "\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"
1142 "\n"
1143 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
1144 " \n"
1145 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
1146 " plane = plane - mod(plane, PI / count);\n"
1147 "\n"
1148 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
1149 "\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"
1155 " return star;\n"
1156 "}\n"
1157 "\n"
1158 "float luminance( vec3 v )\n"
1159 "{\n"
1160 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
1161 "}\n"
1162 "\n"
1163 "vec3 clearskies_ambient( vec3 dir )\n"
1164 "{\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"
1167 " \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"
1172 " \n"
1173 " /* Add gradient */\n"
1174 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
1175 " \n"
1176 " return ambient;\n"
1177 "}\n"
1178 "\n"
1179 "vec3 clearskies_sky( vec3 ray_dir )\n"
1180 "{\n"
1181 " ray_dir.y = abs( ray_dir.y );\n"
1182 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
1183 " \n"
1184 " /* Sun */\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"
1189 " \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"
1192 "\n"
1193 " \n"
1194 " float star = 0.0;\n"
1195 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
1196 "\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"
1201 " }\n"
1202 " }\n"
1203 " \n"
1204 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
1205 " return composite;\n"
1206 "}\n"
1207 "\n"
1208 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
1209 "{\n"
1210 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
1211 "\n"
1212 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
1213 " g_sunset_phase );\n"
1214 "\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"
1219 "\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"
1223 "\n"
1224 " return ambient + (light_sun + sky_reflection) * shadow;\n"
1225 "}\n"
1226 "\n"
1227 "#line 44 0 \n"
1228 "\n"
1229 "float world_depth_sample( vec3 pos )\n"
1230 "{\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"
1233 "}\n"
1234 "\n"
1235 "float world_water_depth( vec3 pos )\n"
1236 "{\n"
1237 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
1238 " return world_depth_sample( pos ) - ref_depth;\n"
1239 "}\n"
1240 "\n"
1241 "float shadow_sample( vec3 co ){\n"
1242 " float height_sample = world_depth_sample( co );\n"
1243 "\n"
1244 " float fdelta = height_sample - co.y;\n"
1245 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
1246 "}\n"
1247 "\n"
1248 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
1249 " if( g_shadow_samples == 0 ){\n"
1250 " return 1.0;\n"
1251 " }\n"
1252 "\n"
1253 " float fspread = g_shadow_spread;\n"
1254 " float flength = g_shadow_length;\n"
1255 "\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"
1261 "\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"
1266 "\n"
1267 " return 1.0 - famt;\n"
1268 "}\n"
1269 "\n"
1270 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
1271 "{\n"
1272 " vec3 specdir = reflect( -dir, wnormal );\n"
1273 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
1274 "}\n"
1275 "\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"
1279 "}\n"
1280 "\n"
1281 "vec3 scene_calculate_light( int light_index, \n"
1282 " vec3 halfview, vec3 co, vec3 normal )\n"
1283 "{\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"
1287 "\n"
1288 " vec3 light_delta = light_co.xyz-co;\n"
1289 " float dist2 = dot(light_delta,light_delta);\n"
1290 "\n"
1291 " light_delta = normalize( light_delta );\n"
1292 "\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"
1296 "\n"
1297 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
1298 "\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"
1302 " }\n"
1303 "\n"
1304 " return light_colour.rgb * attenuation * falloff \n"
1305 " * step( g_day_phase, light_colour.w );\n"
1306 "}\n"
1307 "\n"
1308 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
1309 " vec3 halfview, vec3 co, vec3 normal )\n"
1310 "{\n"
1311 " uint light_count = packed_index & 0x3u;\n"
1312 "\n"
1313 " vec3 l = vec3(0.0);\n"
1314 "\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"
1319 "\n"
1320 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
1321 "\n"
1322 " if( light_count >= 2u ){\n"
1323 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
1324 "\n"
1325 " if( light_count >= 3u ){\n"
1326 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
1327 " }\n"
1328 " }\n"
1329 " }\n"
1330 "\n"
1331 " return l;\n"
1332 "}\n"
1333 "\n"
1334 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
1335 " float light_mask )\n"
1336 "{\n"
1337 " if( g_light_preview == 1 )\n"
1338 " diffuse = vec3(0.75);\n"
1339 "\n"
1340 " // Lighting\n"
1341 " vec3 halfview = uCamera - co;\n"
1342 " float fdist = length(halfview);\n"
1343 " halfview /= fdist;\n"
1344 "\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"
1347 "\n"
1348 " vec3 total_light = clearskies_lighting( \n"
1349 " normal, min( light_mask, world_shadow ), halfview );\n"
1350 "\n"
1351 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
1352 " cube_coord = floor( cube_coord );\n"
1353 "\n"
1354 " if( g_debug_indices == 1 )\n"
1355 " {\n"
1356 " return rand33(cube_coord);\n"
1357 " }\n"
1358 "\n"
1359 " if( g_debug_complexity == 1 )\n"
1360 " {\n"
1361 " ivec3 coord = ivec3( cube_coord );\n"
1362 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
1363 "\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"
1366 " }\n"
1367 "\n"
1368 " // FIXME: this coord should absolutely must be clamped!\n"
1369 " \n"
1370 " ivec3 coord = ivec3( cube_coord );\n"
1371 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
1372 "\n"
1373 " total_light += \n"
1374 " scene_calculate_packed_light_patch( index_sample.x,\n"
1375 " halfview, co, normal ) \n"
1376 " * light_mask;\n"
1377 " total_light += \n"
1378 " scene_calculate_packed_light_patch( index_sample.y,\n"
1379 " halfview, co, normal )\n"
1380 " * light_mask;\n"
1381 "\n"
1382 " // Take a section of the sky function to give us a matching fog colour\n"
1383 "\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"
1388 " \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"
1391 "\n"
1392 " fog_colour += sun_colour;\n"
1393 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
1394 "}\n"
1395 "\n"
1396 "#line 9 0 \n"
1397 "\n"
1398 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
1399 "{\n"
1400 " vec3 pa = p - a;\n"
1401 " vec3 ba = b - a;\n"
1402 "\n"
1403 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
1404 " return length( pa - ba*h );\n"
1405 "}\n"
1406 "\n"
1407 "float compute_board_shadow()\n"
1408 "{\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"
1414 "\n"
1415 " return 1.0 - player_shadow*0.8;\n"
1416 "}\n"
1417 "\n"
1418 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
1419 "{\n"
1420 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
1421 "}\n"
1422 "\n"
1423 "#line 8 0 \n"
1424 "#line 1 2 \n"
1425 "const float k_motion_lerp_amount = 0.01;\n"
1426 "\n"
1427 "#line 2 0 \n"
1428 "\n"
1429 "layout (location = 1) out vec2 oMotionVec;\n"
1430 "\n"
1431 "in vec3 aMotionVec0;\n"
1432 "in vec3 aMotionVec1;\n"
1433 "\n"
1434 "void compute_motion_vectors()\n"
1435 "{\n"
1436 " // Write motion vectors\n"
1437 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
1438 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
1439 "\n"
1440 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
1441 "}\n"
1442 "\n"
1443 "#line 9 0 \n"
1444 "\n"
1445 "void main(){\n"
1446 " compute_motion_vectors();\n"
1447 "\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"
1451 "\n"
1452 " if( vsamplemain.a < 0.15 )\n"
1453 " discard;\n"
1454 "\n"
1455 " vfrag = vsamplemain.rgb;\n"
1456 "\n"
1457 " if( g_light_preview == 1 ){\n"
1458 " vfrag = vec3(0.5);\n"
1459 " }\n"
1460 "\n"
1461 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
1462 " oColour = vec4(vfrag, 1.0);\n"
1463 "}\n"
1464 ""},
1465 };
1466
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",
1481 .vs =
1482 {
1483 .orig_file = "shaders/scene_override.vs",
1484 .static_src =
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"
1488 "\n"
1489 "#line 1 1 \n"
1490 "const float k_motion_lerp_amount = 0.01;\n"
1491 "\n"
1492 "#line 2 0 \n"
1493 "\n"
1494 "out vec3 aMotionVec0;\n"
1495 "out vec3 aMotionVec1;\n"
1496 "\n"
1497 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
1498 "{\n"
1499 " // This magically solves some artifacting errors!\n"
1500 " //\n"
1501 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
1502 "\n"
1503 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
1504 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
1505 "}\n"
1506 "\n"
1507 "#line 6 0 \n"
1508 "\n"
1509 "uniform mat4x3 uMdl;\n"
1510 "uniform mat4 uPv;\n"
1511 "uniform mat4 uPvmPrev;\n"
1512 "uniform mat3 uNormalMtx;\n"
1513 "\n"
1514 "out vec2 aUv;\n"
1515 "out vec4 aNorm;\n"
1516 "out vec3 aCo;\n"
1517 "out vec3 aWorldCo;\n"
1518 "\n"
1519 "void main()\n"
1520 "{\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"
1524 "\n"
1525 " vs_motion_out( vproj0, vproj1 );\n"
1526 "\n"
1527 " gl_Position = vproj0;\n"
1528 "\n"
1529 " aUv = a_uv;\n"
1530 " aNorm = vec4( uNormalMtx * a_norm.xyz, a_norm.w );\n"
1531 " aCo = a_co;\n"
1532 " aWorldCo = world_pos0;\n"
1533 "}\n"
1534 ""},
1535 .fs =
1536 {
1537 .orig_file = "shaders/scene_override.fs",
1538 .static_src =
1539 "uniform sampler2D uTexGarbage;\n"
1540 "uniform sampler2D uTexMain;\n"
1541 "uniform vec3 uCamera;\n"
1542 "uniform vec4 uPlane;\n"
1543 "\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"
1548 "\n"
1549 "#line 1 1 \n"
1550 "// :D\n"
1551 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
1552 "\n"
1553 "#line 12 0 \n"
1554 "#line 1 2 \n"
1555 "// :D\n"
1556 "\n"
1557 "in vec2 aUv;\n"
1558 "in vec4 aNorm;\n"
1559 "in vec3 aCo;\n"
1560 "in vec3 aWorldCo;\n"
1561 "\n"
1562 "#line 1 1 \n"
1563 "layout (location = 0) out vec4 oColour;\n"
1564 "\n"
1565 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
1566 "layout (std140) uniform ub_world_lighting\n"
1567 "{\n"
1568 " vec4 g_cube_min;\n"
1569 " vec4 g_cube_inv_range;\n"
1570 "\n"
1571 " vec4 g_water_plane;\n"
1572 " vec4 g_depth_bounds;\n"
1573 "\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"
1583 "\n"
1584 " float g_water_fog;\n"
1585 " float g_time;\n"
1586 " float g_realtime;\n"
1587 " float g_shadow_length;\n"
1588 " float g_shadow_spread;\n"
1589 "\n"
1590 " float g_time_of_day;\n"
1591 " float g_day_phase;\n"
1592 " float g_sunset_phase;\n"
1593 "\n"
1594 " int g_light_preview;\n"
1595 " int g_shadow_samples;\n"
1596 "\n"
1597 " int g_debug_indices;\n"
1598 " int g_debug_complexity;\n"
1599 "};\n"
1600 "\n"
1601 "uniform sampler2D g_world_depth;\n"
1602 "uniform samplerBuffer uLightsArray;\n"
1603 "uniform usampler3D uLightsIndex;\n"
1604 "\n"
1605 "#line 1 1 \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"
1612 "\n"
1613 "const float SUN_ANGLE = 0.0001;\n"
1614 "const float PI = 3.14159265358979323846264;\n"
1615 "\n"
1616 "//struct world_info\n"
1617 "//{\n"
1618 "// float time,\n"
1619 "// time_of_day,\n"
1620 "// day_phase,\n"
1621 "// sunset_phase;\n"
1622 "// \n"
1623 "// vec3 sun_dir;\n"
1624 "//};\n"
1625 "\n"
1626 "vec3 rand33(vec3 p3)\n"
1627 "{\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"
1631 "}\n"
1632 "\n"
1633 "float stars( vec3 rd, float rr, float size ){\n"
1634 " vec3 co = rd * rr;\n"
1635 "\n"
1636 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
1637 "\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"
1641 "\n"
1642 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
1643 " \n"
1644 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
1645 " plane = plane - mod(plane, PI / count);\n"
1646 "\n"
1647 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
1648 "\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"
1654 " return star;\n"
1655 "}\n"
1656 "\n"
1657 "float luminance( vec3 v )\n"
1658 "{\n"
1659 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
1660 "}\n"
1661 "\n"
1662 "vec3 clearskies_ambient( vec3 dir )\n"
1663 "{\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"
1666 " \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"
1671 " \n"
1672 " /* Add gradient */\n"
1673 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
1674 " \n"
1675 " return ambient;\n"
1676 "}\n"
1677 "\n"
1678 "vec3 clearskies_sky( vec3 ray_dir )\n"
1679 "{\n"
1680 " ray_dir.y = abs( ray_dir.y );\n"
1681 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
1682 " \n"
1683 " /* Sun */\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"
1688 " \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"
1691 "\n"
1692 " \n"
1693 " float star = 0.0;\n"
1694 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
1695 "\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"
1700 " }\n"
1701 " }\n"
1702 " \n"
1703 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
1704 " return composite;\n"
1705 "}\n"
1706 "\n"
1707 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
1708 "{\n"
1709 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
1710 "\n"
1711 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
1712 " g_sunset_phase );\n"
1713 "\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"
1718 "\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"
1722 "\n"
1723 " return ambient + (light_sun + sky_reflection) * shadow;\n"
1724 "}\n"
1725 "\n"
1726 "#line 44 0 \n"
1727 "\n"
1728 "float world_depth_sample( vec3 pos )\n"
1729 "{\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"
1732 "}\n"
1733 "\n"
1734 "float world_water_depth( vec3 pos )\n"
1735 "{\n"
1736 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
1737 " return world_depth_sample( pos ) - ref_depth;\n"
1738 "}\n"
1739 "\n"
1740 "float shadow_sample( vec3 co ){\n"
1741 " float height_sample = world_depth_sample( co );\n"
1742 "\n"
1743 " float fdelta = height_sample - co.y;\n"
1744 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
1745 "}\n"
1746 "\n"
1747 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
1748 " if( g_shadow_samples == 0 ){\n"
1749 " return 1.0;\n"
1750 " }\n"
1751 "\n"
1752 " float fspread = g_shadow_spread;\n"
1753 " float flength = g_shadow_length;\n"
1754 "\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"
1760 "\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"
1765 "\n"
1766 " return 1.0 - famt;\n"
1767 "}\n"
1768 "\n"
1769 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
1770 "{\n"
1771 " vec3 specdir = reflect( -dir, wnormal );\n"
1772 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
1773 "}\n"
1774 "\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"
1778 "}\n"
1779 "\n"
1780 "vec3 scene_calculate_light( int light_index, \n"
1781 " vec3 halfview, vec3 co, vec3 normal )\n"
1782 "{\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"
1786 "\n"
1787 " vec3 light_delta = light_co.xyz-co;\n"
1788 " float dist2 = dot(light_delta,light_delta);\n"
1789 "\n"
1790 " light_delta = normalize( light_delta );\n"
1791 "\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"
1795 "\n"
1796 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
1797 "\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"
1801 " }\n"
1802 "\n"
1803 " return light_colour.rgb * attenuation * falloff \n"
1804 " * step( g_day_phase, light_colour.w );\n"
1805 "}\n"
1806 "\n"
1807 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
1808 " vec3 halfview, vec3 co, vec3 normal )\n"
1809 "{\n"
1810 " uint light_count = packed_index & 0x3u;\n"
1811 "\n"
1812 " vec3 l = vec3(0.0);\n"
1813 "\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"
1818 "\n"
1819 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
1820 "\n"
1821 " if( light_count >= 2u ){\n"
1822 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
1823 "\n"
1824 " if( light_count >= 3u ){\n"
1825 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
1826 " }\n"
1827 " }\n"
1828 " }\n"
1829 "\n"
1830 " return l;\n"
1831 "}\n"
1832 "\n"
1833 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
1834 " float light_mask )\n"
1835 "{\n"
1836 " if( g_light_preview == 1 )\n"
1837 " diffuse = vec3(0.75);\n"
1838 "\n"
1839 " // Lighting\n"
1840 " vec3 halfview = uCamera - co;\n"
1841 " float fdist = length(halfview);\n"
1842 " halfview /= fdist;\n"
1843 "\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"
1846 "\n"
1847 " vec3 total_light = clearskies_lighting( \n"
1848 " normal, min( light_mask, world_shadow ), halfview );\n"
1849 "\n"
1850 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
1851 " cube_coord = floor( cube_coord );\n"
1852 "\n"
1853 " if( g_debug_indices == 1 )\n"
1854 " {\n"
1855 " return rand33(cube_coord);\n"
1856 " }\n"
1857 "\n"
1858 " if( g_debug_complexity == 1 )\n"
1859 " {\n"
1860 " ivec3 coord = ivec3( cube_coord );\n"
1861 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
1862 "\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"
1865 " }\n"
1866 "\n"
1867 " // FIXME: this coord should absolutely must be clamped!\n"
1868 " \n"
1869 " ivec3 coord = ivec3( cube_coord );\n"
1870 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
1871 "\n"
1872 " total_light += \n"
1873 " scene_calculate_packed_light_patch( index_sample.x,\n"
1874 " halfview, co, normal ) \n"
1875 " * light_mask;\n"
1876 " total_light += \n"
1877 " scene_calculate_packed_light_patch( index_sample.y,\n"
1878 " halfview, co, normal )\n"
1879 " * light_mask;\n"
1880 "\n"
1881 " // Take a section of the sky function to give us a matching fog colour\n"
1882 "\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"
1887 " \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"
1890 "\n"
1891 " fog_colour += sun_colour;\n"
1892 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
1893 "}\n"
1894 "\n"
1895 "#line 9 0 \n"
1896 "\n"
1897 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
1898 "{\n"
1899 " vec3 pa = p - a;\n"
1900 " vec3 ba = b - a;\n"
1901 "\n"
1902 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
1903 " return length( pa - ba*h );\n"
1904 "}\n"
1905 "\n"
1906 "float compute_board_shadow()\n"
1907 "{\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"
1913 "\n"
1914 " return 1.0 - player_shadow*0.8;\n"
1915 "}\n"
1916 "\n"
1917 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
1918 "{\n"
1919 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
1920 "}\n"
1921 "\n"
1922 "#line 13 0 \n"
1923 "#line 1 3 \n"
1924 "const float k_motion_lerp_amount = 0.01;\n"
1925 "\n"
1926 "#line 2 0 \n"
1927 "\n"
1928 "layout (location = 1) out vec2 oMotionVec;\n"
1929 "\n"
1930 "in vec3 aMotionVec0;\n"
1931 "in vec3 aMotionVec1;\n"
1932 "\n"
1933 "void compute_motion_vectors()\n"
1934 "{\n"
1935 " // Write motion vectors\n"
1936 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
1937 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
1938 "\n"
1939 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
1940 "}\n"
1941 "\n"
1942 "#line 14 0 \n"
1943 "\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"
1948 "\n"
1949 " if( a < b )\n"
1950 " return vec2(a-s,m);\n"
1951 " else\n"
1952 " return vec2(b-s,1.0-m);\n"
1953 "}\n"
1954 "\n"
1955 "void main(){\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"
1959 "\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"
1963 "\n"
1964 " if( min(min(dy0,dy1)*0.5, dcam) + dither < 0.51 ) \n"
1965 " discard;\n"
1966 "\n"
1967 " compute_motion_vectors();\n"
1968 "\n"
1969 " vec3 vfrag = vec3(0.898,0.811,0.716);\n"
1970 " vec3 qnorm = aNorm.xyz;\n"
1971 "\n"
1972 " qnorm = normalize(floor(aNorm.xyz*4.0)*0.25);\n"
1973 " qnorm += vec3(0.001,0.0,0.0);\n"
1974 "\n"
1975 " if( uAlphatest ){\n"
1976 " vec4 vSample = texture( uTexMain, aUv );\n"
1977 " if( vSample.a < 0.5 )\n"
1978 " discard;\n"
1979 " }\n"
1980 " else{\n"
1981 " }\n"
1982 "\n"
1983 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
1984 " \n"
1985 " // dots\n"
1986 " float d0 = distance( aCo, uPlayerPos.xyz )*2.0;\n"
1987 " float d1 = distance( aCo, uSpawnPos.xyz );\n"
1988 "\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"
1994 "\n"
1995 " // line\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"
2001 "\n"
2002 " vfrag += emit;\n"
2003 "\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"
2008 " }\n"
2009 "\n"
2010 " oColour = vec4( vfrag, 1.0 );\n"
2011 " //oColour = vec4( vfrag, 1.0 );\n"
2012 "}\n"
2013 ""},
2014 };
2015
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",
2034 .vs =
2035 {
2036 .orig_file = "shaders/scene_fxglow.vs",
2037 .static_src =
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"
2041 "\n"
2042 "#line 1 1 \n"
2043 "const float k_motion_lerp_amount = 0.01;\n"
2044 "\n"
2045 "#line 2 0 \n"
2046 "\n"
2047 "out vec3 aMotionVec0;\n"
2048 "out vec3 aMotionVec1;\n"
2049 "\n"
2050 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
2051 "{\n"
2052 " // This magically solves some artifacting errors!\n"
2053 " //\n"
2054 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
2055 "\n"
2056 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
2057 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
2058 "}\n"
2059 "\n"
2060 "#line 6 0 \n"
2061 "\n"
2062 "uniform mat4x3 uMdl;\n"
2063 "uniform mat4 uPv;\n"
2064 "uniform mat4 uPvmPrev;\n"
2065 "uniform vec2 uUvOffset;\n"
2066 "\n"
2067 "out vec2 aUv;\n"
2068 "out vec4 aNorm;\n"
2069 "out vec3 aCo;\n"
2070 "out vec3 aWorldCo;\n"
2071 "\n"
2072 "void main()\n"
2073 "{\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"
2077 "\n"
2078 " vs_motion_out( vproj0, vproj1 );\n"
2079 "\n"
2080 " gl_Position = vproj0;\n"
2081 "\n"
2082 " aUv = a_uv + uUvOffset;\n"
2083 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
2084 " aCo = a_co;\n"
2085 " aWorldCo = world_pos0;\n"
2086 "}\n"
2087 ""},
2088 .fs =
2089 {
2090 .orig_file = "shaders/scene_fxglow.fs",
2091 .static_src =
2092 "uniform sampler2D uTexMain;\n"
2093 "uniform vec3 uCamera;\n"
2094 "\n"
2095 "#line 1 1 \n"
2096 "// :D\n"
2097 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
2098 "\n"
2099 "#line 5 0 \n"
2100 "#line 1 2 \n"
2101 "// :D\n"
2102 "\n"
2103 "in vec2 aUv;\n"
2104 "in vec4 aNorm;\n"
2105 "in vec3 aCo;\n"
2106 "in vec3 aWorldCo;\n"
2107 "\n"
2108 "#line 1 1 \n"
2109 "layout (location = 0) out vec4 oColour;\n"
2110 "\n"
2111 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
2112 "layout (std140) uniform ub_world_lighting\n"
2113 "{\n"
2114 " vec4 g_cube_min;\n"
2115 " vec4 g_cube_inv_range;\n"
2116 "\n"
2117 " vec4 g_water_plane;\n"
2118 " vec4 g_depth_bounds;\n"
2119 "\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"
2129 "\n"
2130 " float g_water_fog;\n"
2131 " float g_time;\n"
2132 " float g_realtime;\n"
2133 " float g_shadow_length;\n"
2134 " float g_shadow_spread;\n"
2135 "\n"
2136 " float g_time_of_day;\n"
2137 " float g_day_phase;\n"
2138 " float g_sunset_phase;\n"
2139 "\n"
2140 " int g_light_preview;\n"
2141 " int g_shadow_samples;\n"
2142 "\n"
2143 " int g_debug_indices;\n"
2144 " int g_debug_complexity;\n"
2145 "};\n"
2146 "\n"
2147 "uniform sampler2D g_world_depth;\n"
2148 "uniform samplerBuffer uLightsArray;\n"
2149 "uniform usampler3D uLightsIndex;\n"
2150 "\n"
2151 "#line 1 1 \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"
2158 "\n"
2159 "const float SUN_ANGLE = 0.0001;\n"
2160 "const float PI = 3.14159265358979323846264;\n"
2161 "\n"
2162 "//struct world_info\n"
2163 "//{\n"
2164 "// float time,\n"
2165 "// time_of_day,\n"
2166 "// day_phase,\n"
2167 "// sunset_phase;\n"
2168 "// \n"
2169 "// vec3 sun_dir;\n"
2170 "//};\n"
2171 "\n"
2172 "vec3 rand33(vec3 p3)\n"
2173 "{\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"
2177 "}\n"
2178 "\n"
2179 "float stars( vec3 rd, float rr, float size ){\n"
2180 " vec3 co = rd * rr;\n"
2181 "\n"
2182 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
2183 "\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"
2187 "\n"
2188 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
2189 " \n"
2190 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
2191 " plane = plane - mod(plane, PI / count);\n"
2192 "\n"
2193 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
2194 "\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"
2200 " return star;\n"
2201 "}\n"
2202 "\n"
2203 "float luminance( vec3 v )\n"
2204 "{\n"
2205 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
2206 "}\n"
2207 "\n"
2208 "vec3 clearskies_ambient( vec3 dir )\n"
2209 "{\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"
2212 " \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"
2217 " \n"
2218 " /* Add gradient */\n"
2219 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
2220 " \n"
2221 " return ambient;\n"
2222 "}\n"
2223 "\n"
2224 "vec3 clearskies_sky( vec3 ray_dir )\n"
2225 "{\n"
2226 " ray_dir.y = abs( ray_dir.y );\n"
2227 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
2228 " \n"
2229 " /* Sun */\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"
2234 " \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"
2237 "\n"
2238 " \n"
2239 " float star = 0.0;\n"
2240 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
2241 "\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"
2246 " }\n"
2247 " }\n"
2248 " \n"
2249 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
2250 " return composite;\n"
2251 "}\n"
2252 "\n"
2253 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
2254 "{\n"
2255 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
2256 "\n"
2257 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
2258 " g_sunset_phase );\n"
2259 "\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"
2264 "\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"
2268 "\n"
2269 " return ambient + (light_sun + sky_reflection) * shadow;\n"
2270 "}\n"
2271 "\n"
2272 "#line 44 0 \n"
2273 "\n"
2274 "float world_depth_sample( vec3 pos )\n"
2275 "{\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"
2278 "}\n"
2279 "\n"
2280 "float world_water_depth( vec3 pos )\n"
2281 "{\n"
2282 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
2283 " return world_depth_sample( pos ) - ref_depth;\n"
2284 "}\n"
2285 "\n"
2286 "float shadow_sample( vec3 co ){\n"
2287 " float height_sample = world_depth_sample( co );\n"
2288 "\n"
2289 " float fdelta = height_sample - co.y;\n"
2290 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
2291 "}\n"
2292 "\n"
2293 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
2294 " if( g_shadow_samples == 0 ){\n"
2295 " return 1.0;\n"
2296 " }\n"
2297 "\n"
2298 " float fspread = g_shadow_spread;\n"
2299 " float flength = g_shadow_length;\n"
2300 "\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"
2306 "\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"
2311 "\n"
2312 " return 1.0 - famt;\n"
2313 "}\n"
2314 "\n"
2315 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
2316 "{\n"
2317 " vec3 specdir = reflect( -dir, wnormal );\n"
2318 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
2319 "}\n"
2320 "\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"
2324 "}\n"
2325 "\n"
2326 "vec3 scene_calculate_light( int light_index, \n"
2327 " vec3 halfview, vec3 co, vec3 normal )\n"
2328 "{\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"
2332 "\n"
2333 " vec3 light_delta = light_co.xyz-co;\n"
2334 " float dist2 = dot(light_delta,light_delta);\n"
2335 "\n"
2336 " light_delta = normalize( light_delta );\n"
2337 "\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"
2341 "\n"
2342 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
2343 "\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"
2347 " }\n"
2348 "\n"
2349 " return light_colour.rgb * attenuation * falloff \n"
2350 " * step( g_day_phase, light_colour.w );\n"
2351 "}\n"
2352 "\n"
2353 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
2354 " vec3 halfview, vec3 co, vec3 normal )\n"
2355 "{\n"
2356 " uint light_count = packed_index & 0x3u;\n"
2357 "\n"
2358 " vec3 l = vec3(0.0);\n"
2359 "\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"
2364 "\n"
2365 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
2366 "\n"
2367 " if( light_count >= 2u ){\n"
2368 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
2369 "\n"
2370 " if( light_count >= 3u ){\n"
2371 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
2372 " }\n"
2373 " }\n"
2374 " }\n"
2375 "\n"
2376 " return l;\n"
2377 "}\n"
2378 "\n"
2379 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
2380 " float light_mask )\n"
2381 "{\n"
2382 " if( g_light_preview == 1 )\n"
2383 " diffuse = vec3(0.75);\n"
2384 "\n"
2385 " // Lighting\n"
2386 " vec3 halfview = uCamera - co;\n"
2387 " float fdist = length(halfview);\n"
2388 " halfview /= fdist;\n"
2389 "\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"
2392 "\n"
2393 " vec3 total_light = clearskies_lighting( \n"
2394 " normal, min( light_mask, world_shadow ), halfview );\n"
2395 "\n"
2396 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
2397 " cube_coord = floor( cube_coord );\n"
2398 "\n"
2399 " if( g_debug_indices == 1 )\n"
2400 " {\n"
2401 " return rand33(cube_coord);\n"
2402 " }\n"
2403 "\n"
2404 " if( g_debug_complexity == 1 )\n"
2405 " {\n"
2406 " ivec3 coord = ivec3( cube_coord );\n"
2407 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
2408 "\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"
2411 " }\n"
2412 "\n"
2413 " // FIXME: this coord should absolutely must be clamped!\n"
2414 " \n"
2415 " ivec3 coord = ivec3( cube_coord );\n"
2416 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
2417 "\n"
2418 " total_light += \n"
2419 " scene_calculate_packed_light_patch( index_sample.x,\n"
2420 " halfview, co, normal ) \n"
2421 " * light_mask;\n"
2422 " total_light += \n"
2423 " scene_calculate_packed_light_patch( index_sample.y,\n"
2424 " halfview, co, normal )\n"
2425 " * light_mask;\n"
2426 "\n"
2427 " // Take a section of the sky function to give us a matching fog colour\n"
2428 "\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"
2433 " \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"
2436 "\n"
2437 " fog_colour += sun_colour;\n"
2438 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
2439 "}\n"
2440 "\n"
2441 "#line 9 0 \n"
2442 "\n"
2443 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
2444 "{\n"
2445 " vec3 pa = p - a;\n"
2446 " vec3 ba = b - a;\n"
2447 "\n"
2448 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
2449 " return length( pa - ba*h );\n"
2450 "}\n"
2451 "\n"
2452 "float compute_board_shadow()\n"
2453 "{\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"
2459 "\n"
2460 " return 1.0 - player_shadow*0.8;\n"
2461 "}\n"
2462 "\n"
2463 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
2464 "{\n"
2465 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
2466 "}\n"
2467 "\n"
2468 "#line 6 0 \n"
2469 "#line 1 3 \n"
2470 "const float k_motion_lerp_amount = 0.01;\n"
2471 "\n"
2472 "#line 2 0 \n"
2473 "\n"
2474 "layout (location = 1) out vec2 oMotionVec;\n"
2475 "\n"
2476 "in vec3 aMotionVec0;\n"
2477 "in vec3 aMotionVec1;\n"
2478 "\n"
2479 "void compute_motion_vectors()\n"
2480 "{\n"
2481 " // Write motion vectors\n"
2482 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
2483 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
2484 "\n"
2485 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
2486 "}\n"
2487 "\n"
2488 "#line 7 0 \n"
2489 "\n"
2490 "void main(){\n"
2491 " oMotionVec = vec2(0.0);\n"
2492 "\n"
2493 " vec4 vsamplemain = texture( uTexMain, aUv );\n"
2494 "\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"
2498 "\n"
2499 " if( vsamplemain.a+dither<0.5 )\n"
2500 " discard;\n"
2501 "\n"
2502 " oColour = vec4( vsamplemain.rgb, 1.0 );\n"
2503 "}\n"
2504 ""},
2505 };
2506
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",
2519 .vs =
2520 {
2521 .orig_file = "shaders/scene.vs",
2522 .static_src =
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"
2526 "\n"
2527 "#line 1 1 \n"
2528 "const float k_motion_lerp_amount = 0.01;\n"
2529 "\n"
2530 "#line 2 0 \n"
2531 "\n"
2532 "out vec3 aMotionVec0;\n"
2533 "out vec3 aMotionVec1;\n"
2534 "\n"
2535 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
2536 "{\n"
2537 " // This magically solves some artifacting errors!\n"
2538 " //\n"
2539 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
2540 "\n"
2541 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
2542 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
2543 "}\n"
2544 "\n"
2545 "#line 6 0 \n"
2546 "\n"
2547 "uniform mat4x3 uMdl;\n"
2548 "uniform mat4 uPv;\n"
2549 "uniform mat4 uPvmPrev;\n"
2550 "\n"
2551 "out vec2 aUv;\n"
2552 "out vec4 aNorm;\n"
2553 "out vec3 aCo;\n"
2554 "out vec3 aWorldCo;\n"
2555 "\n"
2556 "void main()\n"
2557 "{\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"
2561 "\n"
2562 " vs_motion_out( vproj0, vproj1 );\n"
2563 "\n"
2564 " gl_Position = vproj0;\n"
2565 "\n"
2566 " aUv = a_uv;\n"
2567 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
2568 " aCo = a_co;\n"
2569 " aWorldCo = world_pos0;\n"
2570 "}\n"
2571 ""},
2572 .fs =
2573 {
2574 .orig_file = "shaders/scene_vertex_blend.fs",
2575 .static_src =
2576 "uniform sampler2D uTexGarbage;\n"
2577 "uniform sampler2D uTexGradients;\n"
2578 "uniform vec3 uCamera;\n"
2579 "\n"
2580 "#line 1 1 \n"
2581 "// :D\n"
2582 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
2583 "\n"
2584 "#line 6 0 \n"
2585 "#line 1 2 \n"
2586 "// :D\n"
2587 "\n"
2588 "in vec2 aUv;\n"
2589 "in vec4 aNorm;\n"
2590 "in vec3 aCo;\n"
2591 "in vec3 aWorldCo;\n"
2592 "\n"
2593 "#line 1 1 \n"
2594 "layout (location = 0) out vec4 oColour;\n"
2595 "\n"
2596 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
2597 "layout (std140) uniform ub_world_lighting\n"
2598 "{\n"
2599 " vec4 g_cube_min;\n"
2600 " vec4 g_cube_inv_range;\n"
2601 "\n"
2602 " vec4 g_water_plane;\n"
2603 " vec4 g_depth_bounds;\n"
2604 "\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"
2614 "\n"
2615 " float g_water_fog;\n"
2616 " float g_time;\n"
2617 " float g_realtime;\n"
2618 " float g_shadow_length;\n"
2619 " float g_shadow_spread;\n"
2620 "\n"
2621 " float g_time_of_day;\n"
2622 " float g_day_phase;\n"
2623 " float g_sunset_phase;\n"
2624 "\n"
2625 " int g_light_preview;\n"
2626 " int g_shadow_samples;\n"
2627 "\n"
2628 " int g_debug_indices;\n"
2629 " int g_debug_complexity;\n"
2630 "};\n"
2631 "\n"
2632 "uniform sampler2D g_world_depth;\n"
2633 "uniform samplerBuffer uLightsArray;\n"
2634 "uniform usampler3D uLightsIndex;\n"
2635 "\n"
2636 "#line 1 1 \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"
2643 "\n"
2644 "const float SUN_ANGLE = 0.0001;\n"
2645 "const float PI = 3.14159265358979323846264;\n"
2646 "\n"
2647 "//struct world_info\n"
2648 "//{\n"
2649 "// float time,\n"
2650 "// time_of_day,\n"
2651 "// day_phase,\n"
2652 "// sunset_phase;\n"
2653 "// \n"
2654 "// vec3 sun_dir;\n"
2655 "//};\n"
2656 "\n"
2657 "vec3 rand33(vec3 p3)\n"
2658 "{\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"
2662 "}\n"
2663 "\n"
2664 "float stars( vec3 rd, float rr, float size ){\n"
2665 " vec3 co = rd * rr;\n"
2666 "\n"
2667 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
2668 "\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"
2672 "\n"
2673 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
2674 " \n"
2675 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
2676 " plane = plane - mod(plane, PI / count);\n"
2677 "\n"
2678 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
2679 "\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"
2685 " return star;\n"
2686 "}\n"
2687 "\n"
2688 "float luminance( vec3 v )\n"
2689 "{\n"
2690 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
2691 "}\n"
2692 "\n"
2693 "vec3 clearskies_ambient( vec3 dir )\n"
2694 "{\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"
2697 " \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"
2702 " \n"
2703 " /* Add gradient */\n"
2704 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
2705 " \n"
2706 " return ambient;\n"
2707 "}\n"
2708 "\n"
2709 "vec3 clearskies_sky( vec3 ray_dir )\n"
2710 "{\n"
2711 " ray_dir.y = abs( ray_dir.y );\n"
2712 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
2713 " \n"
2714 " /* Sun */\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"
2719 " \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"
2722 "\n"
2723 " \n"
2724 " float star = 0.0;\n"
2725 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
2726 "\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"
2731 " }\n"
2732 " }\n"
2733 " \n"
2734 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
2735 " return composite;\n"
2736 "}\n"
2737 "\n"
2738 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
2739 "{\n"
2740 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
2741 "\n"
2742 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
2743 " g_sunset_phase );\n"
2744 "\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"
2749 "\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"
2753 "\n"
2754 " return ambient + (light_sun + sky_reflection) * shadow;\n"
2755 "}\n"
2756 "\n"
2757 "#line 44 0 \n"
2758 "\n"
2759 "float world_depth_sample( vec3 pos )\n"
2760 "{\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"
2763 "}\n"
2764 "\n"
2765 "float world_water_depth( vec3 pos )\n"
2766 "{\n"
2767 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
2768 " return world_depth_sample( pos ) - ref_depth;\n"
2769 "}\n"
2770 "\n"
2771 "float shadow_sample( vec3 co ){\n"
2772 " float height_sample = world_depth_sample( co );\n"
2773 "\n"
2774 " float fdelta = height_sample - co.y;\n"
2775 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
2776 "}\n"
2777 "\n"
2778 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
2779 " if( g_shadow_samples == 0 ){\n"
2780 " return 1.0;\n"
2781 " }\n"
2782 "\n"
2783 " float fspread = g_shadow_spread;\n"
2784 " float flength = g_shadow_length;\n"
2785 "\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"
2791 "\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"
2796 "\n"
2797 " return 1.0 - famt;\n"
2798 "}\n"
2799 "\n"
2800 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
2801 "{\n"
2802 " vec3 specdir = reflect( -dir, wnormal );\n"
2803 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
2804 "}\n"
2805 "\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"
2809 "}\n"
2810 "\n"
2811 "vec3 scene_calculate_light( int light_index, \n"
2812 " vec3 halfview, vec3 co, vec3 normal )\n"
2813 "{\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"
2817 "\n"
2818 " vec3 light_delta = light_co.xyz-co;\n"
2819 " float dist2 = dot(light_delta,light_delta);\n"
2820 "\n"
2821 " light_delta = normalize( light_delta );\n"
2822 "\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"
2826 "\n"
2827 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
2828 "\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"
2832 " }\n"
2833 "\n"
2834 " return light_colour.rgb * attenuation * falloff \n"
2835 " * step( g_day_phase, light_colour.w );\n"
2836 "}\n"
2837 "\n"
2838 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
2839 " vec3 halfview, vec3 co, vec3 normal )\n"
2840 "{\n"
2841 " uint light_count = packed_index & 0x3u;\n"
2842 "\n"
2843 " vec3 l = vec3(0.0);\n"
2844 "\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"
2849 "\n"
2850 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
2851 "\n"
2852 " if( light_count >= 2u ){\n"
2853 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
2854 "\n"
2855 " if( light_count >= 3u ){\n"
2856 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
2857 " }\n"
2858 " }\n"
2859 " }\n"
2860 "\n"
2861 " return l;\n"
2862 "}\n"
2863 "\n"
2864 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
2865 " float light_mask )\n"
2866 "{\n"
2867 " if( g_light_preview == 1 )\n"
2868 " diffuse = vec3(0.75);\n"
2869 "\n"
2870 " // Lighting\n"
2871 " vec3 halfview = uCamera - co;\n"
2872 " float fdist = length(halfview);\n"
2873 " halfview /= fdist;\n"
2874 "\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"
2877 "\n"
2878 " vec3 total_light = clearskies_lighting( \n"
2879 " normal, min( light_mask, world_shadow ), halfview );\n"
2880 "\n"
2881 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
2882 " cube_coord = floor( cube_coord );\n"
2883 "\n"
2884 " if( g_debug_indices == 1 )\n"
2885 " {\n"
2886 " return rand33(cube_coord);\n"
2887 " }\n"
2888 "\n"
2889 " if( g_debug_complexity == 1 )\n"
2890 " {\n"
2891 " ivec3 coord = ivec3( cube_coord );\n"
2892 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
2893 "\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"
2896 " }\n"
2897 "\n"
2898 " // FIXME: this coord should absolutely must be clamped!\n"
2899 " \n"
2900 " ivec3 coord = ivec3( cube_coord );\n"
2901 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
2902 "\n"
2903 " total_light += \n"
2904 " scene_calculate_packed_light_patch( index_sample.x,\n"
2905 " halfview, co, normal ) \n"
2906 " * light_mask;\n"
2907 " total_light += \n"
2908 " scene_calculate_packed_light_patch( index_sample.y,\n"
2909 " halfview, co, normal )\n"
2910 " * light_mask;\n"
2911 "\n"
2912 " // Take a section of the sky function to give us a matching fog colour\n"
2913 "\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"
2918 " \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"
2921 "\n"
2922 " fog_colour += sun_colour;\n"
2923 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
2924 "}\n"
2925 "\n"
2926 "#line 9 0 \n"
2927 "\n"
2928 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
2929 "{\n"
2930 " vec3 pa = p - a;\n"
2931 " vec3 ba = b - a;\n"
2932 "\n"
2933 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
2934 " return length( pa - ba*h );\n"
2935 "}\n"
2936 "\n"
2937 "float compute_board_shadow()\n"
2938 "{\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"
2944 "\n"
2945 " return 1.0 - player_shadow*0.8;\n"
2946 "}\n"
2947 "\n"
2948 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
2949 "{\n"
2950 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
2951 "}\n"
2952 "\n"
2953 "#line 7 0 \n"
2954 "#line 1 3 \n"
2955 "const float k_motion_lerp_amount = 0.01;\n"
2956 "\n"
2957 "#line 2 0 \n"
2958 "\n"
2959 "layout (location = 1) out vec2 oMotionVec;\n"
2960 "\n"
2961 "in vec3 aMotionVec0;\n"
2962 "in vec3 aMotionVec1;\n"
2963 "\n"
2964 "void compute_motion_vectors()\n"
2965 "{\n"
2966 " // Write motion vectors\n"
2967 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
2968 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
2969 "\n"
2970 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
2971 "}\n"
2972 "\n"
2973 "#line 8 0 \n"
2974 "\n"
2975 "void main()\n"
2976 "{\n"
2977 " compute_motion_vectors();\n"
2978 "\n"
2979 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
2980 "\n"
2981 " // ws modulation\n"
2982 " vec4 wgarbage = vec4(0.5,0.5,0.5,1.0);\n"
2983 " \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"
2988 "\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"
2992 " \n"
2993 " // Patch local noise\n"
2994 " vec4 rgarbage = texture( uTexGarbage, uvdiffuse );\n"
2995 "\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"
2999 "\n"
3000 " vfrag = texture( uTexGradients, uvgradients ).rgb;\n"
3001 " vfrag -= rgarbage.a*0.04;\n"
3002 "\n"
3003 " if( g_light_preview == 1 )\n"
3004 " {\n"
3005 " vfrag = vec3(0.5);\n"
3006 " }\n"
3007 "\n"
3008 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
3009 " oColour = vec4(vfrag, 1.0);\n"
3010 "}\n"
3011 ""},
3012 };
3013
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",
3026 .vs =
3027 {
3028 .orig_file = "shaders/scene.vs",
3029 .static_src =
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"
3033 "\n"
3034 "#line 1 1 \n"
3035 "const float k_motion_lerp_amount = 0.01;\n"
3036 "\n"
3037 "#line 2 0 \n"
3038 "\n"
3039 "out vec3 aMotionVec0;\n"
3040 "out vec3 aMotionVec1;\n"
3041 "\n"
3042 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
3043 "{\n"
3044 " // This magically solves some artifacting errors!\n"
3045 " //\n"
3046 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
3047 "\n"
3048 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
3049 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
3050 "}\n"
3051 "\n"
3052 "#line 6 0 \n"
3053 "\n"
3054 "uniform mat4x3 uMdl;\n"
3055 "uniform mat4 uPv;\n"
3056 "uniform mat4 uPvmPrev;\n"
3057 "\n"
3058 "out vec2 aUv;\n"
3059 "out vec4 aNorm;\n"
3060 "out vec3 aCo;\n"
3061 "out vec3 aWorldCo;\n"
3062 "\n"
3063 "void main()\n"
3064 "{\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"
3068 "\n"
3069 " vs_motion_out( vproj0, vproj1 );\n"
3070 "\n"
3071 " gl_Position = vproj0;\n"
3072 "\n"
3073 " aUv = a_uv;\n"
3074 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
3075 " aCo = a_co;\n"
3076 " aWorldCo = world_pos0;\n"
3077 "}\n"
3078 ""},
3079 .fs =
3080 {
3081 .orig_file = "shaders/scene_terrain.fs",
3082 .static_src =
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"
3088 "\n"
3089 "#line 1 1 \n"
3090 "// :D\n"
3091 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
3092 "\n"
3093 "#line 8 0 \n"
3094 "#line 1 2 \n"
3095 "// :D\n"
3096 "\n"
3097 "in vec2 aUv;\n"
3098 "in vec4 aNorm;\n"
3099 "in vec3 aCo;\n"
3100 "in vec3 aWorldCo;\n"
3101 "\n"
3102 "#line 1 1 \n"
3103 "layout (location = 0) out vec4 oColour;\n"
3104 "\n"
3105 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
3106 "layout (std140) uniform ub_world_lighting\n"
3107 "{\n"
3108 " vec4 g_cube_min;\n"
3109 " vec4 g_cube_inv_range;\n"
3110 "\n"
3111 " vec4 g_water_plane;\n"
3112 " vec4 g_depth_bounds;\n"
3113 "\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"
3123 "\n"
3124 " float g_water_fog;\n"
3125 " float g_time;\n"
3126 " float g_realtime;\n"
3127 " float g_shadow_length;\n"
3128 " float g_shadow_spread;\n"
3129 "\n"
3130 " float g_time_of_day;\n"
3131 " float g_day_phase;\n"
3132 " float g_sunset_phase;\n"
3133 "\n"
3134 " int g_light_preview;\n"
3135 " int g_shadow_samples;\n"
3136 "\n"
3137 " int g_debug_indices;\n"
3138 " int g_debug_complexity;\n"
3139 "};\n"
3140 "\n"
3141 "uniform sampler2D g_world_depth;\n"
3142 "uniform samplerBuffer uLightsArray;\n"
3143 "uniform usampler3D uLightsIndex;\n"
3144 "\n"
3145 "#line 1 1 \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"
3152 "\n"
3153 "const float SUN_ANGLE = 0.0001;\n"
3154 "const float PI = 3.14159265358979323846264;\n"
3155 "\n"
3156 "//struct world_info\n"
3157 "//{\n"
3158 "// float time,\n"
3159 "// time_of_day,\n"
3160 "// day_phase,\n"
3161 "// sunset_phase;\n"
3162 "// \n"
3163 "// vec3 sun_dir;\n"
3164 "//};\n"
3165 "\n"
3166 "vec3 rand33(vec3 p3)\n"
3167 "{\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"
3171 "}\n"
3172 "\n"
3173 "float stars( vec3 rd, float rr, float size ){\n"
3174 " vec3 co = rd * rr;\n"
3175 "\n"
3176 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
3177 "\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"
3181 "\n"
3182 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
3183 " \n"
3184 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
3185 " plane = plane - mod(plane, PI / count);\n"
3186 "\n"
3187 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
3188 "\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"
3194 " return star;\n"
3195 "}\n"
3196 "\n"
3197 "float luminance( vec3 v )\n"
3198 "{\n"
3199 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
3200 "}\n"
3201 "\n"
3202 "vec3 clearskies_ambient( vec3 dir )\n"
3203 "{\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"
3206 " \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"
3211 " \n"
3212 " /* Add gradient */\n"
3213 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
3214 " \n"
3215 " return ambient;\n"
3216 "}\n"
3217 "\n"
3218 "vec3 clearskies_sky( vec3 ray_dir )\n"
3219 "{\n"
3220 " ray_dir.y = abs( ray_dir.y );\n"
3221 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
3222 " \n"
3223 " /* Sun */\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"
3228 " \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"
3231 "\n"
3232 " \n"
3233 " float star = 0.0;\n"
3234 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
3235 "\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"
3240 " }\n"
3241 " }\n"
3242 " \n"
3243 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
3244 " return composite;\n"
3245 "}\n"
3246 "\n"
3247 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
3248 "{\n"
3249 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
3250 "\n"
3251 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
3252 " g_sunset_phase );\n"
3253 "\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"
3258 "\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"
3262 "\n"
3263 " return ambient + (light_sun + sky_reflection) * shadow;\n"
3264 "}\n"
3265 "\n"
3266 "#line 44 0 \n"
3267 "\n"
3268 "float world_depth_sample( vec3 pos )\n"
3269 "{\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"
3272 "}\n"
3273 "\n"
3274 "float world_water_depth( vec3 pos )\n"
3275 "{\n"
3276 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
3277 " return world_depth_sample( pos ) - ref_depth;\n"
3278 "}\n"
3279 "\n"
3280 "float shadow_sample( vec3 co ){\n"
3281 " float height_sample = world_depth_sample( co );\n"
3282 "\n"
3283 " float fdelta = height_sample - co.y;\n"
3284 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
3285 "}\n"
3286 "\n"
3287 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
3288 " if( g_shadow_samples == 0 ){\n"
3289 " return 1.0;\n"
3290 " }\n"
3291 "\n"
3292 " float fspread = g_shadow_spread;\n"
3293 " float flength = g_shadow_length;\n"
3294 "\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"
3300 "\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"
3305 "\n"
3306 " return 1.0 - famt;\n"
3307 "}\n"
3308 "\n"
3309 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
3310 "{\n"
3311 " vec3 specdir = reflect( -dir, wnormal );\n"
3312 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
3313 "}\n"
3314 "\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"
3318 "}\n"
3319 "\n"
3320 "vec3 scene_calculate_light( int light_index, \n"
3321 " vec3 halfview, vec3 co, vec3 normal )\n"
3322 "{\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"
3326 "\n"
3327 " vec3 light_delta = light_co.xyz-co;\n"
3328 " float dist2 = dot(light_delta,light_delta);\n"
3329 "\n"
3330 " light_delta = normalize( light_delta );\n"
3331 "\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"
3335 "\n"
3336 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
3337 "\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"
3341 " }\n"
3342 "\n"
3343 " return light_colour.rgb * attenuation * falloff \n"
3344 " * step( g_day_phase, light_colour.w );\n"
3345 "}\n"
3346 "\n"
3347 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
3348 " vec3 halfview, vec3 co, vec3 normal )\n"
3349 "{\n"
3350 " uint light_count = packed_index & 0x3u;\n"
3351 "\n"
3352 " vec3 l = vec3(0.0);\n"
3353 "\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"
3358 "\n"
3359 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
3360 "\n"
3361 " if( light_count >= 2u ){\n"
3362 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
3363 "\n"
3364 " if( light_count >= 3u ){\n"
3365 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
3366 " }\n"
3367 " }\n"
3368 " }\n"
3369 "\n"
3370 " return l;\n"
3371 "}\n"
3372 "\n"
3373 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
3374 " float light_mask )\n"
3375 "{\n"
3376 " if( g_light_preview == 1 )\n"
3377 " diffuse = vec3(0.75);\n"
3378 "\n"
3379 " // Lighting\n"
3380 " vec3 halfview = uCamera - co;\n"
3381 " float fdist = length(halfview);\n"
3382 " halfview /= fdist;\n"
3383 "\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"
3386 "\n"
3387 " vec3 total_light = clearskies_lighting( \n"
3388 " normal, min( light_mask, world_shadow ), halfview );\n"
3389 "\n"
3390 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
3391 " cube_coord = floor( cube_coord );\n"
3392 "\n"
3393 " if( g_debug_indices == 1 )\n"
3394 " {\n"
3395 " return rand33(cube_coord);\n"
3396 " }\n"
3397 "\n"
3398 " if( g_debug_complexity == 1 )\n"
3399 " {\n"
3400 " ivec3 coord = ivec3( cube_coord );\n"
3401 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
3402 "\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"
3405 " }\n"
3406 "\n"
3407 " // FIXME: this coord should absolutely must be clamped!\n"
3408 " \n"
3409 " ivec3 coord = ivec3( cube_coord );\n"
3410 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
3411 "\n"
3412 " total_light += \n"
3413 " scene_calculate_packed_light_patch( index_sample.x,\n"
3414 " halfview, co, normal ) \n"
3415 " * light_mask;\n"
3416 " total_light += \n"
3417 " scene_calculate_packed_light_patch( index_sample.y,\n"
3418 " halfview, co, normal )\n"
3419 " * light_mask;\n"
3420 "\n"
3421 " // Take a section of the sky function to give us a matching fog colour\n"
3422 "\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"
3427 " \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"
3430 "\n"
3431 " fog_colour += sun_colour;\n"
3432 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
3433 "}\n"
3434 "\n"
3435 "#line 9 0 \n"
3436 "\n"
3437 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
3438 "{\n"
3439 " vec3 pa = p - a;\n"
3440 " vec3 ba = b - a;\n"
3441 "\n"
3442 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
3443 " return length( pa - ba*h );\n"
3444 "}\n"
3445 "\n"
3446 "float compute_board_shadow()\n"
3447 "{\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"
3453 "\n"
3454 " return 1.0 - player_shadow*0.8;\n"
3455 "}\n"
3456 "\n"
3457 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
3458 "{\n"
3459 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
3460 "}\n"
3461 "\n"
3462 "#line 9 0 \n"
3463 "#line 1 3 \n"
3464 "const float k_motion_lerp_amount = 0.01;\n"
3465 "\n"
3466 "#line 2 0 \n"
3467 "\n"
3468 "layout (location = 1) out vec2 oMotionVec;\n"
3469 "\n"
3470 "in vec3 aMotionVec0;\n"
3471 "in vec3 aMotionVec1;\n"
3472 "\n"
3473 "void compute_motion_vectors()\n"
3474 "{\n"
3475 " // Write motion vectors\n"
3476 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
3477 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
3478 "\n"
3479 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
3480 "}\n"
3481 "\n"
3482 "#line 10 0 \n"
3483 "\n"
3484 "void main()\n"
3485 "{\n"
3486 " compute_motion_vectors();\n"
3487 "\n"
3488 " // Colour\n"
3489 " // ------\n"
3490 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
3491 "\n"
3492 " // ws modulation\n"
3493 " vec4 wgarbage = texture( uTexGarbage, aCo.xz * 0.015 );\n"
3494 " \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"
3499 "\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"
3503 " \n"
3504 " // Patch local noise\n"
3505 " vec4 rgarbage = texture( uTexGarbage, uvdiffuse );\n"
3506 "\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"
3513 "\n"
3514 " qnorm = mix( qnorm, aNorm.xyz, amtsand );\n"
3515 " \n"
3516 " if( g_light_preview == 1 )\n"
3517 " {\n"
3518 " vfrag = vec3(0.5);\n"
3519 " }\n"
3520 "\n"
3521 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
3522 " oColour = vec4(vfrag, 1.0);\n"
3523 "}\n"
3524 ""},
3525 };
3526
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",
3541 .vs =
3542 {
3543 .orig_file = "shaders/scene_override.vs",
3544 .static_src =
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"
3548 "\n"
3549 "#line 1 1 \n"
3550 "const float k_motion_lerp_amount = 0.01;\n"
3551 "\n"
3552 "#line 2 0 \n"
3553 "\n"
3554 "out vec3 aMotionVec0;\n"
3555 "out vec3 aMotionVec1;\n"
3556 "\n"
3557 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
3558 "{\n"
3559 " // This magically solves some artifacting errors!\n"
3560 " //\n"
3561 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
3562 "\n"
3563 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
3564 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
3565 "}\n"
3566 "\n"
3567 "#line 6 0 \n"
3568 "\n"
3569 "uniform mat4x3 uMdl;\n"
3570 "uniform mat4 uPv;\n"
3571 "uniform mat4 uPvmPrev;\n"
3572 "uniform mat3 uNormalMtx;\n"
3573 "\n"
3574 "out vec2 aUv;\n"
3575 "out vec4 aNorm;\n"
3576 "out vec3 aCo;\n"
3577 "out vec3 aWorldCo;\n"
3578 "\n"
3579 "void main()\n"
3580 "{\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"
3584 "\n"
3585 " vs_motion_out( vproj0, vproj1 );\n"
3586 "\n"
3587 " gl_Position = vproj0;\n"
3588 "\n"
3589 " aUv = a_uv;\n"
3590 " aNorm = vec4( uNormalMtx * a_norm.xyz, a_norm.w );\n"
3591 " aCo = a_co;\n"
3592 " aWorldCo = world_pos0;\n"
3593 "}\n"
3594 ""},
3595 .fs =
3596 {
3597 .orig_file = "shaders/scene_route.fs",
3598 .static_src =
3599 "uniform sampler2D uTexGarbage;\n"
3600 "uniform sampler2D uTexGradients;\n"
3601 "uniform vec3 uCamera;\n"
3602 "uniform vec4 uColour;\n"
3603 "\n"
3604 "#line 1 1 \n"
3605 "// :D\n"
3606 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
3607 "\n"
3608 "#line 7 0 \n"
3609 "#line 1 2 \n"
3610 "// :D\n"
3611 "\n"
3612 "in vec2 aUv;\n"
3613 "in vec4 aNorm;\n"
3614 "in vec3 aCo;\n"
3615 "in vec3 aWorldCo;\n"
3616 "\n"
3617 "#line 1 1 \n"
3618 "layout (location = 0) out vec4 oColour;\n"
3619 "\n"
3620 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
3621 "layout (std140) uniform ub_world_lighting\n"
3622 "{\n"
3623 " vec4 g_cube_min;\n"
3624 " vec4 g_cube_inv_range;\n"
3625 "\n"
3626 " vec4 g_water_plane;\n"
3627 " vec4 g_depth_bounds;\n"
3628 "\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"
3638 "\n"
3639 " float g_water_fog;\n"
3640 " float g_time;\n"
3641 " float g_realtime;\n"
3642 " float g_shadow_length;\n"
3643 " float g_shadow_spread;\n"
3644 "\n"
3645 " float g_time_of_day;\n"
3646 " float g_day_phase;\n"
3647 " float g_sunset_phase;\n"
3648 "\n"
3649 " int g_light_preview;\n"
3650 " int g_shadow_samples;\n"
3651 "\n"
3652 " int g_debug_indices;\n"
3653 " int g_debug_complexity;\n"
3654 "};\n"
3655 "\n"
3656 "uniform sampler2D g_world_depth;\n"
3657 "uniform samplerBuffer uLightsArray;\n"
3658 "uniform usampler3D uLightsIndex;\n"
3659 "\n"
3660 "#line 1 1 \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"
3667 "\n"
3668 "const float SUN_ANGLE = 0.0001;\n"
3669 "const float PI = 3.14159265358979323846264;\n"
3670 "\n"
3671 "//struct world_info\n"
3672 "//{\n"
3673 "// float time,\n"
3674 "// time_of_day,\n"
3675 "// day_phase,\n"
3676 "// sunset_phase;\n"
3677 "// \n"
3678 "// vec3 sun_dir;\n"
3679 "//};\n"
3680 "\n"
3681 "vec3 rand33(vec3 p3)\n"
3682 "{\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"
3686 "}\n"
3687 "\n"
3688 "float stars( vec3 rd, float rr, float size ){\n"
3689 " vec3 co = rd * rr;\n"
3690 "\n"
3691 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
3692 "\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"
3696 "\n"
3697 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
3698 " \n"
3699 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
3700 " plane = plane - mod(plane, PI / count);\n"
3701 "\n"
3702 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
3703 "\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"
3709 " return star;\n"
3710 "}\n"
3711 "\n"
3712 "float luminance( vec3 v )\n"
3713 "{\n"
3714 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
3715 "}\n"
3716 "\n"
3717 "vec3 clearskies_ambient( vec3 dir )\n"
3718 "{\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"
3721 " \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"
3726 " \n"
3727 " /* Add gradient */\n"
3728 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
3729 " \n"
3730 " return ambient;\n"
3731 "}\n"
3732 "\n"
3733 "vec3 clearskies_sky( vec3 ray_dir )\n"
3734 "{\n"
3735 " ray_dir.y = abs( ray_dir.y );\n"
3736 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
3737 " \n"
3738 " /* Sun */\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"
3743 " \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"
3746 "\n"
3747 " \n"
3748 " float star = 0.0;\n"
3749 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
3750 "\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"
3755 " }\n"
3756 " }\n"
3757 " \n"
3758 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
3759 " return composite;\n"
3760 "}\n"
3761 "\n"
3762 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
3763 "{\n"
3764 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
3765 "\n"
3766 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
3767 " g_sunset_phase );\n"
3768 "\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"
3773 "\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"
3777 "\n"
3778 " return ambient + (light_sun + sky_reflection) * shadow;\n"
3779 "}\n"
3780 "\n"
3781 "#line 44 0 \n"
3782 "\n"
3783 "float world_depth_sample( vec3 pos )\n"
3784 "{\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"
3787 "}\n"
3788 "\n"
3789 "float world_water_depth( vec3 pos )\n"
3790 "{\n"
3791 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
3792 " return world_depth_sample( pos ) - ref_depth;\n"
3793 "}\n"
3794 "\n"
3795 "float shadow_sample( vec3 co ){\n"
3796 " float height_sample = world_depth_sample( co );\n"
3797 "\n"
3798 " float fdelta = height_sample - co.y;\n"
3799 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
3800 "}\n"
3801 "\n"
3802 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
3803 " if( g_shadow_samples == 0 ){\n"
3804 " return 1.0;\n"
3805 " }\n"
3806 "\n"
3807 " float fspread = g_shadow_spread;\n"
3808 " float flength = g_shadow_length;\n"
3809 "\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"
3815 "\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"
3820 "\n"
3821 " return 1.0 - famt;\n"
3822 "}\n"
3823 "\n"
3824 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
3825 "{\n"
3826 " vec3 specdir = reflect( -dir, wnormal );\n"
3827 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
3828 "}\n"
3829 "\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"
3833 "}\n"
3834 "\n"
3835 "vec3 scene_calculate_light( int light_index, \n"
3836 " vec3 halfview, vec3 co, vec3 normal )\n"
3837 "{\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"
3841 "\n"
3842 " vec3 light_delta = light_co.xyz-co;\n"
3843 " float dist2 = dot(light_delta,light_delta);\n"
3844 "\n"
3845 " light_delta = normalize( light_delta );\n"
3846 "\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"
3850 "\n"
3851 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
3852 "\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"
3856 " }\n"
3857 "\n"
3858 " return light_colour.rgb * attenuation * falloff \n"
3859 " * step( g_day_phase, light_colour.w );\n"
3860 "}\n"
3861 "\n"
3862 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
3863 " vec3 halfview, vec3 co, vec3 normal )\n"
3864 "{\n"
3865 " uint light_count = packed_index & 0x3u;\n"
3866 "\n"
3867 " vec3 l = vec3(0.0);\n"
3868 "\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"
3873 "\n"
3874 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
3875 "\n"
3876 " if( light_count >= 2u ){\n"
3877 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
3878 "\n"
3879 " if( light_count >= 3u ){\n"
3880 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
3881 " }\n"
3882 " }\n"
3883 " }\n"
3884 "\n"
3885 " return l;\n"
3886 "}\n"
3887 "\n"
3888 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
3889 " float light_mask )\n"
3890 "{\n"
3891 " if( g_light_preview == 1 )\n"
3892 " diffuse = vec3(0.75);\n"
3893 "\n"
3894 " // Lighting\n"
3895 " vec3 halfview = uCamera - co;\n"
3896 " float fdist = length(halfview);\n"
3897 " halfview /= fdist;\n"
3898 "\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"
3901 "\n"
3902 " vec3 total_light = clearskies_lighting( \n"
3903 " normal, min( light_mask, world_shadow ), halfview );\n"
3904 "\n"
3905 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
3906 " cube_coord = floor( cube_coord );\n"
3907 "\n"
3908 " if( g_debug_indices == 1 )\n"
3909 " {\n"
3910 " return rand33(cube_coord);\n"
3911 " }\n"
3912 "\n"
3913 " if( g_debug_complexity == 1 )\n"
3914 " {\n"
3915 " ivec3 coord = ivec3( cube_coord );\n"
3916 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
3917 "\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"
3920 " }\n"
3921 "\n"
3922 " // FIXME: this coord should absolutely must be clamped!\n"
3923 " \n"
3924 " ivec3 coord = ivec3( cube_coord );\n"
3925 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
3926 "\n"
3927 " total_light += \n"
3928 " scene_calculate_packed_light_patch( index_sample.x,\n"
3929 " halfview, co, normal ) \n"
3930 " * light_mask;\n"
3931 " total_light += \n"
3932 " scene_calculate_packed_light_patch( index_sample.y,\n"
3933 " halfview, co, normal )\n"
3934 " * light_mask;\n"
3935 "\n"
3936 " // Take a section of the sky function to give us a matching fog colour\n"
3937 "\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"
3942 " \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"
3945 "\n"
3946 " fog_colour += sun_colour;\n"
3947 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
3948 "}\n"
3949 "\n"
3950 "#line 9 0 \n"
3951 "\n"
3952 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
3953 "{\n"
3954 " vec3 pa = p - a;\n"
3955 " vec3 ba = b - a;\n"
3956 "\n"
3957 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
3958 " return length( pa - ba*h );\n"
3959 "}\n"
3960 "\n"
3961 "float compute_board_shadow()\n"
3962 "{\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"
3968 "\n"
3969 " return 1.0 - player_shadow*0.8;\n"
3970 "}\n"
3971 "\n"
3972 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
3973 "{\n"
3974 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
3975 "}\n"
3976 "\n"
3977 "#line 8 0 \n"
3978 "#line 1 3 \n"
3979 "const float k_motion_lerp_amount = 0.01;\n"
3980 "\n"
3981 "#line 2 0 \n"
3982 "\n"
3983 "layout (location = 1) out vec2 oMotionVec;\n"
3984 "\n"
3985 "in vec3 aMotionVec0;\n"
3986 "in vec3 aMotionVec1;\n"
3987 "\n"
3988 "void compute_motion_vectors()\n"
3989 "{\n"
3990 " // Write motion vectors\n"
3991 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
3992 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
3993 "\n"
3994 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
3995 "}\n"
3996 "\n"
3997 "#line 9 0 \n"
3998 "\n"
3999 "float filtered_stripe( in float p, in float ddx, in float ddy )\n"
4000 "{\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"
4004 "}\n"
4005 "\n"
4006 "void main()\n"
4007 "{\n"
4008 " compute_motion_vectors();\n"
4009 "\n"
4010 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
4011 "\n"
4012 " // ws modulation\n"
4013 " vec4 wgarbage = texture( uTexGarbage, aCo.xz * 0.015 );\n"
4014 "\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"
4019 "\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"
4023 " \n"
4024 " // Patch local noise\n"
4025 " vec4 rgarbage = texture( uTexGarbage, uvdiffuse );\n"
4026 "\n"
4027 " vfrag = pow(uColour.rgb,vec3(1.0/2.2));\n"
4028 " vfrag -= rgarbage.a*0.1;\n"
4029 "\n"
4030 " if( wgarbage.g < 0.1 )\n"
4031 " discard;\n"
4032 "\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"
4036 "\n"
4037 " if( g_light_preview == 1 )\n"
4038 " {\n"
4039 " vfrag = vec3(0.5);\n"
4040 " }\n"
4041 "\n"
4042 " // Lighting\n"
4043 " oColour = vec4( scene_compute_lighting( vfrag, qnorm, aWorldCo ), 1.0 );\n"
4044 "}\n"
4045 ""},
4046 };
4047
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",
4062 .vs =
4063 {
4064 .orig_file = "shaders/scene.vs",
4065 .static_src =
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"
4069 "\n"
4070 "#line 1 1 \n"
4071 "const float k_motion_lerp_amount = 0.01;\n"
4072 "\n"
4073 "#line 2 0 \n"
4074 "\n"
4075 "out vec3 aMotionVec0;\n"
4076 "out vec3 aMotionVec1;\n"
4077 "\n"
4078 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
4079 "{\n"
4080 " // This magically solves some artifacting errors!\n"
4081 " //\n"
4082 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
4083 "\n"
4084 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
4085 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
4086 "}\n"
4087 "\n"
4088 "#line 6 0 \n"
4089 "\n"
4090 "uniform mat4x3 uMdl;\n"
4091 "uniform mat4 uPv;\n"
4092 "uniform mat4 uPvmPrev;\n"
4093 "\n"
4094 "out vec2 aUv;\n"
4095 "out vec4 aNorm;\n"
4096 "out vec3 aCo;\n"
4097 "out vec3 aWorldCo;\n"
4098 "\n"
4099 "void main()\n"
4100 "{\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"
4104 "\n"
4105 " vs_motion_out( vproj0, vproj1 );\n"
4106 "\n"
4107 " gl_Position = vproj0;\n"
4108 "\n"
4109 " aUv = a_uv;\n"
4110 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
4111 " aCo = a_co;\n"
4112 " aWorldCo = world_pos0;\n"
4113 "}\n"
4114 ""},
4115 .fs =
4116 {
4117 .orig_file = "shaders/scene_depth.fs",
4118 .static_src =
4119 "out vec4 FragColor;\n"
4120 "\n"
4121 "uniform vec3 uCamera;\n"
4122 "uniform vec3 uBoard0;\n"
4123 "uniform vec3 uBoard1;\n"
4124 "\n"
4125 "#line 1 1 \n"
4126 "// :D\n"
4127 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
4128 "\n"
4129 "#line 8 0 \n"
4130 "#line 1 2 \n"
4131 "// :D\n"
4132 "\n"
4133 "in vec2 aUv;\n"
4134 "in vec4 aNorm;\n"
4135 "in vec3 aCo;\n"
4136 "in vec3 aWorldCo;\n"
4137 "\n"
4138 "#line 1 1 \n"
4139 "layout (location = 0) out vec4 oColour;\n"
4140 "\n"
4141 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
4142 "layout (std140) uniform ub_world_lighting\n"
4143 "{\n"
4144 " vec4 g_cube_min;\n"
4145 " vec4 g_cube_inv_range;\n"
4146 "\n"
4147 " vec4 g_water_plane;\n"
4148 " vec4 g_depth_bounds;\n"
4149 "\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"
4159 "\n"
4160 " float g_water_fog;\n"
4161 " float g_time;\n"
4162 " float g_realtime;\n"
4163 " float g_shadow_length;\n"
4164 " float g_shadow_spread;\n"
4165 "\n"
4166 " float g_time_of_day;\n"
4167 " float g_day_phase;\n"
4168 " float g_sunset_phase;\n"
4169 "\n"
4170 " int g_light_preview;\n"
4171 " int g_shadow_samples;\n"
4172 "\n"
4173 " int g_debug_indices;\n"
4174 " int g_debug_complexity;\n"
4175 "};\n"
4176 "\n"
4177 "uniform sampler2D g_world_depth;\n"
4178 "uniform samplerBuffer uLightsArray;\n"
4179 "uniform usampler3D uLightsIndex;\n"
4180 "\n"
4181 "#line 1 1 \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"
4188 "\n"
4189 "const float SUN_ANGLE = 0.0001;\n"
4190 "const float PI = 3.14159265358979323846264;\n"
4191 "\n"
4192 "//struct world_info\n"
4193 "//{\n"
4194 "// float time,\n"
4195 "// time_of_day,\n"
4196 "// day_phase,\n"
4197 "// sunset_phase;\n"
4198 "// \n"
4199 "// vec3 sun_dir;\n"
4200 "//};\n"
4201 "\n"
4202 "vec3 rand33(vec3 p3)\n"
4203 "{\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"
4207 "}\n"
4208 "\n"
4209 "float stars( vec3 rd, float rr, float size ){\n"
4210 " vec3 co = rd * rr;\n"
4211 "\n"
4212 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
4213 "\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"
4217 "\n"
4218 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
4219 " \n"
4220 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
4221 " plane = plane - mod(plane, PI / count);\n"
4222 "\n"
4223 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
4224 "\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"
4230 " return star;\n"
4231 "}\n"
4232 "\n"
4233 "float luminance( vec3 v )\n"
4234 "{\n"
4235 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
4236 "}\n"
4237 "\n"
4238 "vec3 clearskies_ambient( vec3 dir )\n"
4239 "{\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"
4242 " \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"
4247 " \n"
4248 " /* Add gradient */\n"
4249 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
4250 " \n"
4251 " return ambient;\n"
4252 "}\n"
4253 "\n"
4254 "vec3 clearskies_sky( vec3 ray_dir )\n"
4255 "{\n"
4256 " ray_dir.y = abs( ray_dir.y );\n"
4257 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
4258 " \n"
4259 " /* Sun */\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"
4264 " \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"
4267 "\n"
4268 " \n"
4269 " float star = 0.0;\n"
4270 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
4271 "\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"
4276 " }\n"
4277 " }\n"
4278 " \n"
4279 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
4280 " return composite;\n"
4281 "}\n"
4282 "\n"
4283 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
4284 "{\n"
4285 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
4286 "\n"
4287 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
4288 " g_sunset_phase );\n"
4289 "\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"
4294 "\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"
4298 "\n"
4299 " return ambient + (light_sun + sky_reflection) * shadow;\n"
4300 "}\n"
4301 "\n"
4302 "#line 44 0 \n"
4303 "\n"
4304 "float world_depth_sample( vec3 pos )\n"
4305 "{\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"
4308 "}\n"
4309 "\n"
4310 "float world_water_depth( vec3 pos )\n"
4311 "{\n"
4312 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
4313 " return world_depth_sample( pos ) - ref_depth;\n"
4314 "}\n"
4315 "\n"
4316 "float shadow_sample( vec3 co ){\n"
4317 " float height_sample = world_depth_sample( co );\n"
4318 "\n"
4319 " float fdelta = height_sample - co.y;\n"
4320 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
4321 "}\n"
4322 "\n"
4323 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
4324 " if( g_shadow_samples == 0 ){\n"
4325 " return 1.0;\n"
4326 " }\n"
4327 "\n"
4328 " float fspread = g_shadow_spread;\n"
4329 " float flength = g_shadow_length;\n"
4330 "\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"
4336 "\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"
4341 "\n"
4342 " return 1.0 - famt;\n"
4343 "}\n"
4344 "\n"
4345 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
4346 "{\n"
4347 " vec3 specdir = reflect( -dir, wnormal );\n"
4348 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
4349 "}\n"
4350 "\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"
4354 "}\n"
4355 "\n"
4356 "vec3 scene_calculate_light( int light_index, \n"
4357 " vec3 halfview, vec3 co, vec3 normal )\n"
4358 "{\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"
4362 "\n"
4363 " vec3 light_delta = light_co.xyz-co;\n"
4364 " float dist2 = dot(light_delta,light_delta);\n"
4365 "\n"
4366 " light_delta = normalize( light_delta );\n"
4367 "\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"
4371 "\n"
4372 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
4373 "\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"
4377 " }\n"
4378 "\n"
4379 " return light_colour.rgb * attenuation * falloff \n"
4380 " * step( g_day_phase, light_colour.w );\n"
4381 "}\n"
4382 "\n"
4383 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
4384 " vec3 halfview, vec3 co, vec3 normal )\n"
4385 "{\n"
4386 " uint light_count = packed_index & 0x3u;\n"
4387 "\n"
4388 " vec3 l = vec3(0.0);\n"
4389 "\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"
4394 "\n"
4395 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
4396 "\n"
4397 " if( light_count >= 2u ){\n"
4398 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
4399 "\n"
4400 " if( light_count >= 3u ){\n"
4401 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
4402 " }\n"
4403 " }\n"
4404 " }\n"
4405 "\n"
4406 " return l;\n"
4407 "}\n"
4408 "\n"
4409 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
4410 " float light_mask )\n"
4411 "{\n"
4412 " if( g_light_preview == 1 )\n"
4413 " diffuse = vec3(0.75);\n"
4414 "\n"
4415 " // Lighting\n"
4416 " vec3 halfview = uCamera - co;\n"
4417 " float fdist = length(halfview);\n"
4418 " halfview /= fdist;\n"
4419 "\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"
4422 "\n"
4423 " vec3 total_light = clearskies_lighting( \n"
4424 " normal, min( light_mask, world_shadow ), halfview );\n"
4425 "\n"
4426 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
4427 " cube_coord = floor( cube_coord );\n"
4428 "\n"
4429 " if( g_debug_indices == 1 )\n"
4430 " {\n"
4431 " return rand33(cube_coord);\n"
4432 " }\n"
4433 "\n"
4434 " if( g_debug_complexity == 1 )\n"
4435 " {\n"
4436 " ivec3 coord = ivec3( cube_coord );\n"
4437 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
4438 "\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"
4441 " }\n"
4442 "\n"
4443 " // FIXME: this coord should absolutely must be clamped!\n"
4444 " \n"
4445 " ivec3 coord = ivec3( cube_coord );\n"
4446 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
4447 "\n"
4448 " total_light += \n"
4449 " scene_calculate_packed_light_patch( index_sample.x,\n"
4450 " halfview, co, normal ) \n"
4451 " * light_mask;\n"
4452 " total_light += \n"
4453 " scene_calculate_packed_light_patch( index_sample.y,\n"
4454 " halfview, co, normal )\n"
4455 " * light_mask;\n"
4456 "\n"
4457 " // Take a section of the sky function to give us a matching fog colour\n"
4458 "\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"
4463 " \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"
4466 "\n"
4467 " fog_colour += sun_colour;\n"
4468 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
4469 "}\n"
4470 "\n"
4471 "#line 9 0 \n"
4472 "\n"
4473 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
4474 "{\n"
4475 " vec3 pa = p - a;\n"
4476 " vec3 ba = b - a;\n"
4477 "\n"
4478 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
4479 " return length( pa - ba*h );\n"
4480 "}\n"
4481 "\n"
4482 "float compute_board_shadow()\n"
4483 "{\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"
4489 "\n"
4490 " return 1.0 - player_shadow*0.8;\n"
4491 "}\n"
4492 "\n"
4493 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
4494 "{\n"
4495 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
4496 "}\n"
4497 "\n"
4498 "#line 9 0 \n"
4499 "\n"
4500 "// Water blending\n"
4501 "// ==============\n"
4502 "\n"
4503 "float water_depth( vec3 pos, vec3 halfview )\n"
4504 "{\n"
4505 " vec3 pnorm = g_water_plane.xyz;\n"
4506 " float pdist = g_water_plane.w;\n"
4507 "\n"
4508 " float d = dot( pnorm, halfview );\n"
4509 " float t = dot((pnorm*pdist - pos), pnorm) / d;\n"
4510 " return t * g_water_fog;\n"
4511 "}\n"
4512 "\n"
4513 "void main()\n"
4514 "{\n"
4515 " vec3 halfview = normalize( uCamera - aWorldCo );\n"
4516 " float depth = water_depth( aWorldCo, halfview );\n"
4517 " FragColor = vec4( depth, 0.0, 0.0, 0.0 );\n"
4518 "}\n"
4519 ""},
4520 };
4521
4522 GLuint _uniform_scene_depth_uMdl;
4523 GLuint _uniform_scene_depth_uPv;
4524 GLuint _uniform_scene_depth_uPvmPrev;
4525 GLuint _uniform_scene_depth_uCamera;
4526 GLuint _uniform_scene_depth_uBoard0;
4527 GLuint _uniform_scene_depth_uBoard1;
4528 GLuint _uniform_scene_depth_g_world_depth;
4529 GLuint _uniform_scene_depth_uLightsArray;
4530 GLuint _uniform_scene_depth_uLightsIndex;
4531 #include "shaders/scene_position.h"
4532 struct vg_shader _shader_scene_position = {
4533 .name = "scene_position",
4534 .vs =
4535 {
4536 .orig_file = "shaders/scene.vs",
4537 .static_src =
4538 "layout (location=0) in vec3 a_co;\n"
4539 "layout (location=1) in vec4 a_norm;\n"
4540 "layout (location=2) in vec2 a_uv;\n"
4541 "\n"
4542 "#line 1 1 \n"
4543 "const float k_motion_lerp_amount = 0.01;\n"
4544 "\n"
4545 "#line 2 0 \n"
4546 "\n"
4547 "out vec3 aMotionVec0;\n"
4548 "out vec3 aMotionVec1;\n"
4549 "\n"
4550 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
4551 "{\n"
4552 " // This magically solves some artifacting errors!\n"
4553 " //\n"
4554 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
4555 "\n"
4556 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
4557 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
4558 "}\n"
4559 "\n"
4560 "#line 6 0 \n"
4561 "\n"
4562 "uniform mat4x3 uMdl;\n"
4563 "uniform mat4 uPv;\n"
4564 "uniform mat4 uPvmPrev;\n"
4565 "\n"
4566 "out vec2 aUv;\n"
4567 "out vec4 aNorm;\n"
4568 "out vec3 aCo;\n"
4569 "out vec3 aWorldCo;\n"
4570 "\n"
4571 "void main()\n"
4572 "{\n"
4573 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
4574 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
4575 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
4576 "\n"
4577 " vs_motion_out( vproj0, vproj1 );\n"
4578 "\n"
4579 " gl_Position = vproj0;\n"
4580 "\n"
4581 " aUv = a_uv;\n"
4582 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
4583 " aCo = a_co;\n"
4584 " aWorldCo = world_pos0;\n"
4585 "}\n"
4586 ""},
4587 .fs =
4588 {
4589 .orig_file = "shaders/scene_position.fs",
4590 .static_src =
4591 "out vec4 FragColor;\n"
4592 "\n"
4593 "uniform vec3 uCamera;\n"
4594 "uniform vec3 uBoard0;\n"
4595 "uniform vec3 uBoard1;\n"
4596 "\n"
4597 "#line 1 1 \n"
4598 "// :D\n"
4599 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
4600 "\n"
4601 "#line 8 0 \n"
4602 "#line 1 2 \n"
4603 "// :D\n"
4604 "\n"
4605 "in vec2 aUv;\n"
4606 "in vec4 aNorm;\n"
4607 "in vec3 aCo;\n"
4608 "in vec3 aWorldCo;\n"
4609 "\n"
4610 "#line 1 1 \n"
4611 "layout (location = 0) out vec4 oColour;\n"
4612 "\n"
4613 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
4614 "layout (std140) uniform ub_world_lighting\n"
4615 "{\n"
4616 " vec4 g_cube_min;\n"
4617 " vec4 g_cube_inv_range;\n"
4618 "\n"
4619 " vec4 g_water_plane;\n"
4620 " vec4 g_depth_bounds;\n"
4621 "\n"
4622 " vec4 g_daysky_colour;\n"
4623 " vec4 g_nightsky_colour;\n"
4624 " vec4 g_sunset_colour;\n"
4625 " vec4 g_ambient_colour;\n"
4626 " vec4 g_sunset_ambient;\n"
4627 " vec4 g_sun_colour;\n"
4628 " vec4 g_sun_dir;\n"
4629 " vec4 g_board_0;\n"
4630 " vec4 g_board_1;\n"
4631 "\n"
4632 " float g_water_fog;\n"
4633 " float g_time;\n"
4634 " float g_realtime;\n"
4635 " float g_shadow_length;\n"
4636 " float g_shadow_spread;\n"
4637 "\n"
4638 " float g_time_of_day;\n"
4639 " float g_day_phase;\n"
4640 " float g_sunset_phase;\n"
4641 "\n"
4642 " int g_light_preview;\n"
4643 " int g_shadow_samples;\n"
4644 "\n"
4645 " int g_debug_indices;\n"
4646 " int g_debug_complexity;\n"
4647 "};\n"
4648 "\n"
4649 "uniform sampler2D g_world_depth;\n"
4650 "uniform samplerBuffer uLightsArray;\n"
4651 "uniform usampler3D uLightsIndex;\n"
4652 "\n"
4653 "#line 1 1 \n"
4654 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
4655 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
4656 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
4657 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
4658 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
4659 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
4660 "\n"
4661 "const float SUN_ANGLE = 0.0001;\n"
4662 "const float PI = 3.14159265358979323846264;\n"
4663 "\n"
4664 "//struct world_info\n"
4665 "//{\n"
4666 "// float time,\n"
4667 "// time_of_day,\n"
4668 "// day_phase,\n"
4669 "// sunset_phase;\n"
4670 "// \n"
4671 "// vec3 sun_dir;\n"
4672 "//};\n"
4673 "\n"
4674 "vec3 rand33(vec3 p3)\n"
4675 "{\n"
4676 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
4677 " p3 += dot(p3, p3.yxz+33.33);\n"
4678 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
4679 "}\n"
4680 "\n"
4681 "float stars( vec3 rd, float rr, float size ){\n"
4682 " vec3 co = rd * rr;\n"
4683 "\n"
4684 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
4685 "\n"
4686 " float spaces = 1.0 / rr;\n"
4687 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
4688 " a -= mod(a, spaces) - spaces * 0.5;\n"
4689 "\n"
4690 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
4691 " \n"
4692 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
4693 " plane = plane - mod(plane, PI / count);\n"
4694 "\n"
4695 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
4696 "\n"
4697 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
4698 " float ydist = sqrt(rr * rr - level * level);\n"
4699 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
4700 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
4701 " float star = smoothstep(size, 0.0, distance(center, co));\n"
4702 " return star;\n"
4703 "}\n"
4704 "\n"
4705 "float luminance( vec3 v )\n"
4706 "{\n"
4707 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
4708 "}\n"
4709 "\n"
4710 "vec3 clearskies_ambient( vec3 dir )\n"
4711 "{\n"
4712 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
4713 " float sky_gradient = dir.y;\n"
4714 " \n"
4715 " /* Blend phase colours */\n"
4716 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
4717 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
4718 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
4719 " \n"
4720 " /* Add gradient */\n"
4721 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
4722 " \n"
4723 " return ambient;\n"
4724 "}\n"
4725 "\n"
4726 "vec3 clearskies_sky( vec3 ray_dir )\n"
4727 "{\n"
4728 " ray_dir.y = abs( ray_dir.y );\n"
4729 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
4730 " \n"
4731 " /* Sun */\n"
4732 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
4733 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
4734 " float sun_shape = pow( sun_size, 2000.0 );\n"
4735 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
4736 " \n"
4737 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
4738 " sun_colour *= sun_shape;\n"
4739 "\n"
4740 " \n"
4741 " float star = 0.0;\n"
4742 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
4743 "\n"
4744 " if( star_blend > 0.001 ){\n"
4745 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
4746 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
4747 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
4748 " }\n"
4749 " }\n"
4750 " \n"
4751 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
4752 " return composite;\n"
4753 "}\n"
4754 "\n"
4755 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
4756 "{\n"
4757 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
4758 "\n"
4759 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
4760 " g_sunset_phase );\n"
4761 "\n"
4762 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
4763 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
4764 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
4765 " ) * g_sun_colour.rgb * g_day_phase;\n"
4766 "\n"
4767 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
4768 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
4769 " g_sunset_phase );\n"
4770 "\n"
4771 " return ambient + (light_sun + sky_reflection) * shadow;\n"
4772 "}\n"
4773 "\n"
4774 "#line 44 0 \n"
4775 "\n"
4776 "float world_depth_sample( vec3 pos )\n"
4777 "{\n"
4778 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
4779 " return texture( g_world_depth, depth_coord ).r;\n"
4780 "}\n"
4781 "\n"
4782 "float world_water_depth( vec3 pos )\n"
4783 "{\n"
4784 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
4785 " return world_depth_sample( pos ) - ref_depth;\n"
4786 "}\n"
4787 "\n"
4788 "float shadow_sample( vec3 co ){\n"
4789 " float height_sample = world_depth_sample( co );\n"
4790 "\n"
4791 " float fdelta = height_sample - co.y;\n"
4792 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
4793 "}\n"
4794 "\n"
4795 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
4796 " if( g_shadow_samples == 0 ){\n"
4797 " return 1.0;\n"
4798 " }\n"
4799 "\n"
4800 " float fspread = g_shadow_spread;\n"
4801 " float flength = g_shadow_length;\n"
4802 "\n"
4803 " float famt = 0.0;\n"
4804 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
4805 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
4806 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
4807 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
4808 "\n"
4809 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
4810 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
4811 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
4812 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
4813 "\n"
4814 " return 1.0 - famt;\n"
4815 "}\n"
4816 "\n"
4817 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
4818 "{\n"
4819 " vec3 specdir = reflect( -dir, wnormal );\n"
4820 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
4821 "}\n"
4822 "\n"
4823 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
4824 " float dist = pow(fdist*0.0010,0.78);\n"
4825 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
4826 "}\n"
4827 "\n"
4828 "vec3 scene_calculate_light( int light_index, \n"
4829 " vec3 halfview, vec3 co, vec3 normal )\n"
4830 "{\n"
4831 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
4832 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
4833 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
4834 "\n"
4835 " vec3 light_delta = light_co.xyz-co;\n"
4836 " float dist2 = dot(light_delta,light_delta);\n"
4837 "\n"
4838 " light_delta = normalize( light_delta );\n"
4839 "\n"
4840 " float quadratic = dist2*100.0;\n"
4841 " float attenuation = 1.0/( 1.0 + quadratic );\n"
4842 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
4843 "\n"
4844 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
4845 "\n"
4846 " if( light_dir.w < 0.999999 ){\n"
4847 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
4848 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
4849 " }\n"
4850 "\n"
4851 " return light_colour.rgb * attenuation * falloff \n"
4852 " * step( g_day_phase, light_colour.w );\n"
4853 "}\n"
4854 "\n"
4855 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
4856 " vec3 halfview, vec3 co, vec3 normal )\n"
4857 "{\n"
4858 " uint light_count = packed_index & 0x3u;\n"
4859 "\n"
4860 " vec3 l = vec3(0.0);\n"
4861 "\n"
4862 " if( light_count >= 1u ){\n"
4863 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
4864 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
4865 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
4866 "\n"
4867 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
4868 "\n"
4869 " if( light_count >= 2u ){\n"
4870 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
4871 "\n"
4872 " if( light_count >= 3u ){\n"
4873 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
4874 " }\n"
4875 " }\n"
4876 " }\n"
4877 "\n"
4878 " return l;\n"
4879 "}\n"
4880 "\n"
4881 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
4882 " float light_mask )\n"
4883 "{\n"
4884 " if( g_light_preview == 1 )\n"
4885 " diffuse = vec3(0.75);\n"
4886 "\n"
4887 " // Lighting\n"
4888 " vec3 halfview = uCamera - co;\n"
4889 " float fdist = length(halfview);\n"
4890 " halfview /= fdist;\n"
4891 "\n"
4892 " float world_shadow = newlight_compute_sun_shadow( \n"
4893 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
4894 "\n"
4895 " vec3 total_light = clearskies_lighting( \n"
4896 " normal, min( light_mask, world_shadow ), halfview );\n"
4897 "\n"
4898 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
4899 " cube_coord = floor( cube_coord );\n"
4900 "\n"
4901 " if( g_debug_indices == 1 )\n"
4902 " {\n"
4903 " return rand33(cube_coord);\n"
4904 " }\n"
4905 "\n"
4906 " if( g_debug_complexity == 1 )\n"
4907 " {\n"
4908 " ivec3 coord = ivec3( cube_coord );\n"
4909 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
4910 "\n"
4911 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
4912 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
4913 " }\n"
4914 "\n"
4915 " // FIXME: this coord should absolutely must be clamped!\n"
4916 " \n"
4917 " ivec3 coord = ivec3( cube_coord );\n"
4918 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
4919 "\n"
4920 " total_light += \n"
4921 " scene_calculate_packed_light_patch( index_sample.x,\n"
4922 " halfview, co, normal ) \n"
4923 " * light_mask;\n"
4924 " total_light += \n"
4925 " scene_calculate_packed_light_patch( index_sample.y,\n"
4926 " halfview, co, normal )\n"
4927 " * light_mask;\n"
4928 "\n"
4929 " // Take a section of the sky function to give us a matching fog colour\n"
4930 "\n"
4931 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
4932 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
4933 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
4934 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
4935 " \n"
4936 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
4937 " sun_colour *= sun_shape;\n"
4938 "\n"
4939 " fog_colour += sun_colour;\n"
4940 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
4941 "}\n"
4942 "\n"
4943 "#line 9 0 \n"
4944 "\n"
4945 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
4946 "{\n"
4947 " vec3 pa = p - a;\n"
4948 " vec3 ba = b - a;\n"
4949 "\n"
4950 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
4951 " return length( pa - ba*h );\n"
4952 "}\n"
4953 "\n"
4954 "float compute_board_shadow()\n"
4955 "{\n"
4956 " // player shadow\n"
4957 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
4958 " g_board_1.xyz )-0.1 );\n"
4959 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
4960 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
4961 "\n"
4962 " return 1.0 - player_shadow*0.8;\n"
4963 "}\n"
4964 "\n"
4965 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
4966 "{\n"
4967 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
4968 "}\n"
4969 "\n"
4970 "#line 9 0 \n"
4971 "\n"
4972 "void main()\n"
4973 "{\n"
4974 " float height_full = aWorldCo.y;\n"
4975 " float height_water = height_full;\n"
4976 "\n"
4977 " if( height_water > (g_water_plane.y * g_water_plane.w) + 2.0 )\n"
4978 " height_water = -99999.9;\n"
4979 "\n"
4980 " FragColor = vec4( height_full, height_water, 0.0, 0.0 );\n"
4981 "}\n"
4982 ""},
4983 };
4984
4985 GLuint _uniform_scene_position_uMdl;
4986 GLuint _uniform_scene_position_uPv;
4987 GLuint _uniform_scene_position_uPvmPrev;
4988 GLuint _uniform_scene_position_uCamera;
4989 GLuint _uniform_scene_position_uBoard0;
4990 GLuint _uniform_scene_position_uBoard1;
4991 GLuint _uniform_scene_position_g_world_depth;
4992 GLuint _uniform_scene_position_uLightsArray;
4993 GLuint _uniform_scene_position_uLightsIndex;
4994 #include "shaders/scene_cubemapped.h"
4995 struct vg_shader _shader_scene_cubemapped = {
4996 .name = "scene_cubemapped",
4997 .vs =
4998 {
4999 .orig_file = "shaders/scene.vs",
5000 .static_src =
5001 "layout (location=0) in vec3 a_co;\n"
5002 "layout (location=1) in vec4 a_norm;\n"
5003 "layout (location=2) in vec2 a_uv;\n"
5004 "\n"
5005 "#line 1 1 \n"
5006 "const float k_motion_lerp_amount = 0.01;\n"
5007 "\n"
5008 "#line 2 0 \n"
5009 "\n"
5010 "out vec3 aMotionVec0;\n"
5011 "out vec3 aMotionVec1;\n"
5012 "\n"
5013 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
5014 "{\n"
5015 " // This magically solves some artifacting errors!\n"
5016 " //\n"
5017 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
5018 "\n"
5019 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
5020 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
5021 "}\n"
5022 "\n"
5023 "#line 6 0 \n"
5024 "\n"
5025 "uniform mat4x3 uMdl;\n"
5026 "uniform mat4 uPv;\n"
5027 "uniform mat4 uPvmPrev;\n"
5028 "\n"
5029 "out vec2 aUv;\n"
5030 "out vec4 aNorm;\n"
5031 "out vec3 aCo;\n"
5032 "out vec3 aWorldCo;\n"
5033 "\n"
5034 "void main()\n"
5035 "{\n"
5036 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
5037 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
5038 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
5039 "\n"
5040 " vs_motion_out( vproj0, vproj1 );\n"
5041 "\n"
5042 " gl_Position = vproj0;\n"
5043 "\n"
5044 " aUv = a_uv;\n"
5045 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
5046 " aCo = a_co;\n"
5047 " aWorldCo = world_pos0;\n"
5048 "}\n"
5049 ""},
5050 .fs =
5051 {
5052 .orig_file = "shaders/scene_cubemapped.fs",
5053 .static_src =
5054 "uniform sampler2D uTexGarbage;\n"
5055 "uniform sampler2D uTexMain;\n"
5056 "uniform samplerCube uTexCubemap;\n"
5057 "uniform vec3 uCamera;\n"
5058 "uniform vec4 uPlane;\n"
5059 "uniform vec4 uColour;\n"
5060 "\n"
5061 "#line 1 1 \n"
5062 "// :D\n"
5063 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
5064 "\n"
5065 "#line 9 0 \n"
5066 "#line 1 2 \n"
5067 "// :D\n"
5068 "\n"
5069 "in vec2 aUv;\n"
5070 "in vec4 aNorm;\n"
5071 "in vec3 aCo;\n"
5072 "in vec3 aWorldCo;\n"
5073 "\n"
5074 "#line 1 1 \n"
5075 "layout (location = 0) out vec4 oColour;\n"
5076 "\n"
5077 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
5078 "layout (std140) uniform ub_world_lighting\n"
5079 "{\n"
5080 " vec4 g_cube_min;\n"
5081 " vec4 g_cube_inv_range;\n"
5082 "\n"
5083 " vec4 g_water_plane;\n"
5084 " vec4 g_depth_bounds;\n"
5085 "\n"
5086 " vec4 g_daysky_colour;\n"
5087 " vec4 g_nightsky_colour;\n"
5088 " vec4 g_sunset_colour;\n"
5089 " vec4 g_ambient_colour;\n"
5090 " vec4 g_sunset_ambient;\n"
5091 " vec4 g_sun_colour;\n"
5092 " vec4 g_sun_dir;\n"
5093 " vec4 g_board_0;\n"
5094 " vec4 g_board_1;\n"
5095 "\n"
5096 " float g_water_fog;\n"
5097 " float g_time;\n"
5098 " float g_realtime;\n"
5099 " float g_shadow_length;\n"
5100 " float g_shadow_spread;\n"
5101 "\n"
5102 " float g_time_of_day;\n"
5103 " float g_day_phase;\n"
5104 " float g_sunset_phase;\n"
5105 "\n"
5106 " int g_light_preview;\n"
5107 " int g_shadow_samples;\n"
5108 "\n"
5109 " int g_debug_indices;\n"
5110 " int g_debug_complexity;\n"
5111 "};\n"
5112 "\n"
5113 "uniform sampler2D g_world_depth;\n"
5114 "uniform samplerBuffer uLightsArray;\n"
5115 "uniform usampler3D uLightsIndex;\n"
5116 "\n"
5117 "#line 1 1 \n"
5118 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
5119 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
5120 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
5121 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
5122 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
5123 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
5124 "\n"
5125 "const float SUN_ANGLE = 0.0001;\n"
5126 "const float PI = 3.14159265358979323846264;\n"
5127 "\n"
5128 "//struct world_info\n"
5129 "//{\n"
5130 "// float time,\n"
5131 "// time_of_day,\n"
5132 "// day_phase,\n"
5133 "// sunset_phase;\n"
5134 "// \n"
5135 "// vec3 sun_dir;\n"
5136 "//};\n"
5137 "\n"
5138 "vec3 rand33(vec3 p3)\n"
5139 "{\n"
5140 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
5141 " p3 += dot(p3, p3.yxz+33.33);\n"
5142 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
5143 "}\n"
5144 "\n"
5145 "float stars( vec3 rd, float rr, float size ){\n"
5146 " vec3 co = rd * rr;\n"
5147 "\n"
5148 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
5149 "\n"
5150 " float spaces = 1.0 / rr;\n"
5151 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
5152 " a -= mod(a, spaces) - spaces * 0.5;\n"
5153 "\n"
5154 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
5155 " \n"
5156 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
5157 " plane = plane - mod(plane, PI / count);\n"
5158 "\n"
5159 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
5160 "\n"
5161 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
5162 " float ydist = sqrt(rr * rr - level * level);\n"
5163 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
5164 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
5165 " float star = smoothstep(size, 0.0, distance(center, co));\n"
5166 " return star;\n"
5167 "}\n"
5168 "\n"
5169 "float luminance( vec3 v )\n"
5170 "{\n"
5171 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
5172 "}\n"
5173 "\n"
5174 "vec3 clearskies_ambient( vec3 dir )\n"
5175 "{\n"
5176 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
5177 " float sky_gradient = dir.y;\n"
5178 " \n"
5179 " /* Blend phase colours */\n"
5180 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
5181 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
5182 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
5183 " \n"
5184 " /* Add gradient */\n"
5185 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
5186 " \n"
5187 " return ambient;\n"
5188 "}\n"
5189 "\n"
5190 "vec3 clearskies_sky( vec3 ray_dir )\n"
5191 "{\n"
5192 " ray_dir.y = abs( ray_dir.y );\n"
5193 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
5194 " \n"
5195 " /* Sun */\n"
5196 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
5197 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
5198 " float sun_shape = pow( sun_size, 2000.0 );\n"
5199 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
5200 " \n"
5201 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
5202 " sun_colour *= sun_shape;\n"
5203 "\n"
5204 " \n"
5205 " float star = 0.0;\n"
5206 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
5207 "\n"
5208 " if( star_blend > 0.001 ){\n"
5209 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
5210 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
5211 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
5212 " }\n"
5213 " }\n"
5214 " \n"
5215 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
5216 " return composite;\n"
5217 "}\n"
5218 "\n"
5219 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
5220 "{\n"
5221 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
5222 "\n"
5223 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
5224 " g_sunset_phase );\n"
5225 "\n"
5226 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
5227 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
5228 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
5229 " ) * g_sun_colour.rgb * g_day_phase;\n"
5230 "\n"
5231 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
5232 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
5233 " g_sunset_phase );\n"
5234 "\n"
5235 " return ambient + (light_sun + sky_reflection) * shadow;\n"
5236 "}\n"
5237 "\n"
5238 "#line 44 0 \n"
5239 "\n"
5240 "float world_depth_sample( vec3 pos )\n"
5241 "{\n"
5242 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
5243 " return texture( g_world_depth, depth_coord ).r;\n"
5244 "}\n"
5245 "\n"
5246 "float world_water_depth( vec3 pos )\n"
5247 "{\n"
5248 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
5249 " return world_depth_sample( pos ) - ref_depth;\n"
5250 "}\n"
5251 "\n"
5252 "float shadow_sample( vec3 co ){\n"
5253 " float height_sample = world_depth_sample( co );\n"
5254 "\n"
5255 " float fdelta = height_sample - co.y;\n"
5256 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
5257 "}\n"
5258 "\n"
5259 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
5260 " if( g_shadow_samples == 0 ){\n"
5261 " return 1.0;\n"
5262 " }\n"
5263 "\n"
5264 " float fspread = g_shadow_spread;\n"
5265 " float flength = g_shadow_length;\n"
5266 "\n"
5267 " float famt = 0.0;\n"
5268 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
5269 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
5270 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
5271 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
5272 "\n"
5273 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
5274 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
5275 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
5276 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
5277 "\n"
5278 " return 1.0 - famt;\n"
5279 "}\n"
5280 "\n"
5281 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
5282 "{\n"
5283 " vec3 specdir = reflect( -dir, wnormal );\n"
5284 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
5285 "}\n"
5286 "\n"
5287 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
5288 " float dist = pow(fdist*0.0010,0.78);\n"
5289 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
5290 "}\n"
5291 "\n"
5292 "vec3 scene_calculate_light( int light_index, \n"
5293 " vec3 halfview, vec3 co, vec3 normal )\n"
5294 "{\n"
5295 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
5296 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
5297 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
5298 "\n"
5299 " vec3 light_delta = light_co.xyz-co;\n"
5300 " float dist2 = dot(light_delta,light_delta);\n"
5301 "\n"
5302 " light_delta = normalize( light_delta );\n"
5303 "\n"
5304 " float quadratic = dist2*100.0;\n"
5305 " float attenuation = 1.0/( 1.0 + quadratic );\n"
5306 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
5307 "\n"
5308 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
5309 "\n"
5310 " if( light_dir.w < 0.999999 ){\n"
5311 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
5312 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
5313 " }\n"
5314 "\n"
5315 " return light_colour.rgb * attenuation * falloff \n"
5316 " * step( g_day_phase, light_colour.w );\n"
5317 "}\n"
5318 "\n"
5319 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
5320 " vec3 halfview, vec3 co, vec3 normal )\n"
5321 "{\n"
5322 " uint light_count = packed_index & 0x3u;\n"
5323 "\n"
5324 " vec3 l = vec3(0.0);\n"
5325 "\n"
5326 " if( light_count >= 1u ){\n"
5327 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
5328 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
5329 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
5330 "\n"
5331 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
5332 "\n"
5333 " if( light_count >= 2u ){\n"
5334 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
5335 "\n"
5336 " if( light_count >= 3u ){\n"
5337 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
5338 " }\n"
5339 " }\n"
5340 " }\n"
5341 "\n"
5342 " return l;\n"
5343 "}\n"
5344 "\n"
5345 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
5346 " float light_mask )\n"
5347 "{\n"
5348 " if( g_light_preview == 1 )\n"
5349 " diffuse = vec3(0.75);\n"
5350 "\n"
5351 " // Lighting\n"
5352 " vec3 halfview = uCamera - co;\n"
5353 " float fdist = length(halfview);\n"
5354 " halfview /= fdist;\n"
5355 "\n"
5356 " float world_shadow = newlight_compute_sun_shadow( \n"
5357 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
5358 "\n"
5359 " vec3 total_light = clearskies_lighting( \n"
5360 " normal, min( light_mask, world_shadow ), halfview );\n"
5361 "\n"
5362 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
5363 " cube_coord = floor( cube_coord );\n"
5364 "\n"
5365 " if( g_debug_indices == 1 )\n"
5366 " {\n"
5367 " return rand33(cube_coord);\n"
5368 " }\n"
5369 "\n"
5370 " if( g_debug_complexity == 1 )\n"
5371 " {\n"
5372 " ivec3 coord = ivec3( cube_coord );\n"
5373 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
5374 "\n"
5375 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
5376 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
5377 " }\n"
5378 "\n"
5379 " // FIXME: this coord should absolutely must be clamped!\n"
5380 " \n"
5381 " ivec3 coord = ivec3( cube_coord );\n"
5382 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
5383 "\n"
5384 " total_light += \n"
5385 " scene_calculate_packed_light_patch( index_sample.x,\n"
5386 " halfview, co, normal ) \n"
5387 " * light_mask;\n"
5388 " total_light += \n"
5389 " scene_calculate_packed_light_patch( index_sample.y,\n"
5390 " halfview, co, normal )\n"
5391 " * light_mask;\n"
5392 "\n"
5393 " // Take a section of the sky function to give us a matching fog colour\n"
5394 "\n"
5395 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
5396 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
5397 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
5398 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
5399 " \n"
5400 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
5401 " sun_colour *= sun_shape;\n"
5402 "\n"
5403 " fog_colour += sun_colour;\n"
5404 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
5405 "}\n"
5406 "\n"
5407 "#line 9 0 \n"
5408 "\n"
5409 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
5410 "{\n"
5411 " vec3 pa = p - a;\n"
5412 " vec3 ba = b - a;\n"
5413 "\n"
5414 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
5415 " return length( pa - ba*h );\n"
5416 "}\n"
5417 "\n"
5418 "float compute_board_shadow()\n"
5419 "{\n"
5420 " // player shadow\n"
5421 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
5422 " g_board_1.xyz )-0.1 );\n"
5423 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
5424 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
5425 "\n"
5426 " return 1.0 - player_shadow*0.8;\n"
5427 "}\n"
5428 "\n"
5429 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
5430 "{\n"
5431 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
5432 "}\n"
5433 "\n"
5434 "#line 10 0 \n"
5435 "#line 1 3 \n"
5436 "const float k_motion_lerp_amount = 0.01;\n"
5437 "\n"
5438 "#line 2 0 \n"
5439 "\n"
5440 "layout (location = 1) out vec2 oMotionVec;\n"
5441 "\n"
5442 "in vec3 aMotionVec0;\n"
5443 "in vec3 aMotionVec1;\n"
5444 "\n"
5445 "void compute_motion_vectors()\n"
5446 "{\n"
5447 " // Write motion vectors\n"
5448 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
5449 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
5450 "\n"
5451 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
5452 "}\n"
5453 "\n"
5454 "#line 11 0 \n"
5455 "\n"
5456 "void main()\n"
5457 "{\n"
5458 " compute_motion_vectors();\n"
5459 "\n"
5460 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
5461 " vec4 vsamplemain = texture( uTexMain, aUv );\n"
5462 " vec4 wgarbage = texture( uTexGarbage, aCo.xz * 0.0015 + aCo.yx*0.002 );\n"
5463 " vec3 qnorm = aNorm.xyz;\n"
5464 " vfrag = vsamplemain.rgb;\n"
5465 "\n"
5466 " if( g_light_preview == 1 ){\n"
5467 " vfrag = vec3(0.5);\n"
5468 " }\n"
5469 "\n"
5470 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
5471 " oColour = vec4( vfrag, 1.0 );\n"
5472 "\n"
5473 " vec3 halfdir = normalize( aWorldCo - uCamera );\n"
5474 " vec3 reflectdir = reflect( halfdir, qnorm );\n"
5475 " oColour = mix( oColour, \n"
5476 " vec4(texture(uTexCubemap,reflectdir).rgb * uColour.rgb, 1.0),\n"
5477 " uColour.a*wgarbage.b );\n"
5478 "}\n"
5479 ""},
5480 };
5481
5482 GLuint _uniform_scene_cubemapped_uMdl;
5483 GLuint _uniform_scene_cubemapped_uPv;
5484 GLuint _uniform_scene_cubemapped_uPvmPrev;
5485 GLuint _uniform_scene_cubemapped_uTexGarbage;
5486 GLuint _uniform_scene_cubemapped_uTexMain;
5487 GLuint _uniform_scene_cubemapped_uTexCubemap;
5488 GLuint _uniform_scene_cubemapped_uCamera;
5489 GLuint _uniform_scene_cubemapped_uPlane;
5490 GLuint _uniform_scene_cubemapped_uColour;
5491 GLuint _uniform_scene_cubemapped_g_world_depth;
5492 GLuint _uniform_scene_cubemapped_uLightsArray;
5493 GLuint _uniform_scene_cubemapped_uLightsIndex;
5494 #include "shaders/scene_water.h"
5495 struct vg_shader _shader_scene_water = {
5496 .name = "scene_water",
5497 .vs =
5498 {
5499 .orig_file = "shaders/scene.vs",
5500 .static_src =
5501 "layout (location=0) in vec3 a_co;\n"
5502 "layout (location=1) in vec4 a_norm;\n"
5503 "layout (location=2) in vec2 a_uv;\n"
5504 "\n"
5505 "#line 1 1 \n"
5506 "const float k_motion_lerp_amount = 0.01;\n"
5507 "\n"
5508 "#line 2 0 \n"
5509 "\n"
5510 "out vec3 aMotionVec0;\n"
5511 "out vec3 aMotionVec1;\n"
5512 "\n"
5513 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
5514 "{\n"
5515 " // This magically solves some artifacting errors!\n"
5516 " //\n"
5517 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
5518 "\n"
5519 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
5520 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
5521 "}\n"
5522 "\n"
5523 "#line 6 0 \n"
5524 "\n"
5525 "uniform mat4x3 uMdl;\n"
5526 "uniform mat4 uPv;\n"
5527 "uniform mat4 uPvmPrev;\n"
5528 "\n"
5529 "out vec2 aUv;\n"
5530 "out vec4 aNorm;\n"
5531 "out vec3 aCo;\n"
5532 "out vec3 aWorldCo;\n"
5533 "\n"
5534 "void main()\n"
5535 "{\n"
5536 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
5537 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
5538 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
5539 "\n"
5540 " vs_motion_out( vproj0, vproj1 );\n"
5541 "\n"
5542 " gl_Position = vproj0;\n"
5543 "\n"
5544 " aUv = a_uv;\n"
5545 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
5546 " aCo = a_co;\n"
5547 " aWorldCo = world_pos0;\n"
5548 "}\n"
5549 ""},
5550 .fs =
5551 {
5552 .orig_file = "shaders/scene_water.fs",
5553 .static_src =
5554 "uniform sampler2D uTexMain;\n"
5555 "uniform sampler2D uTexDudv;\n"
5556 "uniform sampler2D uTexBack;\n"
5557 "\n"
5558 "uniform vec2 uInvRes;\n"
5559 "uniform float uTime;\n"
5560 "uniform vec3 uCamera;\n"
5561 "uniform float uSurfaceY;\n"
5562 "uniform vec3 uBoard0;\n"
5563 "uniform vec3 uBoard1;\n"
5564 "\n"
5565 "uniform vec3 uShoreColour;\n"
5566 "uniform vec3 uOceanColour;\n"
5567 "\n"
5568 "#line 1 1 \n"
5569 "// :D\n"
5570 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
5571 "\n"
5572 "#line 16 0 \n"
5573 "#line 1 2 \n"
5574 "// :D\n"
5575 "\n"
5576 "in vec2 aUv;\n"
5577 "in vec4 aNorm;\n"
5578 "in vec3 aCo;\n"
5579 "in vec3 aWorldCo;\n"
5580 "\n"
5581 "#line 1 1 \n"
5582 "layout (location = 0) out vec4 oColour;\n"
5583 "\n"
5584 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
5585 "layout (std140) uniform ub_world_lighting\n"
5586 "{\n"
5587 " vec4 g_cube_min;\n"
5588 " vec4 g_cube_inv_range;\n"
5589 "\n"
5590 " vec4 g_water_plane;\n"
5591 " vec4 g_depth_bounds;\n"
5592 "\n"
5593 " vec4 g_daysky_colour;\n"
5594 " vec4 g_nightsky_colour;\n"
5595 " vec4 g_sunset_colour;\n"
5596 " vec4 g_ambient_colour;\n"
5597 " vec4 g_sunset_ambient;\n"
5598 " vec4 g_sun_colour;\n"
5599 " vec4 g_sun_dir;\n"
5600 " vec4 g_board_0;\n"
5601 " vec4 g_board_1;\n"
5602 "\n"
5603 " float g_water_fog;\n"
5604 " float g_time;\n"
5605 " float g_realtime;\n"
5606 " float g_shadow_length;\n"
5607 " float g_shadow_spread;\n"
5608 "\n"
5609 " float g_time_of_day;\n"
5610 " float g_day_phase;\n"
5611 " float g_sunset_phase;\n"
5612 "\n"
5613 " int g_light_preview;\n"
5614 " int g_shadow_samples;\n"
5615 "\n"
5616 " int g_debug_indices;\n"
5617 " int g_debug_complexity;\n"
5618 "};\n"
5619 "\n"
5620 "uniform sampler2D g_world_depth;\n"
5621 "uniform samplerBuffer uLightsArray;\n"
5622 "uniform usampler3D uLightsIndex;\n"
5623 "\n"
5624 "#line 1 1 \n"
5625 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
5626 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
5627 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
5628 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
5629 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
5630 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
5631 "\n"
5632 "const float SUN_ANGLE = 0.0001;\n"
5633 "const float PI = 3.14159265358979323846264;\n"
5634 "\n"
5635 "//struct world_info\n"
5636 "//{\n"
5637 "// float time,\n"
5638 "// time_of_day,\n"
5639 "// day_phase,\n"
5640 "// sunset_phase;\n"
5641 "// \n"
5642 "// vec3 sun_dir;\n"
5643 "//};\n"
5644 "\n"
5645 "vec3 rand33(vec3 p3)\n"
5646 "{\n"
5647 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
5648 " p3 += dot(p3, p3.yxz+33.33);\n"
5649 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
5650 "}\n"
5651 "\n"
5652 "float stars( vec3 rd, float rr, float size ){\n"
5653 " vec3 co = rd * rr;\n"
5654 "\n"
5655 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
5656 "\n"
5657 " float spaces = 1.0 / rr;\n"
5658 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
5659 " a -= mod(a, spaces) - spaces * 0.5;\n"
5660 "\n"
5661 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
5662 " \n"
5663 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
5664 " plane = plane - mod(plane, PI / count);\n"
5665 "\n"
5666 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
5667 "\n"
5668 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
5669 " float ydist = sqrt(rr * rr - level * level);\n"
5670 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
5671 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
5672 " float star = smoothstep(size, 0.0, distance(center, co));\n"
5673 " return star;\n"
5674 "}\n"
5675 "\n"
5676 "float luminance( vec3 v )\n"
5677 "{\n"
5678 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
5679 "}\n"
5680 "\n"
5681 "vec3 clearskies_ambient( vec3 dir )\n"
5682 "{\n"
5683 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
5684 " float sky_gradient = dir.y;\n"
5685 " \n"
5686 " /* Blend phase colours */\n"
5687 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
5688 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
5689 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
5690 " \n"
5691 " /* Add gradient */\n"
5692 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
5693 " \n"
5694 " return ambient;\n"
5695 "}\n"
5696 "\n"
5697 "vec3 clearskies_sky( vec3 ray_dir )\n"
5698 "{\n"
5699 " ray_dir.y = abs( ray_dir.y );\n"
5700 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
5701 " \n"
5702 " /* Sun */\n"
5703 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
5704 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
5705 " float sun_shape = pow( sun_size, 2000.0 );\n"
5706 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
5707 " \n"
5708 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
5709 " sun_colour *= sun_shape;\n"
5710 "\n"
5711 " \n"
5712 " float star = 0.0;\n"
5713 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
5714 "\n"
5715 " if( star_blend > 0.001 ){\n"
5716 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
5717 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
5718 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
5719 " }\n"
5720 " }\n"
5721 " \n"
5722 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
5723 " return composite;\n"
5724 "}\n"
5725 "\n"
5726 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
5727 "{\n"
5728 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
5729 "\n"
5730 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
5731 " g_sunset_phase );\n"
5732 "\n"
5733 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
5734 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
5735 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
5736 " ) * g_sun_colour.rgb * g_day_phase;\n"
5737 "\n"
5738 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
5739 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
5740 " g_sunset_phase );\n"
5741 "\n"
5742 " return ambient + (light_sun + sky_reflection) * shadow;\n"
5743 "}\n"
5744 "\n"
5745 "#line 44 0 \n"
5746 "\n"
5747 "float world_depth_sample( vec3 pos )\n"
5748 "{\n"
5749 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
5750 " return texture( g_world_depth, depth_coord ).r;\n"
5751 "}\n"
5752 "\n"
5753 "float world_water_depth( vec3 pos )\n"
5754 "{\n"
5755 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
5756 " return world_depth_sample( pos ) - ref_depth;\n"
5757 "}\n"
5758 "\n"
5759 "float shadow_sample( vec3 co ){\n"
5760 " float height_sample = world_depth_sample( co );\n"
5761 "\n"
5762 " float fdelta = height_sample - co.y;\n"
5763 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
5764 "}\n"
5765 "\n"
5766 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
5767 " if( g_shadow_samples == 0 ){\n"
5768 " return 1.0;\n"
5769 " }\n"
5770 "\n"
5771 " float fspread = g_shadow_spread;\n"
5772 " float flength = g_shadow_length;\n"
5773 "\n"
5774 " float famt = 0.0;\n"
5775 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
5776 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
5777 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
5778 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
5779 "\n"
5780 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
5781 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
5782 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
5783 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
5784 "\n"
5785 " return 1.0 - famt;\n"
5786 "}\n"
5787 "\n"
5788 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
5789 "{\n"
5790 " vec3 specdir = reflect( -dir, wnormal );\n"
5791 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
5792 "}\n"
5793 "\n"
5794 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
5795 " float dist = pow(fdist*0.0010,0.78);\n"
5796 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
5797 "}\n"
5798 "\n"
5799 "vec3 scene_calculate_light( int light_index, \n"
5800 " vec3 halfview, vec3 co, vec3 normal )\n"
5801 "{\n"
5802 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
5803 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
5804 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
5805 "\n"
5806 " vec3 light_delta = light_co.xyz-co;\n"
5807 " float dist2 = dot(light_delta,light_delta);\n"
5808 "\n"
5809 " light_delta = normalize( light_delta );\n"
5810 "\n"
5811 " float quadratic = dist2*100.0;\n"
5812 " float attenuation = 1.0/( 1.0 + quadratic );\n"
5813 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
5814 "\n"
5815 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
5816 "\n"
5817 " if( light_dir.w < 0.999999 ){\n"
5818 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
5819 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
5820 " }\n"
5821 "\n"
5822 " return light_colour.rgb * attenuation * falloff \n"
5823 " * step( g_day_phase, light_colour.w );\n"
5824 "}\n"
5825 "\n"
5826 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
5827 " vec3 halfview, vec3 co, vec3 normal )\n"
5828 "{\n"
5829 " uint light_count = packed_index & 0x3u;\n"
5830 "\n"
5831 " vec3 l = vec3(0.0);\n"
5832 "\n"
5833 " if( light_count >= 1u ){\n"
5834 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
5835 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
5836 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
5837 "\n"
5838 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
5839 "\n"
5840 " if( light_count >= 2u ){\n"
5841 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
5842 "\n"
5843 " if( light_count >= 3u ){\n"
5844 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
5845 " }\n"
5846 " }\n"
5847 " }\n"
5848 "\n"
5849 " return l;\n"
5850 "}\n"
5851 "\n"
5852 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
5853 " float light_mask )\n"
5854 "{\n"
5855 " if( g_light_preview == 1 )\n"
5856 " diffuse = vec3(0.75);\n"
5857 "\n"
5858 " // Lighting\n"
5859 " vec3 halfview = uCamera - co;\n"
5860 " float fdist = length(halfview);\n"
5861 " halfview /= fdist;\n"
5862 "\n"
5863 " float world_shadow = newlight_compute_sun_shadow( \n"
5864 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
5865 "\n"
5866 " vec3 total_light = clearskies_lighting( \n"
5867 " normal, min( light_mask, world_shadow ), halfview );\n"
5868 "\n"
5869 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
5870 " cube_coord = floor( cube_coord );\n"
5871 "\n"
5872 " if( g_debug_indices == 1 )\n"
5873 " {\n"
5874 " return rand33(cube_coord);\n"
5875 " }\n"
5876 "\n"
5877 " if( g_debug_complexity == 1 )\n"
5878 " {\n"
5879 " ivec3 coord = ivec3( cube_coord );\n"
5880 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
5881 "\n"
5882 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
5883 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
5884 " }\n"
5885 "\n"
5886 " // FIXME: this coord should absolutely must be clamped!\n"
5887 " \n"
5888 " ivec3 coord = ivec3( cube_coord );\n"
5889 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
5890 "\n"
5891 " total_light += \n"
5892 " scene_calculate_packed_light_patch( index_sample.x,\n"
5893 " halfview, co, normal ) \n"
5894 " * light_mask;\n"
5895 " total_light += \n"
5896 " scene_calculate_packed_light_patch( index_sample.y,\n"
5897 " halfview, co, normal )\n"
5898 " * light_mask;\n"
5899 "\n"
5900 " // Take a section of the sky function to give us a matching fog colour\n"
5901 "\n"
5902 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
5903 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
5904 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
5905 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
5906 " \n"
5907 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
5908 " sun_colour *= sun_shape;\n"
5909 "\n"
5910 " fog_colour += sun_colour;\n"
5911 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
5912 "}\n"
5913 "\n"
5914 "#line 9 0 \n"
5915 "\n"
5916 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
5917 "{\n"
5918 " vec3 pa = p - a;\n"
5919 " vec3 ba = b - a;\n"
5920 "\n"
5921 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
5922 " return length( pa - ba*h );\n"
5923 "}\n"
5924 "\n"
5925 "float compute_board_shadow()\n"
5926 "{\n"
5927 " // player shadow\n"
5928 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
5929 " g_board_1.xyz )-0.1 );\n"
5930 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
5931 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
5932 "\n"
5933 " return 1.0 - player_shadow*0.8;\n"
5934 "}\n"
5935 "\n"
5936 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
5937 "{\n"
5938 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
5939 "}\n"
5940 "\n"
5941 "#line 17 0 \n"
5942 "#line 1 3 \n"
5943 "const float k_motion_lerp_amount = 0.01;\n"
5944 "\n"
5945 "#line 2 0 \n"
5946 "\n"
5947 "layout (location = 1) out vec2 oMotionVec;\n"
5948 "\n"
5949 "in vec3 aMotionVec0;\n"
5950 "in vec3 aMotionVec1;\n"
5951 "\n"
5952 "void compute_motion_vectors()\n"
5953 "{\n"
5954 " // Write motion vectors\n"
5955 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
5956 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
5957 "\n"
5958 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
5959 "}\n"
5960 "\n"
5961 "#line 18 0 \n"
5962 "\n"
5963 "// Pasted from common_world.glsl\n"
5964 "vec3 water_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
5965 "{\n"
5966 " float light_mask = compute_board_shadow();\n"
5967 "\n"
5968 " if( g_light_preview == 1 )\n"
5969 " diffuse = vec3(0.75);\n"
5970 "\n"
5971 " // Lighting\n"
5972 " vec3 halfview = uCamera - co;\n"
5973 " float fdist = length(halfview);\n"
5974 " halfview /= fdist;\n"
5975 "\n"
5976 " float world_shadow = newlight_compute_sun_shadow( \n"
5977 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
5978 "\n"
5979 " vec3 total_light = clearskies_lighting( \n"
5980 " normal, min( light_mask, world_shadow ), halfview );\n"
5981 "\n"
5982 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
5983 " cube_coord = floor( cube_coord );\n"
5984 "\n"
5985 " if( g_debug_indices == 1 )\n"
5986 " {\n"
5987 " return rand33(cube_coord);\n"
5988 " }\n"
5989 "\n"
5990 " if( g_debug_complexity == 1 )\n"
5991 " {\n"
5992 " ivec3 coord = ivec3( cube_coord );\n"
5993 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
5994 "\n"
5995 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
5996 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
5997 " }\n"
5998 "\n"
5999 " // FIXME: this coord should absolutely must be clamped!\n"
6000 " \n"
6001 " ivec3 coord = ivec3( cube_coord );\n"
6002 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
6003 "\n"
6004 " total_light += \n"
6005 " scene_calculate_packed_light_patch( index_sample.x,\n"
6006 " halfview, co, normal ) \n"
6007 " * light_mask;\n"
6008 " total_light += \n"
6009 " scene_calculate_packed_light_patch( index_sample.y,\n"
6010 " halfview, co, normal )\n"
6011 " * light_mask;\n"
6012 "\n"
6013 " return diffuse * total_light;\n"
6014 "}\n"
6015 "\n"
6016 "vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue, \n"
6017 " vec4 beneath, vec4 above, vec4 dudva )\n"
6018 "{\n"
6019 " vec3 surface_tint = mix(uShoreColour, uOceanColour, depthvalue);\n"
6020 "\n"
6021 " float ffresnel = pow(1.0-dot( vnorm, halfview ),5.0);\n"
6022 "\n"
6023 " vec3 lightdir = vec3(0.95,0.0,-0.3);\n"
6024 " vec3 specdir = reflect( -lightdir, vnorm );\n"
6025 " float spec = pow(max(dot(halfview,specdir),0.0),20.0)*0.3;\n"
6026 " \n"
6027 " // Depth \n"
6028 " float depthblend = pow( beneath.r, 0.8 );\n"
6029 "\n"
6030 " // Foam\n"
6031 " float fband = fract( aCo.z*0.02+uTime*0.1+depthvalue*10.0 );\n"
6032 " fband = step( fband+dudva.a*0.8, 0.3 ) * max((1.0-depthvalue*4.0),0.0);\n"
6033 "\n"
6034 " vec4 surf = mix( vec4(surface_tint,depthblend), \n"
6035 " vec4(1.0,1.0,1.0,0.5), fband );\n"
6036 " surf.rgb = water_compute_lighting( surf.rgb, aNorm.xyz, aWorldCo );\n"
6037 " surf.rgb = mix(surf.rgb, above.rgb, ffresnel );\n"
6038 "\n"
6039 " // Take a section of the sky function to give us a matching fog colour\n"
6040 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
6041 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
6042 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
6043 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
6044 " \n"
6045 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
6046 " sun_colour *= sun_shape;\n"
6047 "\n"
6048 " fog_colour += sun_colour;\n"
6049 " surf.rgb = scene_apply_fog( surf.rgb, fog_colour, \n"
6050 " distance(uCamera, aWorldCo) );\n"
6051 "\n"
6052 " return surf;\n"
6053 "}\n"
6054 "\n"
6055 "void main()\n"
6056 "{\n"
6057 " compute_motion_vectors();\n"
6058 "\n"
6059 " // Create texture coords\n"
6060 " vec2 ssuv = gl_FragCoord.xy*uInvRes;\n"
6061 " \n"
6062 " // Surface colour composite\n"
6063 " float depthvalue = clamp( -world_water_depth(aCo)*(1.0/25.0), 0.0,1.0 );\n"
6064 "\n"
6065 " vec2 world_coord = aCo.xz * 0.008;\n"
6066 " vec4 time_offsets = vec4( uTime ) * vec4( 0.008, 0.006, 0.003, 0.03 );\n"
6067 " vec4 dudva = texture( uTexDudv, world_coord + time_offsets.xy )-0.5;\n"
6068 " vec4 dudvb = texture( uTexDudv, world_coord *7.0 - time_offsets.zw )-0.5;\n"
6069 "\n"
6070 " vec3 surfnorm = dudva.rgb + dudvb.rgb;\n"
6071 " surfnorm = normalize(vec3(0.0,1.0,0.0) + dudva.xyz*0.4 + dudvb.xyz*0.1);\n"
6072 " \n"
6073 " // Lighting\n"
6074 " vec3 halfview = -normalize( aCo-uCamera );\n"
6075 "\n"
6076 " // Sample textures\n"
6077 " vec4 above = texture( uTexMain, ssuv+ surfnorm.xz*0.2 );\n"
6078 " vec4 beneath = texture( uTexBack, ssuv );\n"
6079 "\n"
6080 " // Fog\n"
6081 " float fdist = pow(length( aCo.xz-uCamera.xz ) * 0.00047, 2.6);\n"
6082 "\n"
6083 " // Composite\n"
6084 " vec4 vsurface = water_surf( halfview, surfnorm, depthvalue, beneath, above, dudva );\n"
6085 " vsurface.a -= fdist;\n"
6086 "\n"
6087 " oColour = vsurface;\n"
6088 "}\n"
6089 ""},
6090 };
6091
6092 GLuint _uniform_scene_water_uMdl;
6093 GLuint _uniform_scene_water_uPv;
6094 GLuint _uniform_scene_water_uPvmPrev;
6095 GLuint _uniform_scene_water_uTexMain;
6096 GLuint _uniform_scene_water_uTexDudv;
6097 GLuint _uniform_scene_water_uTexBack;
6098 GLuint _uniform_scene_water_uInvRes;
6099 GLuint _uniform_scene_water_uTime;
6100 GLuint _uniform_scene_water_uCamera;
6101 GLuint _uniform_scene_water_uSurfaceY;
6102 GLuint _uniform_scene_water_uBoard0;
6103 GLuint _uniform_scene_water_uBoard1;
6104 GLuint _uniform_scene_water_uShoreColour;
6105 GLuint _uniform_scene_water_uOceanColour;
6106 GLuint _uniform_scene_water_g_world_depth;
6107 GLuint _uniform_scene_water_uLightsArray;
6108 GLuint _uniform_scene_water_uLightsIndex;
6109 #include "shaders/scene_water_fast.h"
6110 struct vg_shader _shader_scene_water_fast = {
6111 .name = "scene_water_fast",
6112 .vs =
6113 {
6114 .orig_file = "shaders/scene.vs",
6115 .static_src =
6116 "layout (location=0) in vec3 a_co;\n"
6117 "layout (location=1) in vec4 a_norm;\n"
6118 "layout (location=2) in vec2 a_uv;\n"
6119 "\n"
6120 "#line 1 1 \n"
6121 "const float k_motion_lerp_amount = 0.01;\n"
6122 "\n"
6123 "#line 2 0 \n"
6124 "\n"
6125 "out vec3 aMotionVec0;\n"
6126 "out vec3 aMotionVec1;\n"
6127 "\n"
6128 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
6129 "{\n"
6130 " // This magically solves some artifacting errors!\n"
6131 " //\n"
6132 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
6133 "\n"
6134 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
6135 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
6136 "}\n"
6137 "\n"
6138 "#line 6 0 \n"
6139 "\n"
6140 "uniform mat4x3 uMdl;\n"
6141 "uniform mat4 uPv;\n"
6142 "uniform mat4 uPvmPrev;\n"
6143 "\n"
6144 "out vec2 aUv;\n"
6145 "out vec4 aNorm;\n"
6146 "out vec3 aCo;\n"
6147 "out vec3 aWorldCo;\n"
6148 "\n"
6149 "void main()\n"
6150 "{\n"
6151 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
6152 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
6153 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
6154 "\n"
6155 " vs_motion_out( vproj0, vproj1 );\n"
6156 "\n"
6157 " gl_Position = vproj0;\n"
6158 "\n"
6159 " aUv = a_uv;\n"
6160 " aNorm = vec4( mat3(uMdl) * a_norm.xyz, a_norm.w );\n"
6161 " aCo = a_co;\n"
6162 " aWorldCo = world_pos0;\n"
6163 "}\n"
6164 ""},
6165 .fs =
6166 {
6167 .orig_file = "shaders/scene_water_fast.fs",
6168 .static_src =
6169 "uniform sampler2D uTexDudv;\n"
6170 "\n"
6171 "uniform float uTime;\n"
6172 "uniform vec3 uCamera;\n"
6173 "uniform float uSurfaceY;\n"
6174 "uniform vec3 uBoard0;\n"
6175 "uniform vec3 uBoard1;\n"
6176 "\n"
6177 "uniform vec3 uShoreColour;\n"
6178 "uniform vec3 uOceanColour;\n"
6179 "\n"
6180 "#line 1 1 \n"
6181 "// :D\n"
6182 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
6183 "\n"
6184 "#line 13 0 \n"
6185 "#line 1 2 \n"
6186 "// :D\n"
6187 "\n"
6188 "in vec2 aUv;\n"
6189 "in vec4 aNorm;\n"
6190 "in vec3 aCo;\n"
6191 "in vec3 aWorldCo;\n"
6192 "\n"
6193 "#line 1 1 \n"
6194 "layout (location = 0) out vec4 oColour;\n"
6195 "\n"
6196 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
6197 "layout (std140) uniform ub_world_lighting\n"
6198 "{\n"
6199 " vec4 g_cube_min;\n"
6200 " vec4 g_cube_inv_range;\n"
6201 "\n"
6202 " vec4 g_water_plane;\n"
6203 " vec4 g_depth_bounds;\n"
6204 "\n"
6205 " vec4 g_daysky_colour;\n"
6206 " vec4 g_nightsky_colour;\n"
6207 " vec4 g_sunset_colour;\n"
6208 " vec4 g_ambient_colour;\n"
6209 " vec4 g_sunset_ambient;\n"
6210 " vec4 g_sun_colour;\n"
6211 " vec4 g_sun_dir;\n"
6212 " vec4 g_board_0;\n"
6213 " vec4 g_board_1;\n"
6214 "\n"
6215 " float g_water_fog;\n"
6216 " float g_time;\n"
6217 " float g_realtime;\n"
6218 " float g_shadow_length;\n"
6219 " float g_shadow_spread;\n"
6220 "\n"
6221 " float g_time_of_day;\n"
6222 " float g_day_phase;\n"
6223 " float g_sunset_phase;\n"
6224 "\n"
6225 " int g_light_preview;\n"
6226 " int g_shadow_samples;\n"
6227 "\n"
6228 " int g_debug_indices;\n"
6229 " int g_debug_complexity;\n"
6230 "};\n"
6231 "\n"
6232 "uniform sampler2D g_world_depth;\n"
6233 "uniform samplerBuffer uLightsArray;\n"
6234 "uniform usampler3D uLightsIndex;\n"
6235 "\n"
6236 "#line 1 1 \n"
6237 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
6238 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
6239 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
6240 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
6241 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
6242 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
6243 "\n"
6244 "const float SUN_ANGLE = 0.0001;\n"
6245 "const float PI = 3.14159265358979323846264;\n"
6246 "\n"
6247 "//struct world_info\n"
6248 "//{\n"
6249 "// float time,\n"
6250 "// time_of_day,\n"
6251 "// day_phase,\n"
6252 "// sunset_phase;\n"
6253 "// \n"
6254 "// vec3 sun_dir;\n"
6255 "//};\n"
6256 "\n"
6257 "vec3 rand33(vec3 p3)\n"
6258 "{\n"
6259 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
6260 " p3 += dot(p3, p3.yxz+33.33);\n"
6261 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
6262 "}\n"
6263 "\n"
6264 "float stars( vec3 rd, float rr, float size ){\n"
6265 " vec3 co = rd * rr;\n"
6266 "\n"
6267 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
6268 "\n"
6269 " float spaces = 1.0 / rr;\n"
6270 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
6271 " a -= mod(a, spaces) - spaces * 0.5;\n"
6272 "\n"
6273 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
6274 " \n"
6275 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
6276 " plane = plane - mod(plane, PI / count);\n"
6277 "\n"
6278 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
6279 "\n"
6280 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
6281 " float ydist = sqrt(rr * rr - level * level);\n"
6282 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
6283 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
6284 " float star = smoothstep(size, 0.0, distance(center, co));\n"
6285 " return star;\n"
6286 "}\n"
6287 "\n"
6288 "float luminance( vec3 v )\n"
6289 "{\n"
6290 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
6291 "}\n"
6292 "\n"
6293 "vec3 clearskies_ambient( vec3 dir )\n"
6294 "{\n"
6295 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
6296 " float sky_gradient = dir.y;\n"
6297 " \n"
6298 " /* Blend phase colours */\n"
6299 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
6300 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
6301 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
6302 " \n"
6303 " /* Add gradient */\n"
6304 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
6305 " \n"
6306 " return ambient;\n"
6307 "}\n"
6308 "\n"
6309 "vec3 clearskies_sky( vec3 ray_dir )\n"
6310 "{\n"
6311 " ray_dir.y = abs( ray_dir.y );\n"
6312 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
6313 " \n"
6314 " /* Sun */\n"
6315 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
6316 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
6317 " float sun_shape = pow( sun_size, 2000.0 );\n"
6318 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
6319 " \n"
6320 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
6321 " sun_colour *= sun_shape;\n"
6322 "\n"
6323 " \n"
6324 " float star = 0.0;\n"
6325 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
6326 "\n"
6327 " if( star_blend > 0.001 ){\n"
6328 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
6329 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
6330 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
6331 " }\n"
6332 " }\n"
6333 " \n"
6334 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
6335 " return composite;\n"
6336 "}\n"
6337 "\n"
6338 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
6339 "{\n"
6340 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
6341 "\n"
6342 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
6343 " g_sunset_phase );\n"
6344 "\n"
6345 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
6346 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
6347 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
6348 " ) * g_sun_colour.rgb * g_day_phase;\n"
6349 "\n"
6350 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
6351 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
6352 " g_sunset_phase );\n"
6353 "\n"
6354 " return ambient + (light_sun + sky_reflection) * shadow;\n"
6355 "}\n"
6356 "\n"
6357 "#line 44 0 \n"
6358 "\n"
6359 "float world_depth_sample( vec3 pos )\n"
6360 "{\n"
6361 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
6362 " return texture( g_world_depth, depth_coord ).r;\n"
6363 "}\n"
6364 "\n"
6365 "float world_water_depth( vec3 pos )\n"
6366 "{\n"
6367 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
6368 " return world_depth_sample( pos ) - ref_depth;\n"
6369 "}\n"
6370 "\n"
6371 "float shadow_sample( vec3 co ){\n"
6372 " float height_sample = world_depth_sample( co );\n"
6373 "\n"
6374 " float fdelta = height_sample - co.y;\n"
6375 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
6376 "}\n"
6377 "\n"
6378 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
6379 " if( g_shadow_samples == 0 ){\n"
6380 " return 1.0;\n"
6381 " }\n"
6382 "\n"
6383 " float fspread = g_shadow_spread;\n"
6384 " float flength = g_shadow_length;\n"
6385 "\n"
6386 " float famt = 0.0;\n"
6387 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
6388 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
6389 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
6390 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
6391 "\n"
6392 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
6393 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
6394 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
6395 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
6396 "\n"
6397 " return 1.0 - famt;\n"
6398 "}\n"
6399 "\n"
6400 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
6401 "{\n"
6402 " vec3 specdir = reflect( -dir, wnormal );\n"
6403 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
6404 "}\n"
6405 "\n"
6406 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
6407 " float dist = pow(fdist*0.0010,0.78);\n"
6408 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
6409 "}\n"
6410 "\n"
6411 "vec3 scene_calculate_light( int light_index, \n"
6412 " vec3 halfview, vec3 co, vec3 normal )\n"
6413 "{\n"
6414 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
6415 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
6416 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
6417 "\n"
6418 " vec3 light_delta = light_co.xyz-co;\n"
6419 " float dist2 = dot(light_delta,light_delta);\n"
6420 "\n"
6421 " light_delta = normalize( light_delta );\n"
6422 "\n"
6423 " float quadratic = dist2*100.0;\n"
6424 " float attenuation = 1.0/( 1.0 + quadratic );\n"
6425 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
6426 "\n"
6427 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
6428 "\n"
6429 " if( light_dir.w < 0.999999 ){\n"
6430 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
6431 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
6432 " }\n"
6433 "\n"
6434 " return light_colour.rgb * attenuation * falloff \n"
6435 " * step( g_day_phase, light_colour.w );\n"
6436 "}\n"
6437 "\n"
6438 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
6439 " vec3 halfview, vec3 co, vec3 normal )\n"
6440 "{\n"
6441 " uint light_count = packed_index & 0x3u;\n"
6442 "\n"
6443 " vec3 l = vec3(0.0);\n"
6444 "\n"
6445 " if( light_count >= 1u ){\n"
6446 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
6447 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
6448 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
6449 "\n"
6450 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
6451 "\n"
6452 " if( light_count >= 2u ){\n"
6453 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
6454 "\n"
6455 " if( light_count >= 3u ){\n"
6456 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
6457 " }\n"
6458 " }\n"
6459 " }\n"
6460 "\n"
6461 " return l;\n"
6462 "}\n"
6463 "\n"
6464 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
6465 " float light_mask )\n"
6466 "{\n"
6467 " if( g_light_preview == 1 )\n"
6468 " diffuse = vec3(0.75);\n"
6469 "\n"
6470 " // Lighting\n"
6471 " vec3 halfview = uCamera - co;\n"
6472 " float fdist = length(halfview);\n"
6473 " halfview /= fdist;\n"
6474 "\n"
6475 " float world_shadow = newlight_compute_sun_shadow( \n"
6476 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
6477 "\n"
6478 " vec3 total_light = clearskies_lighting( \n"
6479 " normal, min( light_mask, world_shadow ), halfview );\n"
6480 "\n"
6481 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
6482 " cube_coord = floor( cube_coord );\n"
6483 "\n"
6484 " if( g_debug_indices == 1 )\n"
6485 " {\n"
6486 " return rand33(cube_coord);\n"
6487 " }\n"
6488 "\n"
6489 " if( g_debug_complexity == 1 )\n"
6490 " {\n"
6491 " ivec3 coord = ivec3( cube_coord );\n"
6492 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
6493 "\n"
6494 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
6495 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
6496 " }\n"
6497 "\n"
6498 " // FIXME: this coord should absolutely must be clamped!\n"
6499 " \n"
6500 " ivec3 coord = ivec3( cube_coord );\n"
6501 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
6502 "\n"
6503 " total_light += \n"
6504 " scene_calculate_packed_light_patch( index_sample.x,\n"
6505 " halfview, co, normal ) \n"
6506 " * light_mask;\n"
6507 " total_light += \n"
6508 " scene_calculate_packed_light_patch( index_sample.y,\n"
6509 " halfview, co, normal )\n"
6510 " * light_mask;\n"
6511 "\n"
6512 " // Take a section of the sky function to give us a matching fog colour\n"
6513 "\n"
6514 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
6515 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
6516 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
6517 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
6518 " \n"
6519 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
6520 " sun_colour *= sun_shape;\n"
6521 "\n"
6522 " fog_colour += sun_colour;\n"
6523 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
6524 "}\n"
6525 "\n"
6526 "#line 9 0 \n"
6527 "\n"
6528 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
6529 "{\n"
6530 " vec3 pa = p - a;\n"
6531 " vec3 ba = b - a;\n"
6532 "\n"
6533 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
6534 " return length( pa - ba*h );\n"
6535 "}\n"
6536 "\n"
6537 "float compute_board_shadow()\n"
6538 "{\n"
6539 " // player shadow\n"
6540 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
6541 " g_board_1.xyz )-0.1 );\n"
6542 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
6543 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
6544 "\n"
6545 " return 1.0 - player_shadow*0.8;\n"
6546 "}\n"
6547 "\n"
6548 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
6549 "{\n"
6550 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
6551 "}\n"
6552 "\n"
6553 "#line 14 0 \n"
6554 "#line 1 3 \n"
6555 "const float k_motion_lerp_amount = 0.01;\n"
6556 "\n"
6557 "#line 2 0 \n"
6558 "\n"
6559 "layout (location = 1) out vec2 oMotionVec;\n"
6560 "\n"
6561 "in vec3 aMotionVec0;\n"
6562 "in vec3 aMotionVec1;\n"
6563 "\n"
6564 "void compute_motion_vectors()\n"
6565 "{\n"
6566 " // Write motion vectors\n"
6567 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
6568 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
6569 "\n"
6570 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
6571 "}\n"
6572 "\n"
6573 "#line 15 0 \n"
6574 "\n"
6575 "vec4 water_surf( vec3 halfview, vec3 vnorm, float depthvalue )\n"
6576 "{\n"
6577 " vec3 surface_tint = mix(uShoreColour, uOceanColour, depthvalue);\n"
6578 "\n"
6579 " float ffresnel = pow(1.0-dot( vnorm, halfview ),5.0);\n"
6580 "\n"
6581 " vec3 lightdir = vec3(0.95,0.0,-0.3);\n"
6582 " vec3 specdir = reflect( -lightdir, vnorm );\n"
6583 " float spec = pow(max(dot(halfview,specdir),0.0),20.0)*0.3;\n"
6584 " \n"
6585 " return vec4( surface_tint + spec, max(min(depthvalue*4.0, 1.0),0.0) );\n"
6586 "}\n"
6587 "\n"
6588 "void main()\n"
6589 "{\n"
6590 " compute_motion_vectors();\n"
6591 "\n"
6592 " // Surface colour composite\n"
6593 " float depthvalue = clamp( -world_water_depth( aCo )*(1.0/25.0), 0.0, 1.0 );\n"
6594 "\n"
6595 " vec2 world_coord = aCo.xz * 0.008;\n"
6596 " vec4 time_offsets = vec4( uTime ) * vec4( 0.008, 0.006, 0.003, 0.03 );\n"
6597 " vec4 dudva = texture( uTexDudv, world_coord + time_offsets.xy )-0.5;\n"
6598 " vec4 dudvb = texture( uTexDudv, world_coord *7.0 - time_offsets.zw )-0.5;\n"
6599 "\n"
6600 " vec3 surfnorm = dudva.rgb + dudvb.rgb;\n"
6601 " surfnorm = normalize(vec3(0.0,1.0,0.0) + dudva.xyz*0.4 + dudvb.xyz*0.1);\n"
6602 " \n"
6603 " // Foam\n"
6604 " float fband = fract( aCo.z*0.02+uTime*0.1+depthvalue*10.0 );\n"
6605 " fband = step( fband+dudva.a*0.8, 0.3 ) * max((1.0-depthvalue*4.0),0.0);\n"
6606 "\n"
6607 " // Lighting\n"
6608 " vec3 halfview = -normalize( aCo-uCamera );\n"
6609 "\n"
6610 " // Fog\n"
6611 " float fdist = pow(length( aCo.xz-uCamera.xz ) * 0.00047, 2.6);\n"
6612 "\n"
6613 " // Composite\n"
6614 " vec4 vsurface = water_surf( halfview, surfnorm, depthvalue );\n"
6615 " vsurface.a -= fdist;\n"
6616 " oColour = mix( vsurface, vec4(1.0,1.0,1.0,0.5), fband );\n"
6617 " oColour.rgb = scene_compute_lighting( oColour.rgb, aNorm.xyz, aWorldCo );\n"
6618 "}\n"
6619 ""},
6620 };
6621
6622 GLuint _uniform_scene_water_fast_uMdl;
6623 GLuint _uniform_scene_water_fast_uPv;
6624 GLuint _uniform_scene_water_fast_uPvmPrev;
6625 GLuint _uniform_scene_water_fast_uTexDudv;
6626 GLuint _uniform_scene_water_fast_uTime;
6627 GLuint _uniform_scene_water_fast_uCamera;
6628 GLuint _uniform_scene_water_fast_uSurfaceY;
6629 GLuint _uniform_scene_water_fast_uBoard0;
6630 GLuint _uniform_scene_water_fast_uBoard1;
6631 GLuint _uniform_scene_water_fast_uShoreColour;
6632 GLuint _uniform_scene_water_fast_uOceanColour;
6633 GLuint _uniform_scene_water_fast_g_world_depth;
6634 GLuint _uniform_scene_water_fast_uLightsArray;
6635 GLuint _uniform_scene_water_fast_uLightsIndex;
6636 #include "shaders/scene_scoretext.h"
6637 struct vg_shader _shader_scene_scoretext = {
6638 .name = "scene_scoretext",
6639 .vs =
6640 {
6641 .orig_file = "shaders/scene_sfd.vs",
6642 .static_src =
6643 "layout (location=0) in vec3 a_co;\n"
6644 "layout (location=1) in vec4 a_norm;\n"
6645 "layout (location=2) in vec2 a_uv;\n"
6646 "\n"
6647 "#line 1 1 \n"
6648 "const float k_motion_lerp_amount = 0.01;\n"
6649 "\n"
6650 "#line 2 0 \n"
6651 "\n"
6652 "out vec3 aMotionVec0;\n"
6653 "out vec3 aMotionVec1;\n"
6654 "\n"
6655 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
6656 "{\n"
6657 " // This magically solves some artifacting errors!\n"
6658 " //\n"
6659 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
6660 "\n"
6661 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
6662 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
6663 "}\n"
6664 "\n"
6665 "#line 6 0 \n"
6666 "\n"
6667 "uniform mat4x3 uMdl;\n"
6668 "uniform mat4 uPv;\n"
6669 "uniform mat4 uPvmPrev;\n"
6670 "uniform vec3 uInfo;\n"
6671 "\n"
6672 "out vec2 aUv;\n"
6673 "out vec4 aNorm;\n"
6674 "out vec3 aCo;\n"
6675 "out vec3 aWorldCo;\n"
6676 "\n"
6677 "void main()\n"
6678 "{\n"
6679 " float w = ((a_norm.w)-0.5)*2.0 + fract(uInfo.z) - 0.0;\n"
6680 " float c = -cos(w*0.6);\n"
6681 " float s = -sin(w*0.6);\n"
6682 " float r = 0.2;\n"
6683 "\n"
6684 " float w1 = clamp( w*4.0 - a_co.y*10.0, -1.0, 1.0 ) * (3.14159265*0.5);\n"
6685 " float c1 = cos(w1);\n"
6686 " float s1 = sin(w1);\n"
6687 "\n"
6688 " float yoff = step(0.01,fract(uInfo.z))*-0.5;\n"
6689 "\n"
6690 " mat4x3 mlocal;\n"
6691 " mlocal[0] = vec3(c1, s1,0.0);\n"
6692 " mlocal[1] = vec3(-s1,c1,0.0);\n"
6693 " mlocal[2] = vec3(0.0,0.0,1.0);\n"
6694 " mlocal[3] = vec3(c*r,uInfo.y*0.875 + s*r,uInfo.x*0.5);\n"
6695 "\n"
6696 " vec3 local_pos0 = mlocal * vec4( a_co, 1.0 );\n"
6697 " vec3 world_pos0 = uMdl * vec4( local_pos0, 1.0 );\n"
6698 "\n"
6699 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
6700 " vec4 vproj1 = uPvmPrev * vec4( local_pos0, 1.0 );\n"
6701 "\n"
6702 " vs_motion_out( vproj0, vproj1 );\n"
6703 "\n"
6704 " gl_Position = vproj0;\n"
6705 "\n"
6706 " aUv = a_uv + vec2( floor(uInfo.z+0.5)*(1.0/64.0), yoff );\n"
6707 " aNorm = vec4( mat3(uMdl) * mat3(mlocal) * a_norm.xyz, a_norm.w );\n"
6708 " aCo = a_co;\n"
6709 " aWorldCo = world_pos0;\n"
6710 "}\n"
6711 ""},
6712 .fs =
6713 {
6714 .orig_file = "shaders/scene_standard.fs",
6715 .static_src =
6716 "uniform sampler2D uTexGarbage;\n"
6717 "uniform sampler2D uTexMain;\n"
6718 "uniform vec3 uCamera;\n"
6719 "uniform vec4 uPlane;\n"
6720 "\n"
6721 "#line 1 1 \n"
6722 "// :D\n"
6723 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
6724 "\n"
6725 "#line 7 0 \n"
6726 "#line 1 2 \n"
6727 "// :D\n"
6728 "\n"
6729 "in vec2 aUv;\n"
6730 "in vec4 aNorm;\n"
6731 "in vec3 aCo;\n"
6732 "in vec3 aWorldCo;\n"
6733 "\n"
6734 "#line 1 1 \n"
6735 "layout (location = 0) out vec4 oColour;\n"
6736 "\n"
6737 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
6738 "layout (std140) uniform ub_world_lighting\n"
6739 "{\n"
6740 " vec4 g_cube_min;\n"
6741 " vec4 g_cube_inv_range;\n"
6742 "\n"
6743 " vec4 g_water_plane;\n"
6744 " vec4 g_depth_bounds;\n"
6745 "\n"
6746 " vec4 g_daysky_colour;\n"
6747 " vec4 g_nightsky_colour;\n"
6748 " vec4 g_sunset_colour;\n"
6749 " vec4 g_ambient_colour;\n"
6750 " vec4 g_sunset_ambient;\n"
6751 " vec4 g_sun_colour;\n"
6752 " vec4 g_sun_dir;\n"
6753 " vec4 g_board_0;\n"
6754 " vec4 g_board_1;\n"
6755 "\n"
6756 " float g_water_fog;\n"
6757 " float g_time;\n"
6758 " float g_realtime;\n"
6759 " float g_shadow_length;\n"
6760 " float g_shadow_spread;\n"
6761 "\n"
6762 " float g_time_of_day;\n"
6763 " float g_day_phase;\n"
6764 " float g_sunset_phase;\n"
6765 "\n"
6766 " int g_light_preview;\n"
6767 " int g_shadow_samples;\n"
6768 "\n"
6769 " int g_debug_indices;\n"
6770 " int g_debug_complexity;\n"
6771 "};\n"
6772 "\n"
6773 "uniform sampler2D g_world_depth;\n"
6774 "uniform samplerBuffer uLightsArray;\n"
6775 "uniform usampler3D uLightsIndex;\n"
6776 "\n"
6777 "#line 1 1 \n"
6778 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
6779 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
6780 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
6781 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
6782 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
6783 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
6784 "\n"
6785 "const float SUN_ANGLE = 0.0001;\n"
6786 "const float PI = 3.14159265358979323846264;\n"
6787 "\n"
6788 "//struct world_info\n"
6789 "//{\n"
6790 "// float time,\n"
6791 "// time_of_day,\n"
6792 "// day_phase,\n"
6793 "// sunset_phase;\n"
6794 "// \n"
6795 "// vec3 sun_dir;\n"
6796 "//};\n"
6797 "\n"
6798 "vec3 rand33(vec3 p3)\n"
6799 "{\n"
6800 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
6801 " p3 += dot(p3, p3.yxz+33.33);\n"
6802 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
6803 "}\n"
6804 "\n"
6805 "float stars( vec3 rd, float rr, float size ){\n"
6806 " vec3 co = rd * rr;\n"
6807 "\n"
6808 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
6809 "\n"
6810 " float spaces = 1.0 / rr;\n"
6811 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
6812 " a -= mod(a, spaces) - spaces * 0.5;\n"
6813 "\n"
6814 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
6815 " \n"
6816 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
6817 " plane = plane - mod(plane, PI / count);\n"
6818 "\n"
6819 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
6820 "\n"
6821 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
6822 " float ydist = sqrt(rr * rr - level * level);\n"
6823 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
6824 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
6825 " float star = smoothstep(size, 0.0, distance(center, co));\n"
6826 " return star;\n"
6827 "}\n"
6828 "\n"
6829 "float luminance( vec3 v )\n"
6830 "{\n"
6831 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
6832 "}\n"
6833 "\n"
6834 "vec3 clearskies_ambient( vec3 dir )\n"
6835 "{\n"
6836 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
6837 " float sky_gradient = dir.y;\n"
6838 " \n"
6839 " /* Blend phase colours */\n"
6840 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
6841 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
6842 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
6843 " \n"
6844 " /* Add gradient */\n"
6845 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
6846 " \n"
6847 " return ambient;\n"
6848 "}\n"
6849 "\n"
6850 "vec3 clearskies_sky( vec3 ray_dir )\n"
6851 "{\n"
6852 " ray_dir.y = abs( ray_dir.y );\n"
6853 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
6854 " \n"
6855 " /* Sun */\n"
6856 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
6857 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
6858 " float sun_shape = pow( sun_size, 2000.0 );\n"
6859 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
6860 " \n"
6861 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
6862 " sun_colour *= sun_shape;\n"
6863 "\n"
6864 " \n"
6865 " float star = 0.0;\n"
6866 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
6867 "\n"
6868 " if( star_blend > 0.001 ){\n"
6869 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
6870 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
6871 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
6872 " }\n"
6873 " }\n"
6874 " \n"
6875 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
6876 " return composite;\n"
6877 "}\n"
6878 "\n"
6879 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
6880 "{\n"
6881 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
6882 "\n"
6883 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
6884 " g_sunset_phase );\n"
6885 "\n"
6886 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
6887 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
6888 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
6889 " ) * g_sun_colour.rgb * g_day_phase;\n"
6890 "\n"
6891 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
6892 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
6893 " g_sunset_phase );\n"
6894 "\n"
6895 " return ambient + (light_sun + sky_reflection) * shadow;\n"
6896 "}\n"
6897 "\n"
6898 "#line 44 0 \n"
6899 "\n"
6900 "float world_depth_sample( vec3 pos )\n"
6901 "{\n"
6902 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
6903 " return texture( g_world_depth, depth_coord ).r;\n"
6904 "}\n"
6905 "\n"
6906 "float world_water_depth( vec3 pos )\n"
6907 "{\n"
6908 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
6909 " return world_depth_sample( pos ) - ref_depth;\n"
6910 "}\n"
6911 "\n"
6912 "float shadow_sample( vec3 co ){\n"
6913 " float height_sample = world_depth_sample( co );\n"
6914 "\n"
6915 " float fdelta = height_sample - co.y;\n"
6916 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
6917 "}\n"
6918 "\n"
6919 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
6920 " if( g_shadow_samples == 0 ){\n"
6921 " return 1.0;\n"
6922 " }\n"
6923 "\n"
6924 " float fspread = g_shadow_spread;\n"
6925 " float flength = g_shadow_length;\n"
6926 "\n"
6927 " float famt = 0.0;\n"
6928 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
6929 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
6930 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
6931 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
6932 "\n"
6933 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
6934 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
6935 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
6936 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
6937 "\n"
6938 " return 1.0 - famt;\n"
6939 "}\n"
6940 "\n"
6941 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
6942 "{\n"
6943 " vec3 specdir = reflect( -dir, wnormal );\n"
6944 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
6945 "}\n"
6946 "\n"
6947 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
6948 " float dist = pow(fdist*0.0010,0.78);\n"
6949 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
6950 "}\n"
6951 "\n"
6952 "vec3 scene_calculate_light( int light_index, \n"
6953 " vec3 halfview, vec3 co, vec3 normal )\n"
6954 "{\n"
6955 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
6956 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
6957 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
6958 "\n"
6959 " vec3 light_delta = light_co.xyz-co;\n"
6960 " float dist2 = dot(light_delta,light_delta);\n"
6961 "\n"
6962 " light_delta = normalize( light_delta );\n"
6963 "\n"
6964 " float quadratic = dist2*100.0;\n"
6965 " float attenuation = 1.0/( 1.0 + quadratic );\n"
6966 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
6967 "\n"
6968 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
6969 "\n"
6970 " if( light_dir.w < 0.999999 ){\n"
6971 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
6972 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
6973 " }\n"
6974 "\n"
6975 " return light_colour.rgb * attenuation * falloff \n"
6976 " * step( g_day_phase, light_colour.w );\n"
6977 "}\n"
6978 "\n"
6979 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
6980 " vec3 halfview, vec3 co, vec3 normal )\n"
6981 "{\n"
6982 " uint light_count = packed_index & 0x3u;\n"
6983 "\n"
6984 " vec3 l = vec3(0.0);\n"
6985 "\n"
6986 " if( light_count >= 1u ){\n"
6987 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
6988 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
6989 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
6990 "\n"
6991 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
6992 "\n"
6993 " if( light_count >= 2u ){\n"
6994 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
6995 "\n"
6996 " if( light_count >= 3u ){\n"
6997 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
6998 " }\n"
6999 " }\n"
7000 " }\n"
7001 "\n"
7002 " return l;\n"
7003 "}\n"
7004 "\n"
7005 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
7006 " float light_mask )\n"
7007 "{\n"
7008 " if( g_light_preview == 1 )\n"
7009 " diffuse = vec3(0.75);\n"
7010 "\n"
7011 " // Lighting\n"
7012 " vec3 halfview = uCamera - co;\n"
7013 " float fdist = length(halfview);\n"
7014 " halfview /= fdist;\n"
7015 "\n"
7016 " float world_shadow = newlight_compute_sun_shadow( \n"
7017 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
7018 "\n"
7019 " vec3 total_light = clearskies_lighting( \n"
7020 " normal, min( light_mask, world_shadow ), halfview );\n"
7021 "\n"
7022 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
7023 " cube_coord = floor( cube_coord );\n"
7024 "\n"
7025 " if( g_debug_indices == 1 )\n"
7026 " {\n"
7027 " return rand33(cube_coord);\n"
7028 " }\n"
7029 "\n"
7030 " if( g_debug_complexity == 1 )\n"
7031 " {\n"
7032 " ivec3 coord = ivec3( cube_coord );\n"
7033 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
7034 "\n"
7035 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
7036 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
7037 " }\n"
7038 "\n"
7039 " // FIXME: this coord should absolutely must be clamped!\n"
7040 " \n"
7041 " ivec3 coord = ivec3( cube_coord );\n"
7042 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
7043 "\n"
7044 " total_light += \n"
7045 " scene_calculate_packed_light_patch( index_sample.x,\n"
7046 " halfview, co, normal ) \n"
7047 " * light_mask;\n"
7048 " total_light += \n"
7049 " scene_calculate_packed_light_patch( index_sample.y,\n"
7050 " halfview, co, normal )\n"
7051 " * light_mask;\n"
7052 "\n"
7053 " // Take a section of the sky function to give us a matching fog colour\n"
7054 "\n"
7055 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
7056 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
7057 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
7058 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
7059 " \n"
7060 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
7061 " sun_colour *= sun_shape;\n"
7062 "\n"
7063 " fog_colour += sun_colour;\n"
7064 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
7065 "}\n"
7066 "\n"
7067 "#line 9 0 \n"
7068 "\n"
7069 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
7070 "{\n"
7071 " vec3 pa = p - a;\n"
7072 " vec3 ba = b - a;\n"
7073 "\n"
7074 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
7075 " return length( pa - ba*h );\n"
7076 "}\n"
7077 "\n"
7078 "float compute_board_shadow()\n"
7079 "{\n"
7080 " // player shadow\n"
7081 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
7082 " g_board_1.xyz )-0.1 );\n"
7083 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
7084 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
7085 "\n"
7086 " return 1.0 - player_shadow*0.8;\n"
7087 "}\n"
7088 "\n"
7089 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
7090 "{\n"
7091 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
7092 "}\n"
7093 "\n"
7094 "#line 8 0 \n"
7095 "#line 1 3 \n"
7096 "const float k_motion_lerp_amount = 0.01;\n"
7097 "\n"
7098 "#line 2 0 \n"
7099 "\n"
7100 "layout (location = 1) out vec2 oMotionVec;\n"
7101 "\n"
7102 "in vec3 aMotionVec0;\n"
7103 "in vec3 aMotionVec1;\n"
7104 "\n"
7105 "void compute_motion_vectors()\n"
7106 "{\n"
7107 " // Write motion vectors\n"
7108 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
7109 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
7110 "\n"
7111 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
7112 "}\n"
7113 "\n"
7114 "#line 9 0 \n"
7115 "\n"
7116 "void main()\n"
7117 "{\n"
7118 " compute_motion_vectors();\n"
7119 "\n"
7120 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
7121 " vec4 vsamplemain = texture( uTexMain, aUv );\n"
7122 " vec3 qnorm = aNorm.xyz;\n"
7123 "\n"
7124 " vfrag = vsamplemain.rgb;\n"
7125 "\n"
7126 " if( g_light_preview == 1 )\n"
7127 " {\n"
7128 " vfrag = vec3(0.5);\n"
7129 " }\n"
7130 "\n"
7131 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
7132 " oColour = vec4( vfrag, 1.0 );\n"
7133 "}\n"
7134 ""},
7135 };
7136
7137 GLuint _uniform_scene_scoretext_uMdl;
7138 GLuint _uniform_scene_scoretext_uPv;
7139 GLuint _uniform_scene_scoretext_uPvmPrev;
7140 GLuint _uniform_scene_scoretext_uInfo;
7141 GLuint _uniform_scene_scoretext_uTexGarbage;
7142 GLuint _uniform_scene_scoretext_uTexMain;
7143 GLuint _uniform_scene_scoretext_uCamera;
7144 GLuint _uniform_scene_scoretext_uPlane;
7145 GLuint _uniform_scene_scoretext_g_world_depth;
7146 GLuint _uniform_scene_scoretext_uLightsArray;
7147 GLuint _uniform_scene_scoretext_uLightsIndex;
7148 #include "shaders/scene_font.h"
7149 struct vg_shader _shader_scene_font = {
7150 .name = "scene_font",
7151 .vs =
7152 {
7153 .orig_file = "shaders/model_font.vs",
7154 .static_src =
7155 "layout (location=0) in vec3 a_co;\n"
7156 "layout (location=1) in vec3 a_norm;\n"
7157 "layout (location=2) in vec2 a_uv;\n"
7158 "\n"
7159 "#line 1 1 \n"
7160 "const float k_motion_lerp_amount = 0.01;\n"
7161 "\n"
7162 "#line 2 0 \n"
7163 "\n"
7164 "out vec3 aMotionVec0;\n"
7165 "out vec3 aMotionVec1;\n"
7166 "\n"
7167 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
7168 "{\n"
7169 " // This magically solves some artifacting errors!\n"
7170 " //\n"
7171 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
7172 "\n"
7173 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
7174 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
7175 "}\n"
7176 "\n"
7177 "#line 6 0 \n"
7178 "\n"
7179 "uniform mat4x3 uMdl;\n"
7180 "uniform mat4 uPv;\n"
7181 "uniform mat4 uPvmPrev;\n"
7182 "uniform vec4 uOffset;\n"
7183 "\n"
7184 "out vec2 aUv;\n"
7185 "out vec4 aNorm;\n"
7186 "out vec3 aCo;\n"
7187 "out vec3 aWorldCo;\n"
7188 "\n"
7189 "void main()\n"
7190 "{\n"
7191 " vec3 co = a_co*uOffset.w+uOffset.xyz;\n"
7192 " vec3 world_pos0 = uMdl * vec4( co, 1.0 );\n"
7193 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
7194 " vec4 vproj1 = uPvmPrev * vec4( co, 1.0 );\n"
7195 "\n"
7196 " vs_motion_out( vproj0, vproj1 );\n"
7197 "\n"
7198 " gl_Position = vproj0;\n"
7199 "\n"
7200 " aUv = a_uv;\n"
7201 " aNorm = vec4( mat3(uMdl) * a_norm, 0.0 );\n"
7202 " aCo = co;\n"
7203 " aWorldCo = world_pos0;\n"
7204 "}\n"
7205 ""},
7206 .fs =
7207 {
7208 .orig_file = "shaders/scene_font.fs",
7209 .static_src =
7210 "uniform sampler2D uTexGarbage; // unused\n"
7211 "uniform sampler2D uTexMain; // unused\n"
7212 "uniform vec3 uCamera;\n"
7213 "uniform float uTime;\n"
7214 "uniform float uOpacity;\n"
7215 "uniform float uColourize;\n"
7216 "\n"
7217 "#line 1 1 \n"
7218 "// :D\n"
7219 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
7220 "\n"
7221 "#line 9 0 \n"
7222 "#line 1 2 \n"
7223 "// :D\n"
7224 "\n"
7225 "in vec2 aUv;\n"
7226 "in vec4 aNorm;\n"
7227 "in vec3 aCo;\n"
7228 "in vec3 aWorldCo;\n"
7229 "\n"
7230 "#line 1 1 \n"
7231 "layout (location = 0) out vec4 oColour;\n"
7232 "\n"
7233 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
7234 "layout (std140) uniform ub_world_lighting\n"
7235 "{\n"
7236 " vec4 g_cube_min;\n"
7237 " vec4 g_cube_inv_range;\n"
7238 "\n"
7239 " vec4 g_water_plane;\n"
7240 " vec4 g_depth_bounds;\n"
7241 "\n"
7242 " vec4 g_daysky_colour;\n"
7243 " vec4 g_nightsky_colour;\n"
7244 " vec4 g_sunset_colour;\n"
7245 " vec4 g_ambient_colour;\n"
7246 " vec4 g_sunset_ambient;\n"
7247 " vec4 g_sun_colour;\n"
7248 " vec4 g_sun_dir;\n"
7249 " vec4 g_board_0;\n"
7250 " vec4 g_board_1;\n"
7251 "\n"
7252 " float g_water_fog;\n"
7253 " float g_time;\n"
7254 " float g_realtime;\n"
7255 " float g_shadow_length;\n"
7256 " float g_shadow_spread;\n"
7257 "\n"
7258 " float g_time_of_day;\n"
7259 " float g_day_phase;\n"
7260 " float g_sunset_phase;\n"
7261 "\n"
7262 " int g_light_preview;\n"
7263 " int g_shadow_samples;\n"
7264 "\n"
7265 " int g_debug_indices;\n"
7266 " int g_debug_complexity;\n"
7267 "};\n"
7268 "\n"
7269 "uniform sampler2D g_world_depth;\n"
7270 "uniform samplerBuffer uLightsArray;\n"
7271 "uniform usampler3D uLightsIndex;\n"
7272 "\n"
7273 "#line 1 1 \n"
7274 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
7275 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
7276 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
7277 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
7278 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
7279 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
7280 "\n"
7281 "const float SUN_ANGLE = 0.0001;\n"
7282 "const float PI = 3.14159265358979323846264;\n"
7283 "\n"
7284 "//struct world_info\n"
7285 "//{\n"
7286 "// float time,\n"
7287 "// time_of_day,\n"
7288 "// day_phase,\n"
7289 "// sunset_phase;\n"
7290 "// \n"
7291 "// vec3 sun_dir;\n"
7292 "//};\n"
7293 "\n"
7294 "vec3 rand33(vec3 p3)\n"
7295 "{\n"
7296 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
7297 " p3 += dot(p3, p3.yxz+33.33);\n"
7298 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
7299 "}\n"
7300 "\n"
7301 "float stars( vec3 rd, float rr, float size ){\n"
7302 " vec3 co = rd * rr;\n"
7303 "\n"
7304 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
7305 "\n"
7306 " float spaces = 1.0 / rr;\n"
7307 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
7308 " a -= mod(a, spaces) - spaces * 0.5;\n"
7309 "\n"
7310 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
7311 " \n"
7312 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
7313 " plane = plane - mod(plane, PI / count);\n"
7314 "\n"
7315 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
7316 "\n"
7317 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
7318 " float ydist = sqrt(rr * rr - level * level);\n"
7319 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
7320 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
7321 " float star = smoothstep(size, 0.0, distance(center, co));\n"
7322 " return star;\n"
7323 "}\n"
7324 "\n"
7325 "float luminance( vec3 v )\n"
7326 "{\n"
7327 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
7328 "}\n"
7329 "\n"
7330 "vec3 clearskies_ambient( vec3 dir )\n"
7331 "{\n"
7332 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
7333 " float sky_gradient = dir.y;\n"
7334 " \n"
7335 " /* Blend phase colours */\n"
7336 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
7337 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
7338 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
7339 " \n"
7340 " /* Add gradient */\n"
7341 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
7342 " \n"
7343 " return ambient;\n"
7344 "}\n"
7345 "\n"
7346 "vec3 clearskies_sky( vec3 ray_dir )\n"
7347 "{\n"
7348 " ray_dir.y = abs( ray_dir.y );\n"
7349 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
7350 " \n"
7351 " /* Sun */\n"
7352 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
7353 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
7354 " float sun_shape = pow( sun_size, 2000.0 );\n"
7355 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
7356 " \n"
7357 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
7358 " sun_colour *= sun_shape;\n"
7359 "\n"
7360 " \n"
7361 " float star = 0.0;\n"
7362 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
7363 "\n"
7364 " if( star_blend > 0.001 ){\n"
7365 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
7366 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
7367 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
7368 " }\n"
7369 " }\n"
7370 " \n"
7371 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
7372 " return composite;\n"
7373 "}\n"
7374 "\n"
7375 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
7376 "{\n"
7377 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
7378 "\n"
7379 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
7380 " g_sunset_phase );\n"
7381 "\n"
7382 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
7383 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
7384 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
7385 " ) * g_sun_colour.rgb * g_day_phase;\n"
7386 "\n"
7387 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
7388 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
7389 " g_sunset_phase );\n"
7390 "\n"
7391 " return ambient + (light_sun + sky_reflection) * shadow;\n"
7392 "}\n"
7393 "\n"
7394 "#line 44 0 \n"
7395 "\n"
7396 "float world_depth_sample( vec3 pos )\n"
7397 "{\n"
7398 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
7399 " return texture( g_world_depth, depth_coord ).r;\n"
7400 "}\n"
7401 "\n"
7402 "float world_water_depth( vec3 pos )\n"
7403 "{\n"
7404 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
7405 " return world_depth_sample( pos ) - ref_depth;\n"
7406 "}\n"
7407 "\n"
7408 "float shadow_sample( vec3 co ){\n"
7409 " float height_sample = world_depth_sample( co );\n"
7410 "\n"
7411 " float fdelta = height_sample - co.y;\n"
7412 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
7413 "}\n"
7414 "\n"
7415 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
7416 " if( g_shadow_samples == 0 ){\n"
7417 " return 1.0;\n"
7418 " }\n"
7419 "\n"
7420 " float fspread = g_shadow_spread;\n"
7421 " float flength = g_shadow_length;\n"
7422 "\n"
7423 " float famt = 0.0;\n"
7424 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
7425 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
7426 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
7427 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
7428 "\n"
7429 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
7430 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
7431 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
7432 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
7433 "\n"
7434 " return 1.0 - famt;\n"
7435 "}\n"
7436 "\n"
7437 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
7438 "{\n"
7439 " vec3 specdir = reflect( -dir, wnormal );\n"
7440 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
7441 "}\n"
7442 "\n"
7443 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
7444 " float dist = pow(fdist*0.0010,0.78);\n"
7445 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
7446 "}\n"
7447 "\n"
7448 "vec3 scene_calculate_light( int light_index, \n"
7449 " vec3 halfview, vec3 co, vec3 normal )\n"
7450 "{\n"
7451 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
7452 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
7453 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
7454 "\n"
7455 " vec3 light_delta = light_co.xyz-co;\n"
7456 " float dist2 = dot(light_delta,light_delta);\n"
7457 "\n"
7458 " light_delta = normalize( light_delta );\n"
7459 "\n"
7460 " float quadratic = dist2*100.0;\n"
7461 " float attenuation = 1.0/( 1.0 + quadratic );\n"
7462 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
7463 "\n"
7464 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
7465 "\n"
7466 " if( light_dir.w < 0.999999 ){\n"
7467 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
7468 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
7469 " }\n"
7470 "\n"
7471 " return light_colour.rgb * attenuation * falloff \n"
7472 " * step( g_day_phase, light_colour.w );\n"
7473 "}\n"
7474 "\n"
7475 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
7476 " vec3 halfview, vec3 co, vec3 normal )\n"
7477 "{\n"
7478 " uint light_count = packed_index & 0x3u;\n"
7479 "\n"
7480 " vec3 l = vec3(0.0);\n"
7481 "\n"
7482 " if( light_count >= 1u ){\n"
7483 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
7484 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
7485 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
7486 "\n"
7487 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
7488 "\n"
7489 " if( light_count >= 2u ){\n"
7490 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
7491 "\n"
7492 " if( light_count >= 3u ){\n"
7493 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
7494 " }\n"
7495 " }\n"
7496 " }\n"
7497 "\n"
7498 " return l;\n"
7499 "}\n"
7500 "\n"
7501 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
7502 " float light_mask )\n"
7503 "{\n"
7504 " if( g_light_preview == 1 )\n"
7505 " diffuse = vec3(0.75);\n"
7506 "\n"
7507 " // Lighting\n"
7508 " vec3 halfview = uCamera - co;\n"
7509 " float fdist = length(halfview);\n"
7510 " halfview /= fdist;\n"
7511 "\n"
7512 " float world_shadow = newlight_compute_sun_shadow( \n"
7513 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
7514 "\n"
7515 " vec3 total_light = clearskies_lighting( \n"
7516 " normal, min( light_mask, world_shadow ), halfview );\n"
7517 "\n"
7518 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
7519 " cube_coord = floor( cube_coord );\n"
7520 "\n"
7521 " if( g_debug_indices == 1 )\n"
7522 " {\n"
7523 " return rand33(cube_coord);\n"
7524 " }\n"
7525 "\n"
7526 " if( g_debug_complexity == 1 )\n"
7527 " {\n"
7528 " ivec3 coord = ivec3( cube_coord );\n"
7529 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
7530 "\n"
7531 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
7532 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
7533 " }\n"
7534 "\n"
7535 " // FIXME: this coord should absolutely must be clamped!\n"
7536 " \n"
7537 " ivec3 coord = ivec3( cube_coord );\n"
7538 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
7539 "\n"
7540 " total_light += \n"
7541 " scene_calculate_packed_light_patch( index_sample.x,\n"
7542 " halfview, co, normal ) \n"
7543 " * light_mask;\n"
7544 " total_light += \n"
7545 " scene_calculate_packed_light_patch( index_sample.y,\n"
7546 " halfview, co, normal )\n"
7547 " * light_mask;\n"
7548 "\n"
7549 " // Take a section of the sky function to give us a matching fog colour\n"
7550 "\n"
7551 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
7552 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
7553 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
7554 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
7555 " \n"
7556 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
7557 " sun_colour *= sun_shape;\n"
7558 "\n"
7559 " fog_colour += sun_colour;\n"
7560 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
7561 "}\n"
7562 "\n"
7563 "#line 9 0 \n"
7564 "\n"
7565 "float sdLine( vec3 p, vec3 a, vec3 b )\n"
7566 "{\n"
7567 " vec3 pa = p - a;\n"
7568 " vec3 ba = b - a;\n"
7569 "\n"
7570 " float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n"
7571 " return length( pa - ba*h );\n"
7572 "}\n"
7573 "\n"
7574 "float compute_board_shadow()\n"
7575 "{\n"
7576 " // player shadow\n"
7577 " float dist_to_player = max( 0.0, sdLine( aWorldCo, g_board_0.xyz,\n"
7578 " g_board_1.xyz )-0.1 );\n"
7579 " float player_shadow = max( 1.0-dist_to_player*2.7, 0.0 );\n"
7580 " player_shadow *= player_shadow*player_shadow*player_shadow;\n"
7581 "\n"
7582 " return 1.0 - player_shadow*0.8;\n"
7583 "}\n"
7584 "\n"
7585 "vec3 scene_compute_lighting( vec3 diffuse, vec3 normal, vec3 co )\n"
7586 "{\n"
7587 " return world_compute_lighting( diffuse, normal, co, compute_board_shadow() );\n"
7588 "}\n"
7589 "\n"
7590 "#line 10 0 \n"
7591 "#line 1 3 \n"
7592 "const float k_motion_lerp_amount = 0.01;\n"
7593 "\n"
7594 "#line 2 0 \n"
7595 "\n"
7596 "layout (location = 1) out vec2 oMotionVec;\n"
7597 "\n"
7598 "in vec3 aMotionVec0;\n"
7599 "in vec3 aMotionVec1;\n"
7600 "\n"
7601 "void compute_motion_vectors()\n"
7602 "{\n"
7603 " // Write motion vectors\n"
7604 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
7605 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
7606 "\n"
7607 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
7608 "}\n"
7609 "\n"
7610 "#line 11 0 \n"
7611 "\n"
7612 "vec3 pal( float t ){\n"
7613 " vec3 a = vec3(0.30,0.3,0.3);\n"
7614 " vec3 b = vec3(0.8);\n"
7615 " vec3 c = vec3(0.28,0.3,0.4);\n"
7616 " vec3 d = vec3(0.00,0.1,0.1);\n"
7617 " return a + b*cos( 6.28318*(c*t+d) );\n"
7618 "}\n"
7619 "\n"
7620 "void main(){\n"
7621 " compute_motion_vectors();\n"
7622 " vec3 vfrag = vec3(0.5,0.5,0.5);\n"
7623 " vec3 qnorm = aNorm.xyz;\n"
7624 "\n"
7625 " //vec4 vsamplemain = texture( uTexMain, aUv );\n"
7626 " //vfrag = vsamplemain.rgb;\n"
7627 "\n"
7628 " vec4 spread0 = uTime*0.0002*vec4( 17.3,-19.6, 23.2,-47.7 );\n"
7629 " vec4 spread1 = uTime*0.0002*vec4( -13.3, 12.6,-28.2, 14.7 );\n"
7630 "\n"
7631 " vec2 p = aCo.xy + vec2(0.3);\n"
7632 " float a = atan( p.y/p.x );\n"
7633 " vec4 v0 = step( vec4(0.5), fract(vec4(a) + spread0) );\n"
7634 " vec4 v1 = step( vec4(0.5), fract(vec4(a) + spread1) );\n"
7635 "\n"
7636 " float d = ( v0.x+v0.y+v0.z+v0.w +\n"
7637 " v1.x+v1.y+v1.z+v1.w ) * 0.125;\n"
7638 " \n"
7639 " float dither = fract(dot(vec2(171.0,231.0),gl_FragCoord.xy)/71.0);\n"
7640 " float x = d*0.8+length(p)*0.3;\n"
7641 " x = (floor(x*8.0) + step(dither, fract(x * 8.0))) / 8.0;\n"
7642 "\n"
7643 " if( x + (uOpacity*2.0-1.0) < 0.5 ) \n"
7644 " discard;\n"
7645 "\n"
7646 " vfrag = mix( vec3(x), pal( x ), uColourize );\n"
7647 "\n"
7648 " if( g_light_preview == 1 ){\n"
7649 " vfrag = vec3(0.5);\n"
7650 " }\n"
7651 "\n"
7652 " vfrag = scene_compute_lighting( vfrag, qnorm, aWorldCo );\n"
7653 " oColour = vec4( vfrag, 1.0 );\n"
7654 "}\n"
7655 ""},
7656 };
7657
7658 GLuint _uniform_scene_font_uMdl;
7659 GLuint _uniform_scene_font_uPv;
7660 GLuint _uniform_scene_font_uPvmPrev;
7661 GLuint _uniform_scene_font_uOffset;
7662 GLuint _uniform_scene_font_uTexGarbage;
7663 GLuint _uniform_scene_font_uTexMain;
7664 GLuint _uniform_scene_font_uCamera;
7665 GLuint _uniform_scene_font_uTime;
7666 GLuint _uniform_scene_font_uOpacity;
7667 GLuint _uniform_scene_font_uColourize;
7668 GLuint _uniform_scene_font_g_world_depth;
7669 GLuint _uniform_scene_font_uLightsArray;
7670 GLuint _uniform_scene_font_uLightsIndex;
7671 #include "shaders/model_sky.h"
7672 struct vg_shader _shader_model_sky = {
7673 .name = "model_sky",
7674 .vs =
7675 {
7676 .orig_file = "shaders/model.vs",
7677 .static_src =
7678 "layout (location=0) in vec3 a_co;\n"
7679 "layout (location=1) in vec3 a_norm;\n"
7680 "layout (location=2) in vec2 a_uv;\n"
7681 "layout (location=3) in vec4 a_colour;\n"
7682 "layout (location=4) in vec4 a_weights;\n"
7683 "layout (location=5) in ivec4 a_groups;\n"
7684 "\n"
7685 "#line 1 1 \n"
7686 "const float k_motion_lerp_amount = 0.01;\n"
7687 "\n"
7688 "#line 2 0 \n"
7689 "\n"
7690 "out vec3 aMotionVec0;\n"
7691 "out vec3 aMotionVec1;\n"
7692 "\n"
7693 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
7694 "{\n"
7695 " // This magically solves some artifacting errors!\n"
7696 " //\n"
7697 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
7698 "\n"
7699 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
7700 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
7701 "}\n"
7702 "\n"
7703 "#line 9 0 \n"
7704 "\n"
7705 "uniform mat4x3 uMdl;\n"
7706 "uniform mat4 uPv;\n"
7707 "uniform mat4 uPvmPrev;\n"
7708 "\n"
7709 "out vec4 aColour;\n"
7710 "out vec2 aUv;\n"
7711 "out vec3 aNorm;\n"
7712 "out vec3 aCo;\n"
7713 "out vec3 aWorldCo;\n"
7714 "\n"
7715 "void main()\n"
7716 "{\n"
7717 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
7718 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
7719 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
7720 "\n"
7721 " vs_motion_out( vproj0, vproj1 );\n"
7722 "\n"
7723 " gl_Position = vproj0;\n"
7724 " aWorldCo = world_pos0;\n"
7725 " aColour = a_colour;\n"
7726 " aUv = a_uv;\n"
7727 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
7728 " aCo = a_co;\n"
7729 "}\n"
7730 ""},
7731 .fs =
7732 {
7733 .orig_file = "shaders/model_sky.fs",
7734 .static_src =
7735 "uniform sampler2D uTexGarbage;\n"
7736 "\n"
7737 "in vec4 aColour;\n"
7738 "in vec2 aUv;\n"
7739 "in vec3 aNorm;\n"
7740 "in vec3 aCo;\n"
7741 "in vec3 aWorldCo;\n"
7742 "\n"
7743 "// Spooky!\n"
7744 "const vec3 uCamera = vec3(0.0);\n"
7745 "\n"
7746 "#line 1 1 \n"
7747 "// :D\n"
7748 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
7749 "\n"
7750 "#line 13 0 \n"
7751 "#line 1 2 \n"
7752 "layout (location = 0) out vec4 oColour;\n"
7753 "\n"
7754 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
7755 "layout (std140) uniform ub_world_lighting\n"
7756 "{\n"
7757 " vec4 g_cube_min;\n"
7758 " vec4 g_cube_inv_range;\n"
7759 "\n"
7760 " vec4 g_water_plane;\n"
7761 " vec4 g_depth_bounds;\n"
7762 "\n"
7763 " vec4 g_daysky_colour;\n"
7764 " vec4 g_nightsky_colour;\n"
7765 " vec4 g_sunset_colour;\n"
7766 " vec4 g_ambient_colour;\n"
7767 " vec4 g_sunset_ambient;\n"
7768 " vec4 g_sun_colour;\n"
7769 " vec4 g_sun_dir;\n"
7770 " vec4 g_board_0;\n"
7771 " vec4 g_board_1;\n"
7772 "\n"
7773 " float g_water_fog;\n"
7774 " float g_time;\n"
7775 " float g_realtime;\n"
7776 " float g_shadow_length;\n"
7777 " float g_shadow_spread;\n"
7778 "\n"
7779 " float g_time_of_day;\n"
7780 " float g_day_phase;\n"
7781 " float g_sunset_phase;\n"
7782 "\n"
7783 " int g_light_preview;\n"
7784 " int g_shadow_samples;\n"
7785 "\n"
7786 " int g_debug_indices;\n"
7787 " int g_debug_complexity;\n"
7788 "};\n"
7789 "\n"
7790 "uniform sampler2D g_world_depth;\n"
7791 "uniform samplerBuffer uLightsArray;\n"
7792 "uniform usampler3D uLightsIndex;\n"
7793 "\n"
7794 "#line 1 1 \n"
7795 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
7796 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
7797 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
7798 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
7799 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
7800 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
7801 "\n"
7802 "const float SUN_ANGLE = 0.0001;\n"
7803 "const float PI = 3.14159265358979323846264;\n"
7804 "\n"
7805 "//struct world_info\n"
7806 "//{\n"
7807 "// float time,\n"
7808 "// time_of_day,\n"
7809 "// day_phase,\n"
7810 "// sunset_phase;\n"
7811 "// \n"
7812 "// vec3 sun_dir;\n"
7813 "//};\n"
7814 "\n"
7815 "vec3 rand33(vec3 p3)\n"
7816 "{\n"
7817 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
7818 " p3 += dot(p3, p3.yxz+33.33);\n"
7819 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
7820 "}\n"
7821 "\n"
7822 "float stars( vec3 rd, float rr, float size ){\n"
7823 " vec3 co = rd * rr;\n"
7824 "\n"
7825 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
7826 "\n"
7827 " float spaces = 1.0 / rr;\n"
7828 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
7829 " a -= mod(a, spaces) - spaces * 0.5;\n"
7830 "\n"
7831 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
7832 " \n"
7833 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
7834 " plane = plane - mod(plane, PI / count);\n"
7835 "\n"
7836 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
7837 "\n"
7838 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
7839 " float ydist = sqrt(rr * rr - level * level);\n"
7840 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
7841 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
7842 " float star = smoothstep(size, 0.0, distance(center, co));\n"
7843 " return star;\n"
7844 "}\n"
7845 "\n"
7846 "float luminance( vec3 v )\n"
7847 "{\n"
7848 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
7849 "}\n"
7850 "\n"
7851 "vec3 clearskies_ambient( vec3 dir )\n"
7852 "{\n"
7853 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
7854 " float sky_gradient = dir.y;\n"
7855 " \n"
7856 " /* Blend phase colours */\n"
7857 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
7858 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
7859 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
7860 " \n"
7861 " /* Add gradient */\n"
7862 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
7863 " \n"
7864 " return ambient;\n"
7865 "}\n"
7866 "\n"
7867 "vec3 clearskies_sky( vec3 ray_dir )\n"
7868 "{\n"
7869 " ray_dir.y = abs( ray_dir.y );\n"
7870 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
7871 " \n"
7872 " /* Sun */\n"
7873 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
7874 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
7875 " float sun_shape = pow( sun_size, 2000.0 );\n"
7876 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
7877 " \n"
7878 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
7879 " sun_colour *= sun_shape;\n"
7880 "\n"
7881 " \n"
7882 " float star = 0.0;\n"
7883 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
7884 "\n"
7885 " if( star_blend > 0.001 ){\n"
7886 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
7887 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
7888 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
7889 " }\n"
7890 " }\n"
7891 " \n"
7892 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
7893 " return composite;\n"
7894 "}\n"
7895 "\n"
7896 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
7897 "{\n"
7898 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
7899 "\n"
7900 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
7901 " g_sunset_phase );\n"
7902 "\n"
7903 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
7904 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
7905 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
7906 " ) * g_sun_colour.rgb * g_day_phase;\n"
7907 "\n"
7908 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
7909 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
7910 " g_sunset_phase );\n"
7911 "\n"
7912 " return ambient + (light_sun + sky_reflection) * shadow;\n"
7913 "}\n"
7914 "\n"
7915 "#line 44 0 \n"
7916 "\n"
7917 "float world_depth_sample( vec3 pos )\n"
7918 "{\n"
7919 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
7920 " return texture( g_world_depth, depth_coord ).r;\n"
7921 "}\n"
7922 "\n"
7923 "float world_water_depth( vec3 pos )\n"
7924 "{\n"
7925 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
7926 " return world_depth_sample( pos ) - ref_depth;\n"
7927 "}\n"
7928 "\n"
7929 "float shadow_sample( vec3 co ){\n"
7930 " float height_sample = world_depth_sample( co );\n"
7931 "\n"
7932 " float fdelta = height_sample - co.y;\n"
7933 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
7934 "}\n"
7935 "\n"
7936 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
7937 " if( g_shadow_samples == 0 ){\n"
7938 " return 1.0;\n"
7939 " }\n"
7940 "\n"
7941 " float fspread = g_shadow_spread;\n"
7942 " float flength = g_shadow_length;\n"
7943 "\n"
7944 " float famt = 0.0;\n"
7945 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
7946 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
7947 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
7948 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
7949 "\n"
7950 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
7951 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
7952 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
7953 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
7954 "\n"
7955 " return 1.0 - famt;\n"
7956 "}\n"
7957 "\n"
7958 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
7959 "{\n"
7960 " vec3 specdir = reflect( -dir, wnormal );\n"
7961 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
7962 "}\n"
7963 "\n"
7964 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
7965 " float dist = pow(fdist*0.0010,0.78);\n"
7966 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
7967 "}\n"
7968 "\n"
7969 "vec3 scene_calculate_light( int light_index, \n"
7970 " vec3 halfview, vec3 co, vec3 normal )\n"
7971 "{\n"
7972 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
7973 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
7974 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
7975 "\n"
7976 " vec3 light_delta = light_co.xyz-co;\n"
7977 " float dist2 = dot(light_delta,light_delta);\n"
7978 "\n"
7979 " light_delta = normalize( light_delta );\n"
7980 "\n"
7981 " float quadratic = dist2*100.0;\n"
7982 " float attenuation = 1.0/( 1.0 + quadratic );\n"
7983 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
7984 "\n"
7985 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
7986 "\n"
7987 " if( light_dir.w < 0.999999 ){\n"
7988 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
7989 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
7990 " }\n"
7991 "\n"
7992 " return light_colour.rgb * attenuation * falloff \n"
7993 " * step( g_day_phase, light_colour.w );\n"
7994 "}\n"
7995 "\n"
7996 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
7997 " vec3 halfview, vec3 co, vec3 normal )\n"
7998 "{\n"
7999 " uint light_count = packed_index & 0x3u;\n"
8000 "\n"
8001 " vec3 l = vec3(0.0);\n"
8002 "\n"
8003 " if( light_count >= 1u ){\n"
8004 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
8005 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
8006 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
8007 "\n"
8008 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
8009 "\n"
8010 " if( light_count >= 2u ){\n"
8011 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
8012 "\n"
8013 " if( light_count >= 3u ){\n"
8014 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
8015 " }\n"
8016 " }\n"
8017 " }\n"
8018 "\n"
8019 " return l;\n"
8020 "}\n"
8021 "\n"
8022 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
8023 " float light_mask )\n"
8024 "{\n"
8025 " if( g_light_preview == 1 )\n"
8026 " diffuse = vec3(0.75);\n"
8027 "\n"
8028 " // Lighting\n"
8029 " vec3 halfview = uCamera - co;\n"
8030 " float fdist = length(halfview);\n"
8031 " halfview /= fdist;\n"
8032 "\n"
8033 " float world_shadow = newlight_compute_sun_shadow( \n"
8034 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
8035 "\n"
8036 " vec3 total_light = clearskies_lighting( \n"
8037 " normal, min( light_mask, world_shadow ), halfview );\n"
8038 "\n"
8039 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
8040 " cube_coord = floor( cube_coord );\n"
8041 "\n"
8042 " if( g_debug_indices == 1 )\n"
8043 " {\n"
8044 " return rand33(cube_coord);\n"
8045 " }\n"
8046 "\n"
8047 " if( g_debug_complexity == 1 )\n"
8048 " {\n"
8049 " ivec3 coord = ivec3( cube_coord );\n"
8050 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
8051 "\n"
8052 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
8053 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
8054 " }\n"
8055 "\n"
8056 " // FIXME: this coord should absolutely must be clamped!\n"
8057 " \n"
8058 " ivec3 coord = ivec3( cube_coord );\n"
8059 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
8060 "\n"
8061 " total_light += \n"
8062 " scene_calculate_packed_light_patch( index_sample.x,\n"
8063 " halfview, co, normal ) \n"
8064 " * light_mask;\n"
8065 " total_light += \n"
8066 " scene_calculate_packed_light_patch( index_sample.y,\n"
8067 " halfview, co, normal )\n"
8068 " * light_mask;\n"
8069 "\n"
8070 " // Take a section of the sky function to give us a matching fog colour\n"
8071 "\n"
8072 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
8073 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
8074 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
8075 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
8076 " \n"
8077 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
8078 " sun_colour *= sun_shape;\n"
8079 "\n"
8080 " fog_colour += sun_colour;\n"
8081 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
8082 "}\n"
8083 "\n"
8084 "#line 14 0 \n"
8085 "#line 1 3 \n"
8086 "const float k_motion_lerp_amount = 0.01;\n"
8087 "\n"
8088 "#line 2 0 \n"
8089 "\n"
8090 "layout (location = 1) out vec2 oMotionVec;\n"
8091 "\n"
8092 "in vec3 aMotionVec0;\n"
8093 "in vec3 aMotionVec1;\n"
8094 "\n"
8095 "void compute_motion_vectors()\n"
8096 "{\n"
8097 " // Write motion vectors\n"
8098 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
8099 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
8100 "\n"
8101 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
8102 "}\n"
8103 "\n"
8104 "#line 15 0 \n"
8105 "\n"
8106 "void main()\n"
8107 "{\n"
8108 " compute_motion_vectors();\n"
8109 "\n"
8110 " vec3 rd = normalize(aNorm);\n"
8111 "\n"
8112 " float fmove = g_time * 5.0;\n"
8113 " vec2 cloudplane = (rd.xz / (rd.y*sign(rd.y))) * 0.025;\n"
8114 " vec4 clouds1 = texture( uTexGarbage, cloudplane + vec2(0.1,0.4)*fmove*2.0 );\n"
8115 " vec4 clouds2 = texture( uTexGarbage, cloudplane*2.0 + vec2(0.3,0.1)*fmove );\n"
8116 "\n"
8117 " float cloud_d = max(clouds1.b*clouds2.r -0.2 - clouds2.g*0.4,0.0);\n"
8118 " float cloud_e = pow(cloud_d,1.5)*pow(abs(rd.y),0.3)*2.0;\n"
8119 "\n"
8120 " oColour = vec4( clearskies_sky( -rd ) ,1.0);\n"
8121 "\n"
8122 " vec3 cloud_colour = mix( mix(g_nightsky_colour.rgb,vec3(1.0),g_day_phase), \n"
8123 " g_sunset_colour.rgb, g_sunset_phase );\n"
8124 "\n"
8125 " oColour.rgb = mix( oColour.rgb, cloud_colour, cloud_e );\n"
8126 "}\n"
8127 ""},
8128 };
8129
8130 GLuint _uniform_model_sky_uMdl;
8131 GLuint _uniform_model_sky_uPv;
8132 GLuint _uniform_model_sky_uPvmPrev;
8133 GLuint _uniform_model_sky_uTexGarbage;
8134 GLuint _uniform_model_sky_g_world_depth;
8135 GLuint _uniform_model_sky_uLightsArray;
8136 GLuint _uniform_model_sky_uLightsIndex;
8137 #include "shaders/model_sky_space.h"
8138 struct vg_shader _shader_model_sky_space = {
8139 .name = "model_sky_space",
8140 .vs =
8141 {
8142 .orig_file = "shaders/model.vs",
8143 .static_src =
8144 "layout (location=0) in vec3 a_co;\n"
8145 "layout (location=1) in vec3 a_norm;\n"
8146 "layout (location=2) in vec2 a_uv;\n"
8147 "layout (location=3) in vec4 a_colour;\n"
8148 "layout (location=4) in vec4 a_weights;\n"
8149 "layout (location=5) in ivec4 a_groups;\n"
8150 "\n"
8151 "#line 1 1 \n"
8152 "const float k_motion_lerp_amount = 0.01;\n"
8153 "\n"
8154 "#line 2 0 \n"
8155 "\n"
8156 "out vec3 aMotionVec0;\n"
8157 "out vec3 aMotionVec1;\n"
8158 "\n"
8159 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
8160 "{\n"
8161 " // This magically solves some artifacting errors!\n"
8162 " //\n"
8163 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
8164 "\n"
8165 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
8166 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
8167 "}\n"
8168 "\n"
8169 "#line 9 0 \n"
8170 "\n"
8171 "uniform mat4x3 uMdl;\n"
8172 "uniform mat4 uPv;\n"
8173 "uniform mat4 uPvmPrev;\n"
8174 "\n"
8175 "out vec4 aColour;\n"
8176 "out vec2 aUv;\n"
8177 "out vec3 aNorm;\n"
8178 "out vec3 aCo;\n"
8179 "out vec3 aWorldCo;\n"
8180 "\n"
8181 "void main()\n"
8182 "{\n"
8183 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
8184 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
8185 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
8186 "\n"
8187 " vs_motion_out( vproj0, vproj1 );\n"
8188 "\n"
8189 " gl_Position = vproj0;\n"
8190 " aWorldCo = world_pos0;\n"
8191 " aColour = a_colour;\n"
8192 " aUv = a_uv;\n"
8193 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
8194 " aCo = a_co;\n"
8195 "}\n"
8196 ""},
8197 .fs =
8198 {
8199 .orig_file = "shaders/model_sky_space.fs",
8200 .static_src =
8201 "uniform sampler2D uTexGarbage;\n"
8202 "\n"
8203 "in vec4 aColour;\n"
8204 "in vec2 aUv;\n"
8205 "in vec3 aNorm;\n"
8206 "in vec3 aCo;\n"
8207 "in vec3 aWorldCo;\n"
8208 "\n"
8209 "// Spooky!\n"
8210 "const vec3 uCamera = vec3(0.0);\n"
8211 "\n"
8212 "#line 1 1 \n"
8213 "// :D\n"
8214 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
8215 "\n"
8216 "#line 13 0 \n"
8217 "#line 1 2 \n"
8218 "layout (location = 0) out vec4 oColour;\n"
8219 "\n"
8220 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
8221 "layout (std140) uniform ub_world_lighting\n"
8222 "{\n"
8223 " vec4 g_cube_min;\n"
8224 " vec4 g_cube_inv_range;\n"
8225 "\n"
8226 " vec4 g_water_plane;\n"
8227 " vec4 g_depth_bounds;\n"
8228 "\n"
8229 " vec4 g_daysky_colour;\n"
8230 " vec4 g_nightsky_colour;\n"
8231 " vec4 g_sunset_colour;\n"
8232 " vec4 g_ambient_colour;\n"
8233 " vec4 g_sunset_ambient;\n"
8234 " vec4 g_sun_colour;\n"
8235 " vec4 g_sun_dir;\n"
8236 " vec4 g_board_0;\n"
8237 " vec4 g_board_1;\n"
8238 "\n"
8239 " float g_water_fog;\n"
8240 " float g_time;\n"
8241 " float g_realtime;\n"
8242 " float g_shadow_length;\n"
8243 " float g_shadow_spread;\n"
8244 "\n"
8245 " float g_time_of_day;\n"
8246 " float g_day_phase;\n"
8247 " float g_sunset_phase;\n"
8248 "\n"
8249 " int g_light_preview;\n"
8250 " int g_shadow_samples;\n"
8251 "\n"
8252 " int g_debug_indices;\n"
8253 " int g_debug_complexity;\n"
8254 "};\n"
8255 "\n"
8256 "uniform sampler2D g_world_depth;\n"
8257 "uniform samplerBuffer uLightsArray;\n"
8258 "uniform usampler3D uLightsIndex;\n"
8259 "\n"
8260 "#line 1 1 \n"
8261 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
8262 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
8263 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
8264 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
8265 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
8266 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
8267 "\n"
8268 "const float SUN_ANGLE = 0.0001;\n"
8269 "const float PI = 3.14159265358979323846264;\n"
8270 "\n"
8271 "//struct world_info\n"
8272 "//{\n"
8273 "// float time,\n"
8274 "// time_of_day,\n"
8275 "// day_phase,\n"
8276 "// sunset_phase;\n"
8277 "// \n"
8278 "// vec3 sun_dir;\n"
8279 "//};\n"
8280 "\n"
8281 "vec3 rand33(vec3 p3)\n"
8282 "{\n"
8283 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
8284 " p3 += dot(p3, p3.yxz+33.33);\n"
8285 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
8286 "}\n"
8287 "\n"
8288 "float stars( vec3 rd, float rr, float size ){\n"
8289 " vec3 co = rd * rr;\n"
8290 "\n"
8291 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
8292 "\n"
8293 " float spaces = 1.0 / rr;\n"
8294 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
8295 " a -= mod(a, spaces) - spaces * 0.5;\n"
8296 "\n"
8297 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
8298 " \n"
8299 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
8300 " plane = plane - mod(plane, PI / count);\n"
8301 "\n"
8302 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
8303 "\n"
8304 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
8305 " float ydist = sqrt(rr * rr - level * level);\n"
8306 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
8307 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
8308 " float star = smoothstep(size, 0.0, distance(center, co));\n"
8309 " return star;\n"
8310 "}\n"
8311 "\n"
8312 "float luminance( vec3 v )\n"
8313 "{\n"
8314 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
8315 "}\n"
8316 "\n"
8317 "vec3 clearskies_ambient( vec3 dir )\n"
8318 "{\n"
8319 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
8320 " float sky_gradient = dir.y;\n"
8321 " \n"
8322 " /* Blend phase colours */\n"
8323 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
8324 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
8325 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
8326 " \n"
8327 " /* Add gradient */\n"
8328 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
8329 " \n"
8330 " return ambient;\n"
8331 "}\n"
8332 "\n"
8333 "vec3 clearskies_sky( vec3 ray_dir )\n"
8334 "{\n"
8335 " ray_dir.y = abs( ray_dir.y );\n"
8336 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
8337 " \n"
8338 " /* Sun */\n"
8339 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
8340 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
8341 " float sun_shape = pow( sun_size, 2000.0 );\n"
8342 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
8343 " \n"
8344 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
8345 " sun_colour *= sun_shape;\n"
8346 "\n"
8347 " \n"
8348 " float star = 0.0;\n"
8349 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
8350 "\n"
8351 " if( star_blend > 0.001 ){\n"
8352 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
8353 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
8354 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
8355 " }\n"
8356 " }\n"
8357 " \n"
8358 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
8359 " return composite;\n"
8360 "}\n"
8361 "\n"
8362 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
8363 "{\n"
8364 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
8365 "\n"
8366 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
8367 " g_sunset_phase );\n"
8368 "\n"
8369 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
8370 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
8371 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
8372 " ) * g_sun_colour.rgb * g_day_phase;\n"
8373 "\n"
8374 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
8375 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
8376 " g_sunset_phase );\n"
8377 "\n"
8378 " return ambient + (light_sun + sky_reflection) * shadow;\n"
8379 "}\n"
8380 "\n"
8381 "#line 44 0 \n"
8382 "\n"
8383 "float world_depth_sample( vec3 pos )\n"
8384 "{\n"
8385 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
8386 " return texture( g_world_depth, depth_coord ).r;\n"
8387 "}\n"
8388 "\n"
8389 "float world_water_depth( vec3 pos )\n"
8390 "{\n"
8391 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
8392 " return world_depth_sample( pos ) - ref_depth;\n"
8393 "}\n"
8394 "\n"
8395 "float shadow_sample( vec3 co ){\n"
8396 " float height_sample = world_depth_sample( co );\n"
8397 "\n"
8398 " float fdelta = height_sample - co.y;\n"
8399 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
8400 "}\n"
8401 "\n"
8402 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
8403 " if( g_shadow_samples == 0 ){\n"
8404 " return 1.0;\n"
8405 " }\n"
8406 "\n"
8407 " float fspread = g_shadow_spread;\n"
8408 " float flength = g_shadow_length;\n"
8409 "\n"
8410 " float famt = 0.0;\n"
8411 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
8412 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
8413 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
8414 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
8415 "\n"
8416 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
8417 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
8418 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
8419 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
8420 "\n"
8421 " return 1.0 - famt;\n"
8422 "}\n"
8423 "\n"
8424 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
8425 "{\n"
8426 " vec3 specdir = reflect( -dir, wnormal );\n"
8427 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
8428 "}\n"
8429 "\n"
8430 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
8431 " float dist = pow(fdist*0.0010,0.78);\n"
8432 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
8433 "}\n"
8434 "\n"
8435 "vec3 scene_calculate_light( int light_index, \n"
8436 " vec3 halfview, vec3 co, vec3 normal )\n"
8437 "{\n"
8438 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
8439 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
8440 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
8441 "\n"
8442 " vec3 light_delta = light_co.xyz-co;\n"
8443 " float dist2 = dot(light_delta,light_delta);\n"
8444 "\n"
8445 " light_delta = normalize( light_delta );\n"
8446 "\n"
8447 " float quadratic = dist2*100.0;\n"
8448 " float attenuation = 1.0/( 1.0 + quadratic );\n"
8449 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
8450 "\n"
8451 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
8452 "\n"
8453 " if( light_dir.w < 0.999999 ){\n"
8454 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
8455 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
8456 " }\n"
8457 "\n"
8458 " return light_colour.rgb * attenuation * falloff \n"
8459 " * step( g_day_phase, light_colour.w );\n"
8460 "}\n"
8461 "\n"
8462 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
8463 " vec3 halfview, vec3 co, vec3 normal )\n"
8464 "{\n"
8465 " uint light_count = packed_index & 0x3u;\n"
8466 "\n"
8467 " vec3 l = vec3(0.0);\n"
8468 "\n"
8469 " if( light_count >= 1u ){\n"
8470 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
8471 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
8472 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
8473 "\n"
8474 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
8475 "\n"
8476 " if( light_count >= 2u ){\n"
8477 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
8478 "\n"
8479 " if( light_count >= 3u ){\n"
8480 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
8481 " }\n"
8482 " }\n"
8483 " }\n"
8484 "\n"
8485 " return l;\n"
8486 "}\n"
8487 "\n"
8488 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
8489 " float light_mask )\n"
8490 "{\n"
8491 " if( g_light_preview == 1 )\n"
8492 " diffuse = vec3(0.75);\n"
8493 "\n"
8494 " // Lighting\n"
8495 " vec3 halfview = uCamera - co;\n"
8496 " float fdist = length(halfview);\n"
8497 " halfview /= fdist;\n"
8498 "\n"
8499 " float world_shadow = newlight_compute_sun_shadow( \n"
8500 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
8501 "\n"
8502 " vec3 total_light = clearskies_lighting( \n"
8503 " normal, min( light_mask, world_shadow ), halfview );\n"
8504 "\n"
8505 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
8506 " cube_coord = floor( cube_coord );\n"
8507 "\n"
8508 " if( g_debug_indices == 1 )\n"
8509 " {\n"
8510 " return rand33(cube_coord);\n"
8511 " }\n"
8512 "\n"
8513 " if( g_debug_complexity == 1 )\n"
8514 " {\n"
8515 " ivec3 coord = ivec3( cube_coord );\n"
8516 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
8517 "\n"
8518 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
8519 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
8520 " }\n"
8521 "\n"
8522 " // FIXME: this coord should absolutely must be clamped!\n"
8523 " \n"
8524 " ivec3 coord = ivec3( cube_coord );\n"
8525 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
8526 "\n"
8527 " total_light += \n"
8528 " scene_calculate_packed_light_patch( index_sample.x,\n"
8529 " halfview, co, normal ) \n"
8530 " * light_mask;\n"
8531 " total_light += \n"
8532 " scene_calculate_packed_light_patch( index_sample.y,\n"
8533 " halfview, co, normal )\n"
8534 " * light_mask;\n"
8535 "\n"
8536 " // Take a section of the sky function to give us a matching fog colour\n"
8537 "\n"
8538 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
8539 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
8540 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
8541 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
8542 " \n"
8543 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
8544 " sun_colour *= sun_shape;\n"
8545 "\n"
8546 " fog_colour += sun_colour;\n"
8547 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
8548 "}\n"
8549 "\n"
8550 "#line 14 0 \n"
8551 "#line 1 3 \n"
8552 "const float k_motion_lerp_amount = 0.01;\n"
8553 "\n"
8554 "#line 2 0 \n"
8555 "\n"
8556 "layout (location = 1) out vec2 oMotionVec;\n"
8557 "\n"
8558 "in vec3 aMotionVec0;\n"
8559 "in vec3 aMotionVec1;\n"
8560 "\n"
8561 "void compute_motion_vectors()\n"
8562 "{\n"
8563 " // Write motion vectors\n"
8564 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
8565 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
8566 "\n"
8567 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
8568 "}\n"
8569 "\n"
8570 "#line 15 0 \n"
8571 "\n"
8572 "float stars1( vec3 rd, float rr, float size ){\n"
8573 " vec3 co = rd * rr;\n"
8574 "\n"
8575 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
8576 "\n"
8577 " float spaces = 1.0 / rr;\n"
8578 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
8579 " a -= mod(a, spaces) - spaces * 0.5;\n"
8580 "\n"
8581 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
8582 " \n"
8583 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
8584 " plane = plane - mod(plane, PI / count);\n"
8585 "\n"
8586 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
8587 "\n"
8588 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
8589 " float ydist = sqrt(rr * rr - level * level);\n"
8590 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
8591 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
8592 " float star = smoothstep(size, 0.0, distance(center, co));\n"
8593 " return star;\n"
8594 "}\n"
8595 "\n"
8596 "void main(){\n"
8597 " compute_motion_vectors();\n"
8598 "\n"
8599 " vec3 rd = -normalize(aNorm);\n"
8600 "\n"
8601 " float star = 0.0;\n"
8602 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
8603 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
8604 " star += stars( rd, 1.94 * pow( 1.64, j ), m ) * (1.0 / pow(4.0, j));\n"
8605 " }\n"
8606 "\n"
8607 " oColour = vec4( vec3(star*20.0), 1.0);\n"
8608 "}\n"
8609 ""},
8610 };
8611
8612 GLuint _uniform_model_sky_space_uMdl;
8613 GLuint _uniform_model_sky_space_uPv;
8614 GLuint _uniform_model_sky_space_uPvmPrev;
8615 GLuint _uniform_model_sky_space_uTexGarbage;
8616 GLuint _uniform_model_sky_space_g_world_depth;
8617 GLuint _uniform_model_sky_space_uLightsArray;
8618 GLuint _uniform_model_sky_space_uLightsIndex;
8619 #include "shaders/model_menu.h"
8620 struct vg_shader _shader_model_menu = {
8621 .name = "model_menu",
8622 .vs =
8623 {
8624 .orig_file = "shaders/model.vs",
8625 .static_src =
8626 "layout (location=0) in vec3 a_co;\n"
8627 "layout (location=1) in vec3 a_norm;\n"
8628 "layout (location=2) in vec2 a_uv;\n"
8629 "layout (location=3) in vec4 a_colour;\n"
8630 "layout (location=4) in vec4 a_weights;\n"
8631 "layout (location=5) in ivec4 a_groups;\n"
8632 "\n"
8633 "#line 1 1 \n"
8634 "const float k_motion_lerp_amount = 0.01;\n"
8635 "\n"
8636 "#line 2 0 \n"
8637 "\n"
8638 "out vec3 aMotionVec0;\n"
8639 "out vec3 aMotionVec1;\n"
8640 "\n"
8641 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
8642 "{\n"
8643 " // This magically solves some artifacting errors!\n"
8644 " //\n"
8645 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
8646 "\n"
8647 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
8648 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
8649 "}\n"
8650 "\n"
8651 "#line 9 0 \n"
8652 "\n"
8653 "uniform mat4x3 uMdl;\n"
8654 "uniform mat4 uPv;\n"
8655 "uniform mat4 uPvmPrev;\n"
8656 "\n"
8657 "out vec4 aColour;\n"
8658 "out vec2 aUv;\n"
8659 "out vec3 aNorm;\n"
8660 "out vec3 aCo;\n"
8661 "out vec3 aWorldCo;\n"
8662 "\n"
8663 "void main()\n"
8664 "{\n"
8665 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
8666 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
8667 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
8668 "\n"
8669 " vs_motion_out( vproj0, vproj1 );\n"
8670 "\n"
8671 " gl_Position = vproj0;\n"
8672 " aWorldCo = world_pos0;\n"
8673 " aColour = a_colour;\n"
8674 " aUv = a_uv;\n"
8675 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
8676 " aCo = a_co;\n"
8677 "}\n"
8678 ""},
8679 .fs =
8680 {
8681 .orig_file = "shaders/model_menu.fs",
8682 .static_src =
8683 "out vec4 FragColor;\n"
8684 "\n"
8685 "uniform sampler2D uTexMain;\n"
8686 "uniform vec4 uColour;\n"
8687 "\n"
8688 "in vec4 aColour;\n"
8689 "in vec2 aUv;\n"
8690 "in vec3 aNorm;\n"
8691 "in vec3 aCo;\n"
8692 "\n"
8693 "void main()\n"
8694 "{\n"
8695 " vec4 diffuse = texture( uTexMain, aUv );\n"
8696 "\n"
8697 " if( diffuse.a < 0.5 )\n"
8698 " discard;\n"
8699 "\n"
8700 " FragColor = vec4( diffuse.rgb, 1.0 ) * uColour;\n"
8701 "}\n"
8702 ""},
8703 };
8704
8705 GLuint _uniform_model_menu_uMdl;
8706 GLuint _uniform_model_menu_uPv;
8707 GLuint _uniform_model_menu_uPvmPrev;
8708 GLuint _uniform_model_menu_uTexMain;
8709 GLuint _uniform_model_menu_uColour;
8710 #include "shaders/model_character_view.h"
8711 struct vg_shader _shader_model_character_view = {
8712 .name = "model_character_view",
8713 .vs =
8714 {
8715 .orig_file = "shaders/model_skinned.vs",
8716 .static_src =
8717 "layout (location=0) in vec3 a_co;\n"
8718 "layout (location=1) in vec3 a_norm;\n"
8719 "layout (location=2) in vec2 a_uv;\n"
8720 "layout (location=3) in vec4 a_colour;\n"
8721 "layout (location=4) in vec4 a_weights;\n"
8722 "layout (location=5) in ivec4 a_groups;\n"
8723 "\n"
8724 "#line 1 1 \n"
8725 "const float k_motion_lerp_amount = 0.01;\n"
8726 "\n"
8727 "#line 2 0 \n"
8728 "\n"
8729 "out vec3 aMotionVec0;\n"
8730 "out vec3 aMotionVec1;\n"
8731 "\n"
8732 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
8733 "{\n"
8734 " // This magically solves some artifacting errors!\n"
8735 " //\n"
8736 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
8737 "\n"
8738 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
8739 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
8740 "}\n"
8741 "\n"
8742 "#line 9 0 \n"
8743 "\n"
8744 "uniform mat4 uPv;\n"
8745 "uniform mat4x3 uTransforms[32];\n"
8746 "\n"
8747 "out vec4 aColour;\n"
8748 "out vec2 aUv;\n"
8749 "out vec3 aNorm;\n"
8750 "out vec3 aCo;\n"
8751 "out vec3 aWorldCo;\n"
8752 "\n"
8753 "void main()\n"
8754 "{\n"
8755 " vec4 co_local = vec4( a_co, 1.0 );\n"
8756 " vec3 co0 = uTransforms[ a_groups[0] ] * co_local;\n"
8757 " vec3 co1 = uTransforms[ a_groups[1] ] * co_local;\n"
8758 " vec3 co2 = uTransforms[ a_groups[2] ] * co_local;\n"
8759 " vec3 n0 = mat3(uTransforms[ a_groups[0] ]) * a_norm;\n"
8760 " vec3 n1 = mat3(uTransforms[ a_groups[1] ]) * a_norm;\n"
8761 " vec3 n2 = mat3(uTransforms[ a_groups[2] ]) * a_norm;\n"
8762 "\n"
8763 " vec3 world_pos = co0*a_weights[0] + co1*a_weights[1] + co2*a_weights[2];\n"
8764 " vec3 world_normal = n0*a_weights[0] + n1*a_weights[1] + n2*a_weights[2];\n"
8765 " \n"
8766 " gl_Position = uPv * vec4( world_pos, 1.0 );\n"
8767 " aColour = a_colour;\n"
8768 " aUv = a_uv;\n"
8769 " aNorm = world_normal;\n"
8770 " aCo = a_co;\n"
8771 " aWorldCo = world_pos;\n"
8772 "\n"
8773 " // TODO: motion vectors\n"
8774 " aMotionVec0 = vec3(1.0);\n"
8775 " aMotionVec1 = vec3(1.0);\n"
8776 "}\n"
8777 ""},
8778 .fs =
8779 {
8780 .orig_file = "shaders/model_character_view.fs",
8781 .static_src =
8782 "uniform sampler2D uTexMain;\n"
8783 "uniform vec3 uCamera;\n"
8784 "\n"
8785 "in vec4 aColour;\n"
8786 "in vec2 aUv;\n"
8787 "in vec3 aNorm;\n"
8788 "in vec3 aCo;\n"
8789 "in vec3 aWorldCo;\n"
8790 "\n"
8791 "#line 1 1 \n"
8792 "// :D\n"
8793 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
8794 "\n"
8795 "#line 11 0 \n"
8796 "#line 1 2 \n"
8797 "layout (location = 0) out vec4 oColour;\n"
8798 "\n"
8799 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
8800 "layout (std140) uniform ub_world_lighting\n"
8801 "{\n"
8802 " vec4 g_cube_min;\n"
8803 " vec4 g_cube_inv_range;\n"
8804 "\n"
8805 " vec4 g_water_plane;\n"
8806 " vec4 g_depth_bounds;\n"
8807 "\n"
8808 " vec4 g_daysky_colour;\n"
8809 " vec4 g_nightsky_colour;\n"
8810 " vec4 g_sunset_colour;\n"
8811 " vec4 g_ambient_colour;\n"
8812 " vec4 g_sunset_ambient;\n"
8813 " vec4 g_sun_colour;\n"
8814 " vec4 g_sun_dir;\n"
8815 " vec4 g_board_0;\n"
8816 " vec4 g_board_1;\n"
8817 "\n"
8818 " float g_water_fog;\n"
8819 " float g_time;\n"
8820 " float g_realtime;\n"
8821 " float g_shadow_length;\n"
8822 " float g_shadow_spread;\n"
8823 "\n"
8824 " float g_time_of_day;\n"
8825 " float g_day_phase;\n"
8826 " float g_sunset_phase;\n"
8827 "\n"
8828 " int g_light_preview;\n"
8829 " int g_shadow_samples;\n"
8830 "\n"
8831 " int g_debug_indices;\n"
8832 " int g_debug_complexity;\n"
8833 "};\n"
8834 "\n"
8835 "uniform sampler2D g_world_depth;\n"
8836 "uniform samplerBuffer uLightsArray;\n"
8837 "uniform usampler3D uLightsIndex;\n"
8838 "\n"
8839 "#line 1 1 \n"
8840 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
8841 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
8842 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
8843 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
8844 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
8845 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
8846 "\n"
8847 "const float SUN_ANGLE = 0.0001;\n"
8848 "const float PI = 3.14159265358979323846264;\n"
8849 "\n"
8850 "//struct world_info\n"
8851 "//{\n"
8852 "// float time,\n"
8853 "// time_of_day,\n"
8854 "// day_phase,\n"
8855 "// sunset_phase;\n"
8856 "// \n"
8857 "// vec3 sun_dir;\n"
8858 "//};\n"
8859 "\n"
8860 "vec3 rand33(vec3 p3)\n"
8861 "{\n"
8862 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
8863 " p3 += dot(p3, p3.yxz+33.33);\n"
8864 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
8865 "}\n"
8866 "\n"
8867 "float stars( vec3 rd, float rr, float size ){\n"
8868 " vec3 co = rd * rr;\n"
8869 "\n"
8870 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
8871 "\n"
8872 " float spaces = 1.0 / rr;\n"
8873 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
8874 " a -= mod(a, spaces) - spaces * 0.5;\n"
8875 "\n"
8876 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
8877 " \n"
8878 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
8879 " plane = plane - mod(plane, PI / count);\n"
8880 "\n"
8881 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
8882 "\n"
8883 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
8884 " float ydist = sqrt(rr * rr - level * level);\n"
8885 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
8886 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
8887 " float star = smoothstep(size, 0.0, distance(center, co));\n"
8888 " return star;\n"
8889 "}\n"
8890 "\n"
8891 "float luminance( vec3 v )\n"
8892 "{\n"
8893 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
8894 "}\n"
8895 "\n"
8896 "vec3 clearskies_ambient( vec3 dir )\n"
8897 "{\n"
8898 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
8899 " float sky_gradient = dir.y;\n"
8900 " \n"
8901 " /* Blend phase colours */\n"
8902 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
8903 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
8904 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
8905 " \n"
8906 " /* Add gradient */\n"
8907 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
8908 " \n"
8909 " return ambient;\n"
8910 "}\n"
8911 "\n"
8912 "vec3 clearskies_sky( vec3 ray_dir )\n"
8913 "{\n"
8914 " ray_dir.y = abs( ray_dir.y );\n"
8915 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
8916 " \n"
8917 " /* Sun */\n"
8918 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
8919 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
8920 " float sun_shape = pow( sun_size, 2000.0 );\n"
8921 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
8922 " \n"
8923 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
8924 " sun_colour *= sun_shape;\n"
8925 "\n"
8926 " \n"
8927 " float star = 0.0;\n"
8928 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
8929 "\n"
8930 " if( star_blend > 0.001 ){\n"
8931 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
8932 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
8933 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
8934 " }\n"
8935 " }\n"
8936 " \n"
8937 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
8938 " return composite;\n"
8939 "}\n"
8940 "\n"
8941 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
8942 "{\n"
8943 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
8944 "\n"
8945 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
8946 " g_sunset_phase );\n"
8947 "\n"
8948 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
8949 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
8950 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
8951 " ) * g_sun_colour.rgb * g_day_phase;\n"
8952 "\n"
8953 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
8954 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
8955 " g_sunset_phase );\n"
8956 "\n"
8957 " return ambient + (light_sun + sky_reflection) * shadow;\n"
8958 "}\n"
8959 "\n"
8960 "#line 44 0 \n"
8961 "\n"
8962 "float world_depth_sample( vec3 pos )\n"
8963 "{\n"
8964 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
8965 " return texture( g_world_depth, depth_coord ).r;\n"
8966 "}\n"
8967 "\n"
8968 "float world_water_depth( vec3 pos )\n"
8969 "{\n"
8970 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
8971 " return world_depth_sample( pos ) - ref_depth;\n"
8972 "}\n"
8973 "\n"
8974 "float shadow_sample( vec3 co ){\n"
8975 " float height_sample = world_depth_sample( co );\n"
8976 "\n"
8977 " float fdelta = height_sample - co.y;\n"
8978 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
8979 "}\n"
8980 "\n"
8981 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
8982 " if( g_shadow_samples == 0 ){\n"
8983 " return 1.0;\n"
8984 " }\n"
8985 "\n"
8986 " float fspread = g_shadow_spread;\n"
8987 " float flength = g_shadow_length;\n"
8988 "\n"
8989 " float famt = 0.0;\n"
8990 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
8991 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
8992 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
8993 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
8994 "\n"
8995 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
8996 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
8997 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
8998 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
8999 "\n"
9000 " return 1.0 - famt;\n"
9001 "}\n"
9002 "\n"
9003 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
9004 "{\n"
9005 " vec3 specdir = reflect( -dir, wnormal );\n"
9006 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
9007 "}\n"
9008 "\n"
9009 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
9010 " float dist = pow(fdist*0.0010,0.78);\n"
9011 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
9012 "}\n"
9013 "\n"
9014 "vec3 scene_calculate_light( int light_index, \n"
9015 " vec3 halfview, vec3 co, vec3 normal )\n"
9016 "{\n"
9017 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
9018 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
9019 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
9020 "\n"
9021 " vec3 light_delta = light_co.xyz-co;\n"
9022 " float dist2 = dot(light_delta,light_delta);\n"
9023 "\n"
9024 " light_delta = normalize( light_delta );\n"
9025 "\n"
9026 " float quadratic = dist2*100.0;\n"
9027 " float attenuation = 1.0/( 1.0 + quadratic );\n"
9028 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
9029 "\n"
9030 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
9031 "\n"
9032 " if( light_dir.w < 0.999999 ){\n"
9033 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
9034 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
9035 " }\n"
9036 "\n"
9037 " return light_colour.rgb * attenuation * falloff \n"
9038 " * step( g_day_phase, light_colour.w );\n"
9039 "}\n"
9040 "\n"
9041 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
9042 " vec3 halfview, vec3 co, vec3 normal )\n"
9043 "{\n"
9044 " uint light_count = packed_index & 0x3u;\n"
9045 "\n"
9046 " vec3 l = vec3(0.0);\n"
9047 "\n"
9048 " if( light_count >= 1u ){\n"
9049 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
9050 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
9051 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
9052 "\n"
9053 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
9054 "\n"
9055 " if( light_count >= 2u ){\n"
9056 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
9057 "\n"
9058 " if( light_count >= 3u ){\n"
9059 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
9060 " }\n"
9061 " }\n"
9062 " }\n"
9063 "\n"
9064 " return l;\n"
9065 "}\n"
9066 "\n"
9067 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
9068 " float light_mask )\n"
9069 "{\n"
9070 " if( g_light_preview == 1 )\n"
9071 " diffuse = vec3(0.75);\n"
9072 "\n"
9073 " // Lighting\n"
9074 " vec3 halfview = uCamera - co;\n"
9075 " float fdist = length(halfview);\n"
9076 " halfview /= fdist;\n"
9077 "\n"
9078 " float world_shadow = newlight_compute_sun_shadow( \n"
9079 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
9080 "\n"
9081 " vec3 total_light = clearskies_lighting( \n"
9082 " normal, min( light_mask, world_shadow ), halfview );\n"
9083 "\n"
9084 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
9085 " cube_coord = floor( cube_coord );\n"
9086 "\n"
9087 " if( g_debug_indices == 1 )\n"
9088 " {\n"
9089 " return rand33(cube_coord);\n"
9090 " }\n"
9091 "\n"
9092 " if( g_debug_complexity == 1 )\n"
9093 " {\n"
9094 " ivec3 coord = ivec3( cube_coord );\n"
9095 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9096 "\n"
9097 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
9098 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
9099 " }\n"
9100 "\n"
9101 " // FIXME: this coord should absolutely must be clamped!\n"
9102 " \n"
9103 " ivec3 coord = ivec3( cube_coord );\n"
9104 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9105 "\n"
9106 " total_light += \n"
9107 " scene_calculate_packed_light_patch( index_sample.x,\n"
9108 " halfview, co, normal ) \n"
9109 " * light_mask;\n"
9110 " total_light += \n"
9111 " scene_calculate_packed_light_patch( index_sample.y,\n"
9112 " halfview, co, normal )\n"
9113 " * light_mask;\n"
9114 "\n"
9115 " // Take a section of the sky function to give us a matching fog colour\n"
9116 "\n"
9117 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
9118 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
9119 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
9120 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9121 " \n"
9122 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9123 " sun_colour *= sun_shape;\n"
9124 "\n"
9125 " fog_colour += sun_colour;\n"
9126 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
9127 "}\n"
9128 "\n"
9129 "#line 12 0 \n"
9130 "#line 1 3 \n"
9131 "const float k_motion_lerp_amount = 0.01;\n"
9132 "\n"
9133 "#line 2 0 \n"
9134 "\n"
9135 "layout (location = 1) out vec2 oMotionVec;\n"
9136 "\n"
9137 "in vec3 aMotionVec0;\n"
9138 "in vec3 aMotionVec1;\n"
9139 "\n"
9140 "void compute_motion_vectors()\n"
9141 "{\n"
9142 " // Write motion vectors\n"
9143 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
9144 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
9145 "\n"
9146 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
9147 "}\n"
9148 "\n"
9149 "#line 13 0 \n"
9150 "#line 1 4 \n"
9151 "uniform sampler2D uTexSceneDepth;\n"
9152 "uniform vec3 uInverseRatioDepth;\n"
9153 "uniform vec3 uInverseRatioMain;\n"
9154 "uniform int uDepthMode;\n"
9155 "uniform float uDitherCutoff;\n"
9156 "\n"
9157 "float linear_depth( float depth, float near, float far ) {\n"
9158 " float z = depth * 2.0 - 1.0;\n"
9159 " return (2.0 * near * far) / (far + near - z * (far - near)); \n"
9160 "}\n"
9161 "\n"
9162 "void depth_compare_dither()\n"
9163 "{\n"
9164 " if( uDepthMode == 1 )\n"
9165 " {\n"
9166 " vec2 back_coord = gl_FragCoord.xy * uInverseRatioMain.xy \n"
9167 " * uInverseRatioDepth.xy;\n"
9168 " float back_depth = texture( uTexSceneDepth, back_coord ).r;\n"
9169 " float front_depth = gl_FragCoord.z/gl_FragCoord.w;\n"
9170 "\n"
9171 " back_depth = linear_depth( back_depth, 0.1, 2100.0 );\n"
9172 " float diff = back_depth - front_depth;\n"
9173 "\n"
9174 " vec2 ssuv = gl_FragCoord.xy;\n"
9175 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
9176 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
9177 "\n"
9178 " if( step(0.0,diff)+dither<0.3 )\n"
9179 " discard;\n"
9180 " }\n"
9181 "\n"
9182 " if( uDepthMode == 2 )\n"
9183 " {\n"
9184 " vec2 ssuv = gl_FragCoord.xy;\n"
9185 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
9186 " float dither = fract( vDither.g / 71.0 );\n"
9187 " if( dither<uDitherCutoff ) discard;\n"
9188 " }\n"
9189 "}\n"
9190 "\n"
9191 "#line 14 0 \n"
9192 "\n"
9193 "vec3 character_clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
9194 "{\n"
9195 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
9196 "\n"
9197 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
9198 " g_sunset_phase );\n"
9199 "\n"
9200 "\n"
9201 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
9202 " vec3 light_sun = max(0.0, dot(normal,g_sun_dir.xyz)*0.5+0.5) \n"
9203 " * g_sun_colour.rgb * g_day_phase;\n"
9204 "\n"
9205 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
9206 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
9207 " g_sunset_phase );\n"
9208 "\n"
9209 " return ambient + (light_sun + sky_reflection) * shadow;\n"
9210 "}\n"
9211 "\n"
9212 "vec3 character_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
9213 " float light_mask )\n"
9214 "{\n"
9215 " if( g_light_preview == 1 )\n"
9216 " diffuse = vec3(0.75);\n"
9217 "\n"
9218 " // Lighting\n"
9219 " vec3 halfview = uCamera - co;\n"
9220 " float fdist = length(halfview);\n"
9221 " halfview /= fdist;\n"
9222 "\n"
9223 " float world_shadow = newlight_compute_sun_shadow( \n"
9224 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
9225 "\n"
9226 " vec3 total_light = character_clearskies_lighting( \n"
9227 " normal, min( light_mask, world_shadow ), halfview );\n"
9228 "\n"
9229 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
9230 " cube_coord = floor( cube_coord );\n"
9231 "\n"
9232 " if( g_debug_indices == 1 )\n"
9233 " {\n"
9234 " return rand33(cube_coord);\n"
9235 " }\n"
9236 "\n"
9237 " if( g_debug_complexity == 1 )\n"
9238 " {\n"
9239 " ivec3 coord = ivec3( cube_coord );\n"
9240 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9241 "\n"
9242 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
9243 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
9244 " }\n"
9245 "\n"
9246 " // FIXME: this coord should absolutely must be clamped!\n"
9247 " \n"
9248 " ivec3 coord = ivec3( cube_coord );\n"
9249 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9250 "\n"
9251 " total_light += \n"
9252 " scene_calculate_packed_light_patch( index_sample.x,\n"
9253 " halfview, co, normal ) \n"
9254 " * light_mask;\n"
9255 " total_light += \n"
9256 " scene_calculate_packed_light_patch( index_sample.y,\n"
9257 " halfview, co, normal )\n"
9258 " * light_mask;\n"
9259 "\n"
9260 " // Take a section of the sky function to give us a matching fog colour\n"
9261 "\n"
9262 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
9263 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
9264 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
9265 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9266 " \n"
9267 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9268 " sun_colour *= sun_shape;\n"
9269 "\n"
9270 " fog_colour += sun_colour;\n"
9271 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
9272 "}\n"
9273 "\n"
9274 "void main(){\n"
9275 " depth_compare_dither();\n"
9276 " compute_motion_vectors();\n"
9277 "\n"
9278 " vec3 qnorm = aNorm;\n"
9279 " vec3 diffuse = texture( uTexMain, aUv ).rgb;\n"
9280 " vec3 composite = character_compute_lighting( diffuse, qnorm, aWorldCo, 1.0 );\n"
9281 "\n"
9282 " float dist = distance( aWorldCo, uCamera ) - 0.08;\n"
9283 " float opacity = clamp( dist*dist, 0.0, 1.0 );\n"
9284 "\n"
9285 " oColour = vec4( composite, opacity );\n"
9286 "}\n"
9287 ""},
9288 };
9289
9290 GLuint _uniform_model_character_view_uPv;
9291 GLuint _uniform_model_character_view_uTransforms;
9292 GLuint _uniform_model_character_view_uTexMain;
9293 GLuint _uniform_model_character_view_uCamera;
9294 GLuint _uniform_model_character_view_g_world_depth;
9295 GLuint _uniform_model_character_view_uLightsArray;
9296 GLuint _uniform_model_character_view_uLightsIndex;
9297 GLuint _uniform_model_character_view_uTexSceneDepth;
9298 GLuint _uniform_model_character_view_uInverseRatioDepth;
9299 GLuint _uniform_model_character_view_uInverseRatioMain;
9300 GLuint _uniform_model_character_view_uDepthMode;
9301 GLuint _uniform_model_character_view_uDitherCutoff;
9302 #include "shaders/model_board_view.h"
9303 struct vg_shader _shader_model_board_view = {
9304 .name = "model_board_view",
9305 .vs =
9306 {
9307 .orig_file = "shaders/model.vs",
9308 .static_src =
9309 "layout (location=0) in vec3 a_co;\n"
9310 "layout (location=1) in vec3 a_norm;\n"
9311 "layout (location=2) in vec2 a_uv;\n"
9312 "layout (location=3) in vec4 a_colour;\n"
9313 "layout (location=4) in vec4 a_weights;\n"
9314 "layout (location=5) in ivec4 a_groups;\n"
9315 "\n"
9316 "#line 1 1 \n"
9317 "const float k_motion_lerp_amount = 0.01;\n"
9318 "\n"
9319 "#line 2 0 \n"
9320 "\n"
9321 "out vec3 aMotionVec0;\n"
9322 "out vec3 aMotionVec1;\n"
9323 "\n"
9324 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
9325 "{\n"
9326 " // This magically solves some artifacting errors!\n"
9327 " //\n"
9328 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
9329 "\n"
9330 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
9331 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
9332 "}\n"
9333 "\n"
9334 "#line 9 0 \n"
9335 "\n"
9336 "uniform mat4x3 uMdl;\n"
9337 "uniform mat4 uPv;\n"
9338 "uniform mat4 uPvmPrev;\n"
9339 "\n"
9340 "out vec4 aColour;\n"
9341 "out vec2 aUv;\n"
9342 "out vec3 aNorm;\n"
9343 "out vec3 aCo;\n"
9344 "out vec3 aWorldCo;\n"
9345 "\n"
9346 "void main()\n"
9347 "{\n"
9348 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
9349 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
9350 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
9351 "\n"
9352 " vs_motion_out( vproj0, vproj1 );\n"
9353 "\n"
9354 " gl_Position = vproj0;\n"
9355 " aWorldCo = world_pos0;\n"
9356 " aColour = a_colour;\n"
9357 " aUv = a_uv;\n"
9358 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
9359 " aCo = a_co;\n"
9360 "}\n"
9361 ""},
9362 .fs =
9363 {
9364 .orig_file = "shaders/model_character_view.fs",
9365 .static_src =
9366 "uniform sampler2D uTexMain;\n"
9367 "uniform vec3 uCamera;\n"
9368 "\n"
9369 "in vec4 aColour;\n"
9370 "in vec2 aUv;\n"
9371 "in vec3 aNorm;\n"
9372 "in vec3 aCo;\n"
9373 "in vec3 aWorldCo;\n"
9374 "\n"
9375 "#line 1 1 \n"
9376 "// :D\n"
9377 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
9378 "\n"
9379 "#line 11 0 \n"
9380 "#line 1 2 \n"
9381 "layout (location = 0) out vec4 oColour;\n"
9382 "\n"
9383 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
9384 "layout (std140) uniform ub_world_lighting\n"
9385 "{\n"
9386 " vec4 g_cube_min;\n"
9387 " vec4 g_cube_inv_range;\n"
9388 "\n"
9389 " vec4 g_water_plane;\n"
9390 " vec4 g_depth_bounds;\n"
9391 "\n"
9392 " vec4 g_daysky_colour;\n"
9393 " vec4 g_nightsky_colour;\n"
9394 " vec4 g_sunset_colour;\n"
9395 " vec4 g_ambient_colour;\n"
9396 " vec4 g_sunset_ambient;\n"
9397 " vec4 g_sun_colour;\n"
9398 " vec4 g_sun_dir;\n"
9399 " vec4 g_board_0;\n"
9400 " vec4 g_board_1;\n"
9401 "\n"
9402 " float g_water_fog;\n"
9403 " float g_time;\n"
9404 " float g_realtime;\n"
9405 " float g_shadow_length;\n"
9406 " float g_shadow_spread;\n"
9407 "\n"
9408 " float g_time_of_day;\n"
9409 " float g_day_phase;\n"
9410 " float g_sunset_phase;\n"
9411 "\n"
9412 " int g_light_preview;\n"
9413 " int g_shadow_samples;\n"
9414 "\n"
9415 " int g_debug_indices;\n"
9416 " int g_debug_complexity;\n"
9417 "};\n"
9418 "\n"
9419 "uniform sampler2D g_world_depth;\n"
9420 "uniform samplerBuffer uLightsArray;\n"
9421 "uniform usampler3D uLightsIndex;\n"
9422 "\n"
9423 "#line 1 1 \n"
9424 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
9425 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
9426 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
9427 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
9428 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
9429 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
9430 "\n"
9431 "const float SUN_ANGLE = 0.0001;\n"
9432 "const float PI = 3.14159265358979323846264;\n"
9433 "\n"
9434 "//struct world_info\n"
9435 "//{\n"
9436 "// float time,\n"
9437 "// time_of_day,\n"
9438 "// day_phase,\n"
9439 "// sunset_phase;\n"
9440 "// \n"
9441 "// vec3 sun_dir;\n"
9442 "//};\n"
9443 "\n"
9444 "vec3 rand33(vec3 p3)\n"
9445 "{\n"
9446 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
9447 " p3 += dot(p3, p3.yxz+33.33);\n"
9448 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
9449 "}\n"
9450 "\n"
9451 "float stars( vec3 rd, float rr, float size ){\n"
9452 " vec3 co = rd * rr;\n"
9453 "\n"
9454 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
9455 "\n"
9456 " float spaces = 1.0 / rr;\n"
9457 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
9458 " a -= mod(a, spaces) - spaces * 0.5;\n"
9459 "\n"
9460 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
9461 " \n"
9462 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
9463 " plane = plane - mod(plane, PI / count);\n"
9464 "\n"
9465 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
9466 "\n"
9467 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
9468 " float ydist = sqrt(rr * rr - level * level);\n"
9469 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
9470 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
9471 " float star = smoothstep(size, 0.0, distance(center, co));\n"
9472 " return star;\n"
9473 "}\n"
9474 "\n"
9475 "float luminance( vec3 v )\n"
9476 "{\n"
9477 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
9478 "}\n"
9479 "\n"
9480 "vec3 clearskies_ambient( vec3 dir )\n"
9481 "{\n"
9482 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
9483 " float sky_gradient = dir.y;\n"
9484 " \n"
9485 " /* Blend phase colours */\n"
9486 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
9487 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
9488 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
9489 " \n"
9490 " /* Add gradient */\n"
9491 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
9492 " \n"
9493 " return ambient;\n"
9494 "}\n"
9495 "\n"
9496 "vec3 clearskies_sky( vec3 ray_dir )\n"
9497 "{\n"
9498 " ray_dir.y = abs( ray_dir.y );\n"
9499 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
9500 " \n"
9501 " /* Sun */\n"
9502 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
9503 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
9504 " float sun_shape = pow( sun_size, 2000.0 );\n"
9505 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9506 " \n"
9507 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9508 " sun_colour *= sun_shape;\n"
9509 "\n"
9510 " \n"
9511 " float star = 0.0;\n"
9512 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
9513 "\n"
9514 " if( star_blend > 0.001 ){\n"
9515 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
9516 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
9517 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
9518 " }\n"
9519 " }\n"
9520 " \n"
9521 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
9522 " return composite;\n"
9523 "}\n"
9524 "\n"
9525 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
9526 "{\n"
9527 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
9528 "\n"
9529 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
9530 " g_sunset_phase );\n"
9531 "\n"
9532 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
9533 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
9534 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
9535 " ) * g_sun_colour.rgb * g_day_phase;\n"
9536 "\n"
9537 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
9538 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
9539 " g_sunset_phase );\n"
9540 "\n"
9541 " return ambient + (light_sun + sky_reflection) * shadow;\n"
9542 "}\n"
9543 "\n"
9544 "#line 44 0 \n"
9545 "\n"
9546 "float world_depth_sample( vec3 pos )\n"
9547 "{\n"
9548 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
9549 " return texture( g_world_depth, depth_coord ).r;\n"
9550 "}\n"
9551 "\n"
9552 "float world_water_depth( vec3 pos )\n"
9553 "{\n"
9554 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
9555 " return world_depth_sample( pos ) - ref_depth;\n"
9556 "}\n"
9557 "\n"
9558 "float shadow_sample( vec3 co ){\n"
9559 " float height_sample = world_depth_sample( co );\n"
9560 "\n"
9561 " float fdelta = height_sample - co.y;\n"
9562 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
9563 "}\n"
9564 "\n"
9565 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
9566 " if( g_shadow_samples == 0 ){\n"
9567 " return 1.0;\n"
9568 " }\n"
9569 "\n"
9570 " float fspread = g_shadow_spread;\n"
9571 " float flength = g_shadow_length;\n"
9572 "\n"
9573 " float famt = 0.0;\n"
9574 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
9575 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
9576 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
9577 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
9578 "\n"
9579 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
9580 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
9581 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
9582 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
9583 "\n"
9584 " return 1.0 - famt;\n"
9585 "}\n"
9586 "\n"
9587 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
9588 "{\n"
9589 " vec3 specdir = reflect( -dir, wnormal );\n"
9590 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
9591 "}\n"
9592 "\n"
9593 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
9594 " float dist = pow(fdist*0.0010,0.78);\n"
9595 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
9596 "}\n"
9597 "\n"
9598 "vec3 scene_calculate_light( int light_index, \n"
9599 " vec3 halfview, vec3 co, vec3 normal )\n"
9600 "{\n"
9601 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
9602 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
9603 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
9604 "\n"
9605 " vec3 light_delta = light_co.xyz-co;\n"
9606 " float dist2 = dot(light_delta,light_delta);\n"
9607 "\n"
9608 " light_delta = normalize( light_delta );\n"
9609 "\n"
9610 " float quadratic = dist2*100.0;\n"
9611 " float attenuation = 1.0/( 1.0 + quadratic );\n"
9612 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
9613 "\n"
9614 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
9615 "\n"
9616 " if( light_dir.w < 0.999999 ){\n"
9617 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
9618 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
9619 " }\n"
9620 "\n"
9621 " return light_colour.rgb * attenuation * falloff \n"
9622 " * step( g_day_phase, light_colour.w );\n"
9623 "}\n"
9624 "\n"
9625 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
9626 " vec3 halfview, vec3 co, vec3 normal )\n"
9627 "{\n"
9628 " uint light_count = packed_index & 0x3u;\n"
9629 "\n"
9630 " vec3 l = vec3(0.0);\n"
9631 "\n"
9632 " if( light_count >= 1u ){\n"
9633 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
9634 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
9635 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
9636 "\n"
9637 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
9638 "\n"
9639 " if( light_count >= 2u ){\n"
9640 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
9641 "\n"
9642 " if( light_count >= 3u ){\n"
9643 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
9644 " }\n"
9645 " }\n"
9646 " }\n"
9647 "\n"
9648 " return l;\n"
9649 "}\n"
9650 "\n"
9651 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
9652 " float light_mask )\n"
9653 "{\n"
9654 " if( g_light_preview == 1 )\n"
9655 " diffuse = vec3(0.75);\n"
9656 "\n"
9657 " // Lighting\n"
9658 " vec3 halfview = uCamera - co;\n"
9659 " float fdist = length(halfview);\n"
9660 " halfview /= fdist;\n"
9661 "\n"
9662 " float world_shadow = newlight_compute_sun_shadow( \n"
9663 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
9664 "\n"
9665 " vec3 total_light = clearskies_lighting( \n"
9666 " normal, min( light_mask, world_shadow ), halfview );\n"
9667 "\n"
9668 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
9669 " cube_coord = floor( cube_coord );\n"
9670 "\n"
9671 " if( g_debug_indices == 1 )\n"
9672 " {\n"
9673 " return rand33(cube_coord);\n"
9674 " }\n"
9675 "\n"
9676 " if( g_debug_complexity == 1 )\n"
9677 " {\n"
9678 " ivec3 coord = ivec3( cube_coord );\n"
9679 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9680 "\n"
9681 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
9682 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
9683 " }\n"
9684 "\n"
9685 " // FIXME: this coord should absolutely must be clamped!\n"
9686 " \n"
9687 " ivec3 coord = ivec3( cube_coord );\n"
9688 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9689 "\n"
9690 " total_light += \n"
9691 " scene_calculate_packed_light_patch( index_sample.x,\n"
9692 " halfview, co, normal ) \n"
9693 " * light_mask;\n"
9694 " total_light += \n"
9695 " scene_calculate_packed_light_patch( index_sample.y,\n"
9696 " halfview, co, normal )\n"
9697 " * light_mask;\n"
9698 "\n"
9699 " // Take a section of the sky function to give us a matching fog colour\n"
9700 "\n"
9701 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
9702 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
9703 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
9704 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9705 " \n"
9706 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9707 " sun_colour *= sun_shape;\n"
9708 "\n"
9709 " fog_colour += sun_colour;\n"
9710 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
9711 "}\n"
9712 "\n"
9713 "#line 12 0 \n"
9714 "#line 1 3 \n"
9715 "const float k_motion_lerp_amount = 0.01;\n"
9716 "\n"
9717 "#line 2 0 \n"
9718 "\n"
9719 "layout (location = 1) out vec2 oMotionVec;\n"
9720 "\n"
9721 "in vec3 aMotionVec0;\n"
9722 "in vec3 aMotionVec1;\n"
9723 "\n"
9724 "void compute_motion_vectors()\n"
9725 "{\n"
9726 " // Write motion vectors\n"
9727 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
9728 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
9729 "\n"
9730 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
9731 "}\n"
9732 "\n"
9733 "#line 13 0 \n"
9734 "#line 1 4 \n"
9735 "uniform sampler2D uTexSceneDepth;\n"
9736 "uniform vec3 uInverseRatioDepth;\n"
9737 "uniform vec3 uInverseRatioMain;\n"
9738 "uniform int uDepthMode;\n"
9739 "uniform float uDitherCutoff;\n"
9740 "\n"
9741 "float linear_depth( float depth, float near, float far ) {\n"
9742 " float z = depth * 2.0 - 1.0;\n"
9743 " return (2.0 * near * far) / (far + near - z * (far - near)); \n"
9744 "}\n"
9745 "\n"
9746 "void depth_compare_dither()\n"
9747 "{\n"
9748 " if( uDepthMode == 1 )\n"
9749 " {\n"
9750 " vec2 back_coord = gl_FragCoord.xy * uInverseRatioMain.xy \n"
9751 " * uInverseRatioDepth.xy;\n"
9752 " float back_depth = texture( uTexSceneDepth, back_coord ).r;\n"
9753 " float front_depth = gl_FragCoord.z/gl_FragCoord.w;\n"
9754 "\n"
9755 " back_depth = linear_depth( back_depth, 0.1, 2100.0 );\n"
9756 " float diff = back_depth - front_depth;\n"
9757 "\n"
9758 " vec2 ssuv = gl_FragCoord.xy;\n"
9759 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
9760 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
9761 "\n"
9762 " if( step(0.0,diff)+dither<0.3 )\n"
9763 " discard;\n"
9764 " }\n"
9765 "\n"
9766 " if( uDepthMode == 2 )\n"
9767 " {\n"
9768 " vec2 ssuv = gl_FragCoord.xy;\n"
9769 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
9770 " float dither = fract( vDither.g / 71.0 );\n"
9771 " if( dither<uDitherCutoff ) discard;\n"
9772 " }\n"
9773 "}\n"
9774 "\n"
9775 "#line 14 0 \n"
9776 "\n"
9777 "vec3 character_clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
9778 "{\n"
9779 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
9780 "\n"
9781 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
9782 " g_sunset_phase );\n"
9783 "\n"
9784 "\n"
9785 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
9786 " vec3 light_sun = max(0.0, dot(normal,g_sun_dir.xyz)*0.5+0.5) \n"
9787 " * g_sun_colour.rgb * g_day_phase;\n"
9788 "\n"
9789 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
9790 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
9791 " g_sunset_phase );\n"
9792 "\n"
9793 " return ambient + (light_sun + sky_reflection) * shadow;\n"
9794 "}\n"
9795 "\n"
9796 "vec3 character_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
9797 " float light_mask )\n"
9798 "{\n"
9799 " if( g_light_preview == 1 )\n"
9800 " diffuse = vec3(0.75);\n"
9801 "\n"
9802 " // Lighting\n"
9803 " vec3 halfview = uCamera - co;\n"
9804 " float fdist = length(halfview);\n"
9805 " halfview /= fdist;\n"
9806 "\n"
9807 " float world_shadow = newlight_compute_sun_shadow( \n"
9808 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
9809 "\n"
9810 " vec3 total_light = character_clearskies_lighting( \n"
9811 " normal, min( light_mask, world_shadow ), halfview );\n"
9812 "\n"
9813 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
9814 " cube_coord = floor( cube_coord );\n"
9815 "\n"
9816 " if( g_debug_indices == 1 )\n"
9817 " {\n"
9818 " return rand33(cube_coord);\n"
9819 " }\n"
9820 "\n"
9821 " if( g_debug_complexity == 1 )\n"
9822 " {\n"
9823 " ivec3 coord = ivec3( cube_coord );\n"
9824 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9825 "\n"
9826 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
9827 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
9828 " }\n"
9829 "\n"
9830 " // FIXME: this coord should absolutely must be clamped!\n"
9831 " \n"
9832 " ivec3 coord = ivec3( cube_coord );\n"
9833 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
9834 "\n"
9835 " total_light += \n"
9836 " scene_calculate_packed_light_patch( index_sample.x,\n"
9837 " halfview, co, normal ) \n"
9838 " * light_mask;\n"
9839 " total_light += \n"
9840 " scene_calculate_packed_light_patch( index_sample.y,\n"
9841 " halfview, co, normal )\n"
9842 " * light_mask;\n"
9843 "\n"
9844 " // Take a section of the sky function to give us a matching fog colour\n"
9845 "\n"
9846 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
9847 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
9848 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
9849 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
9850 " \n"
9851 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
9852 " sun_colour *= sun_shape;\n"
9853 "\n"
9854 " fog_colour += sun_colour;\n"
9855 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
9856 "}\n"
9857 "\n"
9858 "void main(){\n"
9859 " depth_compare_dither();\n"
9860 " compute_motion_vectors();\n"
9861 "\n"
9862 " vec3 qnorm = aNorm;\n"
9863 " vec3 diffuse = texture( uTexMain, aUv ).rgb;\n"
9864 " vec3 composite = character_compute_lighting( diffuse, qnorm, aWorldCo, 1.0 );\n"
9865 "\n"
9866 " float dist = distance( aWorldCo, uCamera ) - 0.08;\n"
9867 " float opacity = clamp( dist*dist, 0.0, 1.0 );\n"
9868 "\n"
9869 " oColour = vec4( composite, opacity );\n"
9870 "}\n"
9871 ""},
9872 };
9873
9874 GLuint _uniform_model_board_view_uMdl;
9875 GLuint _uniform_model_board_view_uPv;
9876 GLuint _uniform_model_board_view_uPvmPrev;
9877 GLuint _uniform_model_board_view_uTexMain;
9878 GLuint _uniform_model_board_view_uCamera;
9879 GLuint _uniform_model_board_view_g_world_depth;
9880 GLuint _uniform_model_board_view_uLightsArray;
9881 GLuint _uniform_model_board_view_uLightsIndex;
9882 GLuint _uniform_model_board_view_uTexSceneDepth;
9883 GLuint _uniform_model_board_view_uInverseRatioDepth;
9884 GLuint _uniform_model_board_view_uInverseRatioMain;
9885 GLuint _uniform_model_board_view_uDepthMode;
9886 GLuint _uniform_model_board_view_uDitherCutoff;
9887 #include "shaders/model_entity.h"
9888 struct vg_shader _shader_model_entity = {
9889 .name = "model_entity",
9890 .vs =
9891 {
9892 .orig_file = "shaders/model.vs",
9893 .static_src =
9894 "layout (location=0) in vec3 a_co;\n"
9895 "layout (location=1) in vec3 a_norm;\n"
9896 "layout (location=2) in vec2 a_uv;\n"
9897 "layout (location=3) in vec4 a_colour;\n"
9898 "layout (location=4) in vec4 a_weights;\n"
9899 "layout (location=5) in ivec4 a_groups;\n"
9900 "\n"
9901 "#line 1 1 \n"
9902 "const float k_motion_lerp_amount = 0.01;\n"
9903 "\n"
9904 "#line 2 0 \n"
9905 "\n"
9906 "out vec3 aMotionVec0;\n"
9907 "out vec3 aMotionVec1;\n"
9908 "\n"
9909 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
9910 "{\n"
9911 " // This magically solves some artifacting errors!\n"
9912 " //\n"
9913 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
9914 "\n"
9915 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
9916 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
9917 "}\n"
9918 "\n"
9919 "#line 9 0 \n"
9920 "\n"
9921 "uniform mat4x3 uMdl;\n"
9922 "uniform mat4 uPv;\n"
9923 "uniform mat4 uPvmPrev;\n"
9924 "\n"
9925 "out vec4 aColour;\n"
9926 "out vec2 aUv;\n"
9927 "out vec3 aNorm;\n"
9928 "out vec3 aCo;\n"
9929 "out vec3 aWorldCo;\n"
9930 "\n"
9931 "void main()\n"
9932 "{\n"
9933 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
9934 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
9935 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
9936 "\n"
9937 " vs_motion_out( vproj0, vproj1 );\n"
9938 "\n"
9939 " gl_Position = vproj0;\n"
9940 " aWorldCo = world_pos0;\n"
9941 " aColour = a_colour;\n"
9942 " aUv = a_uv;\n"
9943 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
9944 " aCo = a_co;\n"
9945 "}\n"
9946 ""},
9947 .fs =
9948 {
9949 .orig_file = "shaders/model_entity.fs",
9950 .static_src =
9951 "uniform sampler2D uTexMain;\n"
9952 "uniform vec3 uCamera;\n"
9953 "\n"
9954 "in vec4 aColour;\n"
9955 "in vec2 aUv;\n"
9956 "in vec3 aNorm;\n"
9957 "in vec3 aCo;\n"
9958 "in vec3 aWorldCo;\n"
9959 "\n"
9960 "#line 1 1 \n"
9961 "// :D\n"
9962 "const float CLEARSKIES_LIGHT_DOT_MIN = 0.0;\n"
9963 "\n"
9964 "#line 11 0 \n"
9965 "#line 1 2 \n"
9966 "layout (location = 0) out vec4 oColour;\n"
9967 "\n"
9968 "// OpenGL wiki: Recommends do not use vec3 because of drivers. hence the v4s...\n"
9969 "layout (std140) uniform ub_world_lighting\n"
9970 "{\n"
9971 " vec4 g_cube_min;\n"
9972 " vec4 g_cube_inv_range;\n"
9973 "\n"
9974 " vec4 g_water_plane;\n"
9975 " vec4 g_depth_bounds;\n"
9976 "\n"
9977 " vec4 g_daysky_colour;\n"
9978 " vec4 g_nightsky_colour;\n"
9979 " vec4 g_sunset_colour;\n"
9980 " vec4 g_ambient_colour;\n"
9981 " vec4 g_sunset_ambient;\n"
9982 " vec4 g_sun_colour;\n"
9983 " vec4 g_sun_dir;\n"
9984 " vec4 g_board_0;\n"
9985 " vec4 g_board_1;\n"
9986 "\n"
9987 " float g_water_fog;\n"
9988 " float g_time;\n"
9989 " float g_realtime;\n"
9990 " float g_shadow_length;\n"
9991 " float g_shadow_spread;\n"
9992 "\n"
9993 " float g_time_of_day;\n"
9994 " float g_day_phase;\n"
9995 " float g_sunset_phase;\n"
9996 "\n"
9997 " int g_light_preview;\n"
9998 " int g_shadow_samples;\n"
9999 "\n"
10000 " int g_debug_indices;\n"
10001 " int g_debug_complexity;\n"
10002 "};\n"
10003 "\n"
10004 "uniform sampler2D g_world_depth;\n"
10005 "uniform samplerBuffer uLightsArray;\n"
10006 "uniform usampler3D uLightsIndex;\n"
10007 "\n"
10008 "#line 1 1 \n"
10009 "//const vec3 DAYSKY_COLOUR = vec3( 0.37, 0.54, 0.97 );\n"
10010 "//const vec3 NIGHTSKY_COLOUR = vec3( 0.03, 0.05, 0.20 );\n"
10011 "//const vec3 SUNSET_COLOUR = vec3( 1.00, 0.32, 0.01 );\n"
10012 "//const vec3 AMBIENT_COLOUR = vec3( 0.13, 0.17, 0.35 );\n"
10013 "//const vec3 SUNSET_AMBIENT = vec3( 0.25, 0.17, 0.51 );\n"
10014 "//const vec3 SUN_COLOUR = vec3( 1.10, 0.89, 0.35 );\n"
10015 "\n"
10016 "const float SUN_ANGLE = 0.0001;\n"
10017 "const float PI = 3.14159265358979323846264;\n"
10018 "\n"
10019 "//struct world_info\n"
10020 "//{\n"
10021 "// float time,\n"
10022 "// time_of_day,\n"
10023 "// day_phase,\n"
10024 "// sunset_phase;\n"
10025 "// \n"
10026 "// vec3 sun_dir;\n"
10027 "//};\n"
10028 "\n"
10029 "vec3 rand33(vec3 p3)\n"
10030 "{\n"
10031 " p3 = fract(p3 * vec3(.1031, .1030, .0973));\n"
10032 " p3 += dot(p3, p3.yxz+33.33);\n"
10033 " return fract((p3.xxy + p3.yxx)*p3.zyx);\n"
10034 "}\n"
10035 "\n"
10036 "float stars( vec3 rd, float rr, float size ){\n"
10037 " vec3 co = rd * rr;\n"
10038 "\n"
10039 " float a = atan(co.y, length(co.xz)) + 4.0 * PI;\n"
10040 "\n"
10041 " float spaces = 1.0 / rr;\n"
10042 " size = (rr * 0.0015) * fwidth(a) * 1000.0 * size;\n"
10043 " a -= mod(a, spaces) - spaces * 0.5;\n"
10044 "\n"
10045 " float count = floor(sqrt(pow(rr, 2.0) * (1.0 - pow(sin(a), 2.0))) * 3.0);\n"
10046 " \n"
10047 " float plane = atan(co.z, co.x) + 4.0 * PI;\n"
10048 " plane = plane - mod(plane, PI / count);\n"
10049 "\n"
10050 " vec2 delta = rand33(vec3(plane, a, 0.0)).xy;\n"
10051 "\n"
10052 " float level = sin(a + spaces * (delta.y - 0.5) * (1.0 - size)) * rr;\n"
10053 " float ydist = sqrt(rr * rr - level * level);\n"
10054 " float angle = plane + (PI * (delta.x * (1.0-size) + size * 0.5) / count);\n"
10055 " vec3 center = vec3(cos(angle) * ydist, level, sin(angle) * ydist);\n"
10056 " float star = smoothstep(size, 0.0, distance(center, co));\n"
10057 " return star;\n"
10058 "}\n"
10059 "\n"
10060 "float luminance( vec3 v )\n"
10061 "{\n"
10062 " return dot( v, vec3(0.2126, 0.7052, 0.0722) );\n"
10063 "}\n"
10064 "\n"
10065 "vec3 clearskies_ambient( vec3 dir )\n"
10066 "{\n"
10067 " float sun_azimuth = g_sunset_phase * (dot( dir.xz, g_sun_dir.xz )*0.4+0.6);\n"
10068 " float sky_gradient = dir.y;\n"
10069 " \n"
10070 " /* Blend phase colours */\n"
10071 " vec3 ambient = g_daysky_colour.rgb * (g_day_phase-g_sunset_phase*0.1);\n"
10072 " ambient += g_sunset_colour.rgb * (1.0-dir.y*0.5)*sun_azimuth;\n"
10073 " ambient += g_nightsky_colour.rgb * (1.0-g_day_phase);\n"
10074 " \n"
10075 " /* Add gradient */\n"
10076 " ambient -= sky_gradient * luminance(ambient)*1.6;\n"
10077 " \n"
10078 " return ambient;\n"
10079 "}\n"
10080 "\n"
10081 "vec3 clearskies_sky( vec3 ray_dir )\n"
10082 "{\n"
10083 " ray_dir.y = abs( ray_dir.y );\n"
10084 " vec3 sky_colour = clearskies_ambient( ray_dir );\n"
10085 " \n"
10086 " /* Sun */\n"
10087 " float sun_theta = dot( ray_dir, g_sun_dir.xyz );\n"
10088 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 + SUN_ANGLE );\n"
10089 " float sun_shape = pow( sun_size, 2000.0 );\n"
10090 " sun_shape += sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
10091 " \n"
10092 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
10093 " sun_colour *= sun_shape;\n"
10094 "\n"
10095 " \n"
10096 " float star = 0.0;\n"
10097 " float star_blend = 10.0*max(0.0,(1.0-g_day_phase*2.0));\n"
10098 "\n"
10099 " if( star_blend > 0.001 ){\n"
10100 " for( float j = 1.0; j <= 4.1; j += 1.0 ){\n"
10101 " float m = mix(0.6, 0.9, smoothstep(1.0, 2.0, j));\n"
10102 " star += stars( ray_dir, 1.94 * pow( 1.64, j ), m ) * (1.0/pow(4.0, j));\n"
10103 " }\n"
10104 " }\n"
10105 " \n"
10106 " vec3 composite = sky_colour + sun_colour + star*star_blend;\n"
10107 " return composite;\n"
10108 "}\n"
10109 "\n"
10110 "vec3 clearskies_lighting( vec3 normal, float shadow, vec3 halfview )\n"
10111 "{\n"
10112 " float fresnel = 1.0 - abs(dot(normal,halfview));\n"
10113 "\n"
10114 " vec3 reflect_colour = mix( g_daysky_colour.rgb, g_sunset_colour.rgb, \n"
10115 " g_sunset_phase );\n"
10116 "\n"
10117 " vec3 sky_reflection = 0.5 * fresnel * reflect_colour;\n"
10118 " vec3 light_sun = max( CLEARSKIES_LIGHT_DOT_MIN, \n"
10119 " dot(normal,g_sun_dir.xyz)*0.75+0.25\n"
10120 " ) * g_sun_colour.rgb * g_day_phase;\n"
10121 "\n"
10122 " float scaled_shadow = max( shadow, 1.0 - max(g_sun_dir.y,0.0) );\n"
10123 " vec3 ambient = mix( g_ambient_colour.rgb, g_sunset_ambient.rgb, \n"
10124 " g_sunset_phase );\n"
10125 "\n"
10126 " return ambient + (light_sun + sky_reflection) * shadow;\n"
10127 "}\n"
10128 "\n"
10129 "#line 44 0 \n"
10130 "\n"
10131 "float world_depth_sample( vec3 pos )\n"
10132 "{\n"
10133 " vec2 depth_coord = (pos.xz - g_depth_bounds.xy) * g_depth_bounds.zw; \n"
10134 " return texture( g_world_depth, depth_coord ).r;\n"
10135 "}\n"
10136 "\n"
10137 "float world_water_depth( vec3 pos )\n"
10138 "{\n"
10139 " float ref_depth = g_water_plane.y*g_water_plane.w;\n"
10140 " return world_depth_sample( pos ) - ref_depth;\n"
10141 "}\n"
10142 "\n"
10143 "float shadow_sample( vec3 co ){\n"
10144 " float height_sample = world_depth_sample( co );\n"
10145 "\n"
10146 " float fdelta = height_sample - co.y;\n"
10147 " return clamp( fdelta, 0.2, 0.4 )-0.2;\n"
10148 "}\n"
10149 "\n"
10150 "float newlight_compute_sun_shadow( vec3 co, vec3 dir ){\n"
10151 " if( g_shadow_samples == 0 ){\n"
10152 " return 1.0;\n"
10153 " }\n"
10154 "\n"
10155 " float fspread = g_shadow_spread;\n"
10156 " float flength = g_shadow_length;\n"
10157 "\n"
10158 " float famt = 0.0;\n"
10159 " famt += shadow_sample(co+(dir+vec3(-0.56,0.55, 0.30)*fspread)*flength*0.1);\n"
10160 " famt += shadow_sample(co+(dir+vec3( 0.80,0.68, 0.34)*fspread)*flength*0.2);\n"
10161 " famt += shadow_sample(co+(dir+vec3( 0.78,0.07,-0.06)*fspread)*flength*0.3);\n"
10162 " famt += shadow_sample(co+(dir+vec3(-0.59,0.07,-0.42)*fspread)*flength*0.4);\n"
10163 "\n"
10164 " //famt+=shadow_sample(co+(dir+vec3(-0.790,-0.933,-0.875)*fspread)*flength*0.5);\n"
10165 " //famt+=shadow_sample(co+(dir+vec3( 0.807,-0.690, 0.472)*fspread)*flength*0.6);\n"
10166 " //famt+=shadow_sample(co+(dir+vec3( 0.522,-0.379, 0.350)*fspread)*flength*0.7);\n"
10167 " //famt+=shadow_sample(co+(dir+vec3( 0.483, 0.201, 0.306)*fspread)*flength*0.8);\n"
10168 "\n"
10169 " return 1.0 - famt;\n"
10170 "}\n"
10171 "\n"
10172 "float newlight_specular( vec3 wnormal, vec3 dir, vec3 halfview, float exponent )\n"
10173 "{\n"
10174 " vec3 specdir = reflect( -dir, wnormal );\n"
10175 " return pow(max(dot( halfview, specdir ), 0.0), exponent);\n"
10176 "}\n"
10177 "\n"
10178 "vec3 scene_apply_fog( vec3 vfrag, vec3 colour, float fdist ){\n"
10179 " float dist = pow(fdist*0.0010,0.78);\n"
10180 " return mix( vfrag, colour, min( 1.0, dist ) );\n"
10181 "}\n"
10182 "\n"
10183 "vec3 scene_calculate_light( int light_index, \n"
10184 " vec3 halfview, vec3 co, vec3 normal )\n"
10185 "{\n"
10186 " vec4 light_colour = texelFetch( uLightsArray, light_index+0 );\n"
10187 " vec4 light_co = texelFetch( uLightsArray, light_index+1 );\n"
10188 " vec4 light_dir = texelFetch( uLightsArray, light_index+2 );\n"
10189 "\n"
10190 " vec3 light_delta = light_co.xyz-co;\n"
10191 " float dist2 = dot(light_delta,light_delta);\n"
10192 "\n"
10193 " light_delta = normalize( light_delta );\n"
10194 "\n"
10195 " float quadratic = dist2*100.0;\n"
10196 " float attenuation = 1.0/( 1.0 + quadratic );\n"
10197 " attenuation *= max( dot( light_delta, normal ), 0.0 );\n"
10198 "\n"
10199 " float falloff = max( 0.0, 1.0-(dist2*light_co.w) );\n"
10200 "\n"
10201 " if( light_dir.w < 0.999999 ){\n"
10202 " float spot_theta = max( 0.0, dot( light_delta, -light_dir.xyz ) );\n"
10203 " falloff *= max( 0.0, (spot_theta - light_dir.w) / (1.0-light_dir.w) );\n"
10204 " }\n"
10205 "\n"
10206 " return light_colour.rgb * attenuation * falloff \n"
10207 " * step( g_day_phase, light_colour.w );\n"
10208 "}\n"
10209 "\n"
10210 "vec3 scene_calculate_packed_light_patch( uint packed_index, \n"
10211 " vec3 halfview, vec3 co, vec3 normal )\n"
10212 "{\n"
10213 " uint light_count = packed_index & 0x3u;\n"
10214 "\n"
10215 " vec3 l = vec3(0.0);\n"
10216 "\n"
10217 " if( light_count >= 1u ){\n"
10218 " int index_0 = int( ((packed_index >> 2u) & 0x3ffu) * 3u );\n"
10219 " int index_1 = int( ((packed_index >> 12u) & 0x3ffu) * 3u );\n"
10220 " int index_2 = int( ((packed_index >> 22u) & 0x3ffu) * 3u );\n"
10221 "\n"
10222 " l += scene_calculate_light( index_0, halfview, co, normal );\n"
10223 "\n"
10224 " if( light_count >= 2u ){\n"
10225 " l += scene_calculate_light( index_1, halfview, co, normal );\n"
10226 "\n"
10227 " if( light_count >= 3u ){\n"
10228 " l += scene_calculate_light( index_2, halfview, co, normal );\n"
10229 " }\n"
10230 " }\n"
10231 " }\n"
10232 "\n"
10233 " return l;\n"
10234 "}\n"
10235 "\n"
10236 "vec3 world_compute_lighting( vec3 diffuse, vec3 normal, vec3 co,\n"
10237 " float light_mask )\n"
10238 "{\n"
10239 " if( g_light_preview == 1 )\n"
10240 " diffuse = vec3(0.75);\n"
10241 "\n"
10242 " // Lighting\n"
10243 " vec3 halfview = uCamera - co;\n"
10244 " float fdist = length(halfview);\n"
10245 " halfview /= fdist;\n"
10246 "\n"
10247 " float world_shadow = newlight_compute_sun_shadow( \n"
10248 " co, g_sun_dir.xyz * (1.0/(max(g_sun_dir.y,0.0)+0.2)) );\n"
10249 "\n"
10250 " vec3 total_light = clearskies_lighting( \n"
10251 " normal, min( light_mask, world_shadow ), halfview );\n"
10252 "\n"
10253 " vec3 cube_coord = (co - g_cube_min.xyz) * g_cube_inv_range.xyz;\n"
10254 " cube_coord = floor( cube_coord );\n"
10255 "\n"
10256 " if( g_debug_indices == 1 )\n"
10257 " {\n"
10258 " return rand33(cube_coord);\n"
10259 " }\n"
10260 "\n"
10261 " if( g_debug_complexity == 1 )\n"
10262 " {\n"
10263 " ivec3 coord = ivec3( cube_coord );\n"
10264 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
10265 "\n"
10266 " uint light_count = (index_sample.x & 0x3u) + (index_sample.y & 0x3u);\n"
10267 " return vec3( float(light_count)*(1.0/6.0), 0.0, 0.5 );\n"
10268 " }\n"
10269 "\n"
10270 " // FIXME: this coord should absolutely must be clamped!\n"
10271 " \n"
10272 " ivec3 coord = ivec3( cube_coord );\n"
10273 " uvec4 index_sample = texelFetch( uLightsIndex, coord, 0 );\n"
10274 "\n"
10275 " total_light += \n"
10276 " scene_calculate_packed_light_patch( index_sample.x,\n"
10277 " halfview, co, normal ) \n"
10278 " * light_mask;\n"
10279 " total_light += \n"
10280 " scene_calculate_packed_light_patch( index_sample.y,\n"
10281 " halfview, co, normal )\n"
10282 " * light_mask;\n"
10283 "\n"
10284 " // Take a section of the sky function to give us a matching fog colour\n"
10285 "\n"
10286 " vec3 fog_colour = clearskies_ambient( -halfview );\n"
10287 " float sun_theta = dot( -halfview, g_sun_dir.xyz );\n"
10288 " float sun_size = max( 0.0, sun_theta * 0.5 + 0.5 );\n"
10289 " float sun_shape = sun_size * max(g_sun_dir.y,0.0) * 0.5;\n"
10290 " \n"
10291 " vec3 sun_colour = mix( vec3(1.0), g_sunset_colour.rgb, g_sunset_phase*0.5 );\n"
10292 " sun_colour *= sun_shape;\n"
10293 "\n"
10294 " fog_colour += sun_colour;\n"
10295 " return scene_apply_fog( diffuse * total_light, fog_colour, fdist );\n"
10296 "}\n"
10297 "\n"
10298 "#line 12 0 \n"
10299 "#line 1 3 \n"
10300 "const float k_motion_lerp_amount = 0.01;\n"
10301 "\n"
10302 "#line 2 0 \n"
10303 "\n"
10304 "layout (location = 1) out vec2 oMotionVec;\n"
10305 "\n"
10306 "in vec3 aMotionVec0;\n"
10307 "in vec3 aMotionVec1;\n"
10308 "\n"
10309 "void compute_motion_vectors()\n"
10310 "{\n"
10311 " // Write motion vectors\n"
10312 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10313 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10314 "\n"
10315 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10316 "}\n"
10317 "\n"
10318 "#line 13 0 \n"
10319 "\n"
10320 "void main()\n"
10321 "{\n"
10322 " compute_motion_vectors();\n"
10323 "\n"
10324 " vec3 qnorm = normalize(floor(aNorm*2.0)*0.5) + vec3(0.001,0.0,0.0);\n"
10325 " vec3 diffuse = texture( uTexMain, aUv ).rgb;\n"
10326 " vec3 composite = world_compute_lighting( diffuse, qnorm, aWorldCo, 1.0 );\n"
10327 "\n"
10328 " oColour = vec4( composite, 1.0 );\n"
10329 "}\n"
10330 ""},
10331 };
10332
10333 GLuint _uniform_model_entity_uMdl;
10334 GLuint _uniform_model_entity_uPv;
10335 GLuint _uniform_model_entity_uPvmPrev;
10336 GLuint _uniform_model_entity_uTexMain;
10337 GLuint _uniform_model_entity_uCamera;
10338 GLuint _uniform_model_entity_g_world_depth;
10339 GLuint _uniform_model_entity_uLightsArray;
10340 GLuint _uniform_model_entity_uLightsIndex;
10341 #include "shaders/model_gate.h"
10342 struct vg_shader _shader_model_gate = {
10343 .name = "model_gate",
10344 .vs =
10345 {
10346 .orig_file = "shaders/model.vs",
10347 .static_src =
10348 "layout (location=0) in vec3 a_co;\n"
10349 "layout (location=1) in vec3 a_norm;\n"
10350 "layout (location=2) in vec2 a_uv;\n"
10351 "layout (location=3) in vec4 a_colour;\n"
10352 "layout (location=4) in vec4 a_weights;\n"
10353 "layout (location=5) in ivec4 a_groups;\n"
10354 "\n"
10355 "#line 1 1 \n"
10356 "const float k_motion_lerp_amount = 0.01;\n"
10357 "\n"
10358 "#line 2 0 \n"
10359 "\n"
10360 "out vec3 aMotionVec0;\n"
10361 "out vec3 aMotionVec1;\n"
10362 "\n"
10363 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10364 "{\n"
10365 " // This magically solves some artifacting errors!\n"
10366 " //\n"
10367 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10368 "\n"
10369 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10370 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10371 "}\n"
10372 "\n"
10373 "#line 9 0 \n"
10374 "\n"
10375 "uniform mat4x3 uMdl;\n"
10376 "uniform mat4 uPv;\n"
10377 "uniform mat4 uPvmPrev;\n"
10378 "\n"
10379 "out vec4 aColour;\n"
10380 "out vec2 aUv;\n"
10381 "out vec3 aNorm;\n"
10382 "out vec3 aCo;\n"
10383 "out vec3 aWorldCo;\n"
10384 "\n"
10385 "void main()\n"
10386 "{\n"
10387 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
10388 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
10389 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
10390 "\n"
10391 " vs_motion_out( vproj0, vproj1 );\n"
10392 "\n"
10393 " gl_Position = vproj0;\n"
10394 " aWorldCo = world_pos0;\n"
10395 " aColour = a_colour;\n"
10396 " aUv = a_uv;\n"
10397 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
10398 " aCo = a_co;\n"
10399 "}\n"
10400 ""},
10401 .fs =
10402 {
10403 .orig_file = "shaders/model_gate_lq.fs",
10404 .static_src =
10405 "out vec4 FragColor;\n"
10406 "\n"
10407 "uniform float uTime;\n"
10408 "uniform vec3 uCam;\n"
10409 "uniform vec2 uInvRes;\n"
10410 "uniform vec4 uColour;\n"
10411 "\n"
10412 "in vec3 aNorm;\n"
10413 "in vec2 aUv;\n"
10414 "in vec3 aCo;\n"
10415 "\n"
10416 "void main()\n"
10417 "{\n"
10418 " vec2 ssuv = gl_FragCoord.xy;\n"
10419 " float opacity = 1.0-smoothstep(0.0,1.0,aUv.y+uColour.a);\n"
10420 " \n"
10421 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10422 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10423 "\n"
10424 " if( opacity+dither<0.5 )\n"
10425 " discard;\n"
10426 "\n"
10427 " FragColor = uColour;\n"
10428 "}\n"
10429 ""},
10430 };
10431
10432 GLuint _uniform_model_gate_uMdl;
10433 GLuint _uniform_model_gate_uPv;
10434 GLuint _uniform_model_gate_uPvmPrev;
10435 GLuint _uniform_model_gate_uTime;
10436 GLuint _uniform_model_gate_uCam;
10437 GLuint _uniform_model_gate_uInvRes;
10438 GLuint _uniform_model_gate_uColour;
10439 #include "shaders/model_gate_unlinked.h"
10440 struct vg_shader _shader_model_gate_unlinked = {
10441 .name = "model_gate_unlinked",
10442 .vs =
10443 {
10444 .orig_file = "shaders/model.vs",
10445 .static_src =
10446 "layout (location=0) in vec3 a_co;\n"
10447 "layout (location=1) in vec3 a_norm;\n"
10448 "layout (location=2) in vec2 a_uv;\n"
10449 "layout (location=3) in vec4 a_colour;\n"
10450 "layout (location=4) in vec4 a_weights;\n"
10451 "layout (location=5) in ivec4 a_groups;\n"
10452 "\n"
10453 "#line 1 1 \n"
10454 "const float k_motion_lerp_amount = 0.01;\n"
10455 "\n"
10456 "#line 2 0 \n"
10457 "\n"
10458 "out vec3 aMotionVec0;\n"
10459 "out vec3 aMotionVec1;\n"
10460 "\n"
10461 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10462 "{\n"
10463 " // This magically solves some artifacting errors!\n"
10464 " //\n"
10465 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10466 "\n"
10467 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10468 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10469 "}\n"
10470 "\n"
10471 "#line 9 0 \n"
10472 "\n"
10473 "uniform mat4x3 uMdl;\n"
10474 "uniform mat4 uPv;\n"
10475 "uniform mat4 uPvmPrev;\n"
10476 "\n"
10477 "out vec4 aColour;\n"
10478 "out vec2 aUv;\n"
10479 "out vec3 aNorm;\n"
10480 "out vec3 aCo;\n"
10481 "out vec3 aWorldCo;\n"
10482 "\n"
10483 "void main()\n"
10484 "{\n"
10485 " vec3 world_pos0 = uMdl * vec4( a_co, 1.0 );\n"
10486 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
10487 " vec4 vproj1 = uPvmPrev * vec4( a_co, 1.0 );\n"
10488 "\n"
10489 " vs_motion_out( vproj0, vproj1 );\n"
10490 "\n"
10491 " gl_Position = vproj0;\n"
10492 " aWorldCo = world_pos0;\n"
10493 " aColour = a_colour;\n"
10494 " aUv = a_uv;\n"
10495 " aNorm = normalize( mat3(uMdl) * a_norm );\n"
10496 " aCo = a_co;\n"
10497 "}\n"
10498 ""},
10499 .fs =
10500 {
10501 .orig_file = "shaders/model_gate_unlinked.fs",
10502 .static_src =
10503 "out vec4 FragColor;\n"
10504 "\n"
10505 "uniform float uTime;\n"
10506 "uniform vec3 uCam;\n"
10507 "uniform vec4 uColour;\n"
10508 "\n"
10509 "in vec3 aNorm;\n"
10510 "in vec2 aUv;\n"
10511 "in vec3 aCo;\n"
10512 "\n"
10513 "#line 1 1 \n"
10514 "const float k_motion_lerp_amount = 0.01;\n"
10515 "\n"
10516 "#line 2 0 \n"
10517 "\n"
10518 "layout (location = 1) out vec2 oMotionVec;\n"
10519 "\n"
10520 "in vec3 aMotionVec0;\n"
10521 "in vec3 aMotionVec1;\n"
10522 "\n"
10523 "void compute_motion_vectors()\n"
10524 "{\n"
10525 " // Write motion vectors\n"
10526 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10527 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10528 "\n"
10529 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10530 "}\n"
10531 "\n"
10532 "#line 12 0 \n"
10533 "\n"
10534 "const int NOISE_LOOP = 3;\n"
10535 "vec3 digital_noise( uvec3 iuv ){\n"
10536 " iuv *=uvec3(8,2524,7552);\n"
10537 " for( int i=0; i<NOISE_LOOP; i++ )\n"
10538 " iuv += (iuv.yzx<<2) ^ (iuv.yxz)+iuv.z;\n"
10539 " return vec3(iuv)*(1.0/float(0xffffffffU));\n"
10540 "}\n"
10541 "\n"
10542 "vec2 rand_hash22( vec2 p ){\n"
10543 " vec3 p3 = fract(vec3(p.xyx) * 213.8976123);\n"
10544 " p3 += dot(p3, p3.yzx+19.19);\n"
10545 " return fract(vec2((p3.x + p3.y)*p3.z, (p3.x+p3.z)*p3.y));\n"
10546 "}\n"
10547 "\n"
10548 "void main(){\n"
10549 " compute_motion_vectors();\n"
10550 "\n"
10551 " vec2 ssuv = gl_FragCoord.xy;\n"
10552 " float grad = 1.0-aUv.y*0.1;\n"
10553 " float opacity = rand_hash22( vec2(floor(aUv.y*100.0),floor(aCo.z*10.0+uTime*40.0)) ).r*grad;\n"
10554 " \n"
10555 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10556 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10557 "\n"
10558 " if( opacity<0.9 )\n"
10559 " discard;\n"
10560 "\n"
10561 " FragColor = vec4(0.7,0.5,0.5,1.0);\n"
10562 "}\n"
10563 ""},
10564 };
10565
10566 GLuint _uniform_model_gate_unlinked_uMdl;
10567 GLuint _uniform_model_gate_unlinked_uPv;
10568 GLuint _uniform_model_gate_unlinked_uPvmPrev;
10569 GLuint _uniform_model_gate_unlinked_uTime;
10570 GLuint _uniform_model_gate_unlinked_uCam;
10571 GLuint _uniform_model_gate_unlinked_uColour;
10572 #include "shaders/model_font.h"
10573 struct vg_shader _shader_model_font = {
10574 .name = "model_font",
10575 .vs =
10576 {
10577 .orig_file = "shaders/model_font.vs",
10578 .static_src =
10579 "layout (location=0) in vec3 a_co;\n"
10580 "layout (location=1) in vec3 a_norm;\n"
10581 "layout (location=2) in vec2 a_uv;\n"
10582 "\n"
10583 "#line 1 1 \n"
10584 "const float k_motion_lerp_amount = 0.01;\n"
10585 "\n"
10586 "#line 2 0 \n"
10587 "\n"
10588 "out vec3 aMotionVec0;\n"
10589 "out vec3 aMotionVec1;\n"
10590 "\n"
10591 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10592 "{\n"
10593 " // This magically solves some artifacting errors!\n"
10594 " //\n"
10595 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10596 "\n"
10597 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10598 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10599 "}\n"
10600 "\n"
10601 "#line 6 0 \n"
10602 "\n"
10603 "uniform mat4x3 uMdl;\n"
10604 "uniform mat4 uPv;\n"
10605 "uniform mat4 uPvmPrev;\n"
10606 "uniform vec4 uOffset;\n"
10607 "\n"
10608 "out vec2 aUv;\n"
10609 "out vec4 aNorm;\n"
10610 "out vec3 aCo;\n"
10611 "out vec3 aWorldCo;\n"
10612 "\n"
10613 "void main()\n"
10614 "{\n"
10615 " vec3 co = a_co*uOffset.w+uOffset.xyz;\n"
10616 " vec3 world_pos0 = uMdl * vec4( co, 1.0 );\n"
10617 " vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
10618 " vec4 vproj1 = uPvmPrev * vec4( co, 1.0 );\n"
10619 "\n"
10620 " vs_motion_out( vproj0, vproj1 );\n"
10621 "\n"
10622 " gl_Position = vproj0;\n"
10623 "\n"
10624 " aUv = a_uv;\n"
10625 " aNorm = vec4( mat3(uMdl) * a_norm, 0.0 );\n"
10626 " aCo = co;\n"
10627 " aWorldCo = world_pos0;\n"
10628 "}\n"
10629 ""},
10630 .fs =
10631 {
10632 .orig_file = "shaders/model_font.fs",
10633 .static_src =
10634 "layout (location = 0) out vec4 oColour;\n"
10635 "\n"
10636 "uniform sampler2D uTexMain;\n"
10637 "uniform vec4 uColour;\n"
10638 "\n"
10639 "in vec2 aUv;\n"
10640 "in vec4 aNorm;\n"
10641 "in vec3 aCo;\n"
10642 "\n"
10643 "#line 1 1 \n"
10644 "const float k_motion_lerp_amount = 0.01;\n"
10645 "\n"
10646 "#line 2 0 \n"
10647 "\n"
10648 "layout (location = 1) out vec2 oMotionVec;\n"
10649 "\n"
10650 "in vec3 aMotionVec0;\n"
10651 "in vec3 aMotionVec1;\n"
10652 "\n"
10653 "void compute_motion_vectors()\n"
10654 "{\n"
10655 " // Write motion vectors\n"
10656 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10657 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10658 "\n"
10659 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10660 "}\n"
10661 "\n"
10662 "#line 11 0 \n"
10663 "#line 1 2 \n"
10664 "uniform sampler2D uTexSceneDepth;\n"
10665 "uniform vec3 uInverseRatioDepth;\n"
10666 "uniform vec3 uInverseRatioMain;\n"
10667 "uniform int uDepthMode;\n"
10668 "uniform float uDitherCutoff;\n"
10669 "\n"
10670 "float linear_depth( float depth, float near, float far ) {\n"
10671 " float z = depth * 2.0 - 1.0;\n"
10672 " return (2.0 * near * far) / (far + near - z * (far - near)); \n"
10673 "}\n"
10674 "\n"
10675 "void depth_compare_dither()\n"
10676 "{\n"
10677 " if( uDepthMode == 1 )\n"
10678 " {\n"
10679 " vec2 back_coord = gl_FragCoord.xy * uInverseRatioMain.xy \n"
10680 " * uInverseRatioDepth.xy;\n"
10681 " float back_depth = texture( uTexSceneDepth, back_coord ).r;\n"
10682 " float front_depth = gl_FragCoord.z/gl_FragCoord.w;\n"
10683 "\n"
10684 " back_depth = linear_depth( back_depth, 0.1, 2100.0 );\n"
10685 " float diff = back_depth - front_depth;\n"
10686 "\n"
10687 " vec2 ssuv = gl_FragCoord.xy;\n"
10688 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10689 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10690 "\n"
10691 " if( step(0.0,diff)+dither<0.3 )\n"
10692 " discard;\n"
10693 " }\n"
10694 "\n"
10695 " if( uDepthMode == 2 )\n"
10696 " {\n"
10697 " vec2 ssuv = gl_FragCoord.xy;\n"
10698 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10699 " float dither = fract( vDither.g / 71.0 );\n"
10700 " if( dither<uDitherCutoff ) discard;\n"
10701 " }\n"
10702 "}\n"
10703 "\n"
10704 "#line 12 0 \n"
10705 "\n"
10706 "void main(){\n"
10707 " depth_compare_dither();\n"
10708 " compute_motion_vectors();\n"
10709 " oColour = texture( uTexMain, aUv ) * uColour;\n"
10710 "}\n"
10711 ""},
10712 };
10713
10714 GLuint _uniform_model_font_uMdl;
10715 GLuint _uniform_model_font_uPv;
10716 GLuint _uniform_model_font_uPvmPrev;
10717 GLuint _uniform_model_font_uOffset;
10718 GLuint _uniform_model_font_uTexMain;
10719 GLuint _uniform_model_font_uColour;
10720 GLuint _uniform_model_font_uTexSceneDepth;
10721 GLuint _uniform_model_font_uInverseRatioDepth;
10722 GLuint _uniform_model_font_uInverseRatioMain;
10723 GLuint _uniform_model_font_uDepthMode;
10724 GLuint _uniform_model_font_uDitherCutoff;
10725 #include "shaders/particle.h"
10726 struct vg_shader _shader_particle = {
10727 .name = "particle",
10728 .vs =
10729 {
10730 .orig_file = "shaders/particle.vs",
10731 .static_src =
10732 "layout (location=0) in vec3 a_co;\n"
10733 "layout (location=1) in vec4 a_colour;\n"
10734 "\n"
10735 "#line 1 1 \n"
10736 "const float k_motion_lerp_amount = 0.01;\n"
10737 "\n"
10738 "#line 2 0 \n"
10739 "\n"
10740 "out vec3 aMotionVec0;\n"
10741 "out vec3 aMotionVec1;\n"
10742 "\n"
10743 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10744 "{\n"
10745 " // This magically solves some artifacting errors!\n"
10746 " //\n"
10747 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10748 "\n"
10749 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10750 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10751 "}\n"
10752 "\n"
10753 "#line 5 0 \n"
10754 "\n"
10755 "uniform mat4 uPv;\n"
10756 "uniform mat4 uPvPrev;\n"
10757 "\n"
10758 "out vec4 aColour;\n"
10759 "\n"
10760 "void main(){\n"
10761 " vec4 vproj0 = uPv * vec4( a_co, 1.0 );\n"
10762 " vec4 vproj1 = uPvPrev * vec4( a_co, 1.0 );\n"
10763 " vs_motion_out( vproj0, vproj1 );\n"
10764 "\n"
10765 " gl_Position = vproj0;\n"
10766 " aColour = a_colour;\n"
10767 "}\n"
10768 ""},
10769 .fs =
10770 {
10771 .orig_file = "shaders/particle.fs",
10772 .static_src =
10773 "layout (location = 0) out vec4 oColour;\n"
10774 "in vec4 aColour;\n"
10775 "\n"
10776 "#line 1 1 \n"
10777 "const float k_motion_lerp_amount = 0.01;\n"
10778 "\n"
10779 "#line 2 0 \n"
10780 "\n"
10781 "layout (location = 1) out vec2 oMotionVec;\n"
10782 "\n"
10783 "in vec3 aMotionVec0;\n"
10784 "in vec3 aMotionVec1;\n"
10785 "\n"
10786 "void compute_motion_vectors()\n"
10787 "{\n"
10788 " // Write motion vectors\n"
10789 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10790 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10791 "\n"
10792 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10793 "}\n"
10794 "\n"
10795 "#line 5 0 \n"
10796 "\n"
10797 "void main(){\n"
10798 " compute_motion_vectors();\n"
10799 "\n"
10800 " //vec2 ssuv = gl_FragCoord.xy;\n"
10801 " //vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10802 " //float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10803 "\n"
10804 " //if( vsamplemain.a+dither<0.5 )\n"
10805 " // discard;\n"
10806 "\n"
10807 " oColour = aColour;\n"
10808 "}\n"
10809 ""},
10810 };
10811
10812 GLuint _uniform_particle_uPv;
10813 GLuint _uniform_particle_uPvPrev;
10814 #include "shaders/trail.h"
10815 struct vg_shader _shader_trail = {
10816 .name = "trail",
10817 .vs =
10818 {
10819 .orig_file = "shaders/trail.vs",
10820 .static_src =
10821 "layout (location=0) in vec4 a_co;\n"
10822 "\n"
10823 "#line 1 1 \n"
10824 "const float k_motion_lerp_amount = 0.01;\n"
10825 "\n"
10826 "#line 2 0 \n"
10827 "\n"
10828 "out vec3 aMotionVec0;\n"
10829 "out vec3 aMotionVec1;\n"
10830 "\n"
10831 "void vs_motion_out( vec4 vproj0, vec4 vproj1 )\n"
10832 "{\n"
10833 " // This magically solves some artifacting errors!\n"
10834 " //\n"
10835 " vproj1 = vproj0*(1.0-k_motion_lerp_amount) + vproj1*k_motion_lerp_amount;\n"
10836 "\n"
10837 " aMotionVec0 = vec3( vproj0.xy, vproj0.w );\n"
10838 " aMotionVec1 = vec3( vproj1.xy, vproj1.w );\n"
10839 "}\n"
10840 "\n"
10841 "#line 4 0 \n"
10842 "\n"
10843 "uniform mat4 uPv;\n"
10844 "uniform mat4 uPvPrev;\n"
10845 "\n"
10846 "out float aAlpha;\n"
10847 "\n"
10848 "void main(){\n"
10849 " vec4 vproj0 = uPv * vec4( a_co.xyz, 1.0 );\n"
10850 " vec4 vproj1 = uPvPrev * vec4( a_co.xyz, 1.0 );\n"
10851 " vs_motion_out( vproj0, vproj1 );\n"
10852 "\n"
10853 " gl_Position = vproj0;\n"
10854 " aAlpha = a_co.w;\n"
10855 "}\n"
10856 ""},
10857 .fs =
10858 {
10859 .orig_file = "shaders/trail.fs",
10860 .static_src =
10861 "layout (location = 0) out vec4 oColour;\n"
10862 "in float aAlpha;\n"
10863 "uniform vec4 uColour;\n"
10864 "\n"
10865 "#line 1 1 \n"
10866 "const float k_motion_lerp_amount = 0.01;\n"
10867 "\n"
10868 "#line 2 0 \n"
10869 "\n"
10870 "layout (location = 1) out vec2 oMotionVec;\n"
10871 "\n"
10872 "in vec3 aMotionVec0;\n"
10873 "in vec3 aMotionVec1;\n"
10874 "\n"
10875 "void compute_motion_vectors()\n"
10876 "{\n"
10877 " // Write motion vectors\n"
10878 " vec2 vmotion0 = aMotionVec0.xy / aMotionVec0.z;\n"
10879 " vec2 vmotion1 = aMotionVec1.xy / aMotionVec1.z;\n"
10880 "\n"
10881 " oMotionVec = (vmotion1-vmotion0) * (1.0/k_motion_lerp_amount);\n"
10882 "}\n"
10883 "\n"
10884 "#line 6 0 \n"
10885 "\n"
10886 "void main(){\n"
10887 " compute_motion_vectors();\n"
10888 "\n"
10889 " vec2 ssuv = gl_FragCoord.xy;\n"
10890 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), ssuv) );\n"
10891 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
10892 "\n"
10893 " if( aAlpha+dither<0.5 )\n"
10894 " discard;\n"
10895 "\n"
10896 " oColour = vec4( uColour.rgb, uColour.a * aAlpha );\n"
10897 "}\n"
10898 ""},
10899 };
10900
10901 GLuint _uniform_trail_uPv;
10902 GLuint _uniform_trail_uPvPrev;
10903 GLuint _uniform_trail_uColour;
10904 #include "shaders/blit.h"
10905 struct vg_shader _shader_blit = {
10906 .name = "blit",
10907 .vs =
10908 {
10909 .orig_file = "shaders/blit.vs",
10910 .static_src =
10911 "layout (location=0) in vec2 a_co;\n"
10912 "out vec2 aUv;\n"
10913 "\n"
10914 "uniform vec2 uInverseRatio;\n"
10915 "\n"
10916 "void main()\n"
10917 "{\n"
10918 " gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
10919 " aUv = a_co * uInverseRatio;\n"
10920 "}\n"
10921 ""},
10922 .fs =
10923 {
10924 .orig_file = "shaders/blit.fs",
10925 .static_src =
10926 "out vec4 FragColor;\n"
10927 "uniform sampler2D uTexMain;\n"
10928 "\n"
10929 "in vec2 aUv;\n"
10930 "\n"
10931 "float kPi = 3.14159265358979;\n"
10932 "\n"
10933 "vec2 fisheye_distort(vec2 xy)\n"
10934 "{\n"
10935 " float aperture = 1350.0;\n"
10936 " float apertureHalf = 0.5 * aperture * (kPi / 180.0);\n"
10937 " float maxFactor = sin(apertureHalf);\n"
10938 "\n"
10939 " vec2 uv;\n"
10940 " float d = length(xy);\n"
10941 " if(d < (2.0-maxFactor))\n"
10942 " {\n"
10943 " d = length(xy * maxFactor);\n"
10944 " float z = sqrt(1.0 - d * d);\n"
10945 " float r = atan(d, z) / kPi;\n"
10946 " float phi = atan(xy.y, xy.x);\n"
10947 "\n"
10948 " uv.x = r * cos(phi) + 0.5;\n"
10949 " uv.y = r * sin(phi) + 0.5;\n"
10950 " }\n"
10951 " else\n"
10952 " {\n"
10953 " uv = 0.5*xy + 0.5;\n"
10954 " }\n"
10955 " \n"
10956 " return uv;\n"
10957 "}\n"
10958 "\n"
10959 "\n"
10960 "void main()\n"
10961 "{\n"
10962 " vec2 vwarp = 2.0*aUv - 1.0;\n"
10963 " vwarp = fisheye_distort( vwarp );\n"
10964 "\n"
10965 " FragColor = texture( uTexMain, aUv );\n"
10966 "}\n"
10967 ""},
10968 };
10969
10970 GLuint _uniform_blit_uInverseRatio;
10971 GLuint _uniform_blit_uTexMain;
10972 #include "shaders/blitblur.h"
10973 struct vg_shader _shader_blitblur = {
10974 .name = "blitblur",
10975 .vs =
10976 {
10977 .orig_file = "shaders/blit.vs",
10978 .static_src =
10979 "layout (location=0) in vec2 a_co;\n"
10980 "out vec2 aUv;\n"
10981 "\n"
10982 "uniform vec2 uInverseRatio;\n"
10983 "\n"
10984 "void main()\n"
10985 "{\n"
10986 " gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
10987 " aUv = a_co * uInverseRatio;\n"
10988 "}\n"
10989 ""},
10990 .fs =
10991 {
10992 .orig_file = "shaders/blitblur.fs",
10993 .static_src =
10994 "out vec4 FragColor;\n"
10995 "uniform sampler2D uTexMain;\n"
10996 "uniform sampler2D uTexMotion;\n"
10997 "uniform float uBlurStrength;\n"
10998 "uniform vec2 uOverrideDir;\n"
10999 "uniform float uTime;\n"
11000 "uniform float uGlitchStrength;\n"
11001 "uniform vec2 uClampUv;\n"
11002 "\n"
11003 "in vec2 aUv;\n"
11004 "\n"
11005 "vec2 rand_hash22( vec2 p ){\n"
11006 " vec3 p3 = fract(vec3(p.xyx) * 213.8976123);\n"
11007 " p3 += dot(p3, p3.yzx+19.19);\n"
11008 " return fract(vec2((p3.x + p3.y)*p3.z, (p3.x+p3.z)*p3.y));\n"
11009 "}\n"
11010 "\n"
11011 "const int NOISE_LOOP = 3;\n"
11012 "vec3 digital_noise( uvec3 iuv ){\n"
11013 " iuv *=uvec3(8,2524,7552);\n"
11014 " for( int i=0; i<NOISE_LOOP; i++ )\n"
11015 " iuv += (iuv.yzx<<2) ^ (iuv.yxz)+iuv.z;\n"
11016 " return vec3(iuv)*(1.0/float(0xffffffffU));\n"
11017 "}\n"
11018 "\n"
11019 "void main(){\n"
11020 " vec2 vuv = aUv; \n"
11021 "\n"
11022 " //if( uGlitchStrength > 0.0 ){\n"
11023 " // uvec3 p = uvec3( gl_FragCoord.xy, uint(uTime*30.0) );\n"
11024 " // vec2 g = digital_noise(p).xy;\n"
11025 " // vuv = aUv + g.xy*uGlitchStrength - uGlitchStrength*0.5;\n"
11026 " //}\n"
11027 "\n"
11028 " vec2 vrand = rand_hash22( vuv ) * 2.0 - vec2(1.0);\n"
11029 " vec2 vrand1 = rand_hash22( vrand ) * 2.0 - vec2(1.0);\n"
11030 " \n"
11031 " vec2 vdir = texture( uTexMotion, vuv ).xy * uBlurStrength + uOverrideDir;\n"
11032 "\n"
11033 " vec4 vcolour0 = texture( uTexMain, min(vuv + vdir*vrand.x,uClampUv) );\n"
11034 " vec4 vcolour1 = texture( uTexMain, min(vuv + vdir*vrand.y,uClampUv) );\n"
11035 " vec4 vcolour2 = texture( uTexMain, min(vuv + vdir*vrand1.x,uClampUv) );\n"
11036 " vec4 vcolour3 = texture( uTexMain, min(vuv + vdir*vrand1.y,uClampUv) );\n"
11037 "\n"
11038 " FragColor = ( vcolour0 + vcolour1 + vcolour2 + vcolour3 ) * 0.25;\n"
11039 "}\n"
11040 ""},
11041 };
11042
11043 GLuint _uniform_blitblur_uInverseRatio;
11044 GLuint _uniform_blitblur_uTexMain;
11045 GLuint _uniform_blitblur_uTexMotion;
11046 GLuint _uniform_blitblur_uBlurStrength;
11047 GLuint _uniform_blitblur_uOverrideDir;
11048 GLuint _uniform_blitblur_uTime;
11049 GLuint _uniform_blitblur_uGlitchStrength;
11050 GLuint _uniform_blitblur_uClampUv;
11051 #include "shaders/blitcolour.h"
11052 struct vg_shader _shader_blitcolour = {
11053 .name = "blitcolour",
11054 .vs =
11055 {
11056 .orig_file = "shaders/blit.vs",
11057 .static_src =
11058 "layout (location=0) in vec2 a_co;\n"
11059 "out vec2 aUv;\n"
11060 "\n"
11061 "uniform vec2 uInverseRatio;\n"
11062 "\n"
11063 "void main()\n"
11064 "{\n"
11065 " gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
11066 " aUv = a_co * uInverseRatio;\n"
11067 "}\n"
11068 ""},
11069 .fs =
11070 {
11071 .orig_file = "shaders/colour.fs",
11072 .static_src =
11073 "out vec4 FragColor;\n"
11074 "uniform vec4 uColour;\n"
11075 "\n"
11076 "in vec2 aUv;\n"
11077 "\n"
11078 "void main()\n"
11079 "{\n"
11080 " FragColor = uColour;\n"
11081 "}\n"
11082 ""},
11083 };
11084
11085 GLuint _uniform_blitcolour_uInverseRatio;
11086 GLuint _uniform_blitcolour_uColour;
11087 #include "shaders/blit_transition.h"
11088 struct vg_shader _shader_blit_transition = {
11089 .name = "blit_transition",
11090 .vs =
11091 {
11092 .orig_file = "shaders/blit.vs",
11093 .static_src =
11094 "layout (location=0) in vec2 a_co;\n"
11095 "out vec2 aUv;\n"
11096 "\n"
11097 "uniform vec2 uInverseRatio;\n"
11098 "\n"
11099 "void main()\n"
11100 "{\n"
11101 " gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
11102 " aUv = a_co * uInverseRatio;\n"
11103 "}\n"
11104 ""},
11105 .fs =
11106 {
11107 .orig_file = "shaders/blit_transition.fs",
11108 .static_src =
11109 "out vec4 FragColor;\n"
11110 "in vec2 aUv;\n"
11111 "uniform float uT;\n"
11112 "\n"
11113 "void main(){\n"
11114 " float d = uT + distance( aUv, vec2(0.5,0.5) );\n"
11115 "\n"
11116 " vec3 vDither = vec3( dot( vec2( 171.0, 231.0 ), gl_FragCoord.xy) );\n"
11117 " float dither = fract( vDither.g / 71.0 ) - 0.5;\n"
11118 "\n"
11119 " if( d+dither < -0.5 )\n"
11120 " discard;\n"
11121 "\n"
11122 " FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n"
11123 "}\n"
11124 ""},
11125 };
11126
11127 GLuint _uniform_blit_transition_uInverseRatio;
11128 GLuint _uniform_blit_transition_uT;
11129 #include "shaders/routeui.h"
11130 struct vg_shader _shader_routeui = {
11131 .name = "routeui",
11132 .vs =
11133 {
11134 .orig_file = "shaders/routeui.vs",
11135 .static_src =
11136 "layout (location=0) in vec2 a_co;\n"
11137 "\n"
11138 "uniform vec4 uOffset;\n"
11139 "\n"
11140 "void main()\n"
11141 "{\n"
11142 " vec2 vpos = a_co * uOffset.zw + uOffset.xy;\n"
11143 " gl_Position = vec4(vpos,0.0,1.0);\n"
11144 "}\n"
11145 ""},
11146 .fs =
11147 {
11148 .orig_file = "shaders/routeui.fs",
11149 .static_src =
11150 "out vec4 FragColor;\n"
11151 "\n"
11152 "uniform vec4 uColour;\n"
11153 "\n"
11154 "void main()\n"
11155 "{\n"
11156 " FragColor = uColour;\n"
11157 "}\n"
11158 ""},
11159 };
11160
11161 GLuint _uniform_routeui_uOffset;
11162 GLuint _uniform_routeui_uColour;
11163
11164
11165 void vg_auto_shader_link(void)
11166 {
11167 _uniform_scene_standard_uMdl = glGetUniformLocation( _shader_scene_standard.id, "uMdl" );
11168 _uniform_scene_standard_uPv = glGetUniformLocation( _shader_scene_standard.id, "uPv" );
11169 _uniform_scene_standard_uPvmPrev = glGetUniformLocation( _shader_scene_standard.id, "uPvmPrev" );
11170 _uniform_scene_standard_uTexGarbage = glGetUniformLocation( _shader_scene_standard.id, "uTexGarbage" );
11171 _uniform_scene_standard_uTexMain = glGetUniformLocation( _shader_scene_standard.id, "uTexMain" );
11172 _uniform_scene_standard_uCamera = glGetUniformLocation( _shader_scene_standard.id, "uCamera" );
11173 _uniform_scene_standard_uPlane = glGetUniformLocation( _shader_scene_standard.id, "uPlane" );
11174 _uniform_scene_standard_g_world_depth = glGetUniformLocation( _shader_scene_standard.id, "g_world_depth" );
11175 _uniform_scene_standard_uLightsArray = glGetUniformLocation( _shader_scene_standard.id, "uLightsArray" );
11176 _uniform_scene_standard_uLightsIndex = glGetUniformLocation( _shader_scene_standard.id, "uLightsIndex" );
11177 _uniform_scene_standard_alphatest_uMdl = glGetUniformLocation( _shader_scene_standard_alphatest.id, "uMdl" );
11178 _uniform_scene_standard_alphatest_uPv = glGetUniformLocation( _shader_scene_standard_alphatest.id, "uPv" );
11179 _uniform_scene_standard_alphatest_uPvmPrev = glGetUniformLocation( _shader_scene_standard_alphatest.id, "uPvmPrev" );
11180 _uniform_scene_standard_alphatest_uTexGarbage = glGetUniformLocation( _shader_scene_standard_alphatest.id, "uTexGarbage" );
11181 _uniform_scene_standard_alphatest_uTexMain = glGetUniformLocation( _shader_scene_standard_alphatest.id, "uTexMain" );
11182 _uniform_scene_standard_alphatest_uCamera = glGetUniformLocation( _shader_scene_standard_alphatest.id, "uCamera" );
11183 _uniform_scene_standard_alphatest_uPlane = glGetUniformLocation( _shader_scene_standard_alphatest.id, "uPlane" );
11184 _uniform_scene_standard_alphatest_g_world_depth = glGetUniformLocation( _shader_scene_standard_alphatest.id, "g_world_depth" );
11185 _uniform_scene_standard_alphatest_uLightsArray = glGetUniformLocation( _shader_scene_standard_alphatest.id, "uLightsArray" );
11186 _uniform_scene_standard_alphatest_uLightsIndex = glGetUniformLocation( _shader_scene_standard_alphatest.id, "uLightsIndex" );
11187 _uniform_scene_foliage_uMdl = glGetUniformLocation( _shader_scene_foliage.id, "uMdl" );
11188 _uniform_scene_foliage_uPv = glGetUniformLocation( _shader_scene_foliage.id, "uPv" );
11189 _uniform_scene_foliage_uPvmPrev = glGetUniformLocation( _shader_scene_foliage.id, "uPvmPrev" );
11190 _uniform_scene_foliage_uTime = glGetUniformLocation( _shader_scene_foliage.id, "uTime" );
11191 _uniform_scene_foliage_uTexGarbage = glGetUniformLocation( _shader_scene_foliage.id, "uTexGarbage" );
11192 _uniform_scene_foliage_uTexMain = glGetUniformLocation( _shader_scene_foliage.id, "uTexMain" );
11193 _uniform_scene_foliage_uCamera = glGetUniformLocation( _shader_scene_foliage.id, "uCamera" );
11194 _uniform_scene_foliage_uPlane = glGetUniformLocation( _shader_scene_foliage.id, "uPlane" );
11195 _uniform_scene_foliage_g_world_depth = glGetUniformLocation( _shader_scene_foliage.id, "g_world_depth" );
11196 _uniform_scene_foliage_uLightsArray = glGetUniformLocation( _shader_scene_foliage.id, "uLightsArray" );
11197 _uniform_scene_foliage_uLightsIndex = glGetUniformLocation( _shader_scene_foliage.id, "uLightsIndex" );
11198 _uniform_scene_override_uMdl = glGetUniformLocation( _shader_scene_override.id, "uMdl" );
11199 _uniform_scene_override_uPv = glGetUniformLocation( _shader_scene_override.id, "uPv" );
11200 _uniform_scene_override_uPvmPrev = glGetUniformLocation( _shader_scene_override.id, "uPvmPrev" );
11201 _uniform_scene_override_uNormalMtx = glGetUniformLocation( _shader_scene_override.id, "uNormalMtx" );
11202 _uniform_scene_override_uTexGarbage = glGetUniformLocation( _shader_scene_override.id, "uTexGarbage" );
11203 _uniform_scene_override_uTexMain = glGetUniformLocation( _shader_scene_override.id, "uTexMain" );
11204 _uniform_scene_override_uCamera = glGetUniformLocation( _shader_scene_override.id, "uCamera" );
11205 _uniform_scene_override_uPlane = glGetUniformLocation( _shader_scene_override.id, "uPlane" );
11206 _uniform_scene_override_uPlayerPos = glGetUniformLocation( _shader_scene_override.id, "uPlayerPos" );
11207 _uniform_scene_override_uSpawnPos = glGetUniformLocation( _shader_scene_override.id, "uSpawnPos" );
11208 _uniform_scene_override_uAlphatest = glGetUniformLocation( _shader_scene_override.id, "uAlphatest" );
11209 _uniform_scene_override_uMapInfo = glGetUniformLocation( _shader_scene_override.id, "uMapInfo" );
11210 _uniform_scene_override_g_world_depth = glGetUniformLocation( _shader_scene_override.id, "g_world_depth" );
11211 _uniform_scene_override_uLightsArray = glGetUniformLocation( _shader_scene_override.id, "uLightsArray" );
11212 _uniform_scene_override_uLightsIndex = glGetUniformLocation( _shader_scene_override.id, "uLightsIndex" );
11213 _uniform_scene_fxglow_uMdl = glGetUniformLocation( _shader_scene_fxglow.id, "uMdl" );
11214 _uniform_scene_fxglow_uPv = glGetUniformLocation( _shader_scene_fxglow.id, "uPv" );
11215 _uniform_scene_fxglow_uPvmPrev = glGetUniformLocation( _shader_scene_fxglow.id, "uPvmPrev" );
11216 _uniform_scene_fxglow_uUvOffset = glGetUniformLocation( _shader_scene_fxglow.id, "uUvOffset" );
11217 _uniform_scene_fxglow_uTexMain = glGetUniformLocation( _shader_scene_fxglow.id, "uTexMain" );
11218 _uniform_scene_fxglow_uCamera = glGetUniformLocation( _shader_scene_fxglow.id, "uCamera" );
11219 _uniform_scene_fxglow_g_world_depth = glGetUniformLocation( _shader_scene_fxglow.id, "g_world_depth" );
11220 _uniform_scene_fxglow_uLightsArray = glGetUniformLocation( _shader_scene_fxglow.id, "uLightsArray" );
11221 _uniform_scene_fxglow_uLightsIndex = glGetUniformLocation( _shader_scene_fxglow.id, "uLightsIndex" );
11222 _uniform_scene_vertex_blend_uMdl = glGetUniformLocation( _shader_scene_vertex_blend.id, "uMdl" );
11223 _uniform_scene_vertex_blend_uPv = glGetUniformLocation( _shader_scene_vertex_blend.id, "uPv" );
11224 _uniform_scene_vertex_blend_uPvmPrev = glGetUniformLocation( _shader_scene_vertex_blend.id, "uPvmPrev" );
11225 _uniform_scene_vertex_blend_uTexGarbage = glGetUniformLocation( _shader_scene_vertex_blend.id, "uTexGarbage" );
11226 _uniform_scene_vertex_blend_uTexGradients = glGetUniformLocation( _shader_scene_vertex_blend.id, "uTexGradients" );
11227 _uniform_scene_vertex_blend_uCamera = glGetUniformLocation( _shader_scene_vertex_blend.id, "uCamera" );
11228 _uniform_scene_vertex_blend_g_world_depth = glGetUniformLocation( _shader_scene_vertex_blend.id, "g_world_depth" );
11229 _uniform_scene_vertex_blend_uLightsArray = glGetUniformLocation( _shader_scene_vertex_blend.id, "uLightsArray" );
11230 _uniform_scene_vertex_blend_uLightsIndex = glGetUniformLocation( _shader_scene_vertex_blend.id, "uLightsIndex" );
11231 _uniform_scene_terrain_uMdl = glGetUniformLocation( _shader_scene_terrain.id, "uMdl" );
11232 _uniform_scene_terrain_uPv = glGetUniformLocation( _shader_scene_terrain.id, "uPv" );
11233 _uniform_scene_terrain_uPvmPrev = glGetUniformLocation( _shader_scene_terrain.id, "uPvmPrev" );
11234 _uniform_scene_terrain_uTexGarbage = glGetUniformLocation( _shader_scene_terrain.id, "uTexGarbage" );
11235 _uniform_scene_terrain_uTexGradients = glGetUniformLocation( _shader_scene_terrain.id, "uTexGradients" );
11236 _uniform_scene_terrain_uCamera = glGetUniformLocation( _shader_scene_terrain.id, "uCamera" );
11237 _uniform_scene_terrain_uSandColour = glGetUniformLocation( _shader_scene_terrain.id, "uSandColour" );
11238 _uniform_scene_terrain_uBlendOffset = glGetUniformLocation( _shader_scene_terrain.id, "uBlendOffset" );
11239 _uniform_scene_terrain_g_world_depth = glGetUniformLocation( _shader_scene_terrain.id, "g_world_depth" );
11240 _uniform_scene_terrain_uLightsArray = glGetUniformLocation( _shader_scene_terrain.id, "uLightsArray" );
11241 _uniform_scene_terrain_uLightsIndex = glGetUniformLocation( _shader_scene_terrain.id, "uLightsIndex" );
11242 _uniform_scene_route_uMdl = glGetUniformLocation( _shader_scene_route.id, "uMdl" );
11243 _uniform_scene_route_uPv = glGetUniformLocation( _shader_scene_route.id, "uPv" );
11244 _uniform_scene_route_uPvmPrev = glGetUniformLocation( _shader_scene_route.id, "uPvmPrev" );
11245 _uniform_scene_route_uNormalMtx = glGetUniformLocation( _shader_scene_route.id, "uNormalMtx" );
11246 _uniform_scene_route_uTexGarbage = glGetUniformLocation( _shader_scene_route.id, "uTexGarbage" );
11247 _uniform_scene_route_uTexGradients = glGetUniformLocation( _shader_scene_route.id, "uTexGradients" );
11248 _uniform_scene_route_uCamera = glGetUniformLocation( _shader_scene_route.id, "uCamera" );
11249 _uniform_scene_route_uColour = glGetUniformLocation( _shader_scene_route.id, "uColour" );
11250 _uniform_scene_route_g_world_depth = glGetUniformLocation( _shader_scene_route.id, "g_world_depth" );
11251 _uniform_scene_route_uLightsArray = glGetUniformLocation( _shader_scene_route.id, "uLightsArray" );
11252 _uniform_scene_route_uLightsIndex = glGetUniformLocation( _shader_scene_route.id, "uLightsIndex" );
11253 _uniform_scene_depth_uMdl = glGetUniformLocation( _shader_scene_depth.id, "uMdl" );
11254 _uniform_scene_depth_uPv = glGetUniformLocation( _shader_scene_depth.id, "uPv" );
11255 _uniform_scene_depth_uPvmPrev = glGetUniformLocation( _shader_scene_depth.id, "uPvmPrev" );
11256 _uniform_scene_depth_uCamera = glGetUniformLocation( _shader_scene_depth.id, "uCamera" );
11257 _uniform_scene_depth_uBoard0 = glGetUniformLocation( _shader_scene_depth.id, "uBoard0" );
11258 _uniform_scene_depth_uBoard1 = glGetUniformLocation( _shader_scene_depth.id, "uBoard1" );
11259 _uniform_scene_depth_g_world_depth = glGetUniformLocation( _shader_scene_depth.id, "g_world_depth" );
11260 _uniform_scene_depth_uLightsArray = glGetUniformLocation( _shader_scene_depth.id, "uLightsArray" );
11261 _uniform_scene_depth_uLightsIndex = glGetUniformLocation( _shader_scene_depth.id, "uLightsIndex" );
11262 _uniform_scene_position_uMdl = glGetUniformLocation( _shader_scene_position.id, "uMdl" );
11263 _uniform_scene_position_uPv = glGetUniformLocation( _shader_scene_position.id, "uPv" );
11264 _uniform_scene_position_uPvmPrev = glGetUniformLocation( _shader_scene_position.id, "uPvmPrev" );
11265 _uniform_scene_position_uCamera = glGetUniformLocation( _shader_scene_position.id, "uCamera" );
11266 _uniform_scene_position_uBoard0 = glGetUniformLocation( _shader_scene_position.id, "uBoard0" );
11267 _uniform_scene_position_uBoard1 = glGetUniformLocation( _shader_scene_position.id, "uBoard1" );
11268 _uniform_scene_position_g_world_depth = glGetUniformLocation( _shader_scene_position.id, "g_world_depth" );
11269 _uniform_scene_position_uLightsArray = glGetUniformLocation( _shader_scene_position.id, "uLightsArray" );
11270 _uniform_scene_position_uLightsIndex = glGetUniformLocation( _shader_scene_position.id, "uLightsIndex" );
11271 _uniform_scene_cubemapped_uMdl = glGetUniformLocation( _shader_scene_cubemapped.id, "uMdl" );
11272 _uniform_scene_cubemapped_uPv = glGetUniformLocation( _shader_scene_cubemapped.id, "uPv" );
11273 _uniform_scene_cubemapped_uPvmPrev = glGetUniformLocation( _shader_scene_cubemapped.id, "uPvmPrev" );
11274 _uniform_scene_cubemapped_uTexGarbage = glGetUniformLocation( _shader_scene_cubemapped.id, "uTexGarbage" );
11275 _uniform_scene_cubemapped_uTexMain = glGetUniformLocation( _shader_scene_cubemapped.id, "uTexMain" );
11276 _uniform_scene_cubemapped_uTexCubemap = glGetUniformLocation( _shader_scene_cubemapped.id, "uTexCubemap" );
11277 _uniform_scene_cubemapped_uCamera = glGetUniformLocation( _shader_scene_cubemapped.id, "uCamera" );
11278 _uniform_scene_cubemapped_uPlane = glGetUniformLocation( _shader_scene_cubemapped.id, "uPlane" );
11279 _uniform_scene_cubemapped_uColour = glGetUniformLocation( _shader_scene_cubemapped.id, "uColour" );
11280 _uniform_scene_cubemapped_g_world_depth = glGetUniformLocation( _shader_scene_cubemapped.id, "g_world_depth" );
11281 _uniform_scene_cubemapped_uLightsArray = glGetUniformLocation( _shader_scene_cubemapped.id, "uLightsArray" );
11282 _uniform_scene_cubemapped_uLightsIndex = glGetUniformLocation( _shader_scene_cubemapped.id, "uLightsIndex" );
11283 _uniform_scene_water_uMdl = glGetUniformLocation( _shader_scene_water.id, "uMdl" );
11284 _uniform_scene_water_uPv = glGetUniformLocation( _shader_scene_water.id, "uPv" );
11285 _uniform_scene_water_uPvmPrev = glGetUniformLocation( _shader_scene_water.id, "uPvmPrev" );
11286 _uniform_scene_water_uTexMain = glGetUniformLocation( _shader_scene_water.id, "uTexMain" );
11287 _uniform_scene_water_uTexDudv = glGetUniformLocation( _shader_scene_water.id, "uTexDudv" );
11288 _uniform_scene_water_uTexBack = glGetUniformLocation( _shader_scene_water.id, "uTexBack" );
11289 _uniform_scene_water_uInvRes = glGetUniformLocation( _shader_scene_water.id, "uInvRes" );
11290 _uniform_scene_water_uTime = glGetUniformLocation( _shader_scene_water.id, "uTime" );
11291 _uniform_scene_water_uCamera = glGetUniformLocation( _shader_scene_water.id, "uCamera" );
11292 _uniform_scene_water_uSurfaceY = glGetUniformLocation( _shader_scene_water.id, "uSurfaceY" );
11293 _uniform_scene_water_uBoard0 = glGetUniformLocation( _shader_scene_water.id, "uBoard0" );
11294 _uniform_scene_water_uBoard1 = glGetUniformLocation( _shader_scene_water.id, "uBoard1" );
11295 _uniform_scene_water_uShoreColour = glGetUniformLocation( _shader_scene_water.id, "uShoreColour" );
11296 _uniform_scene_water_uOceanColour = glGetUniformLocation( _shader_scene_water.id, "uOceanColour" );
11297 _uniform_scene_water_g_world_depth = glGetUniformLocation( _shader_scene_water.id, "g_world_depth" );
11298 _uniform_scene_water_uLightsArray = glGetUniformLocation( _shader_scene_water.id, "uLightsArray" );
11299 _uniform_scene_water_uLightsIndex = glGetUniformLocation( _shader_scene_water.id, "uLightsIndex" );
11300 _uniform_scene_water_fast_uMdl = glGetUniformLocation( _shader_scene_water_fast.id, "uMdl" );
11301 _uniform_scene_water_fast_uPv = glGetUniformLocation( _shader_scene_water_fast.id, "uPv" );
11302 _uniform_scene_water_fast_uPvmPrev = glGetUniformLocation( _shader_scene_water_fast.id, "uPvmPrev" );
11303 _uniform_scene_water_fast_uTexDudv = glGetUniformLocation( _shader_scene_water_fast.id, "uTexDudv" );
11304 _uniform_scene_water_fast_uTime = glGetUniformLocation( _shader_scene_water_fast.id, "uTime" );
11305 _uniform_scene_water_fast_uCamera = glGetUniformLocation( _shader_scene_water_fast.id, "uCamera" );
11306 _uniform_scene_water_fast_uSurfaceY = glGetUniformLocation( _shader_scene_water_fast.id, "uSurfaceY" );
11307 _uniform_scene_water_fast_uBoard0 = glGetUniformLocation( _shader_scene_water_fast.id, "uBoard0" );
11308 _uniform_scene_water_fast_uBoard1 = glGetUniformLocation( _shader_scene_water_fast.id, "uBoard1" );
11309 _uniform_scene_water_fast_uShoreColour = glGetUniformLocation( _shader_scene_water_fast.id, "uShoreColour" );
11310 _uniform_scene_water_fast_uOceanColour = glGetUniformLocation( _shader_scene_water_fast.id, "uOceanColour" );
11311 _uniform_scene_water_fast_g_world_depth = glGetUniformLocation( _shader_scene_water_fast.id, "g_world_depth" );
11312 _uniform_scene_water_fast_uLightsArray = glGetUniformLocation( _shader_scene_water_fast.id, "uLightsArray" );
11313 _uniform_scene_water_fast_uLightsIndex = glGetUniformLocation( _shader_scene_water_fast.id, "uLightsIndex" );
11314 _uniform_scene_scoretext_uMdl = glGetUniformLocation( _shader_scene_scoretext.id, "uMdl" );
11315 _uniform_scene_scoretext_uPv = glGetUniformLocation( _shader_scene_scoretext.id, "uPv" );
11316 _uniform_scene_scoretext_uPvmPrev = glGetUniformLocation( _shader_scene_scoretext.id, "uPvmPrev" );
11317 _uniform_scene_scoretext_uInfo = glGetUniformLocation( _shader_scene_scoretext.id, "uInfo" );
11318 _uniform_scene_scoretext_uTexGarbage = glGetUniformLocation( _shader_scene_scoretext.id, "uTexGarbage" );
11319 _uniform_scene_scoretext_uTexMain = glGetUniformLocation( _shader_scene_scoretext.id, "uTexMain" );
11320 _uniform_scene_scoretext_uCamera = glGetUniformLocation( _shader_scene_scoretext.id, "uCamera" );
11321 _uniform_scene_scoretext_uPlane = glGetUniformLocation( _shader_scene_scoretext.id, "uPlane" );
11322 _uniform_scene_scoretext_g_world_depth = glGetUniformLocation( _shader_scene_scoretext.id, "g_world_depth" );
11323 _uniform_scene_scoretext_uLightsArray = glGetUniformLocation( _shader_scene_scoretext.id, "uLightsArray" );
11324 _uniform_scene_scoretext_uLightsIndex = glGetUniformLocation( _shader_scene_scoretext.id, "uLightsIndex" );
11325 _uniform_scene_font_uMdl = glGetUniformLocation( _shader_scene_font.id, "uMdl" );
11326 _uniform_scene_font_uPv = glGetUniformLocation( _shader_scene_font.id, "uPv" );
11327 _uniform_scene_font_uPvmPrev = glGetUniformLocation( _shader_scene_font.id, "uPvmPrev" );
11328 _uniform_scene_font_uOffset = glGetUniformLocation( _shader_scene_font.id, "uOffset" );
11329 _uniform_scene_font_uTexGarbage = glGetUniformLocation( _shader_scene_font.id, "uTexGarbage" );
11330 _uniform_scene_font_uTexMain = glGetUniformLocation( _shader_scene_font.id, "uTexMain" );
11331 _uniform_scene_font_uCamera = glGetUniformLocation( _shader_scene_font.id, "uCamera" );
11332 _uniform_scene_font_uTime = glGetUniformLocation( _shader_scene_font.id, "uTime" );
11333 _uniform_scene_font_uOpacity = glGetUniformLocation( _shader_scene_font.id, "uOpacity" );
11334 _uniform_scene_font_uColourize = glGetUniformLocation( _shader_scene_font.id, "uColourize" );
11335 _uniform_scene_font_g_world_depth = glGetUniformLocation( _shader_scene_font.id, "g_world_depth" );
11336 _uniform_scene_font_uLightsArray = glGetUniformLocation( _shader_scene_font.id, "uLightsArray" );
11337 _uniform_scene_font_uLightsIndex = glGetUniformLocation( _shader_scene_font.id, "uLightsIndex" );
11338 _uniform_model_sky_uMdl = glGetUniformLocation( _shader_model_sky.id, "uMdl" );
11339 _uniform_model_sky_uPv = glGetUniformLocation( _shader_model_sky.id, "uPv" );
11340 _uniform_model_sky_uPvmPrev = glGetUniformLocation( _shader_model_sky.id, "uPvmPrev" );
11341 _uniform_model_sky_uTexGarbage = glGetUniformLocation( _shader_model_sky.id, "uTexGarbage" );
11342 _uniform_model_sky_g_world_depth = glGetUniformLocation( _shader_model_sky.id, "g_world_depth" );
11343 _uniform_model_sky_uLightsArray = glGetUniformLocation( _shader_model_sky.id, "uLightsArray" );
11344 _uniform_model_sky_uLightsIndex = glGetUniformLocation( _shader_model_sky.id, "uLightsIndex" );
11345 _uniform_model_sky_space_uMdl = glGetUniformLocation( _shader_model_sky_space.id, "uMdl" );
11346 _uniform_model_sky_space_uPv = glGetUniformLocation( _shader_model_sky_space.id, "uPv" );
11347 _uniform_model_sky_space_uPvmPrev = glGetUniformLocation( _shader_model_sky_space.id, "uPvmPrev" );
11348 _uniform_model_sky_space_uTexGarbage = glGetUniformLocation( _shader_model_sky_space.id, "uTexGarbage" );
11349 _uniform_model_sky_space_g_world_depth = glGetUniformLocation( _shader_model_sky_space.id, "g_world_depth" );
11350 _uniform_model_sky_space_uLightsArray = glGetUniformLocation( _shader_model_sky_space.id, "uLightsArray" );
11351 _uniform_model_sky_space_uLightsIndex = glGetUniformLocation( _shader_model_sky_space.id, "uLightsIndex" );
11352 _uniform_model_menu_uMdl = glGetUniformLocation( _shader_model_menu.id, "uMdl" );
11353 _uniform_model_menu_uPv = glGetUniformLocation( _shader_model_menu.id, "uPv" );
11354 _uniform_model_menu_uPvmPrev = glGetUniformLocation( _shader_model_menu.id, "uPvmPrev" );
11355 _uniform_model_menu_uTexMain = glGetUniformLocation( _shader_model_menu.id, "uTexMain" );
11356 _uniform_model_menu_uColour = glGetUniformLocation( _shader_model_menu.id, "uColour" );
11357 _uniform_model_character_view_uPv = glGetUniformLocation( _shader_model_character_view.id, "uPv" );
11358 _uniform_model_character_view_uTransforms = glGetUniformLocation( _shader_model_character_view.id, "uTransforms" );
11359 _uniform_model_character_view_uTexMain = glGetUniformLocation( _shader_model_character_view.id, "uTexMain" );
11360 _uniform_model_character_view_uCamera = glGetUniformLocation( _shader_model_character_view.id, "uCamera" );
11361 _uniform_model_character_view_g_world_depth = glGetUniformLocation( _shader_model_character_view.id, "g_world_depth" );
11362 _uniform_model_character_view_uLightsArray = glGetUniformLocation( _shader_model_character_view.id, "uLightsArray" );
11363 _uniform_model_character_view_uLightsIndex = glGetUniformLocation( _shader_model_character_view.id, "uLightsIndex" );
11364 _uniform_model_character_view_uTexSceneDepth = glGetUniformLocation( _shader_model_character_view.id, "uTexSceneDepth" );
11365 _uniform_model_character_view_uInverseRatioDepth = glGetUniformLocation( _shader_model_character_view.id, "uInverseRatioDepth" );
11366 _uniform_model_character_view_uInverseRatioMain = glGetUniformLocation( _shader_model_character_view.id, "uInverseRatioMain" );
11367 _uniform_model_character_view_uDepthMode = glGetUniformLocation( _shader_model_character_view.id, "uDepthMode" );
11368 _uniform_model_character_view_uDitherCutoff = glGetUniformLocation( _shader_model_character_view.id, "uDitherCutoff" );
11369 _uniform_model_board_view_uMdl = glGetUniformLocation( _shader_model_board_view.id, "uMdl" );
11370 _uniform_model_board_view_uPv = glGetUniformLocation( _shader_model_board_view.id, "uPv" );
11371 _uniform_model_board_view_uPvmPrev = glGetUniformLocation( _shader_model_board_view.id, "uPvmPrev" );
11372 _uniform_model_board_view_uTexMain = glGetUniformLocation( _shader_model_board_view.id, "uTexMain" );
11373 _uniform_model_board_view_uCamera = glGetUniformLocation( _shader_model_board_view.id, "uCamera" );
11374 _uniform_model_board_view_g_world_depth = glGetUniformLocation( _shader_model_board_view.id, "g_world_depth" );
11375 _uniform_model_board_view_uLightsArray = glGetUniformLocation( _shader_model_board_view.id, "uLightsArray" );
11376 _uniform_model_board_view_uLightsIndex = glGetUniformLocation( _shader_model_board_view.id, "uLightsIndex" );
11377 _uniform_model_board_view_uTexSceneDepth = glGetUniformLocation( _shader_model_board_view.id, "uTexSceneDepth" );
11378 _uniform_model_board_view_uInverseRatioDepth = glGetUniformLocation( _shader_model_board_view.id, "uInverseRatioDepth" );
11379 _uniform_model_board_view_uInverseRatioMain = glGetUniformLocation( _shader_model_board_view.id, "uInverseRatioMain" );
11380 _uniform_model_board_view_uDepthMode = glGetUniformLocation( _shader_model_board_view.id, "uDepthMode" );
11381 _uniform_model_board_view_uDitherCutoff = glGetUniformLocation( _shader_model_board_view.id, "uDitherCutoff" );
11382 _uniform_model_entity_uMdl = glGetUniformLocation( _shader_model_entity.id, "uMdl" );
11383 _uniform_model_entity_uPv = glGetUniformLocation( _shader_model_entity.id, "uPv" );
11384 _uniform_model_entity_uPvmPrev = glGetUniformLocation( _shader_model_entity.id, "uPvmPrev" );
11385 _uniform_model_entity_uTexMain = glGetUniformLocation( _shader_model_entity.id, "uTexMain" );
11386 _uniform_model_entity_uCamera = glGetUniformLocation( _shader_model_entity.id, "uCamera" );
11387 _uniform_model_entity_g_world_depth = glGetUniformLocation( _shader_model_entity.id, "g_world_depth" );
11388 _uniform_model_entity_uLightsArray = glGetUniformLocation( _shader_model_entity.id, "uLightsArray" );
11389 _uniform_model_entity_uLightsIndex = glGetUniformLocation( _shader_model_entity.id, "uLightsIndex" );
11390 _uniform_model_gate_uMdl = glGetUniformLocation( _shader_model_gate.id, "uMdl" );
11391 _uniform_model_gate_uPv = glGetUniformLocation( _shader_model_gate.id, "uPv" );
11392 _uniform_model_gate_uPvmPrev = glGetUniformLocation( _shader_model_gate.id, "uPvmPrev" );
11393 _uniform_model_gate_uTime = glGetUniformLocation( _shader_model_gate.id, "uTime" );
11394 _uniform_model_gate_uCam = glGetUniformLocation( _shader_model_gate.id, "uCam" );
11395 _uniform_model_gate_uInvRes = glGetUniformLocation( _shader_model_gate.id, "uInvRes" );
11396 _uniform_model_gate_uColour = glGetUniformLocation( _shader_model_gate.id, "uColour" );
11397 _uniform_model_gate_unlinked_uMdl = glGetUniformLocation( _shader_model_gate_unlinked.id, "uMdl" );
11398 _uniform_model_gate_unlinked_uPv = glGetUniformLocation( _shader_model_gate_unlinked.id, "uPv" );
11399 _uniform_model_gate_unlinked_uPvmPrev = glGetUniformLocation( _shader_model_gate_unlinked.id, "uPvmPrev" );
11400 _uniform_model_gate_unlinked_uTime = glGetUniformLocation( _shader_model_gate_unlinked.id, "uTime" );
11401 _uniform_model_gate_unlinked_uCam = glGetUniformLocation( _shader_model_gate_unlinked.id, "uCam" );
11402 _uniform_model_gate_unlinked_uColour = glGetUniformLocation( _shader_model_gate_unlinked.id, "uColour" );
11403 _uniform_model_font_uMdl = glGetUniformLocation( _shader_model_font.id, "uMdl" );
11404 _uniform_model_font_uPv = glGetUniformLocation( _shader_model_font.id, "uPv" );
11405 _uniform_model_font_uPvmPrev = glGetUniformLocation( _shader_model_font.id, "uPvmPrev" );
11406 _uniform_model_font_uOffset = glGetUniformLocation( _shader_model_font.id, "uOffset" );
11407 _uniform_model_font_uTexMain = glGetUniformLocation( _shader_model_font.id, "uTexMain" );
11408 _uniform_model_font_uColour = glGetUniformLocation( _shader_model_font.id, "uColour" );
11409 _uniform_model_font_uTexSceneDepth = glGetUniformLocation( _shader_model_font.id, "uTexSceneDepth" );
11410 _uniform_model_font_uInverseRatioDepth = glGetUniformLocation( _shader_model_font.id, "uInverseRatioDepth" );
11411 _uniform_model_font_uInverseRatioMain = glGetUniformLocation( _shader_model_font.id, "uInverseRatioMain" );
11412 _uniform_model_font_uDepthMode = glGetUniformLocation( _shader_model_font.id, "uDepthMode" );
11413 _uniform_model_font_uDitherCutoff = glGetUniformLocation( _shader_model_font.id, "uDitherCutoff" );
11414 _uniform_particle_uPv = glGetUniformLocation( _shader_particle.id, "uPv" );
11415 _uniform_particle_uPvPrev = glGetUniformLocation( _shader_particle.id, "uPvPrev" );
11416 _uniform_trail_uPv = glGetUniformLocation( _shader_trail.id, "uPv" );
11417 _uniform_trail_uPvPrev = glGetUniformLocation( _shader_trail.id, "uPvPrev" );
11418 _uniform_trail_uColour = glGetUniformLocation( _shader_trail.id, "uColour" );
11419 _uniform_blit_uInverseRatio = glGetUniformLocation( _shader_blit.id, "uInverseRatio" );
11420 _uniform_blit_uTexMain = glGetUniformLocation( _shader_blit.id, "uTexMain" );
11421 _uniform_blitblur_uInverseRatio = glGetUniformLocation( _shader_blitblur.id, "uInverseRatio" );
11422 _uniform_blitblur_uTexMain = glGetUniformLocation( _shader_blitblur.id, "uTexMain" );
11423 _uniform_blitblur_uTexMotion = glGetUniformLocation( _shader_blitblur.id, "uTexMotion" );
11424 _uniform_blitblur_uBlurStrength = glGetUniformLocation( _shader_blitblur.id, "uBlurStrength" );
11425 _uniform_blitblur_uOverrideDir = glGetUniformLocation( _shader_blitblur.id, "uOverrideDir" );
11426 _uniform_blitblur_uTime = glGetUniformLocation( _shader_blitblur.id, "uTime" );
11427 _uniform_blitblur_uGlitchStrength = glGetUniformLocation( _shader_blitblur.id, "uGlitchStrength" );
11428 _uniform_blitblur_uClampUv = glGetUniformLocation( _shader_blitblur.id, "uClampUv" );
11429 _uniform_blitcolour_uInverseRatio = glGetUniformLocation( _shader_blitcolour.id, "uInverseRatio" );
11430 _uniform_blitcolour_uColour = glGetUniformLocation( _shader_blitcolour.id, "uColour" );
11431 _uniform_blit_transition_uInverseRatio = glGetUniformLocation( _shader_blit_transition.id, "uInverseRatio" );
11432 _uniform_blit_transition_uT = glGetUniformLocation( _shader_blit_transition.id, "uT" );
11433 _uniform_routeui_uOffset = glGetUniformLocation( _shader_routeui.id, "uOffset" );
11434 _uniform_routeui_uColour = glGetUniformLocation( _shader_routeui.id, "uColour" );
11435 }
11436
11437 void vg_auto_shader_register(void)
11438 {
11439 vg_shader_register( &_shader_scene_standard );
11440 vg_shader_register( &_shader_scene_standard_alphatest );
11441 vg_shader_register( &_shader_scene_foliage );
11442 vg_shader_register( &_shader_scene_override );
11443 vg_shader_register( &_shader_scene_fxglow );
11444 vg_shader_register( &_shader_scene_vertex_blend );
11445 vg_shader_register( &_shader_scene_terrain );
11446 vg_shader_register( &_shader_scene_route );
11447 vg_shader_register( &_shader_scene_depth );
11448 vg_shader_register( &_shader_scene_position );
11449 vg_shader_register( &_shader_scene_cubemapped );
11450 vg_shader_register( &_shader_scene_water );
11451 vg_shader_register( &_shader_scene_water_fast );
11452 vg_shader_register( &_shader_scene_scoretext );
11453 vg_shader_register( &_shader_scene_font );
11454 vg_shader_register( &_shader_model_sky );
11455 vg_shader_register( &_shader_model_sky_space );
11456 vg_shader_register( &_shader_model_menu );
11457 vg_shader_register( &_shader_model_character_view );
11458 vg_shader_register( &_shader_model_board_view );
11459 vg_shader_register( &_shader_model_entity );
11460 vg_shader_register( &_shader_model_gate );
11461 vg_shader_register( &_shader_model_gate_unlinked );
11462 vg_shader_register( &_shader_model_font );
11463 vg_shader_register( &_shader_particle );
11464 vg_shader_register( &_shader_trail );
11465 vg_shader_register( &_shader_blit );
11466 vg_shader_register( &_shader_blitblur );
11467 vg_shader_register( &_shader_blitcolour );
11468 vg_shader_register( &_shader_blit_transition );
11469 vg_shader_register( &_shader_routeui );
11470 }
11471