Do actual domain resolution
[carveJwlIkooP6JGAAIwe30JlM.git] / world_gen.c
1 /*
2 * Copyright (C) 2021-2023 Mt.ZERO Software, Harry Godden - All Rights Reserved
3 *
4 * World generation/population. Different to regular loading, since it needs to
5 * create geometry, apply procedural stuff and save that image to files etc.
6 */
7 #include "world.h"
8 #include "world_gen.h"
9 #include "world_load.h"
10 #include "world_volumes.h"
11 #include "world_gate.h"
12 #include <string.h>
13
14 /*
15 * Add all triangles from the model, which match the material ID
16 * applies affine transform to the model
17 */
18 static void world_add_all_if_material( m4x3f transform, scene_context *scene,
19 mdl_context *mdl, u32 id )
20 {
21 for( u32 i=0; i<mdl_arrcount(&mdl->meshs); i++ ){
22 mdl_mesh *mesh = mdl_arritm( &mdl->meshs, i );
23
24 for( u32 j=0; j<mesh->submesh_count; j++ ){
25 mdl_submesh *sm = mdl_arritm( &mdl->submeshs, mesh->submesh_start+j );
26 if( sm->material_id == id ){
27 m4x3f transform2;
28 mdl_transform_m4x3( &mesh->transform, transform2 );
29 m4x3_mul( transform, transform2, transform2 );
30
31 scene_add_mdl_submesh( scene, mdl, sm, transform2 );
32 }
33 }
34 }
35 }
36
37 /*
38 * Adds a small blob shape to the world at a raycast location. This is for the
39 * grass sprites
40 *
41 * /''''\
42 * / \
43 * | |
44 * |________|
45 */
46 static void world_gen_add_blob( vg_rand *rand, world_instance *world,
47 scene_context *scene, ray_hit *hit )
48 {
49 m4x3f transform;
50 v4f qsurface, qrandom;
51 v3f axis;
52
53 v3_cross( (v3f){0.0f,1.0f,0.0f}, hit->normal, axis );
54
55 float angle = v3_dot(hit->normal,(v3f){0.0f,1.0f,0.0f});
56 q_axis_angle( qsurface, axis, angle );
57 q_axis_angle( qrandom, (v3f){0.0f,1.0f,0.0f}, vg_randf64(rand)*VG_TAUf );
58 q_mul( qsurface, qrandom, qsurface );
59 q_m3x3( qsurface, transform );
60 v3_copy( hit->pos, transform[3] );
61
62 scene_vert verts[] =
63 {
64 { .co = { -1.00f, 0.0f, 0.0f } },
65 { .co = { 1.00f, 0.0f, 0.0f } },
66 { .co = { -1.00f, 1.2f, 0.0f } },
67 { .co = { 1.00f, 1.2f, 0.0f } },
68 { .co = { -0.25f, 2.0f, 0.0f } },
69 { .co = { 0.25f, 2.0f, 0.0f } }
70 };
71
72 const u32 indices[] = { 0,1,3, 0,3,2, 2,3,5, 2,5,4 };
73
74 if( scene->vertex_count + vg_list_size(verts) > scene->max_vertices )
75 vg_fatal_error( "Scene vertex buffer overflow" );
76
77 if( scene->indice_count + vg_list_size(indices) > scene->max_indices )
78 vg_fatal_error( "Scene index buffer overflow" );
79
80 scene_vert *dst_verts = &scene->arrvertices[ scene->vertex_count ];
81 u32 *dst_indices = &scene->arrindices [ scene->indice_count ];
82
83 scene_vert *ref = &world->scene_geo.arrvertices[ hit->tri[0] ];
84
85 for( u32 i=0; i<vg_list_size(verts); i++ ){
86 scene_vert *pvert = &dst_verts[ i ],
87 *src = &verts[ i ];
88
89 m4x3_mulv( transform, src->co, pvert->co );
90 scene_vert_pack_norm( pvert, transform[1], 0.0f );
91
92 v2_copy( ref->uv, pvert->uv );
93 }
94
95 for( u32 i=0; i<vg_list_size(indices); i++ )
96 dst_indices[i] = indices[i] + scene->vertex_count;
97
98 scene->vertex_count += vg_list_size(verts);
99 scene->indice_count += vg_list_size(indices);
100 }
101
102 /*
103 * Sprinkle foliage models over the map on terrain material
104 */
105 static void world_apply_procedural_foliage( world_instance *world,
106 scene_context *scene,
107 struct world_surface *mat )
108 {
109 if( (vg.quality_profile == k_quality_profile_low) ||
110 (vg.quality_profile == k_quality_profile_min) )
111 return;
112
113 vg_info( "Applying foliage (%u)\n", mat->info.pstr_name );
114
115 v3f volume;
116 v3_sub( world->scene_geo.bbx[1], world->scene_geo.bbx[0], volume );
117 volume[1] = 1.0f;
118
119 int count = 0;
120
121 float area = volume[0]*volume[2];
122 u32 particles = 0.08f * area;
123
124 vg_info( "Map area: %f. Max particles: %u\n", area, particles );
125
126 u64 t0 = SDL_GetPerformanceCounter();
127 #if 0
128 for( u32 i=0; i<particles; i++ ){
129 v3f pos;
130 v3_mul( volume, (v3f){ vg_randf64(), 1000.0f, vg_randf64() }, pos );
131 pos[1] = 1000.0f;
132 v3_add( pos, world->scene_geo.bbx[0], pos );
133
134 ray_hit hit;
135 hit.dist = INFINITY;
136
137 if( ray_world( world, pos, (v3f){0.0f,-1.0f,0.0f}, &hit,
138 k_material_flag_ghosts )){
139 struct world_surface *m1 = ray_hit_surface( world, &hit );
140 if((hit.normal[1] > 0.8f) && (m1 == mat) && (hit.pos[1] > 0.0f+10.0f)){
141 world_gen_add_blob( world, scene, &hit );
142 count ++;
143 }
144 }
145 }
146 #else
147
148 vg_rand rand;
149 vg_rand_seed( &rand, 3030 );
150
151 const f32 tile_scale = 16.0f;
152 v2i tiles = { volume[0]/tile_scale, volume[2]/tile_scale };
153
154 u32 per_tile = particles/(tiles[0]*tiles[1]);
155
156 for( i32 x=0; x<tiles[0]; x ++ ){
157 for( i32 z=0; z<tiles[1]; z ++ ){
158 for( u32 i=0; i<per_tile; i ++ ){
159 v3f co = { (f32)x+vg_randf64(&rand), 0, (f32)z+vg_randf64(&rand) };
160 v3_muls( co, tile_scale, co );
161 co[1] = 1000.0f;
162 v3_add( co, world->scene_geo.bbx[0], co );
163
164 ray_hit hit;
165 hit.dist = INFINITY;
166
167 if( ray_world( world, co, (v3f){0.0f,-1.0f,0.0f}, &hit,
168 k_material_flag_ghosts )){
169 struct world_surface *m1 = ray_hit_surface( world, &hit );
170 if((hit.normal[1] > 0.8f) && (m1 == mat) &&
171 (hit.pos[1] > 0.0f+10.0f)){
172 world_gen_add_blob( &rand, world, scene, &hit );
173 count ++;
174 }
175 }
176
177 }
178 }
179 }
180
181 #endif
182
183
184
185 u64 t1 = SDL_GetPerformanceCounter(),
186 utime_blobs = t1-t0,
187 ufreq = SDL_GetPerformanceFrequency();
188 f64 ftime_blobs = ((f64)utime_blobs / (f64)ufreq)*1000.0;
189
190 vg_info( "%d foliage models added. %f%% (%fms)\n", count,
191 100.0*((f64)count/(f64)particles), ftime_blobs);
192 }
193
194 static
195 void world_unpack_submesh_dynamic( world_instance *world,
196 scene_context *scene, mdl_submesh *sm ){
197 if( sm->flags & k_submesh_flag_consumed ) return;
198
199 m4x3f identity;
200 m4x3_identity( identity );
201 scene_add_mdl_submesh( scene, &world->meta, sm, identity );
202
203 scene_copy_slice( scene, sm );
204 sm->flags |= k_submesh_flag_consumed;
205 }
206
207 /*
208 * Create the main meshes for the world
209 */
210 void world_gen_generate_meshes( world_instance *world )
211 {
212 /*
213 * Compile meshes into the world scenes
214 */
215 scene_init( &world->scene_geo, 320000, 1200000 );
216 u32 buf_size = scene_mem_required( &world->scene_geo );
217 u8 *buffer = vg_linear_alloc( world->heap, buf_size );
218 scene_supply_buffer( &world->scene_geo, buffer );
219
220 m4x3f midentity;
221 m4x3_identity( midentity );
222
223 /*
224 * Generate scene: collidable geometry
225 * ----------------------------------------------------------------
226 */
227
228 vg_info( "Generating collidable geometry\n" );
229
230 for( u32 i=0; i<world->surface_count; i++ ){
231 struct world_surface *surf = &world->surfaces[ i ];
232
233 if( surf->info.flags & k_material_flag_collision )
234 world_add_all_if_material( midentity, &world->scene_geo,
235 &world->meta, i );
236
237 scene_copy_slice( &world->scene_geo, &surf->sm_geo );
238 scene_set_vertex_flags( &world->scene_geo,
239 surf->sm_geo.vertex_start,
240 surf->sm_geo.vertex_count,
241 (u16)(surf->info.flags & 0xffff) );
242 }
243
244 /* compress that bad boy */
245 u32 new_vert_max = world->scene_geo.vertex_count,
246 new_vert_size = vg_align8(new_vert_max*sizeof(scene_vert)),
247 new_indice_len = world->scene_geo.indice_count*sizeof(u32);
248
249 u32 *src_indices = world->scene_geo.arrindices,
250 *dst_indices = (u32 *)(buffer + new_vert_size);
251
252 memmove( dst_indices, src_indices, new_indice_len );
253
254 world->scene_geo.max_indices = world->scene_geo.indice_count;
255 world->scene_geo.max_vertices = world->scene_geo.vertex_count;
256 buf_size = scene_mem_required( &world->scene_geo );
257
258 buffer = vg_linear_resize( world->heap, buffer, buf_size );
259
260 world->scene_geo.arrvertices = (scene_vert *)(buffer);
261 world->scene_geo.arrindices = (u32 *)(buffer + new_vert_size);
262
263 scene_upload_async( &world->scene_geo, &world->mesh_geo );
264
265 /* need send off the memory to the gpu before we can create the bvh. */
266 vg_async_stall();
267 vg_info( "creating bvh\n" );
268 world->geo_bh = scene_bh_create( world->heap, &world->scene_geo );
269
270 /*
271 * Generate scene: non-collidable geometry
272 * ----------------------------------------------------------------
273 */
274 vg_info( "Generating non-collidable geometry\n" );
275
276 vg_async_item *call = scene_alloc_async( &world->scene_no_collide,
277 &world->mesh_no_collide,
278 250000, 500000 );
279
280 for( u32 i=0; i<world->surface_count; i++ ){
281 struct world_surface *surf = &world->surfaces[ i ];
282
283 if( !(surf->info.flags & k_material_flag_collision) ){
284 world_add_all_if_material( midentity,
285 &world->scene_no_collide, &world->meta, i );
286 }
287
288 if( surf->info.flags & k_material_flag_grow_grass ){
289 world_apply_procedural_foliage( world, &world->scene_no_collide,
290 surf );
291 }
292
293 scene_copy_slice( &world->scene_no_collide, &surf->sm_no_collide );
294 }
295
296 /* unpack traffic models.. TODO: should we just put all these submeshes in a
297 * dynamic models list? and then the actual entitities point to the
298 * models. we only have 2 types at the moment which need dynamic models but
299 * would make sense to do this when/if we have more.
300 */
301 for( u32 i=0; i<mdl_arrcount( &world->ent_traffic ); i++ ){
302 ent_traffic *vehc = mdl_arritm( &world->ent_traffic, i );
303
304 for( u32 j=0; j<vehc->submesh_count; j++ ){
305 mdl_submesh *sm = mdl_arritm( &world->meta.submeshs,
306 vehc->submesh_start+j );
307 world_unpack_submesh_dynamic( world, &world->scene_no_collide, sm );
308 world->surfaces[ sm->material_id ].flags |= WORLD_SURFACE_HAS_TRAFFIC;
309 }
310 }
311
312 /* unpack challenge models */
313 for( u32 i=0; i<mdl_arrcount( &world->ent_objective ); i++ ){
314 ent_objective *objective = mdl_arritm( &world->ent_objective, i );
315
316 for( u32 j=0; j<objective->submesh_count; j ++ ){
317 mdl_submesh *sm = mdl_arritm( &world->meta.submeshs,
318 objective->submesh_start+j );
319 world_unpack_submesh_dynamic( world, &world->scene_no_collide, sm );
320 }
321 }
322
323 /* unpack region models */
324 for( u32 i=0; i<mdl_arrcount( &world->ent_region ); i++ ){
325 ent_region *region = mdl_arritm( &world->ent_region, i );
326
327 for( u32 j=0; j<region->submesh_count; j ++ ){
328 mdl_submesh *sm = mdl_arritm( &world->meta.submeshs,
329 region->submesh_start+j );
330 world_unpack_submesh_dynamic( world, &world->scene_no_collide, sm );
331 }
332 }
333
334 /* unpack gate models */
335 for( u32 i=0; i<mdl_arrcount( &world->ent_gate ); i++ ){
336 ent_gate *gate = mdl_arritm( &world->ent_gate, i );
337
338 if( !(gate->flags & k_ent_gate_custom_mesh) ) continue;
339
340 for( u32 j=0; j<gate->submesh_count; j ++ ){
341 mdl_submesh *sm = mdl_arritm( &world->meta.submeshs,
342 gate->submesh_start+j );
343 world_unpack_submesh_dynamic( world, &world->scene_no_collide, sm );
344 }
345 }
346
347 /* unpack prop models */
348 for( u32 i=0; i<mdl_arrcount( &world->ent_prop ); i++ ){
349 ent_prop *prop = mdl_arritm( &world->ent_prop, i );
350
351 for( u32 j=0; j<prop->submesh_count; j ++ ){
352 mdl_submesh *sm = mdl_arritm( &world->meta.submeshs,
353 prop->submesh_start+j );
354 world->surfaces[ sm->material_id ].flags |= WORLD_SURFACE_HAS_PROPS;
355 world_unpack_submesh_dynamic( world, &world->scene_no_collide, sm );
356 }
357 }
358
359 vg_async_dispatch( call, async_scene_upload );
360 }
361
362 /* signed distance function for cone */
363 static f32 fsd_cone_infinite( v3f p, v2f c ){
364 v2f q = { v2_length( (v2f){ p[0], p[2] } ), -p[1] };
365 float s = vg_maxf( 0.0f, v2_dot( q, c ) );
366
367 v2f v0;
368 v2_muls( c, s, v0 );
369 v2_sub( q, v0, v0 );
370
371 float d = v2_length( v0 );
372 return d * ((q[0]*c[1]-q[1]*c[0]<0.0f)?-1.0f:1.0f);
373 }
374
375 struct light_indices_upload_info{
376 world_instance *world;
377 v3i count;
378
379 void *data;
380 };
381
382 /*
383 * Async reciever to buffer light index data
384 */
385 static void async_upload_light_indices( void *payload, u32 size ){
386 struct light_indices_upload_info *info = payload;
387
388 glGenTextures( 1, &info->world->tex_light_cubes );
389 glBindTexture( GL_TEXTURE_3D, info->world->tex_light_cubes );
390 glTexImage3D( GL_TEXTURE_3D, 0, GL_RG32UI,
391 info->count[0], info->count[1], info->count[2],
392 0, GL_RG_INTEGER, GL_UNSIGNED_INT, info->data );
393 glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
394 glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
395 }
396
397 /*
398 * Computes light indices for world
399 */
400 void world_gen_compute_light_indices( world_instance *world )
401 {
402 /* light cubes */
403 v3f cubes_min, cubes_max;
404 v3_muls( world->scene_geo.bbx[0], 1.0f/k_world_light_cube_size, cubes_min );
405 v3_muls( world->scene_geo.bbx[1], 1.0f/k_world_light_cube_size, cubes_max );
406
407 v3_sub( cubes_min, (v3f){ 0.5f, 0.5f, 0.5f }, cubes_min );
408 v3_add( cubes_max, (v3f){ 0.5f, 0.5f, 0.5f }, cubes_max );
409
410 v3_floor( cubes_min, cubes_min );
411 v3_floor( cubes_max, cubes_max );
412
413 v3i icubes_min, icubes_max;
414
415 for( int i=0; i<3; i++ ){
416 icubes_min[i] = cubes_min[i];
417 icubes_max[i] = cubes_max[i];
418 }
419
420 v3f cube_size;
421
422 v3i icubes_count;
423 v3i_sub( icubes_max, icubes_min, icubes_count );
424
425 for( int i=0; i<3; i++ ){
426 int clamped_count = VG_MIN( 128, icubes_count[i]+1 );
427 float clamped_max = icubes_min[i] + clamped_count,
428 max = icubes_min[i] + icubes_count[i]+1;
429
430 icubes_count[i] = clamped_count;
431 cube_size[i] = (max / clamped_max) * k_world_light_cube_size;
432 cubes_max[i] = clamped_max;
433 }
434
435 v3_mul( cubes_min, cube_size, cubes_min );
436 v3_mul( cubes_max, cube_size, cubes_max );
437
438 for( int i=0; i<3; i++ ){
439 float range = cubes_max[i]-cubes_min[i];
440 world->ub_lighting.g_cube_inv_range[i] = 1.0f / range;
441 world->ub_lighting.g_cube_inv_range[i] *= (float)icubes_count[i];
442
443 vg_info( "cubes[%d]: %d\n", i, icubes_count[i] );
444 }
445
446 int total_cubes = icubes_count[0]*icubes_count[1]*icubes_count[2];
447
448 u32 data_size = vg_align8(total_cubes*sizeof(u32)*2),
449 hdr_size = vg_align8(sizeof(struct light_indices_upload_info));
450
451 vg_async_item *call = vg_async_alloc( data_size + hdr_size );
452 struct light_indices_upload_info *info = call->payload;
453 info->data = ((u8*)call->payload) + hdr_size;
454 info->world = world;
455 u32 *cubes_index = info->data;
456
457 for( int i=0; i<3; i++ )
458 info->count[i] = icubes_count[i];
459
460 vg_info( "Computing light cubes (%d) [%f %f %f] -> [%f %f %f]\n",
461 total_cubes, cubes_min[0], -cubes_min[2], cubes_min[1],
462 cubes_max[0], -cubes_max[2], cubes_max[1] );
463 v3_copy( cubes_min, world->ub_lighting.g_cube_min );
464
465 float bound_radius = v3_length( cube_size );
466
467 for( int iz = 0; iz<icubes_count[2]; iz ++ ){
468 for( int iy = 0; iy<icubes_count[1]; iy++ ){
469 for( int ix = 0; ix<icubes_count[0]; ix++ ){
470 boxf bbx;
471 v3_div( (v3f){ ix, iy, iz }, world->ub_lighting.g_cube_inv_range,
472 bbx[0] );
473 v3_div( (v3f){ ix+1, iy+1, iz+1 },
474 world->ub_lighting.g_cube_inv_range,
475 bbx[1] );
476
477 v3_add( bbx[0], world->ub_lighting.g_cube_min, bbx[0] );
478 v3_add( bbx[1], world->ub_lighting.g_cube_min, bbx[1] );
479
480 v3f center;
481 v3_add( bbx[0], bbx[1], center );
482 v3_muls( center, 0.5f, center );
483
484 u32 indices[6] = { 0, 0, 0, 0, 0, 0 };
485 u32 count = 0;
486
487 float influences[6] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
488 const int N = vg_list_size( influences );
489
490 for( u32 j=0; j<mdl_arrcount(&world->ent_light); j ++ ){
491 ent_light *light = mdl_arritm( &world->ent_light, j );
492 v3f closest;
493 closest_point_aabb( light->transform.co, bbx, closest );
494
495 f32 dist2 = v3_dist2( closest, light->transform.co );
496
497 if( dist2 > light->range*light->range )
498 continue;
499
500 f32 dist = sqrtf(dist2),
501 influence = 1.0f/(dist+1.0f);
502
503 if( light->type == k_light_type_spot){
504 v3f local;
505 m4x3_mulv( light->inverse_world, center, local );
506
507 float r = fsd_cone_infinite( local, light->angle_sin_cos );
508
509 if( r > bound_radius )
510 continue;
511 }
512
513 int best_pos = N;
514 for( int k=best_pos-1; k>=0; k -- )
515 if( influence > influences[k] )
516 best_pos = k;
517
518 if( best_pos < N ){
519 for( int k=N-1; k>best_pos; k -- ){
520 influences[k] = influences[k-1];
521 indices[k] = indices[k-1];
522 }
523
524 influences[best_pos] = influence;
525 indices[best_pos] = j;
526 }
527 }
528
529 for( int j=0; j<N; j++ )
530 if( influences[j] > 0.0f )
531 count ++;
532
533 int base_index = iz * (icubes_count[0]*icubes_count[1]) +
534 iy * (icubes_count[0]) +
535 ix;
536
537 int lower_count = VG_MIN( 3, count );
538 u32 packed_index_lower = lower_count;
539 packed_index_lower |= indices[0]<<2;
540 packed_index_lower |= indices[1]<<12;
541 packed_index_lower |= indices[2]<<22;
542
543 int upper_count = VG_MAX( 0, count - lower_count );
544 u32 packed_index_upper = upper_count;
545 packed_index_upper |= indices[3]<<2;
546 packed_index_upper |= indices[4]<<12;
547 packed_index_upper |= indices[5]<<22;
548
549 cubes_index[ base_index*2 + 0 ] = packed_index_lower;
550 cubes_index[ base_index*2 + 1 ] = packed_index_upper;
551 }
552 }
553 }
554
555 vg_async_dispatch( call, async_upload_light_indices );
556 }
557
558 /*
559 * Rendering pass needed to complete the world
560 */
561 void async_world_postprocess( void *payload, u32 _size )
562 {
563 /* create scene lighting buffer */
564 world_instance *world = payload;
565
566 u32 size = VG_MAX(mdl_arrcount(&world->ent_light),1) * sizeof(float)*12;
567 vg_info( "Upload %ubytes (lighting)\n", size );
568
569 glGenBuffers( 1, &world->tbo_light_entities );
570 glBindBuffer( GL_TEXTURE_BUFFER, world->tbo_light_entities );
571 glBufferData( GL_TEXTURE_BUFFER, size, NULL, GL_DYNAMIC_DRAW );
572
573 /* buffer layout
574 *
575 * colour position direction (spots)
576 * | . . . . | . . . . | . . . . |
577 * | Re Ge Be Night | Xco Yco Zco Range | Dx Dy Dz Da |
578 *
579 */
580
581 v4f *light_dst = glMapBuffer( GL_TEXTURE_BUFFER, GL_WRITE_ONLY );
582 for( u32 i=0; i<mdl_arrcount(&world->ent_light); i++ ){
583 ent_light *light = mdl_arritm( &world->ent_light, i );
584
585 /* colour + night */
586 v3_muls( light->colour, light->colour[3] * 2.0f, light_dst[i*3+0] );
587 light_dst[i*3+0][3] = 2.0f;
588
589 if( !light->daytime ){
590 u32 hash = (i * 29986577u) & 0xffu;
591 float switch_on = hash;
592 switch_on *= (1.0f/255.0f);
593
594 light_dst[i*3+0][3] = 0.44f + switch_on * 0.015f;
595 }
596
597 /* position + 1/range^2 */
598 v3_copy( light->transform.co, light_dst[i*3+1] );
599 light_dst[i*3+1][3] = 1.0f/(light->range*light->range);
600
601 /* direction + angle */
602 q_mulv( light->transform.q, (v3f){0.0f,-1.0f,0.0f}, light_dst[i*3+2]);
603 light_dst[i*3+2][3] = cosf( light->angle );
604 }
605
606 glUnmapBuffer( GL_TEXTURE_BUFFER );
607
608 glGenTextures( 1, &world->tex_light_entities );
609 glBindTexture( GL_TEXTURE_BUFFER, world->tex_light_entities );
610 glTexBuffer( GL_TEXTURE_BUFFER, GL_RGBA32F, world->tbo_light_entities );
611
612 /* Upload lighting uniform buffer */
613 if( world->water.enabled )
614 v4_copy( world->water.plane, world->ub_lighting.g_water_plane );
615
616 v4f info_vec;
617 v3f *bounds = world->scene_geo.bbx;
618
619 info_vec[0] = bounds[0][0];
620 info_vec[1] = bounds[0][2];
621 info_vec[2] = 1.0f/ (bounds[1][0]-bounds[0][0]);
622 info_vec[3] = 1.0f/ (bounds[1][2]-bounds[0][2]);
623 v4_copy( info_vec, world->ub_lighting.g_depth_bounds );
624
625 /*
626 * Rendering the depth map
627 */
628 vg_camera ortho;
629
630 v3f extent;
631 v3_sub( world->scene_geo.bbx[1], world->scene_geo.bbx[0], extent );
632
633 float fl = world->scene_geo.bbx[0][0],
634 fr = world->scene_geo.bbx[1][0],
635 fb = world->scene_geo.bbx[0][2],
636 ft = world->scene_geo.bbx[1][2],
637 rl = 1.0f / (fr-fl),
638 tb = 1.0f / (ft-fb);
639
640 m4x4_zero( ortho.mtx.p );
641 ortho.mtx.p[0][0] = 2.0f * rl;
642 ortho.mtx.p[2][1] = 2.0f * tb;
643 ortho.mtx.p[3][0] = (fr + fl) * -rl;
644 ortho.mtx.p[3][1] = (ft + fb) * -tb;
645 ortho.mtx.p[3][3] = 1.0f;
646 m4x3_identity( ortho.transform );
647 vg_camera_update_view( &ortho );
648 vg_camera_finalize( &ortho );
649
650 glDisable(GL_DEPTH_TEST);
651 glDisable(GL_BLEND);
652 glDisable(GL_CULL_FACE);
653 render_fb_bind( &world->heightmap, 0 );
654 shader_blitcolour_use();
655 shader_blitcolour_uColour( (v4f){-9999.0f,-9999.0f,-9999.0f,-9999.0f} );
656 render_fsquad();
657
658 glEnable(GL_BLEND);
659 glBlendFunc(GL_ONE, GL_ONE);
660 glBlendEquation(GL_MAX);
661
662 render_world_position( world, &ortho );
663 glDisable(GL_BLEND);
664 glEnable(GL_DEPTH_TEST);
665 glBindFramebuffer( GL_FRAMEBUFFER, 0 );
666
667 /* upload full buffer */
668 glBindBuffer( GL_UNIFORM_BUFFER, world->ubo_lighting );
669 glBufferSubData( GL_UNIFORM_BUFFER, 0,
670 sizeof(struct ub_world_lighting), &world->ub_lighting );
671
672 /*
673 * Allocate cubemaps
674 */
675 for( u32 i=0; i<mdl_arrcount(&world->ent_cubemap); i++ ){
676 ent_cubemap *cm = mdl_arritm(&world->ent_cubemap,i);
677
678 glGenTextures( 1, &cm->texture_id );
679 glBindTexture( GL_TEXTURE_CUBE_MAP, cm->texture_id );
680 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
681 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
682 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
683 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
684 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
685
686 for( u32 j=0; j<6; j ++ ) {
687 glTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X + j, 0, GL_RGB,
688 WORLD_CUBEMAP_RES, WORLD_CUBEMAP_RES,
689 0, GL_RGB, GL_UNSIGNED_BYTE, NULL );
690 }
691
692 glGenFramebuffers( 1, &cm->framebuffer_id );
693 glBindFramebuffer( GL_FRAMEBUFFER, cm->framebuffer_id );
694 glGenRenderbuffers(1, &cm->renderbuffer_id );
695 glBindRenderbuffer( GL_RENDERBUFFER, cm->renderbuffer_id );
696 glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_COMPONENT24,
697 WORLD_CUBEMAP_RES, WORLD_CUBEMAP_RES );
698
699 glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
700 GL_TEXTURE_CUBE_MAP_POSITIVE_X, cm->texture_id, 0 );
701 glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
702 GL_RENDERBUFFER, cm->renderbuffer_id );
703
704 glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
705 GL_TEXTURE_CUBE_MAP_POSITIVE_X, cm->texture_id, 0 );
706
707 if( glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE ){
708 vg_error( "Cubemap framebuffer incomplete.\n" );
709 }
710 }
711
712 glBindFramebuffer( GL_FRAMEBUFFER, 0 );
713 }
714
715 /* Loads textures from the pack file */
716 void world_gen_load_surfaces( world_instance *world )
717 {
718 vg_info( "Loading textures\n" );
719 world->texture_count = 0;
720
721 world->texture_count = world->meta.textures.count+1;
722 world->textures = vg_linear_alloc( world->heap,
723 vg_align8(sizeof(GLuint)*world->texture_count) );
724 world->textures[0] = vg.tex_missing;
725
726 for( u32 i=0; i<mdl_arrcount(&world->meta.textures); i++ )
727 {
728 mdl_texture *tex = mdl_arritm( &world->meta.textures, i );
729
730 if( !tex->file.pack_size )
731 {
732 vg_fatal_error( "World models must have packed textures!" );
733 }
734
735 vg_linear_clear( vg_mem.scratch );
736 void *src_data = vg_linear_alloc( vg_mem.scratch,
737 tex->file.pack_size );
738 mdl_fread_pack_file( &world->meta, &tex->file, src_data );
739
740 vg_tex2d_load_qoi_async( src_data, tex->file.pack_size,
741 VG_TEX2D_NEAREST|VG_TEX2D_REPEAT,
742 &world->textures[i+1] );
743 }
744
745 vg_info( "Loading materials\n" );
746
747 world->surface_count = world->meta.materials.count+1;
748 world->surfaces = vg_linear_alloc( world->heap,
749 vg_align8(sizeof(struct world_surface)*world->surface_count) );
750
751 /* error material */
752 struct world_surface *errmat = &world->surfaces[0];
753 memset( errmat, 0, sizeof(struct world_surface) );
754
755 for( u32 i=0; i<mdl_arrcount(&world->meta.materials); i++ )
756 {
757 struct world_surface *surf = &world->surfaces[i+1];
758 surf->info = *(mdl_material *)mdl_arritm( &world->meta.materials, i );
759 surf->flags = 0;
760
761 if( surf->info.shader == k_shader_water )
762 {
763 struct shader_props_water *props = surf->info.props.compiled;
764 world->ub_lighting.g_water_fog = props->fog_scale;
765 }
766
767 if( surf->info.shader == k_shader_standard_cutout ||
768 surf->info.shader == k_shader_foliage )
769 {
770 struct shader_props_standard *props = surf->info.props.compiled;
771 surf->alpha_tex = props->tex_diffuse;
772 }
773 else
774 surf->alpha_tex = 0;
775 }
776 }