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