cool font shader and entity bvh fix
[carveJwlIkooP6JGAAIwe30JlM.git] / world_render.c
1 /*
2 * Copyright (C) 2021-2023 Mt.ZERO Software, Harry Godden - All Rights Reserved
3 */
4
5 #ifndef WORLD_RENDER_C
6 #define WORLD_RENDER_C
7
8 #include "world.h"
9 #include "world_render.h"
10 #include "font.h"
11 #include "gui.h"
12
13 static int ccmd_set_time( int argc, const char *argv[] ){
14 if( argc == 1 ){
15 world_instance *world = world_current_instance();
16 world->time = atof( argv[0] );
17 }
18 else {
19 vg_error( "Usage set_time <0-1.0>\n" );
20 }
21 return 0;
22 }
23
24 VG_STATIC void async_world_render_init( void *payload, u32 size )
25 {
26 vg_info( "Allocate uniform buffers\n" );
27 for( int i=0; i<4; i++ ){
28 world_instance *world = &world_static.instances[i];
29 world->ubo_bind_point = i;
30
31 glGenBuffers( 1, &world->ubo_lighting );
32 glBindBuffer( GL_UNIFORM_BUFFER, world->ubo_lighting );
33 glBufferData( GL_UNIFORM_BUFFER, sizeof(struct ub_world_lighting),
34 NULL, GL_DYNAMIC_DRAW );
35
36 glBindBufferBase( GL_UNIFORM_BUFFER, i, world->ubo_lighting );
37 VG_CHECK_GL_ERR();
38 }
39
40 vg_info( "Allocate frame buffers\n" );
41 for( int i=0; i<4; i++ ){
42 world_instance *world = &world_static.instances[i];
43 struct framebuffer *fb = &world->heightmap;
44
45 fb->display_name = NULL;
46 fb->link = NULL;
47 fb->fixed_w = 1024;
48 fb->fixed_h = 1024;
49 fb->resolution_div = 0;
50
51 fb->attachments[0].display_name = NULL;
52 fb->attachments[0].purpose = k_framebuffer_attachment_type_texture;
53 fb->attachments[0].internalformat = GL_RG16F;
54 fb->attachments[0].format = GL_RG;
55 fb->attachments[0].type = GL_FLOAT;
56 fb->attachments[0].attachment = GL_COLOR_ATTACHMENT0;
57
58 fb->attachments[1].purpose = k_framebuffer_attachment_type_none;
59 fb->attachments[2].purpose = k_framebuffer_attachment_type_none;
60 fb->attachments[3].purpose = k_framebuffer_attachment_type_none;
61 fb->attachments[4].purpose = k_framebuffer_attachment_type_none;
62
63 render_fb_allocate( fb );
64 }
65 }
66
67 VG_STATIC void world_render_init(void)
68 {
69 VG_VAR_F32( k_day_length );
70 VG_VAR_I32( k_debug_light_indices );
71 VG_VAR_I32( k_debug_light_complexity );
72 VG_VAR_I32( k_light_preview );
73 vg_console_reg_cmd( "set_time", ccmd_set_time, NULL );
74
75 world_render.sky_rate = 1.0;
76 world_render.sky_target_rate = 1.0;
77
78 shader_scene_standard_register();
79 shader_scene_standard_alphatest_register();
80 shader_scene_cubemapped_register();
81 shader_scene_fxglow_register();
82 shader_scene_vertex_blend_register();
83 shader_scene_terrain_register();
84 shader_scene_depth_register();
85 shader_scene_position_register();
86 shader_model_sky_register();
87
88 vg_info( "Loading world resources\n" );
89 vg_linear_clear( vg_mem.scratch );
90
91 mdl_context msky;
92 mdl_open( &msky, "models/rs_skydome.mdl", vg_mem.scratch );
93 mdl_load_metadata_block( &msky, vg_mem.scratch );
94 mdl_async_load_glmesh( &msky, &world_render.skydome );
95 mdl_close( &msky );
96
97 vg_info( "Loading default world textures\n" );
98 vg_tex2d_load_qoi_async_file( "textures/garbage.qoi",
99 VG_TEX2D_NEAREST|VG_TEX2D_REPEAT,
100 &world_render.tex_terrain_noise );
101
102 vg_async_call( async_world_render_init, NULL, 0 );
103 }
104
105 VG_STATIC void world_link_lighting_ub( world_instance *world, GLuint shader )
106 {
107 GLuint idx = glGetUniformBlockIndex( shader, "ub_world_lighting" );
108 glUniformBlockBinding( shader, idx, world->ubo_bind_point );
109 }
110
111 VG_STATIC void world_bind_position_texture( world_instance *world,
112 GLuint shader, GLuint location,
113 int slot )
114 {
115 render_fb_bind_texture( &world->heightmap, 0, slot );
116 glUniform1i( location, slot );
117 }
118
119 VG_STATIC void world_bind_light_array( world_instance *world,
120 GLuint shader, GLuint location,
121 int slot )
122 {
123 glActiveTexture( GL_TEXTURE0 + slot );
124 glBindTexture( GL_TEXTURE_BUFFER, world->tex_light_entities );
125 glUniform1i( location, slot );
126 }
127
128 VG_STATIC void world_bind_light_index( world_instance *world,
129 GLuint shader, GLuint location,
130 int slot )
131 {
132 glActiveTexture( GL_TEXTURE0 + slot );
133 glBindTexture( GL_TEXTURE_3D, world->tex_light_cubes );
134 glUniform1i( location, slot );
135 }
136
137 VG_STATIC void render_world_depth( world_instance *world, camera *cam );
138
139 /*
140 * Rendering
141 */
142
143 VG_STATIC void bind_terrain_noise(void)
144 {
145 glActiveTexture( GL_TEXTURE0 );
146 glBindTexture( GL_TEXTURE_2D, world_render.tex_terrain_noise );
147 }
148
149 struct world_pass{
150 camera *cam;
151 enum mdl_shader shader;
152 enum world_geo_type geo_type;
153
154 void (*fn_bind_textures)( world_instance *world,
155 struct world_surface *mat );
156 void (*fn_set_mdl)( m4x3f mdl );
157 void (*fn_set_uPvmPrev)( m4x4f pvm );
158 };
159
160 VG_STATIC
161 void world_render_traffic( world_instance *world, u32 material_id,
162 struct world_pass *pass ){
163 if( !mdl_arrcount( &world->ent_traffic ) ) return;
164
165 /* HACK: use the first material for every traffic entity */
166 ent_traffic *first = mdl_arritm( &world->ent_traffic, 0 );
167 if( !first->submesh_count ) return;
168
169 mdl_submesh *sm = mdl_arritm( &world->meta.submeshs, first->submesh_start );
170 if( sm->material_id != material_id ) return;
171
172 struct world_surface *mat = &world->surfaces[ material_id ];
173 pass->fn_bind_textures( world, mat );
174
175 for( u32 j=0; j<mdl_arrcount( &world->ent_traffic ); j++ ){
176 ent_traffic *traffic = mdl_arritm( &world->ent_traffic, j );
177
178 for( u32 k=0; k<traffic->submesh_count; k++ ){
179 sm = mdl_arritm( &world->meta.submeshs,
180 traffic->submesh_start+k );
181
182 m4x3f mmdl;
183 q_m3x3( traffic->transform.q, mmdl );
184 v3_copy( traffic->transform.co, mmdl[3] );
185
186 m4x4f m4mdl;
187 m4x3_expand( mmdl, m4mdl );
188 m4x4_mul( pass->cam->mtx_prev.pv, m4mdl, m4mdl );
189
190 pass->fn_set_mdl( mmdl );
191 pass->fn_set_uPvmPrev( m4mdl );
192
193 mdl_draw_submesh( sm );
194 }
195 }
196 }
197
198 VG_STATIC
199 void world_render_pass( world_instance *world, struct world_pass *pass ){
200 for( int i=0; i<world->surface_count; i++ ){
201 struct world_surface *mat = &world->surfaces[i];
202
203 if( mat->info.shader == pass->shader ){
204 mdl_submesh *sm;
205
206 if( pass->geo_type == k_world_geo_type_solid ){
207 sm = &mat->sm_geo;
208 }
209 else{
210 world_render_traffic( world, i, pass );
211 sm = &mat->sm_no_collide;
212 }
213
214 if( !sm->indice_count )
215 continue;
216
217 m4x3f mmdl;
218 m4x3_identity( mmdl );
219 pass->fn_set_mdl( mmdl );
220 pass->fn_set_uPvmPrev( pass->cam->mtx_prev.pv );
221
222 pass->fn_bind_textures( world, mat );
223 mdl_draw_submesh( sm );
224 }
225 }
226 }
227
228 VG_STATIC
229 void world_render_both_stages( world_instance *world, struct world_pass *pass )
230 {
231 mesh_bind( &world->mesh_geo );
232 pass->geo_type = k_world_geo_type_solid;
233 world_render_pass( world, pass );
234
235 glDisable( GL_CULL_FACE );
236 mesh_bind( &world->mesh_no_collide );
237 pass->geo_type = k_world_geo_type_nonsolid;
238 world_render_pass( world, pass );
239 glEnable( GL_CULL_FACE );
240 }
241
242 VG_STATIC void bindpoint_diffuse_texture1( world_instance *world,
243 struct world_surface *mat )
244
245 {
246 glActiveTexture( GL_TEXTURE1 );
247 glBindTexture( GL_TEXTURE_2D, world->textures[ mat->info.tex_diffuse ] );
248 }
249
250 VG_STATIC void bindpoint_diffuse1_and_cubemap10( world_instance *world,
251 struct world_surface *mat ){
252 glActiveTexture( GL_TEXTURE1 );
253 glBindTexture( GL_TEXTURE_2D, world->textures[ mat->info.tex_diffuse ] );
254
255 u32 cubemap_id = mat->info.tex_none0,
256 cubemap_index = 0;
257
258 if( mdl_entity_id_type( cubemap_id ) == k_ent_cubemap ){
259 cubemap_index = mdl_entity_id_id( cubemap_id );
260 }
261
262 ent_cubemap *cm = mdl_arritm( &world->ent_cubemap, cubemap_index );
263 glActiveTexture( GL_TEXTURE10 );
264 glBindTexture( GL_TEXTURE_CUBE_MAP, cm->texture_id );
265
266 shader_scene_cubemapped_uColour( mat->info.colour );
267 }
268
269 VG_STATIC void render_world_vb( world_instance *world, camera *cam )
270 {
271 shader_scene_vertex_blend_use();
272 shader_scene_vertex_blend_uTexGarbage(0);
273 shader_scene_vertex_blend_uTexGradients(1);
274 world_link_lighting_ub( world, _shader_scene_vertex_blend.id );
275 world_bind_position_texture( world, _shader_scene_vertex_blend.id,
276 _uniform_scene_vertex_blend_g_world_depth, 2 );
277 world_bind_light_array( world, _shader_scene_vertex_blend.id,
278 _uniform_scene_vertex_blend_uLightsArray, 3 );
279 world_bind_light_index( world, _shader_scene_vertex_blend.id,
280 _uniform_scene_vertex_blend_uLightsIndex, 4 );
281
282 glActiveTexture( GL_TEXTURE0 );
283 glBindTexture( GL_TEXTURE_2D, world_render.tex_terrain_noise );
284
285 shader_scene_vertex_blend_uPv( cam->mtx.pv );
286 shader_scene_vertex_blend_uCamera( cam->transform[3] );
287
288 struct world_pass pass = {
289 .shader = k_shader_standard_vertex_blend,
290 .cam = cam,
291 .fn_bind_textures = bindpoint_diffuse_texture1,
292 .fn_set_mdl = shader_scene_vertex_blend_uMdl,
293 .fn_set_uPvmPrev = shader_scene_vertex_blend_uPvmPrev,
294 };
295
296 world_render_both_stages( world, &pass );
297 }
298
299 VG_STATIC void world_shader_standard_bind( world_instance *world, camera *cam ){
300 shader_scene_standard_use();
301 shader_scene_standard_uTexGarbage(0);
302 shader_scene_standard_uTexMain(1);
303 shader_scene_standard_uPv( cam->mtx.pv );
304
305 world_link_lighting_ub( world, _shader_scene_standard.id );
306 world_bind_position_texture( world, _shader_scene_standard.id,
307 _uniform_scene_standard_g_world_depth, 2 );
308 world_bind_light_array( world, _shader_scene_standard.id,
309 _uniform_scene_standard_uLightsArray, 3 );
310 world_bind_light_index( world, _shader_scene_standard.id,
311 _uniform_scene_standard_uLightsIndex, 4 );
312
313 bind_terrain_noise();
314 shader_scene_standard_uCamera( cam->transform[3] );
315 }
316
317 VG_STATIC void render_world_standard( world_instance *world, camera *cam ){
318 world_shader_standard_bind( world, cam );
319 struct world_pass pass = {
320 .shader = k_shader_standard,
321 .cam = cam,
322 .fn_bind_textures = bindpoint_diffuse_texture1,
323 .fn_set_mdl = shader_scene_standard_uMdl,
324 .fn_set_uPvmPrev = shader_scene_standard_uPvmPrev,
325 };
326
327 world_render_both_stages( world, &pass );
328 }
329
330 VG_STATIC void render_world_cubemapped( world_instance *world, camera *cam,
331 int layer_depth ){
332 if( !mdl_arrcount( &world->ent_cubemap ) )
333 return;
334
335 if( layer_depth == -1 ){
336 world_shader_standard_bind( world, cam );
337
338 struct world_pass pass = {
339 .shader = k_shader_cubemap,
340 .cam = cam,
341 .fn_bind_textures = bindpoint_diffuse_texture1,
342 .fn_set_mdl = shader_scene_standard_uMdl,
343 .fn_set_uPvmPrev = shader_scene_standard_uPvmPrev,
344 };
345
346 world_render_both_stages( world, &pass );
347 }
348 else {
349 shader_scene_cubemapped_use();
350 shader_scene_cubemapped_uTexGarbage(0);
351 shader_scene_cubemapped_uTexMain(1);
352 shader_scene_cubemapped_uTexCubemap(10);
353 shader_scene_cubemapped_uPv( cam->mtx.pv );
354
355 world_link_lighting_ub( world, _shader_scene_cubemapped.id );
356 world_bind_position_texture( world, _shader_scene_cubemapped.id,
357 _uniform_scene_cubemapped_g_world_depth, 2 );
358 world_bind_light_array( world, _shader_scene_cubemapped.id,
359 _uniform_scene_cubemapped_uLightsArray, 3 );
360 world_bind_light_index( world, _shader_scene_cubemapped.id,
361 _uniform_scene_cubemapped_uLightsIndex, 4 );
362
363 bind_terrain_noise();
364 shader_scene_cubemapped_uCamera( cam->transform[3] );
365
366 struct world_pass pass = {
367 .shader = k_shader_cubemap,
368 .cam = cam,
369 .fn_bind_textures = bindpoint_diffuse1_and_cubemap10,
370 .fn_set_mdl = shader_scene_cubemapped_uMdl,
371 .fn_set_uPvmPrev = shader_scene_cubemapped_uPvmPrev,
372 };
373
374 world_render_both_stages( world, &pass );
375 }
376 }
377
378 VG_STATIC void render_world_alphatest( world_instance *world, camera *cam ){
379 shader_scene_standard_alphatest_use();
380 shader_scene_standard_alphatest_uTexGarbage(0);
381 shader_scene_standard_alphatest_uTexMain(1);
382 shader_scene_standard_alphatest_uPv( cam->mtx.pv );
383
384 world_link_lighting_ub( world, _shader_scene_standard_alphatest.id );
385 world_bind_position_texture( world, _shader_scene_standard_alphatest.id,
386 _uniform_scene_standard_alphatest_g_world_depth, 2 );
387 world_bind_light_array( world, _shader_scene_standard_alphatest.id,
388 _uniform_scene_standard_alphatest_uLightsArray, 3 );
389 world_bind_light_index( world, _shader_scene_standard_alphatest.id,
390 _uniform_scene_standard_alphatest_uLightsIndex, 4 );
391
392
393 bind_terrain_noise();
394
395
396 shader_scene_standard_alphatest_uCamera( cam->transform[3] );
397
398 glDisable(GL_CULL_FACE);
399
400 struct world_pass pass = {
401 .shader = k_shader_standard_cutout,
402 .cam = cam,
403 .fn_bind_textures = bindpoint_diffuse_texture1,
404 .fn_set_mdl = shader_scene_standard_alphatest_uMdl,
405 .fn_set_uPvmPrev = shader_scene_standard_alphatest_uPvmPrev,
406 };
407
408 world_render_both_stages( world, &pass );
409
410 glEnable(GL_CULL_FACE);
411 }
412
413 VG_STATIC
414 void world_render_challenges( world_instance *world, struct world_pass *pass,
415 v3f pos, int layer_depth ){
416 if( !world ) return;
417
418 /* sort lists */
419 const f32 radius = 40.0f;
420 bh_iter it;
421 bh_iter_init_range( 0, &it, pos, radius+10.0f );
422 i32 idx;
423
424 u32 challenge_list[ 32 ],
425 unlock_list[ 32 ];
426
427 u32 challenge_count = 0,
428 unlock_count = 0;
429
430 while( bh_next( world->entity_bh, &it, &idx ) ){
431 u32 id = world->entity_list[ idx ],
432 type = mdl_entity_id_type( id ),
433 index = mdl_entity_id_id( id );
434
435 if( type == k_ent_challenge ) {
436 if( challenge_count < vg_list_size(challenge_list) )
437 challenge_list[ challenge_count ++ ] = index;
438 }
439 else if( type == k_ent_unlock ){
440 if( unlock_count < vg_list_size(unlock_list) )
441 unlock_list[ unlock_count ++ ] = index;
442 }
443 }
444
445 /* render challenges */
446 glDisable( GL_CULL_FACE );
447 mesh_bind( &world->mesh_no_collide );
448 u32 last_material = 0;
449 for( u32 i=0; i<challenge_count; i++ ){
450 u32 index = challenge_list[ i ];
451 ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index );
452 if( challenge->flags & k_ent_challenge_hidden ) continue;
453
454 f32 dist = v3_dist( challenge->transform.co, pos ) * (1.0f/radius),
455 scale = vg_smoothstepf( vg_clampf( 5.0f-dist*5.0f, 0.0f,1.0f ) );
456
457 v3_fill( challenge->transform.s, scale );
458
459 m4x3f mmdl;
460 mdl_transform_m4x3( &challenge->transform, mmdl );
461 shader_scene_fxglow_uMdl( mmdl );
462
463 for( u32 j=0; j<challenge->submesh_count; j++ ){
464 mdl_submesh *sm = mdl_arritm( &world->meta.submeshs,
465 challenge->submesh_start + j );
466
467 if( sm->material_id != last_material ){
468 last_material = sm->material_id;
469
470 pass->fn_bind_textures( world, &world->surfaces[sm->material_id] );
471 }
472
473 mdl_draw_submesh( sm );
474 }
475 }
476
477 /* render texts */
478 shader_scene_font_use();
479 shader_scene_font_uTexGarbage(0);
480 shader_scene_font_uTexMain(1);
481 shader_scene_font_uPv( skaterift.cam.mtx.pv );
482 shader_scene_font_uTime( vg.time );
483
484 /* TODO: Code dupe... */
485 world_link_lighting_ub( world, _shader_scene_font.id );
486 world_bind_position_texture( world, _shader_scene_font.id,
487 _uniform_scene_font_g_world_depth, 2 );
488 world_bind_light_array( world, _shader_scene_font.id,
489 _uniform_scene_font_uLightsArray, 3 );
490 world_bind_light_index( world, _shader_scene_font.id,
491 _uniform_scene_font_uLightsIndex, 4 );
492
493 bind_terrain_noise();
494 shader_scene_font_uCamera( skaterift.cam.transform[3] );
495
496 //shader_scene_font_uColour( (v4f){1.0f,1.0f,1.0f,1.0f} );
497 glActiveTexture( GL_TEXTURE1 );
498 glBindTexture( GL_TEXTURE_2D, gui.font.texture );
499
500 mesh_bind( &gui.font.mesh );
501
502 char buf[32];
503 u32 count = 0;
504
505 for( u32 i=0; i<mdl_arrcount(&world->ent_unlock); i++ ){
506 ent_unlock *unlock = mdl_arritm( &world->ent_unlock, i );
507 vg_line_point( unlock->transform.co, 0.2f, VG__GREEN );
508 if( unlock->status ) count ++;
509 }
510
511 int c=0;
512 c+=highscore_intl( buf+c, count, 3 );
513 buf[c++] = '/';
514 c+=highscore_intl( buf+c, mdl_arrcount(&world->ent_unlock), 3 );
515 buf[c++] = '\0';
516
517 f32 w = font3d_string_width( &gui.font, 1, buf );
518 m4x3f mlocal;
519 m3x3_identity( mlocal );
520 mlocal[3][0] = -w*0.5f;
521
522 for( u32 i=0; i<unlock_count; i++ ){
523 u32 index = unlock_list[ i ];
524 ent_unlock *unlock = mdl_arritm( &world->ent_unlock, index );
525 m4x3f mmdl;
526 mdl_transform_m4x3( &unlock->transform, mmdl );
527 m4x3_mul( mmdl, mlocal, mmdl );
528
529 vg_line_point( unlock->transform.co, 0.25f, VG__RED );
530
531 f32 dist = v3_dist( unlock->transform.co, pos ) * (1.0f/radius),
532 scale = vg_smoothstepf( vg_clampf( 10.0f-dist*10.0f, 0.0f,1.0f ) ),
533 colour = 0.0f;
534
535 if( unlock->status )
536 colour = 1.0f;
537
538 shader_scene_font_uOpacity( scale );
539 shader_scene_font_uColourize( colour );
540
541 struct font3d_render render = {
542 .font = &gui.font,
543 .variant_id = 1,
544 .shader = k_font_shader_world
545 };
546
547 font3d_begin( buf, &skaterift.cam, mmdl, &render );
548 font3d_draw( &render );
549 }
550 }
551
552 VG_STATIC void render_world_fxglow( world_instance *world, camera *cam,
553 int layer_depth ){
554 shader_scene_fxglow_use();
555 shader_scene_fxglow_uTexMain(1);
556 shader_scene_fxglow_uPv( cam->mtx.pv );
557
558 world_link_lighting_ub( world, _shader_scene_fxglow.id );
559 world_bind_position_texture( world, _shader_scene_fxglow.id,
560 _uniform_scene_fxglow_g_world_depth, 2 );
561 world_bind_light_array( world, _shader_scene_fxglow.id,
562 _uniform_scene_fxglow_uLightsArray, 3 );
563 world_bind_light_index( world, _shader_scene_fxglow.id,
564 _uniform_scene_fxglow_uLightsIndex, 4 );
565
566 shader_scene_fxglow_uCamera( cam->transform[3] );
567 glDisable(GL_CULL_FACE);
568
569 struct world_pass pass = {
570 .shader = k_shader_fxglow,
571 .cam = cam,
572 .fn_bind_textures = bindpoint_diffuse_texture1,
573 .fn_set_mdl = shader_scene_fxglow_uMdl,
574 .fn_set_uPvmPrev = shader_scene_fxglow_uPvmPrev,
575 };
576
577 world_render_both_stages( world, &pass );
578 world_render_challenges( world, &pass, cam->pos, layer_depth );
579
580 glEnable(GL_CULL_FACE);
581 }
582
583 VG_STATIC void bindpoint_terrain( world_instance *world,
584 struct world_surface *mat )
585 {
586 glActiveTexture( GL_TEXTURE1 );
587 glBindTexture( GL_TEXTURE_2D, world->textures[ mat->info.tex_diffuse ] );
588
589 shader_scene_terrain_uSandColour( mat->info.colour );
590 shader_scene_terrain_uBlendOffset( mat->info.colour1 );
591 }
592
593 VG_STATIC void render_terrain( world_instance *world, camera *cam )
594 {
595 shader_scene_terrain_use();
596 shader_scene_terrain_uTexGarbage(0);
597 shader_scene_terrain_uTexGradients(1);
598
599 world_link_lighting_ub( world, _shader_scene_terrain.id );
600 world_bind_position_texture( world, _shader_scene_terrain.id,
601 _uniform_scene_terrain_g_world_depth, 2 );
602 world_bind_light_array( world, _shader_scene_terrain.id,
603 _uniform_scene_terrain_uLightsArray, 3 );
604 world_bind_light_index( world, _shader_scene_terrain.id,
605 _uniform_scene_terrain_uLightsIndex, 4 );
606
607 glActiveTexture( GL_TEXTURE0 );
608 glBindTexture( GL_TEXTURE_2D, world_render.tex_terrain_noise );
609
610 shader_scene_terrain_uPv( cam->mtx.pv );
611 shader_scene_terrain_uCamera( cam->transform[3] );
612
613 struct world_pass pass = {
614 .shader = k_shader_terrain_blend,
615 .cam = cam,
616 .fn_bind_textures = bindpoint_terrain,
617 .fn_set_mdl = shader_scene_terrain_uMdl,
618 .fn_set_uPvmPrev = shader_scene_terrain_uPvmPrev,
619 };
620
621 world_render_both_stages( world, &pass );
622 }
623
624 VG_STATIC void render_sky( world_instance *world, camera *cam )
625 {
626 /*
627 * Modify matrix to remove clipping and view translation
628 */
629 m4x4f v,
630 v_prev,
631 pv,
632 pv_prev;
633
634 m4x4_copy( cam->mtx.v, v );
635 m4x4_copy( cam->mtx_prev.v, v_prev );
636 v3_zero( v[3] );
637 v3_zero( v_prev[3] );
638
639 m4x4_copy( cam->mtx.p, pv );
640 m4x4_copy( cam->mtx_prev.p, pv_prev );
641 m4x4_reset_clipping( pv, cam->farz, cam->nearz );
642 m4x4_reset_clipping( pv_prev, cam->farz, cam->nearz );
643
644 m4x4_mul( pv, v, pv );
645 m4x4_mul( pv_prev, v_prev, pv_prev );
646
647 m4x3f identity_matrix;
648 m4x3_identity( identity_matrix );
649
650 /*
651 * Draw
652 */
653 shader_model_sky_use();
654 shader_model_sky_uMdl( identity_matrix );
655 shader_model_sky_uPv( pv );
656 shader_model_sky_uPvmPrev( pv_prev );
657 shader_model_sky_uTexGarbage(0);
658 world_link_lighting_ub( world, _shader_model_sky.id );
659
660 glActiveTexture( GL_TEXTURE0 );
661 glBindTexture( GL_TEXTURE_2D, world_render.tex_terrain_noise );
662
663 glDepthMask( GL_FALSE );
664 glDisable( GL_DEPTH_TEST );
665
666 mesh_bind( &world_render.skydome );
667 mesh_draw( &world_render.skydome );
668
669 glEnable( GL_DEPTH_TEST );
670 glDepthMask( GL_TRUE );
671 }
672
673 VG_STATIC void render_world_gates( world_instance *world, camera *cam,
674 int layer_depth )
675 {
676 float closest = INFINITY;
677 struct ent_gate *gate = NULL;
678
679 for( u32 i=0; i<mdl_arrcount(&world->ent_gate); i++ ){
680 ent_gate *gi = mdl_arritm( &world->ent_gate, i );
681
682 if( !(gi->flags & k_ent_gate_linked) )
683 continue;
684
685 float dist = v3_dist2( gi->co[0], cam->transform[3] );
686
687 vg_line_point( gi->co[0], 0.25f, VG__BLUE );
688
689 if( dist < closest ){
690 closest = dist;
691 gate = gi;
692 }
693 }
694
695 world->rendering_gate = gate;
696 if( gate ){
697 if( gate->flags & k_ent_gate_locked ) return;
698
699 if( gate->flags & k_ent_gate_nonlocal ){
700 if( world_static.load_state != k_world_loader_none ){
701 world->rendering_gate = NULL;
702 return;
703 }
704
705 world_instance *dest_world = &world_static.instances[ gate->target ];
706 render_gate( world, dest_world, gate, cam, layer_depth );
707 }
708 else{
709 render_gate( world, world, gate, cam, layer_depth );
710 }
711 }
712 }
713
714 VG_STATIC void world_prerender( world_instance *world )
715 {
716
717 if( mdl_arrcount( &world->ent_light ) ){
718 f32 rate = vg_maxf(0.1f, fabsf(k_day_length)) * vg_signf(k_day_length);
719 world->time += vg.time_delta * (1.0/(rate*60.0));
720 }
721 else{
722 world->time = 0.834;
723 }
724
725 struct ub_world_lighting *state = &world->ub_lighting;
726
727 state->g_time = world->time;
728 state->g_realtime = vg.time;
729 state->g_debug_indices = k_debug_light_indices;
730 state->g_light_preview = k_light_preview;
731 state->g_debug_complexity = k_debug_light_complexity;
732 state->g_time_of_day = vg_fractf( world->time );
733 state->g_day_phase = cosf( state->g_time_of_day * VG_PIf * 2.0f );
734 state->g_sunset_phase= cosf( state->g_time_of_day * VG_PIf * 4.0f + VG_PIf );
735
736 state->g_day_phase = state->g_day_phase * 0.5f + 0.5f;
737 state->g_sunset_phase = powf( state->g_sunset_phase * 0.5f + 0.5f, 6.0f );
738
739 float a = state->g_time_of_day * VG_PIf * 2.0f;
740 state->g_sun_dir[0] = sinf( a );
741 state->g_sun_dir[1] = cosf( a );
742 state->g_sun_dir[2] = 0.2f;
743 v3_normalize( state->g_sun_dir );
744
745 world->probabilities[ k_probability_curve_constant ] = 1.0f;
746 float dp = state->g_day_phase;
747
748 world->probabilities[ k_probability_curve_wildlife_day ] =
749 (dp*dp*0.8f+state->g_sunset_phase)*0.8f;
750 world->probabilities[ k_probability_curve_wildlife_night ] =
751 1.0f-powf(fabsf((state->g_time_of_day-0.5f)*5.0f),5.0f);
752
753 glBindBuffer( GL_UNIFORM_BUFFER, world->ubo_lighting );
754 glBufferSubData( GL_UNIFORM_BUFFER, 0,
755 sizeof(struct ub_world_lighting), &world->ub_lighting );
756 }
757
758 VG_STATIC void skateshop_render(void);
759 VG_STATIC void render_world( world_instance *world, camera *cam,
760 int layer_depth )
761 {
762 render_sky( world, cam );
763
764 render_world_routes( world, cam, layer_depth );
765 render_world_standard( world, cam );
766 render_world_cubemapped( world, cam, layer_depth );
767
768 render_world_vb( world, cam );
769 render_world_alphatest( world, cam );
770 render_world_fxglow( world, cam, layer_depth );
771 render_terrain( world, cam );
772
773 if( layer_depth == 0 ){
774 skateshop_render();
775
776 /* Render SFD's */
777 u32 closest = 0;
778 float min_dist = INFINITY;
779
780 if( !mdl_arrcount( &world->ent_route ) )
781 return;
782
783 for( u32 i=0; i<mdl_arrcount( &world->ent_route ); i++ ){
784 ent_route *route = mdl_arritm( &world->ent_route, i );
785 float dist = v3_dist2( route->board_transform[3], cam->pos );
786
787 if( dist < min_dist ){
788 min_dist = dist;
789 closest = i;
790 }
791 }
792
793 ent_route *route = mdl_arritm( &world->ent_route, closest );
794 sfd_render( world, cam, route->board_transform );
795 }
796 }
797
798 VG_STATIC void render_cubemap_side( world_instance *world, ent_cubemap *cm,
799 u32 side ){
800 camera cam;
801 glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
802 GL_TEXTURE_CUBE_MAP_POSITIVE_X + side, cm->texture_id, 0 );
803 glClear( GL_DEPTH_BUFFER_BIT );
804
805 v3f forward[6] = {
806 { -1.0f, 0.0f, 0.0f },
807 { 1.0f, 0.0f, 0.0f },
808 { 0.0f, -1.0f, 0.0f },
809 { 0.0f, 1.0f, 0.0f },
810 { 0.0f, 0.0f, -1.0f },
811 { 0.0f, 0.0f, 1.0f }
812 };
813 v3f up[6] = {
814 { 0.0f, -1.0f, 0.0f },
815 { 0.0f, -1.0f, 0.0f },
816 { 0.0f, 0.0f, 1.0f },
817 { 0.0f, 0.0f, -1.0f },
818 { 0.0f, -1.0f, 0.0f },
819 { 0.0f, -1.0f, 0.0f }
820 };
821
822 v3_zero( cam.angles );
823 v3_copy( cm->co, cam.pos );
824
825 v3_copy( forward[side], cam.transform[2] );
826 v3_copy( up[side], cam.transform[1] );
827 v3_cross( up[side], forward[side], cam.transform[0] );
828 v3_copy( cm->co, cam.transform[3] );
829 m4x3_invert_affine( cam.transform, cam.transform_inverse );
830
831 camera_update_view( &cam );
832
833 cam.nearz = 0.1f;
834 cam.farz = 1000.0f;
835 cam.fov = 90.0f;
836 m4x4_copy( cam.mtx.p, cam.mtx_prev.p );
837 m4x4_projection( cam.mtx.p, cam.fov, 1.0f, cam.nearz, cam.farz );
838 camera_finalize( &cam );
839 camera_finalize( &cam );
840
841 render_world( world, &cam, -1 );
842 }
843
844 VG_STATIC void render_world_cubemaps( world_instance *world ){
845 if( world->cubemap_cooldown )
846 world->cubemap_cooldown --;
847 else{
848 world->cubemap_cooldown = 60;
849
850 glViewport( 0, 0, WORLD_CUBEMAP_RES, WORLD_CUBEMAP_RES );
851 for( u32 i=0; i<mdl_arrcount( &world->ent_cubemap ); i++ ){
852 ent_cubemap *cm = mdl_arritm( &world->ent_cubemap, i );
853 glBindFramebuffer( GL_FRAMEBUFFER, cm->framebuffer_id );
854
855 world->cubemap_side ++;
856 if( world->cubemap_side >= 6 )
857 world->cubemap_side = 0;
858
859 render_cubemap_side( world, cm, world->cubemap_side );
860 }
861 }
862 }
863
864 VG_STATIC void render_world_depth( world_instance *world, camera *cam )
865 {
866 m4x3f identity_matrix;
867 m4x3_identity( identity_matrix );
868
869 shader_scene_depth_use();
870 shader_scene_depth_uCamera( cam->transform[3] );
871 shader_scene_depth_uPv( cam->mtx.pv );
872 shader_scene_depth_uPvmPrev( cam->mtx_prev.pv );
873 shader_scene_depth_uMdl( identity_matrix );
874 world_link_lighting_ub( world, _shader_scene_depth.id );
875
876 mesh_bind( &world->mesh_geo );
877 mesh_draw( &world->mesh_geo );
878 }
879
880 VG_STATIC void render_world_position( world_instance *world, camera *cam )
881 {
882 m4x3f identity_matrix;
883 m4x3_identity( identity_matrix );
884
885 shader_scene_position_use();
886 shader_scene_position_uCamera( cam->transform[3] );
887 shader_scene_position_uPv( cam->mtx.pv );
888 shader_scene_position_uPvmPrev( cam->mtx_prev.pv );
889 shader_scene_position_uMdl( identity_matrix );
890 world_link_lighting_ub( world, _shader_scene_position.id );
891
892 mesh_bind( &world->mesh_geo );
893 mesh_draw( &world->mesh_geo );
894 }
895
896 #endif