2 * Copyright (C) 2021-2023 Mt.ZERO Software, Harry Godden - All Rights Reserved
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.
9 #include "world_load.h"
10 #include "world_volumes.h"
11 #include "world_gate.h"
15 * Add all triangles from the model, which match the material ID
16 * applies affine transform to the model
18 static void world_add_all_if_material( m4x3f transform
, scene_context
*scene
,
19 mdl_context
*mdl
, u32 id
)
21 for( u32 i
=0; i
<mdl_arrcount(&mdl
->meshs
); i
++ ){
22 mdl_mesh
*mesh
= mdl_arritm( &mdl
->meshs
, i
);
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
){
28 mdl_transform_m4x3( &mesh
->transform
, transform2
);
29 m4x3_mul( transform
, transform2
, transform2
);
31 scene_add_mdl_submesh( scene
, mdl
, sm
, transform2
);
38 * Adds a small blob shape to the world at a raycast location. This is for the
46 static void world_gen_add_blob( vg_rand
*rand
, world_instance
*world
,
47 scene_context
*scene
, ray_hit
*hit
)
50 v4f qsurface
, qrandom
;
53 v3_cross( (v3f
){0.0f
,1.0f
,0.0f
}, hit
->normal
, axis
);
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] );
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
} }
72 const u32 indices
[] = { 0,1,3, 0,3,2, 2,3,5, 2,5,4 };
74 if( scene
->vertex_count
+ vg_list_size(verts
) > scene
->max_vertices
)
75 vg_fatal_error( "Scene vertex buffer overflow" );
77 if( scene
->indice_count
+ vg_list_size(indices
) > scene
->max_indices
)
78 vg_fatal_error( "Scene index buffer overflow" );
80 scene_vert
*dst_verts
= &scene
->arrvertices
[ scene
->vertex_count
];
81 u32
*dst_indices
= &scene
->arrindices
[ scene
->indice_count
];
83 scene_vert
*ref
= &world
->scene_geo
.arrvertices
[ hit
->tri
[0] ];
85 for( u32 i
=0; i
<vg_list_size(verts
); i
++ ){
86 scene_vert
*pvert
= &dst_verts
[ i
],
89 m4x3_mulv( transform
, src
->co
, pvert
->co
);
90 scene_vert_pack_norm( pvert
, transform
[1], 0.0f
);
92 v2_copy( ref
->uv
, pvert
->uv
);
95 for( u32 i
=0; i
<vg_list_size(indices
); i
++ )
96 dst_indices
[i
] = indices
[i
] + scene
->vertex_count
;
98 scene
->vertex_count
+= vg_list_size(verts
);
99 scene
->indice_count
+= vg_list_size(indices
);
103 * Sprinkle foliage models over the map on terrain material
105 static void world_apply_procedural_foliage( world_instance
*world
,
106 scene_context
*scene
,
107 struct world_surface
*mat
)
109 if( (vg
.quality_profile
== k_quality_profile_low
) ||
110 (vg
.quality_profile
== k_quality_profile_min
) )
113 vg_info( "Applying foliage (%u)\n", mat
->info
.pstr_name
);
116 v3_sub( world
->scene_geo
.bbx
[1], world
->scene_geo
.bbx
[0], volume
);
121 float area
= volume
[0]*volume
[2];
122 u32 particles
= 0.08f
* area
;
124 vg_info( "Map area: %f. Max particles: %u\n", area
, particles
);
126 u64 t0
= SDL_GetPerformanceCounter();
128 for( u32 i
=0; i
<particles
; i
++ ){
130 v3_mul( volume
, (v3f
){ vg_randf64(), 1000.0f
, vg_randf64() }, pos
);
132 v3_add( pos
, world
->scene_geo
.bbx
[0], pos
);
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
);
149 vg_rand_seed( &rand
, 3030 );
151 const f32 tile_scale
= 16.0f
;
152 v2i tiles
= { volume
[0]/tile_scale
, volume
[2]/tile_scale
};
154 u32 per_tile
= particles
/(tiles
[0]*tiles
[1]);
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
);
162 v3_add( co
, world
->scene_geo
.bbx
[0], co
);
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
);
185 u64 t1
= SDL_GetPerformanceCounter(),
187 ufreq
= SDL_GetPerformanceFrequency();
188 f64 ftime_blobs
= ((f64
)utime_blobs
/ (f64
)ufreq
)*1000.0;
190 vg_info( "%d foliage models added. %f%% (%fms)\n", count
,
191 100.0*((f64
)count
/(f64
)particles
), ftime_blobs
);
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;
200 m4x3_identity( identity
);
201 scene_add_mdl_submesh( scene
, &world
->meta
, sm
, identity
);
203 scene_copy_slice( scene
, sm
);
204 sm
->flags
|= k_submesh_flag_consumed
;
208 * Create the main meshes for the world
210 void world_gen_generate_meshes( world_instance
*world
)
213 * Compile meshes into the world scenes
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
);
221 m4x3_identity( midentity
);
224 * Generate scene: collidable geometry
225 * ----------------------------------------------------------------
228 vg_info( "Generating collidable geometry\n" );
230 for( u32 i
=0; i
<world
->surface_count
; i
++ ){
231 struct world_surface
*surf
= &world
->surfaces
[ i
];
233 if( surf
->info
.flags
& k_material_flag_collision
)
234 world_add_all_if_material( midentity
, &world
->scene_geo
,
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) );
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
);
249 u32
*src_indices
= world
->scene_geo
.arrindices
,
250 *dst_indices
= (u32
*)(buffer
+ new_vert_size
);
252 memmove( dst_indices
, src_indices
, new_indice_len
);
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
);
258 buffer
= vg_linear_resize( world
->heap
, buffer
, buf_size
);
260 world
->scene_geo
.arrvertices
= (scene_vert
*)(buffer
);
261 world
->scene_geo
.arrindices
= (u32
*)(buffer
+ new_vert_size
);
263 scene_upload_async( &world
->scene_geo
, &world
->mesh_geo
);
265 /* need send off the memory to the gpu before we can create the bvh. */
267 vg_info( "creating bvh\n" );
268 world
->geo_bh
= scene_bh_create( world
->heap
, &world
->scene_geo
);
271 * Generate scene: non-collidable geometry
272 * ----------------------------------------------------------------
274 vg_info( "Generating non-collidable geometry\n" );
276 vg_async_item
*call
= scene_alloc_async( &world
->scene_no_collide
,
277 &world
->mesh_no_collide
,
280 for( u32 i
=0; i
<world
->surface_count
; i
++ ){
281 struct world_surface
*surf
= &world
->surfaces
[ i
];
283 if( !(surf
->info
.flags
& k_material_flag_collision
) ){
284 world_add_all_if_material( midentity
,
285 &world
->scene_no_collide
, &world
->meta
, i
);
288 if( surf
->info
.flags
& k_material_flag_grow_grass
){
289 world_apply_procedural_foliage( world
, &world
->scene_no_collide
,
293 scene_copy_slice( &world
->scene_no_collide
, &surf
->sm_no_collide
);
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.
301 for( u32 i
=0; i
<mdl_arrcount( &world
->ent_traffic
); i
++ ){
302 ent_traffic
*vehc
= mdl_arritm( &world
->ent_traffic
, i
);
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
;
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
);
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
);
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
);
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
);
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
);
338 if( !(gate
->flags
& k_ent_gate_custom_mesh
) ) continue;
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
);
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
);
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
);
359 vg_async_dispatch( call
, async_scene_upload
);
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
) );
371 float d
= v2_length( v0
);
372 return d
* ((q
[0]*c
[1]-q
[1]*c
[0]<0.0f
)?-1.0f
:1.0f
);
375 struct light_indices_upload_info
{
376 world_instance
*world
;
383 * Async reciever to buffer light index data
385 static void async_upload_light_indices( void *payload
, u32 size
){
386 struct light_indices_upload_info
*info
= payload
;
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
);
398 * Computes light indices for world
400 void world_gen_compute_light_indices( world_instance
*world
)
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
);
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
);
410 v3_floor( cubes_min
, cubes_min
);
411 v3_floor( cubes_max
, cubes_max
);
413 v3i icubes_min
, icubes_max
;
415 for( int i
=0; i
<3; i
++ ){
416 icubes_min
[i
] = cubes_min
[i
];
417 icubes_max
[i
] = cubes_max
[i
];
423 v3i_sub( icubes_max
, icubes_min
, icubes_count
);
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;
430 icubes_count
[i
] = clamped_count
;
431 cube_size
[i
] = (max
/ clamped_max
) * k_world_light_cube_size
;
432 cubes_max
[i
] = clamped_max
;
435 v3_mul( cubes_min
, cube_size
, cubes_min
);
436 v3_mul( cubes_max
, cube_size
, cubes_max
);
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
];
443 vg_info( "cubes[%d]: %d\n", i
, icubes_count
[i
] );
446 int total_cubes
= icubes_count
[0]*icubes_count
[1]*icubes_count
[2];
448 u32 data_size
= vg_align8(total_cubes
*sizeof(u32
)*2),
449 hdr_size
= vg_align8(sizeof(struct light_indices_upload_info
));
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
;
455 u32
*cubes_index
= info
->data
;
457 for( int i
=0; i
<3; i
++ )
458 info
->count
[i
] = icubes_count
[i
];
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
);
465 float bound_radius
= v3_length( cube_size
);
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
++ ){
471 v3_div( (v3f
){ ix
, iy
, iz
}, world
->ub_lighting
.g_cube_inv_range
,
473 v3_div( (v3f
){ ix
+1, iy
+1, iz
+1 },
474 world
->ub_lighting
.g_cube_inv_range
,
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] );
481 v3_add( bbx
[0], bbx
[1], center
);
482 v3_muls( center
, 0.5f
, center
);
484 u32 indices
[6] = { 0, 0, 0, 0, 0, 0 };
487 float influences
[6] = { 0.0f
, 0.0f
, 0.0f
, 0.0f
, 0.0f
, 0.0f
};
488 const int N
= vg_list_size( influences
);
490 for( u32 j
=0; j
<mdl_arrcount(&world
->ent_light
); j
++ ){
491 ent_light
*light
= mdl_arritm( &world
->ent_light
, j
);
493 closest_point_aabb( light
->transform
.co
, bbx
, closest
);
495 f32 dist2
= v3_dist2( closest
, light
->transform
.co
);
497 if( dist2
> light
->range
*light
->range
)
500 f32 dist
= sqrtf(dist2
),
501 influence
= 1.0f
/(dist
+1.0f
);
503 if( light
->type
== k_light_type_spot
){
505 m4x3_mulv( light
->inverse_world
, center
, local
);
507 float r
= fsd_cone_infinite( local
, light
->angle_sin_cos
);
509 if( r
> bound_radius
)
514 for( int k
=best_pos
-1; k
>=0; k
-- )
515 if( influence
> influences
[k
] )
519 for( int k
=N
-1; k
>best_pos
; k
-- ){
520 influences
[k
] = influences
[k
-1];
521 indices
[k
] = indices
[k
-1];
524 influences
[best_pos
] = influence
;
525 indices
[best_pos
] = j
;
529 for( int j
=0; j
<N
; j
++ )
530 if( influences
[j
] > 0.0f
)
533 int base_index
= iz
* (icubes_count
[0]*icubes_count
[1]) +
534 iy
* (icubes_count
[0]) +
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;
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;
549 cubes_index
[ base_index
*2 + 0 ] = packed_index_lower
;
550 cubes_index
[ base_index
*2 + 1 ] = packed_index_upper
;
555 vg_async_dispatch( call
, async_upload_light_indices
);
559 * Rendering pass needed to complete the world
561 void async_world_postprocess( void *payload
, u32 _size
)
563 /* create scene lighting buffer */
564 world_instance
*world
= payload
;
566 u32 size
= VG_MAX(mdl_arrcount(&world
->ent_light
),1) * sizeof(float)*12;
567 vg_info( "Upload %ubytes (lighting)\n", size
);
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
);
575 * colour position direction (spots)
576 * | . . . . | . . . . | . . . . |
577 * | Re Ge Be Night | Xco Yco Zco Range | Dx Dy Dz Da |
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
);
586 v3_muls( light
->colour
, light
->colour
[3] * 2.0f
, light_dst
[i
*3+0] );
587 light_dst
[i
*3+0][3] = 2.0f
;
589 if( !light
->daytime
){
590 u32 hash
= (i
* 29986577u) & 0xffu
;
591 float switch_on
= hash
;
592 switch_on
*= (1.0f
/255.0f
);
594 light_dst
[i
*3+0][3] = 0.44f
+ switch_on
* 0.015f
;
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
);
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
);
606 glUnmapBuffer( GL_TEXTURE_BUFFER
);
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
);
612 /* Upload lighting uniform buffer */
613 if( world
->water
.enabled
)
614 v4_copy( world
->water
.plane
, world
->ub_lighting
.g_water_plane
);
617 v3f
*bounds
= world
->scene_geo
.bbx
;
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
);
626 * Rendering the depth map
631 v3_sub( world
->scene_geo
.bbx
[1], world
->scene_geo
.bbx
[0], extent
);
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],
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
);
650 glDisable(GL_DEPTH_TEST
);
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
} );
659 glBlendFunc(GL_ONE
, GL_ONE
);
660 glBlendEquation(GL_MAX
);
662 render_world_position( world
, &ortho
);
664 glEnable(GL_DEPTH_TEST
);
665 glBindFramebuffer( GL_FRAMEBUFFER
, 0 );
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
);
675 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_cubemap
); i
++ ){
676 ent_cubemap
*cm
= mdl_arritm(&world
->ent_cubemap
,i
);
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
);
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
);
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
);
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
);
704 glFramebufferTexture2D( GL_FRAMEBUFFER
, GL_COLOR_ATTACHMENT0
,
705 GL_TEXTURE_CUBE_MAP_POSITIVE_X
, cm
->texture_id
, 0 );
707 if( glCheckFramebufferStatus(GL_FRAMEBUFFER
) != GL_FRAMEBUFFER_COMPLETE
){
708 vg_error( "Cubemap framebuffer incomplete.\n" );
712 glBindFramebuffer( GL_FRAMEBUFFER
, 0 );
715 /* Loads textures from the pack file */
716 void world_gen_load_surfaces( world_instance
*world
)
718 vg_info( "Loading textures\n" );
719 world
->texture_count
= 0;
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
;
726 for( u32 i
=0; i
<mdl_arrcount(&world
->meta
.textures
); i
++ )
728 mdl_texture
*tex
= mdl_arritm( &world
->meta
.textures
, i
);
730 if( !tex
->file
.pack_size
)
732 vg_fatal_error( "World models must have packed textures!" );
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
);
740 vg_tex2d_load_qoi_async( src_data
, tex
->file
.pack_size
,
741 VG_TEX2D_NEAREST
|VG_TEX2D_REPEAT
,
742 &world
->textures
[i
+1] );
745 vg_info( "Loading materials\n" );
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
) );
752 struct world_surface
*errmat
= &world
->surfaces
[0];
753 memset( errmat
, 0, sizeof(struct world_surface
) );
755 for( u32 i
=0; i
<mdl_arrcount(&world
->meta
.materials
); i
++ )
757 struct world_surface
*surf
= &world
->surfaces
[i
+1];
758 surf
->info
= *(mdl_material
*)mdl_arritm( &world
->meta
.materials
, i
);
761 if( surf
->info
.shader
== k_shader_water
)
763 struct shader_props_water
*props
= surf
->info
.props
.compiled
;
764 world
->ub_lighting
.g_water_fog
= props
->fog_scale
;
767 if( surf
->info
.shader
== k_shader_standard_cutout
||
768 surf
->info
.shader
== k_shader_foliage
)
770 struct shader_props_standard
*props
= surf
->info
.props
.compiled
;
771 surf
->alpha_tex
= props
->tex_diffuse
;