projects / carveJwlIkooP6JGAAIwe30JlM.git / blob
? search:


40d6f4c9653c4473c58de098038ae2948cae9ee7
[carveJwlIkooP6JGAAIwe30JlM.git] / world_gen.h
1 /*
2 * Copyright (C) 2021-2022 Mt.ZERO Software, Harry Godden - All Rights Reserved
3 */
4
5 #ifndef WORLD_GEN_H
6 #define WORLD_GEN_H
7
8 #include "world.h"
9
10 /* load world TODO: Put back vg back in loading state while this happens */
11 VG_STATIC void world_load(void);
12
13
14 VG_STATIC void world_add_all_if_material( m4x3f transform, scene *pscene,
15 mdl_context *mdl, u32 id )
16 {
17 for( int i=0; i<mdl->info.node_count; i++ )
18 {
19 mdl_node *pnode = mdl_node_from_id( mdl, i );
20
21 for( int j=0; j<pnode->submesh_count; j++ )
22 {
23 mdl_submesh *sm = mdl_node_submesh( mdl, pnode, j );
24 if( sm->material_id == id )
25 {
26 m4x3f transform2;
27 mdl_node_transform( pnode, transform2 );
28 m4x3_mul( transform, transform2, transform2 );
29
30 scene_add_submesh( pscene, mdl, sm, transform2 );
31 }
32 }
33
34 #if 0
35 if( pnode->classtype == k_classtype_instance )
36 {
37 if( pnode->sub_uid )
38 {
39 u32 instance_id = pnode->sub_uid -1;
40 struct instance_cache *cache = &world.instance_cache[instance_id];
41 mdl_context *mdl2 = cache->mdl;
42
43 m4x3f transform2;
44 mdl_node_transform( pnode, transform2 );
45 m4x3_mul( transform, transform2, transform2 );
46
47 world_add_all_if_material( transform2, pscene, mdl2, id );
48 }
49 }
50 #endif
51 }
52 }
53
54 /* Sprinkle foliage models over the map on terrain material */
55 VG_STATIC void world_apply_procedural_foliage(void)
56 {
57 vg_linear_clear( vg_mem.scratch );
58
59 mdl_context *mfoliage =
60 mdl_load_full( vg_mem.scratch, "models/rs_foliage.mdl");
61
62 v3f volume;
63 v3_sub( world.scene_geo->bbx[1], world.scene_geo->bbx[0], volume );
64 volume[1] = 1.0f;
65
66 m4x3f transform;
67 mdl_node *mblob = mdl_node_from_name( mfoliage, "blob" );
68 mdl_submesh *sm_blob = mdl_node_submesh( mfoliage, mblob, 0 );
69
70 for( int i=0;i<100000;i++ )
71 {
72 v3f pos;
73 v3_mul( volume, (v3f){ vg_randf(), 1000.0f, vg_randf() }, pos );
74 pos[1] = 1000.0f;
75 v3_add( pos, world.scene_geo->bbx[0], pos );
76
77 ray_hit hit;
78 hit.dist = INFINITY;
79
80 if( ray_world( pos, (v3f){0.0f,-1.0f,0.0f}, &hit ))
81 {
82 if( (hit.normal[1] > 0.8f) && ray_hit_is_terrain(&hit) &&
83 (hit.pos[1] > 0.0f+10.0f) )
84 {
85 v4f qsurface, qrandom;
86 v3f axis;
87
88 v3_cross( (v3f){0.0f,1.0f,0.0f}, hit.normal, axis );
89
90 float angle = v3_dot(hit.normal,(v3f){0.0f,1.0f,0.0f});
91 q_axis_angle( qsurface, axis, angle );
92 q_axis_angle( qrandom, (v3f){0.0f,1.0f,0.0f}, vg_randf()*VG_TAUf );
93 q_mul( qsurface, qrandom, qsurface );
94 q_m3x3( qsurface, transform );
95
96 v3_copy( hit.pos, transform[3] );
97 scene_add_submesh( world.scene_no_collide, mfoliage,
98 sm_blob, transform);
99 }
100 }
101 }
102 }
103
104 VG_STATIC void world_ents_allocate(void)
105 {
106 vg_info( "Allocating entities\n" );
107
108 /* count entites to allocate buffers for them.
109 * maybe in the future we just store these numbers in the model file...
110 *
111 * TODO: use this in world_routes too */
112
113 struct countable
114 {
115 enum classtype ct;
116 void **to_allocate;
117 u32 item_size;
118 int count;
119 }
120 entity_counts[] =
121 {
122 {
123 k_classtype_spawn,
124 (void*)&world.spawns,
125 sizeof(struct respawn_point)
126 },
127 {
128 k_classtype_audio,
129 (void*)&world.audio_things,
130 sizeof(struct world_audio_thing)
131 },
132 {
133 k_classtype_trigger,
134 (void*)&world.triggers,
135 sizeof(struct trigger_zone)
136 }
137 };
138
139 for( int i=0; i<vg_list_size(entity_counts); i++ )
140 entity_counts[i].count = 0;
141
142 for( int i=0; i<world.meta->info.node_count; i++ )
143 {
144 mdl_node *pnode = mdl_node_from_id( world.meta, i );
145
146 for( int j=0; j<vg_list_size(entity_counts); j ++ )
147 {
148 if( pnode->classtype == entity_counts[j].ct )
149 {
150 entity_counts[j].count ++;
151 break;
152 }
153 }
154 }
155
156 for( int i=0; i<vg_list_size(entity_counts); i++ )
157 {
158 struct countable *counter = &entity_counts[i];
159
160 u32 bufsize = counter->item_size*counter->count;
161 *counter->to_allocate = vg_linear_alloc( world.dynamic_vgl, bufsize );
162 }
163 }
164
165 VG_STATIC void world_pct_spawn( mdl_node *pnode )
166 {
167 struct respawn_point *rp = &world.spawns[ world.spawn_count ++ ];
168
169 v3_copy( pnode->co, rp->co );
170 v4_copy( pnode->q, rp->q );
171 rp->name = mdl_pstr( world.meta, pnode->pstr_name );
172 }
173
174 VG_STATIC void world_pct_water( mdl_node *pnode )
175 {
176 if( world.water.enabled )
177 {
178 vg_warn( "Multiple water surfaces in level! ('%s')\n",
179 mdl_pstr( world.meta, pnode->pstr_name ));
180 return;
181 }
182
183 mdl_submesh *sm = mdl_node_submesh( world.meta, pnode, 0 );
184
185 if( sm )
186 {
187 vg_acquire_thread_sync();
188 {
189 mdl_unpack_submesh( world.meta, &world.mesh_water, sm );
190 world.water.enabled = 1;
191 water_set_surface( pnode->co[1] );
192 }
193 vg_release_thread_sync();
194 }
195 else
196 {
197 vg_warn( "Water entity has no submeshes!\n" );
198 }
199 }
200
201 VG_STATIC void world_pct_instance( mdl_node *pnode )
202 {
203 struct classtype_instance *inst = mdl_get_entdata( world.meta, pnode );
204 pnode->sub_uid = 0;
205
206 int cache_entry = 0;
207 for( int i=0; i<world.instance_cache_count; i++ )
208 {
209 struct instance_cache *cache = &world.instance_cache[i];
210 if( inst->pstr_file == cache->pstr_file )
211 {
212 cache_entry = 1;
213 pnode->sub_uid = i+1;
214 break;
215 }
216 }
217
218 if( !cache_entry )
219 {
220 if( world.instance_cache_count == vg_list_size(world.instance_cache) )
221 vg_fatal_exit_loop( "Instance cache is full!" );
222
223 struct instance_cache *cache =
224 &world.instance_cache[world.instance_cache_count ++ ];
225
226 cache->pstr_file = inst->pstr_file;
227
228 #if 0
229 cache->mdl = mdl_load( filename );
230
231 if( cache->mdl )
232 {
233 world.instance_cache_count ++;
234 pnode->sub_uid = world.instance_cache_count;
235 mdl_link_materials( mworld, cache->mdl );
236 vg_success( "Cached %s\n", filename );
237 }
238 else
239 {
240 vg_warn( "Failed to cache %s\n", filename );
241 }
242 #endif
243 }
244 }
245
246 VG_STATIC void world_pct_audio( mdl_node *pnode )
247 {
248 struct world_audio_thing *thing = &world.audio_things[
249 world.audio_things_count ];
250
251 memset( thing, 0, sizeof(struct world_audio_thing) );
252 struct classtype_audio *aud = mdl_get_entdata( world.meta, pnode );
253
254 v3_copy( pnode->co, thing->pos );
255
256 if( aud->flags & AUDIO_FLAG_SPACIAL_3D )
257 thing->volume = aud->volume * pnode->s[0];
258 else
259 thing->volume = aud->volume;
260
261 thing->flags = aud->flags;
262 thing->temp_embedded_clip.path = mdl_pstr( world.meta, aud->pstr_file );
263 audio_clip_load( &thing->temp_embedded_clip );
264 thing->player.name = mdl_pstr( world.meta, pnode->pstr_name );
265 thing->player.enqued = 0;
266
267 pnode->sub_uid = world.audio_things_count;
268 world.audio_things_count ++;
269 }
270
271 VG_STATIC void world_entities_process(void)
272 {
273 struct entity_instruction
274 {
275 enum classtype ct;
276 void (*process)( mdl_node *pnode );
277 }
278 entity_instructions[] =
279 {
280 { k_classtype_spawn, world_pct_spawn },
281 { k_classtype_water, world_pct_water },
282 { k_classtype_instance, world_pct_instance },
283 { k_classtype_audio, world_pct_audio },
284 };
285
286 for( int i=0; i<world.meta->info.node_count; i++ )
287 {
288 mdl_node *pnode = mdl_node_from_id( world.meta, i );
289
290 for( int j=0; j<vg_list_size(entity_instructions); j++ )
291 {
292 struct entity_instruction *instr = &entity_instructions[j];
293
294 if( pnode->classtype == instr->ct )
295 {
296 instr->process( pnode );
297 break;
298 }
299 }
300
301 #if 0
302 else if( pnode->classtype == k_classtype_achievement_box )
303 {
304 world.achievement_zones =
305 buffer_reserve( world.achievement_zones,
306 world.achievement_zones_count,
307 &world.achievement_zones_cap, 1,
308 sizeof(struct achievement_zone) );
309
310 struct achievement_zone *zone = &world.achievement_zones[
311 world.achievement_zones_count ++ ];
312
313
314 struct classtype_achievement_box *box = mdl_get_entdata(mworld,pnode);
315
316 mdl_node_transform( pnode, zone->transform );
317 m4x3_invert_full( zone->transform, zone->inv_transform );
318 vg_strncpy( mdl_pstr(mworld, box->pstr_name), zone->name, 31 );
319 zone->name[31] = 0x00;
320 zone->triggered = 0;
321
322 if( box->trigger )
323 zone->ptarget_delegated = mdl_node_from_id( mworld, box->trigger );
324 else
325 zone->ptarget_delegated = NULL;
326 }
327 #endif
328 }
329
330 #if 0
331 /* fixup links */
332 for( int i=0; i<world.achievement_zones_count; i ++ )
333 {
334 struct achievement_zone *ach = &world.achievement_zones[ i ];
335 if( ach->ptarget_delegated )
336 {
337 u32 id = ach->ptarget_delegated->sub_uid;
338 ach->ptarget = &world.audio_things[ id ];
339 }
340 else
341 ach->ptarget = NULL;
342 }
343 #endif
344 }
345
346 VG_STATIC void world_load_instance_cache(void)
347 {
348 vg_linear_clear( vg_mem.scratch );
349
350 for( int i=0; i<world.instance_cache_count; i++ )
351 {
352 struct instance_cache *inst = &world.instance_cache[i];
353
354 const char *filename = mdl_pstr( world.meta, inst->pstr_file );
355 inst->mdl = mdl_load_full( vg_mem.scratch, filename );
356 }
357 }
358
359 VG_STATIC void world_generate(void)
360 {
361 /*
362 * Compile meshes into the world scenes
363 */
364 world.scene_geo = scene_init( world.dynamic_vgl, 500000, 1200000 );
365
366 /*
367 * TODO: System to dynamically allocate these
368 */
369 u32 mat_surf = 0,
370 mat_surf_oob = 0,
371 mat_vertex_blend = 0,
372 mat_alphatest = 0,
373 mat_graffiti = 0,
374 mat_subworld = 0,
375 mat_terrain = 0;
376
377 for( int i=1; i<world.meta->info.material_count; i++ )
378 {
379 mdl_material *mat = &world.meta->material_buffer[ i ];
380 const char *mat_name = mdl_pstr( world.meta, mat->pstr_name );
381
382 if( !strcmp( "surf", mat_name ))
383 mat_surf = i;
384 else if( !strcmp( "surf_oob", mat_name ))
385 mat_surf_oob = i;
386 else if( !strcmp( "vertex_blend", mat_name ))
387 mat_vertex_blend = i;
388 else if( !strcmp( "alphatest", mat_name ))
389 mat_alphatest = i;
390 else if( !strcmp( "graffitibox", mat_name ))
391 mat_graffiti = i;
392 else if( !strcmp( "terrain", mat_name ) )
393 mat_terrain = i;
394 }
395
396 m4x3f midentity;
397 m4x3_identity( midentity );
398
399 world_load_instance_cache();
400
401 /*
402 * Generate scene: collidable geometry
403 * ----------------------------------------------------------------
404 */
405
406 vg_info( "Generating collidable geometry\n" );
407 vg_info( "terrain...\n" );
408 /* terrain */
409 if( mat_terrain )
410 world_add_all_if_material( midentity, world.scene_geo,
411 world.meta, mat_terrain );
412 scene_copy_slice( world.scene_geo, &world.sm_terrain );
413
414 /* oob */
415 vg_info( "oob...\n" );
416 if( mat_surf_oob )
417 world_add_all_if_material( midentity, world.scene_geo,
418 world.meta, mat_surf_oob );
419 else
420 vg_warn( "No OOB surface\n" );
421 scene_copy_slice( world.scene_geo, &world.sm_geo_std_oob );
422
423
424 /* surface */
425 vg_info( "surface...\n" );
426 if( mat_surf )
427 world_add_all_if_material( midentity, world.scene_geo,
428 world.meta, mat_surf );
429 scene_copy_slice( world.scene_geo, &world.sm_geo_std );
430
431 /* vertex_blend */
432 vg_info( "vertex blend...\n" );
433 if( mat_vertex_blend )
434 world_add_all_if_material( midentity, world.scene_geo,
435 world.meta, mat_vertex_blend);
436 scene_copy_slice( world.scene_geo, &world.sm_geo_vb );
437
438 /* compress that bad boy */
439 world.scene_geo = scene_fix( world.dynamic_vgl, world.scene_geo );
440
441 vg_acquire_thread_sync();
442 {
443 scene_upload( world.scene_geo, &world.mesh_geo );
444 }
445 vg_release_thread_sync();
446
447 /* setup spacial mapping and rigidbody */
448 world.geo_bh = scene_bh_create( world.dynamic_vgl, world.scene_geo );
449
450 v3_zero( world.rb_geo.co );
451 q_identity( world.rb_geo.q );
452
453 world.rb_geo.type = k_rb_shape_scene;
454 world.rb_geo.inf.scene.bh_scene = world.geo_bh;
455 world.rb_geo.is_world = 1;
456 rb_init( &world.rb_geo );
457
458 /*
459 * Generate scene: non-collidable geometry
460 * ----------------------------------------------------------------
461 */
462 vg_info( "Generating non-collidable geometry\n" );
463
464 world.scene_no_collide = scene_init( world.dynamic_vgl, 200000, 500000 );
465
466 vg_info( "Applying foliage\n" );
467 world_apply_procedural_foliage();
468 scene_copy_slice( world.scene_no_collide, &world.sm_foliage_main );
469
470 vg_info( "alphatest...\n" );
471 world_add_all_if_material( midentity, world.scene_no_collide,
472 world.meta, mat_alphatest );
473 scene_copy_slice( world.scene_no_collide, &world.sm_foliage_alphatest );
474
475 vg_info( "graffiti...\n" );
476 world_add_all_if_material( midentity, world.scene_no_collide,
477 world.meta, mat_graffiti );
478 scene_copy_slice( world.scene_no_collide, &world.sm_graffiti );
479
480
481 /* upload and free that */
482 vg_acquire_thread_sync();
483 {
484 scene_upload( world.scene_no_collide, &world.mesh_no_collide );
485 }
486 vg_release_thread_sync();
487
488 vg_linear_del( world.dynamic_vgl, world.scene_no_collide );
489 world.scene_no_collide = NULL;
490 }
491
492 VG_STATIC void world_post_process(void)
493 {
494 /* initialize audio if need be */
495 audio_lock();
496 for( int i=0; i<world.audio_things_count; i++ )
497 {
498 struct world_audio_thing *thingy = &world.audio_things[ i ];
499
500 audio_player_init( &thingy->player );
501 audio_player_set_flags( &thingy->player, thingy->flags );
502 audio_player_set_vol( &thingy->player, thingy->volume );
503 audio_player_set_pan( &thingy->player, 0.0f );
504
505 if( thingy->flags & AUDIO_FLAG_SPACIAL_3D )
506 audio_player_set_position( &thingy->player, thingy->pos );
507
508 if( thingy->flags & AUDIO_FLAG_AUTO_START )
509 audio_player_playclip( &thingy->player, &thingy->temp_embedded_clip );
510 }
511 audio_unlock();
512
513 vg_acquire_thread_sync();
514 {
515 /*
516 * Rendering the depth map
517 */
518 m4x4f ortho;
519 m4x3f camera;
520
521 v3f extent;
522 v3_sub( world.scene_geo->bbx[1], world.scene_geo->bbx[0], extent );
523
524 float fl = world.scene_geo->bbx[0][0],
525 fr = world.scene_geo->bbx[1][0],
526 fb = world.scene_geo->bbx[0][2],
527 ft = world.scene_geo->bbx[1][2],
528 rl = 1.0f / (fr-fl),
529 tb = 1.0f / (ft-fb);
530
531 m4x4_zero( ortho );
532 ortho[0][0] = 2.0f * rl;
533 ortho[2][1] = 2.0f * tb;
534 ortho[3][0] = (fr + fl) * -rl;
535 ortho[3][1] = (ft + fb) * -tb;
536 ortho[3][3] = 1.0f;
537 m4x3_identity( camera );
538
539 glDisable(GL_DEPTH_TEST);
540 glDisable(GL_BLEND);
541 glDisable(GL_CULL_FACE);
542 glBindFramebuffer( GL_FRAMEBUFFER, gpipeline.fb_depthmap );
543 glViewport( 0, 0, 1024, 1024 );
544 shader_fscolour_use();
545 shader_fscolour_uColour( (v4f){-9999.0f,-9999.0f,-9999.0f,-9999.0f} );
546 render_fsquad();
547
548 /* todo: hmm?? */
549 glEnable(GL_BLEND);
550 glBlendFunc(GL_ONE, GL_ONE);
551 glBlendEquation(GL_MAX);
552 render_world_depth( ortho, camera );
553 glDisable(GL_BLEND);
554 glEnable(GL_DEPTH_TEST);
555 glBindFramebuffer( GL_FRAMEBUFFER, 0 );
556
557
558 /*
559 * TODO: World settings entity
560 */
561 struct ub_world_lighting *winfo = &gpipeline.ub_world_lighting;
562
563 if( world.water.enabled )
564 v4_copy( world.water.plane, winfo->g_water_plane );
565
566 v4f info_vec;
567 v3f *bounds = world.scene_geo->bbx;
568
569 info_vec[0] = bounds[0][0];
570 info_vec[1] = bounds[0][2];
571 info_vec[2] = 1.0f/ (bounds[1][0]-bounds[0][0]);
572 info_vec[3] = 1.0f/ (bounds[1][2]-bounds[0][2]);
573 v4_copy( info_vec, winfo->g_depth_bounds );
574
575 winfo->g_water_fog = 0.04f;
576 render_update_lighting_ub();
577 }
578
579 vg_release_thread_sync();
580
581 /*
582 * Setup scene collider
583 */
584 }
585
586
587 VG_STATIC void world_unload(void)
588 {
589 /* free meshes */
590 mesh_free( &world.mesh_geo );
591 mesh_free( &world.mesh_no_collide );
592 mesh_free( &world.mesh_route_lines );
593 mesh_free( &world.mesh_water );
594
595 world.time = 0.0;
596 world.rewind_from = 0.0;
597 world.rewind_to = 0.0;
598 world.last_use = 0.0;
599 world.active_gate = 0;
600 world.current_run_version = 2;
601 world.active_route_board = 0;
602 v3_zero( world.render_gate_pos );
603
604 for( int i=0; i<vg_list_size(world.ui_bars); i++ )
605 {
606 struct route_ui_bar *uib = &world.ui_bars[i];
607 uib->segment_start = 0;
608 uib->segment_count = 0;
609 uib->fade_start = 0;
610 uib->fade_count = 0;
611 uib->fade_timer_start = 0.0;
612 uib->xpos = 0.0f;
613 }
614
615 /* delete the entire block of memory */
616 memset( world.dynamic_vgl, 0xff, 72*1024*1024 );
617
618 vg_linear_clear( world.dynamic_vgl );
619
620 for( u32 i=0; i<72*1024*1024; i++ )
621 ((u8 *)world.dynamic_vgl)[i] = 0xff^i;
622
623 /* clean dangling pointers */
624 world.meta = NULL;
625
626 world.scene_geo = NULL;
627 world.scene_lines = NULL;
628 world.scene_no_collide = NULL;
629
630 world.geo_bh = NULL;
631 world.trigger_bh = NULL;
632 world.audio_bh = NULL;
633
634 world.spawns = NULL;
635 world.spawn_count = 0;
636
637 world.audio_things = NULL;
638 world.audio_things_count = 0;
639
640 world.logic_entities = NULL;
641 world.logic_entity_count = 0;
642
643 world.logic_actions = NULL;
644 world.logic_action_count = 0;
645
646 world.triggers = NULL;
647 world.trigger_count = 0;
648
649 world.nodes = NULL;
650 world.node_count = 0;
651
652 world.routes = NULL;
653 world.route_count = 0;
654
655 world.gates = NULL;
656 world.gate_count = 0;
657
658 world.collectors = NULL;
659 world.collector_count = 0;
660
661 world.instance_cache_count = 0;
662 world.water.enabled = 0;
663 }
664
665 VG_STATIC void world_load(void)
666 {
667 world_unload();
668
669 world.meta = mdl_load_full( world.dynamic_vgl, world.world_name );
670 vg_info( "Loading world: %s\n", world.world_name );
671
672 /* dynamic allocations */
673 world_ents_allocate();
674 world_routes_allocate();
675
676 /* meta processing */
677 world_routes_process();
678 world_entities_process();
679
680 /* main bulk */
681 world_generate();
682 world_routes_generate();
683 world_post_process();
684 }
685
686 #endif /* WORLD_GEN_H */
Skaterift source tree