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 VG_STATIC void world_load( world_instance *world, const char *path );
  11
  12 VG_STATIC void world_add_all_if_material( m4x3f transform, scene *pscene,
  13                                           mdl_context *mdl, u32 id )
  14 {
  15    for( u32 i=0; i<mdl_arrcount(&mdl->meshs); i++ ){
  16       mdl_mesh *mesh = mdl_arritm( &mdl->meshs, i );
  17
  18       for( u32 j=0; j<mesh->submesh_count; j++ ){
  19          mdl_submesh *sm = mdl_arritm( &mdl->submeshs, mesh->submesh_start+j );
  20          if( sm->material_id == id ){
  21             m4x3f transform2;
  22             mdl_transform_m4x3( &mesh->transform, transform2 );
  23             m4x3_mul( transform, transform2, transform2 );
  24
  25             scene_add_mdl_submesh( pscene, mdl, sm, transform2 );
  26          }
  27       }
  28    }
  29 }
  30
  31 VG_STATIC void world_add_blob( world_instance *world,
  32                                scene *pscene, ray_hit *hit )
  33 {
  34    m4x3f transform;
  35    v4f qsurface, qrandom;
  36    v3f axis;
  37
  38    v3_cross( (v3f){0.0f,1.0f,0.0f}, hit->normal, axis );
  39
  40    float angle = v3_dot(hit->normal,(v3f){0.0f,1.0f,0.0f});
  41    q_axis_angle( qsurface, axis, angle );
  42    q_axis_angle( qrandom, (v3f){0.0f,1.0f,0.0f}, vg_randf()*VG_TAUf );
  43    q_mul( qsurface, qrandom, qsurface );
  44    q_m3x3( qsurface, transform );
  45    v3_copy( hit->pos, transform[3] );
  46
  47    scene_vert verts[] =
  48    {
  49       { .co = { -1.00f, 0.0f, 0.0f } },
  50       { .co = {  1.00f, 0.0f, 0.0f } },
  51       { .co = { -1.00f, 1.2f, 0.0f } },
  52       { .co = {  1.00f, 1.2f, 0.0f } },
  53       { .co = { -0.25f, 2.0f, 0.0f } },
  54       { .co = {  0.25f, 2.0f, 0.0f } }
  55    };
  56
  57    const u32 indices[] = { 0,1,3, 0,3,2, 2,3,5, 2,5,4 };
  58
  59    if( pscene->vertex_count + vg_list_size(verts) > pscene->max_vertices )
  60       vg_fatal_exit_loop( "Scene vertex buffer overflow" );
  61
  62    if( pscene->indice_count + vg_list_size(indices) > pscene->max_indices )
  63       vg_fatal_exit_loop( "Scene index buffer overflow" );
  64
  65    scene_vert *dst_verts = &pscene->arrvertices[ pscene->vertex_count ];
  66    u32 *dst_indices      = &pscene->arrindices [ pscene->indice_count ];
  67
  68    scene_vert *ref       = &world->scene_geo->arrvertices[ hit->tri[0] ];
  69
  70    for( u32 i=0; i<vg_list_size(verts); i++ )
  71    {
  72       scene_vert *pvert = &dst_verts[ i ],
  73                  *src   = &verts[ i ];
  74
  75       m4x3_mulv( transform, src->co, pvert->co );
  76       scene_vert_pack_norm( pvert, transform[1] );
  77
  78       v2_copy( ref->uv, pvert->uv );
  79    }
  80
  81    for( u32 i=0; i<vg_list_size(indices); i++ )
  82       dst_indices[i] = indices[i] + pscene->vertex_count;
  83
  84    pscene->vertex_count += vg_list_size(verts);
  85    pscene->indice_count += vg_list_size(indices);
  86 }
  87
  88 /* Sprinkle foliage models over the map on terrain material */
  89 VG_STATIC void world_apply_procedural_foliage( world_instance *world,
  90                                                struct world_surface *mat )
  91 {
  92    if( vg.quality_profile == k_quality_profile_low )
  93       return;
  94
  95    vg_info( "Applying foliage (%u)\n", mat->info.pstr_name );
  96
  97    v3f volume;
  98    v3_sub( world->scene_geo->bbx[1], world->scene_geo->bbx[0], volume );
  99    volume[1] = 1.0f;
 100
 101    int count = 0;
 102
 103    float area = volume[0]*volume[2];
 104    u32 particles = 0.08f * area;
 105
 106    vg_info( "Map area: %f. Max particles: %u\n", area, particles );
 107
 108    for( u32 i=0; i<particles; i++ ){
 109       v3f pos;
 110       v3_mul( volume, (v3f){ vg_randf(), 1000.0f, vg_randf() }, pos );
 111       pos[1] = 1000.0f;
 112       v3_add( pos, world->scene_geo->bbx[0], pos );
 113
 114       ray_hit hit;
 115       hit.dist = INFINITY;
 116
 117       if( ray_world( world, pos, (v3f){0.0f,-1.0f,0.0f}, &hit )){
 118          struct world_surface *m1 = ray_hit_surface( world, &hit );
 119          if((hit.normal[1] > 0.8f) && (m1 == mat) && (hit.pos[1] > 0.0f+10.0f)){
 120             world_add_blob( world, world->scene_no_collide, &hit );
 121             count ++;
 122          }
 123       }
 124    }
 125
 126    vg_info( "%d foliage models added\n", count );
 127 }
 128
 129
 130 #if 0
 131 VG_STATIC void world_pct_spawn( world_instance *world, mdl_node *pnode )
 132 {
 133    struct respawn_point *rp = &world->spawns[ world->spawn_count ++ ];
 134
 135    v3_copy( pnode->co, rp->co );
 136    v4_copy( pnode->q, rp->q );
 137    rp->name = mdl_pstr( world->meta, pnode->pstr_name );
 138 }
 139
 140 VG_STATIC void world_pct_audio( world_instance *world, mdl_node *pnode )
 141 {
 142    struct world_audio_thing *thing = &world->audio_things[
 143                                       world->audio_things_count ];
 144
 145    memset( thing, 0, sizeof(struct world_audio_thing) );
 146    struct classtype_audio *aud = mdl_get_entdata( world->meta, pnode );
 147
 148    v3_copy( pnode->co, thing->pos );
 149
 150    thing->volume = aud->volume;
 151    thing->range = pnode->s[0];
 152
 153    thing->flags = aud->flags;
 154    thing->temp_embedded_clip.path = mdl_pstr( world->meta, aud->pstr_file );
 155    thing->temp_embedded_clip.flags = aud->flags;
 156
 157    audio_clip_load( &thing->temp_embedded_clip, world_global.generic_heap );
 158
 159    pnode->sub_uid = world->audio_things_count;
 160    world->audio_things_count ++;
 161 }
 162
 163 VG_STATIC void world_pct_world_light( world_instance *world, mdl_node *pnode )
 164 {
 165    struct world_light *light = &world->lights[ world->light_count ++ ];
 166    light->node = pnode;
 167    light->inf  = mdl_get_entdata( world->meta, pnode );
 168
 169    q_m3x3( pnode->q,   light->inverse_world );
 170    v3_copy( pnode->co, light->inverse_world[3] );
 171    m4x3_invert_affine( light->inverse_world, light->inverse_world );
 172
 173    light->angle_sin_cos[0] = sinf( light->inf->angle * 0.5f );
 174    light->angle_sin_cos[1] = cosf( light->inf->angle * 0.5f );
 175 }
 176
 177 VG_STATIC void world_pct_nonlocal_gate( world_instance *world, mdl_node *pnode )
 178 {
 179    struct nonlocal_gate *gate = &world->nonlocal_gates[
 180                                        world->nonlocalgate_count ++ ];
 181    struct classtype_gate *inf = mdl_get_entdata( world->meta, pnode );
 182
 183    gate->working = 0;
 184    gate->node = pnode;
 185    gate->target_map_index = 0;
 186    v2_copy( inf->dims, gate->gate.dims );
 187 }
 188
 189 VG_STATIC void world_entities_process( world_instance *world )
 190 {
 191    struct entity_instruction
 192    {
 193       enum classtype ct;
 194       void (*process)( world_instance *world, mdl_node *pnode );
 195    }
 196    entity_instructions[] =
 197    {
 198       { k_classtype_spawn,    world_pct_spawn },
 199       { k_classtype_water,    world_pct_water },
 200       { k_classtype_audio,    world_pct_audio },
 201       { k_classtype_world_light, world_pct_world_light },
 202       { k_classtype_nonlocal_gate, world_pct_nonlocal_gate }
 203    };
 204
 205    for( int i=0; i<world->meta->info.node_count; i++ )
 206    {
 207       mdl_node *pnode = mdl_node_from_id( world->meta, i );
 208
 209       for( int j=0; j<vg_list_size(entity_instructions); j++ )
 210       {
 211          struct entity_instruction *instr = &entity_instructions[j];
 212
 213          if( pnode->classtype == instr->ct )
 214          {
 215             instr->process( world, pnode );
 216             break;
 217          }
 218       }
 219    }
 220 }
 221 VG_STATIC void world_link_nonlocal_gates( int index_a, int index_b )
 222 {
 223    vg_info( "Linking non-local gates\n" );
 224    world_instance *a = &world_global.worlds[ index_a ],
 225                   *b = &world_global.worlds[ index_b ];
 226
 227    for( int i=0; i<a->nonlocalgate_count; i++ )
 228    {
 229       struct nonlocal_gate *ga = &a->nonlocal_gates[i];
 230       struct classtype_gate *ga_inf = mdl_get_entdata( a->meta, ga->node );
 231       const char *ga_name = mdl_pstr( a->meta, ga_inf->target );
 232
 233       for( int j=0; j<b->nonlocalgate_count; j++ )
 234       {
 235          struct nonlocal_gate *gb = &b->nonlocal_gates[j];
 236          struct classtype_gate *gb_inf = mdl_get_entdata( b->meta, gb->node );
 237          const char *gb_name = mdl_pstr( b->meta, gb_inf->target );
 238
 239          if( !strcmp( ga_name, gb_name ) )
 240          {
 241             vg_success( "Created longjump for ID '%s'\n", ga_name );
 242
 243             v4f qYflip;
 244             q_axis_angle( qYflip, (v3f){0.0f,1.0f,0.0f}, VG_PIf );
 245
 246             /* TODO: Gates are created very wonkily. refactor. */
 247             ga->target_map_index = index_b;
 248             gb->target_map_index = index_a;
 249             ga->working = 1;
 250             gb->working = 1;
 251
 252             v4_copy( ga->node->q,  ga->gate.q[0] );
 253             v4_copy( gb->node->q,  ga->gate.q[1] );
 254             v3_copy( ga->node->co, ga->gate.co[0] );
 255             v3_copy( gb->node->co, ga->gate.co[1] );
 256
 257             v4_copy( gb->node->q,  gb->gate.q[0] );
 258             v4_copy( ga->node->q,  gb->gate.q[1] );
 259             v3_copy( gb->node->co, gb->gate.co[0] );
 260             v3_copy( ga->node->co, gb->gate.co[1] );
 261
 262             /* reverse B's direction */
 263             q_mul( gb->gate.q[0], qYflip, gb->gate.q[0] );
 264             q_mul( gb->gate.q[1], qYflip, gb->gate.q[1] );
 265             q_normalize( gb->gate.q[0] );
 266             q_normalize( gb->gate.q[1] );
 267
 268             gate_transform_update( &ga->gate );
 269             gate_transform_update( &gb->gate );
 270          }
 271       }
 272    }
 273 }
 274 #endif
 275
 276 #if 0
 277 VG_STATIC float colour_luminance( v3f v )
 278 {
 279    return v3_dot( v, (v3f){0.2126f, 0.7152f, 0.0722f} );
 280 }
 281
 282 VG_STATIC float calc_light_influence( world_instance *world, v3f position,
 283                                       int light )
 284 {
 285    struct world_light *world_light = &world->lights[ light ];
 286    struct classtype_world_light *inf = world_light->inf;
 287
 288    v3f light_delta;
 289    v3_sub( world_light->node->co, position, light_delta );
 290    v3_muls( light_delta, 10.0f, light_delta );
 291
 292    float quadratic = v3_dot( light_delta, light_delta ),
 293          attenuation = 1.0f/( 1.0f + quadratic );
 294
 295    float quadratic_light = attenuation * colour_luminance( inf->colour );
 296
 297    if( (inf->type == k_light_type_point) ||
 298        (inf->type == k_light_type_point_nighttime_only) )
 299    {
 300       return quadratic_light;
 301    }
 302    else if( (inf->type == k_light_type_spot) ||
 303             (inf->type == k_light_type_spot_nighttime_only) )
 304    {
 305       v3f dir;
 306       q_mulv( world_light->node->q, (v3f){0.0f,1.0f,0.0f}, dir );
 307
 308       float spot_theta = vg_maxf( 0.0f, v3_dot( light_delta, dir ) ),
 309             falloff    = spot_theta >= 0.0f? 1.0f: 0.0f;
 310
 311       return quadratic_light * falloff;
 312    }
 313    else
 314       return 0.0f;
 315 }
 316 #endif
 317
 318 VG_STATIC void world_generate( world_instance *world )
 319 {
 320    /*
 321     * Compile meshes into the world scenes
 322     */
 323    world->scene_geo = scene_init( world_global.generic_heap, 320000, 1200000 );
 324
 325    m4x3f midentity;
 326    m4x3_identity( midentity );
 327
 328    /*
 329     * Generate scene: collidable geometry
 330     * ----------------------------------------------------------------
 331     */
 332
 333    vg_info( "Generating collidable geometry\n" );
 334
 335    for( u32 i=0; i<world->surface_count; i++ ){
 336       struct world_surface *surf = &world->surfaces[ i ];
 337
 338       if( surf->info.flags & k_material_flag_collision )
 339          world_add_all_if_material( midentity, world->scene_geo,
 340                                     &world->meta, i );
 341
 342       scene_copy_slice( world->scene_geo, &surf->sm_geo );
 343    }
 344
 345    /* compress that bad boy */
 346    world->scene_geo = scene_fix( world_global.generic_heap, world->scene_geo );
 347
 348    vg_acquire_thread_sync();
 349    {
 350       scene_upload( world->scene_geo, &world->mesh_geo );
 351    }
 352    vg_release_thread_sync();
 353
 354    /* setup spacial mapping and rigidbody */
 355    world->geo_bh = scene_bh_create( world_global.generic_heap,
 356                                     world->scene_geo );
 357
 358    v3_zero( world->rb_geo.co );
 359    q_identity( world->rb_geo.q );
 360
 361    world->rb_geo.type = k_rb_shape_scene;
 362    world->rb_geo.inf.scene.bh_scene = world->geo_bh;
 363    world->rb_geo.is_world = 1;
 364    rb_init( &world->rb_geo );
 365
 366    /*
 367     * Generate scene: non-collidable geometry
 368     * ----------------------------------------------------------------
 369     */
 370    vg_info( "Generating non-collidable geometry\n" );
 371
 372    world->scene_no_collide = scene_init( world_global.generic_heap,
 373                                          200000, 500000 );
 374
 375    for( u32 i=0; i<world->surface_count; i++ ){
 376       struct world_surface *mat = &world->surfaces[ i ];
 377
 378       if( !(mat->info.flags & k_material_flag_collision) ){
 379          world_add_all_if_material( midentity, world->scene_no_collide,
 380                                     &world->meta, i );
 381       }
 382
 383       if( mat->info.flags & k_material_flag_grow_grass )
 384          world_apply_procedural_foliage( world, mat );
 385
 386       scene_copy_slice( world->scene_no_collide, &mat->sm_no_collide );
 387    }
 388
 389    /* upload and free that */
 390    vg_acquire_thread_sync();
 391    {
 392       scene_upload( world->scene_no_collide, &world->mesh_no_collide );
 393    }
 394    vg_release_thread_sync();
 395
 396    vg_linear_del( world_global.generic_heap, world->scene_no_collide );
 397    world->scene_no_collide = NULL;
 398 }
 399
 400 float fsd_cone_infinite( v3f p, v2f c )
 401 {
 402    v2f q = { v2_length( (v2f){ p[0], p[2] } ), -p[1] };
 403    float s = vg_maxf( 0.0f, v2_dot( q, c ) );
 404
 405    v2f v0;
 406    v2_muls( c, s, v0 );
 407    v2_sub( q, v0, v0 );
 408
 409    float d = v2_length( v0 );
 410    return d * ((q[0]*c[1]-q[1]*c[0]<0.0f)?-1.0f:1.0f);
 411 }
 412
 413 VG_STATIC void world_compute_light_indices( world_instance *world )
 414 {
 415    /* light cubes */
 416    v3f cubes_min, cubes_max;
 417    v3_muls( world->scene_geo->bbx[0], 1.0f/k_light_cube_size, cubes_min );
 418    v3_muls( world->scene_geo->bbx[1], 1.0f/k_light_cube_size, cubes_max );
 419
 420    v3_sub( cubes_min, (v3f){ 0.5f, 0.5f, 0.5f }, cubes_min );
 421    v3_add( cubes_max, (v3f){ 0.5f, 0.5f, 0.5f }, cubes_max );
 422
 423    v3_floor( cubes_min, cubes_min );
 424    v3_floor( cubes_max, cubes_max );
 425
 426    v3i icubes_min, icubes_max;
 427
 428    for( int i=0; i<3; i++ ){
 429       icubes_min[i] = cubes_min[i];
 430       icubes_max[i] = cubes_max[i];
 431    }
 432
 433    v3i icubes_count;
 434    v3i_sub( icubes_max, icubes_min, icubes_count );
 435
 436    for( int i=0; i<3; i++ ){
 437       icubes_count[i] = VG_MIN( 128, icubes_count[i]+1 );
 438       cubes_max[i] = icubes_min[i] + icubes_count[i];
 439    }
 440
 441    v3_muls( cubes_min, k_light_cube_size, cubes_min );
 442    v3_muls( cubes_max, k_light_cube_size, cubes_max );
 443
 444    for( int i=0; i<3; i++ ){
 445       float range = cubes_max[i]-cubes_min[i];
 446       world->ub_lighting.g_cube_inv_range[i] = 1.0f / range;
 447       world->ub_lighting.g_cube_inv_range[i] *= (float)icubes_count[i];
 448
 449       vg_info( "cubes[%d]: %d\n", i, icubes_count[i] );
 450    }
 451
 452    int total_cubes = icubes_count[0]*icubes_count[1]*icubes_count[2];
 453
 454    u32 *cubes_index = vg_linear_alloc( world_global.generic_heap,
 455                                        total_cubes * sizeof(u32) * 2.0f );
 456
 457    vg_info( "Computing light cubes (%d) [%f %f %f] -> [%f %f %f]\n",
 458              total_cubes, cubes_min[0], -cubes_min[2], cubes_min[1],
 459                           cubes_max[0], -cubes_max[2], cubes_max[1] );
 460
 461    v3_copy( cubes_min, world->ub_lighting.g_cube_min );
 462
 463    v3f cube_size;
 464    v3_div( (v3f){1.0f,1.0f,1.0f}, world->ub_lighting.g_cube_inv_range,
 465             cube_size );
 466    float bound_radius = v3_length( cube_size );
 467
 468    for( int iz = 0; iz<icubes_count[2]; iz ++ ){
 469       for( int iy = 0; iy<icubes_count[1]; iy++ ){
 470          for( int ix = 0; ix<icubes_count[0]; ix++ ){
 471             boxf bbx;
 472             v3_div( (v3f){ ix, iy, iz }, world->ub_lighting.g_cube_inv_range,
 473                   bbx[0] );
 474             v3_div( (v3f){ ix+1, iy+1, iz+1 },
 475                   world->ub_lighting.g_cube_inv_range,
 476                   bbx[1] );
 477
 478             v3_add( bbx[0], world->ub_lighting.g_cube_min, bbx[0] );
 479             v3_add( bbx[1], world->ub_lighting.g_cube_min, bbx[1] );
 480
 481             v3f center;
 482             v3_add( bbx[0], bbx[1], center );
 483             v3_muls( center, 0.5f, center );
 484
 485             u32 indices[6] = { 0, 0, 0, 0, 0, 0 };
 486             u32 count = 0;
 487
 488             float influences[6] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
 489             const int N = vg_list_size( influences );
 490
 491             for( u32 j=0; j<mdl_arrcount(&world->ent_light); j ++ ){
 492                ent_light *light = mdl_arritm( &world->ent_light, j );
 493                v3f closest;
 494                closest_point_aabb( light->transform.co, bbx, closest );
 495
 496                float dist = v3_dist( closest, light->transform.co ),
 497                      influence = 1.0f/(dist+1.0f);
 498
 499                if( dist > light->range )
 500                   continue;
 501
 502                if( light->type == k_light_type_spot){
 503                   v3f local;
 504                   m4x3_mulv( light->inverse_world, center, local );
 505
 506                   float r = fsd_cone_infinite( local, light->angle_sin_cos );
 507
 508                   if( r > bound_radius )
 509                      continue;
 510                }
 511
 512                int best_pos = N;
 513                for( int k=best_pos-1; k>=0; k -- )
 514                   if( influence > influences[k] )
 515                      best_pos = k;
 516
 517                if( best_pos < N ){
 518                   for( int k=N-1; k>best_pos; k -- ){
 519                      influences[k] = influences[k-1];
 520                      indices[k] = indices[k-1];
 521                   }
 522
 523                   influences[best_pos] = influence;
 524                   indices[best_pos] = j;
 525                }
 526             }
 527
 528             for( int j=0; j<N; j++ )
 529                if( influences[j] > 0.0f )
 530                   count ++;
 531
 532             int base_index = iz * (icubes_count[0]*icubes_count[1]) +
 533                              iy * (icubes_count[0]) +
 534                              ix;
 535
 536             int lower_count = VG_MIN( 3, count );
 537             u32 packed_index_lower = lower_count;
 538             packed_index_lower |= indices[0]<<2;
 539             packed_index_lower |= indices[1]<<12;
 540             packed_index_lower |= indices[2]<<22;
 541
 542             int upper_count = VG_MAX( 0, count - lower_count );
 543             u32 packed_index_upper = upper_count;
 544             packed_index_upper |= indices[3]<<2;
 545             packed_index_upper |= indices[4]<<12;
 546             packed_index_upper |= indices[5]<<22;
 547
 548             cubes_index[ base_index*2 + 0 ] = packed_index_lower;
 549             cubes_index[ base_index*2 + 1 ] = packed_index_upper;
 550          }
 551       }
 552    }
 553
 554    vg_acquire_thread_sync();
 555
 556    glGenTextures( 1, &world->tex_light_cubes );
 557    glBindTexture( GL_TEXTURE_3D, world->tex_light_cubes );
 558    glTexImage3D( GL_TEXTURE_3D, 0, GL_RG32UI,
 559                  icubes_count[0], icubes_count[1], icubes_count[2],
 560                  0, GL_RG_INTEGER, GL_UNSIGNED_INT, cubes_index );
 561    glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
 562    glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
 563
 564    vg_linear_del( world_global.generic_heap, cubes_index );
 565
 566    vg_release_thread_sync();
 567 }
 568
 569 VG_STATIC int reset_player( int argc, char const *argv[] );
 570 VG_STATIC void world_post_process( world_instance *world )
 571 {
 572    /* initialize audio if need be */
 573 #if 0
 574    audio_lock();
 575    for( int i=0; i<world->audio_things_count; i++ )
 576    {
 577       struct world_audio_thing *thingy = &world->audio_things[ i ];
 578
 579       if( thingy->flags & AUDIO_FLAG_AUTO_START )
 580       {
 581          audio_channel *ch =
 582             audio_request_channel( &thingy->temp_embedded_clip, thingy->flags );
 583
 584          audio_channel_edit_volume( ch, thingy->volume, 1 );
 585          audio_channel_set_spacial( ch, thingy->pos, thingy->range );
 586
 587          if( !(ch->flags & AUDIO_FLAG_LOOP) )
 588             ch = audio_relinquish_channel( ch );
 589       }
 590    }
 591    audio_unlock();
 592 #endif
 593
 594    world_compute_light_indices( world );
 595
 596    vg_acquire_thread_sync();
 597    {
 598       /* create scene lighting buffer */
 599
 600       u32 size = VG_MAX(mdl_arrcount(&world->ent_light),1) * sizeof(float)*12;
 601       vg_info( "Upload %ubytes (lighting)\n", size );
 602
 603       glGenBuffers( 1, &world->tbo_light_entities );
 604       glBindBuffer( GL_TEXTURE_BUFFER, world->tbo_light_entities );
 605       glBufferData( GL_TEXTURE_BUFFER, size, NULL, GL_DYNAMIC_DRAW );
 606
 607       /* buffer layout
 608        *
 609        *  colour               position                direction (spots)
 610        * | .   .   .   .     | .   .   .   .         | .   .   .   .  |
 611        * | Re  Ge  Be  Night | Xco Yco Zco Range     | Dx  Dy  Dz  Da |
 612        *
 613        */
 614
 615       v4f *light_dst = glMapBuffer( GL_TEXTURE_BUFFER, GL_WRITE_ONLY );
 616       for( u32 i=0; i<mdl_arrcount(&world->ent_light); i++ ){
 617          ent_light *light = mdl_arritm( &world->ent_light, i );
 618
 619          /* colour  + night */
 620          v3_muls( light->colour, light->colour[3] * 2.0f, light_dst[i*3+0] );
 621          light_dst[i*3+0][3] = -1.0f;
 622
 623          if( !light->daytime ){
 624             u32 hash = (i * 29986577) & 0xff;
 625             float switch_on = hash;
 626                   switch_on *= (1.0f/255.0f);
 627
 628             light_dst[i*3+0][3] = 0.44f + switch_on * 0.015f;
 629          }
 630
 631          /* position + 1/range^2 */
 632          v3_copy( light->transform.co, light_dst[i*3+1] );
 633          light_dst[i*3+1][3] = 1.0f/(light->range*light->range);
 634
 635          /* direction + angle */
 636          q_mulv( light->transform.q, (v3f){0.0f,-1.0f,0.0f}, light_dst[i*3+2]);
 637          light_dst[i*3+2][3] = cosf( light->angle );
 638       }
 639
 640       glUnmapBuffer( GL_TEXTURE_BUFFER );
 641
 642       glGenTextures( 1, &world->tex_light_entities );
 643       glBindTexture( GL_TEXTURE_BUFFER, world->tex_light_entities );
 644       glTexBuffer( GL_TEXTURE_BUFFER, GL_RGBA32F, world->tbo_light_entities );
 645
 646       /* Upload lighting uniform buffer */
 647       if( world->water.enabled )
 648          v4_copy( world->water.plane, world->ub_lighting.g_water_plane );
 649
 650       v4f info_vec;
 651       v3f *bounds = world->scene_geo->bbx;
 652
 653       info_vec[0] = bounds[0][0];
 654       info_vec[1] = bounds[0][2];
 655       info_vec[2] = 1.0f/ (bounds[1][0]-bounds[0][0]);
 656       info_vec[3] = 1.0f/ (bounds[1][2]-bounds[0][2]);
 657       v4_copy( info_vec, world->ub_lighting.g_depth_bounds );
 658
 659       /*
 660        * Rendering the depth map
 661        */
 662       camera ortho;
 663
 664       v3f extent;
 665       v3_sub( world->scene_geo->bbx[1], world->scene_geo->bbx[0], extent );
 666
 667       float fl = world->scene_geo->bbx[0][0],
 668             fr = world->scene_geo->bbx[1][0],
 669             fb = world->scene_geo->bbx[0][2],
 670             ft = world->scene_geo->bbx[1][2],
 671             rl = 1.0f / (fr-fl),
 672             tb = 1.0f / (ft-fb);
 673
 674       m4x4_zero( ortho.mtx.p );
 675       ortho.mtx.p[0][0] = 2.0f * rl;
 676       ortho.mtx.p[2][1] = 2.0f * tb;
 677       ortho.mtx.p[3][0] = (fr + fl) * -rl;
 678       ortho.mtx.p[3][1] = (ft + fb) * -tb;
 679       ortho.mtx.p[3][3] = 1.0f;
 680       m4x3_identity( ortho.transform );
 681       camera_update_view( &ortho );
 682       camera_finalize( &ortho );
 683
 684       glDisable(GL_DEPTH_TEST);
 685       glDisable(GL_BLEND);
 686       glDisable(GL_CULL_FACE);
 687       render_fb_bind( &world->heightmap );
 688       shader_blitcolour_use();
 689       shader_blitcolour_uColour( (v4f){-9999.0f,-9999.0f,-9999.0f,-9999.0f} );
 690       render_fsquad();
 691
 692       glEnable(GL_BLEND);
 693       glBlendFunc(GL_ONE, GL_ONE);
 694       glBlendEquation(GL_MAX);
 695
 696       render_world_position( world, &ortho );
 697       glDisable(GL_BLEND);
 698       glEnable(GL_DEPTH_TEST);
 699       glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 700
 701       /* upload full buffer */
 702       glBindBuffer( GL_UNIFORM_BUFFER, world->ubo_lighting );
 703       glBufferSubData( GL_UNIFORM_BUFFER, 0,
 704                        sizeof(struct ub_world_lighting), &world->ub_lighting );
 705    }
 706
 707    vg_release_thread_sync();
 708
 709 #if 0
 710    /*
 711     * Setup scene collider
 712     */
 713    reset_player( 1, (const char *[]){"start"} );
 714 #endif
 715 }
 716
 717 VG_STATIC void world_process_resources( world_instance *world )
 718 {
 719    vg_info( "Loading textures\n" );
 720
 721    world->texture_count = 0;
 722
 723    world->texture_count = world->meta.textures.count+1;
 724    world->textures = vg_linear_alloc( world_global.generic_heap,
 725                                       sizeof(GLuint)*world->texture_count );
 726
 727    vg_acquire_thread_sync();
 728    {
 729       /* error texture */
 730       world->textures[0] = vg_tex2d_new();
 731       vg_tex2d_set_error();
 732       vg_tex2d_nearest();
 733       vg_tex2d_repeat();
 734
 735       for( u32 i=0; i<mdl_arrcount(&world->meta.textures); i++ ){
 736          mdl_texture *tex = mdl_arritm( &world->meta.textures, i );
 737
 738          if( !tex->file.pack_size ){
 739             vg_release_thread_sync();
 740             vg_fatal_exit_loop( "World models must have packed textures!" );
 741          }
 742
 743          vg_linear_clear( vg_mem.scratch );
 744          world->textures[i+1] = vg_tex2d_new();
 745          vg_tex2d_set_error();
 746          vg_tex2d_qoi( mdl_arritm( &world->meta.pack, tex->file.pack_offset ),
 747                        tex->file.pack_size,
 748                        mdl_pstr( &world->meta, tex->file.pstr_path ));
 749          vg_tex2d_nearest();
 750          vg_tex2d_repeat();
 751       }
 752    }
 753    vg_release_thread_sync();
 754
 755    vg_info( "Loading materials\n" );
 756
 757    world->surface_count = world->meta.materials.count+1;
 758    world->surfaces = vg_linear_alloc( world_global.generic_heap,
 759                            sizeof(struct world_surface)*world->surface_count );
 760
 761    /* error material */
 762    struct world_surface *errmat = &world->surfaces[0];
 763    memset( errmat, 0, sizeof(struct world_surface) );
 764
 765    for( u32 i=0; i<mdl_arrcount(&world->meta.materials); i++ ){
 766       world->surfaces[i+1].info =
 767          *(mdl_material *)mdl_arritm( &world->meta.materials, i );
 768    }
 769 }
 770
 771 VG_STATIC void world_unload( world_instance *world )
 772 {
 773    vg_acquire_thread_sync();
 774
 775    /* free meshes */
 776    mesh_free( &world->mesh_route_lines );
 777    mesh_free( &world->mesh_geo );
 778    mesh_free( &world->mesh_no_collide );
 779
 780    /* glDeleteBuffers silently ignores 0's and names that do not correspond to
 781     * existing buffer objects.
 782     * */
 783    glDeleteBuffers( 1, &world->tbo_light_entities );
 784    glDeleteTextures( 1, &world->tex_light_entities );
 785    glDeleteTextures( 1, &world->tex_light_cubes );
 786
 787    /* FIXME: CANT DO THIS HERE */
 788    /*        whynot? */
 789    /*        oh this should be moved to a global function */
 790    world_global.time = 0.0;
 791    world_global.rewind_from = 0.0;
 792    world_global.rewind_to = 0.0;
 793    world_global.last_use = 0.0;
 794    world_global.sfd.active_route_board = 0;
 795
 796    /* delete textures and meshes */
 797    glDeleteTextures( world->texture_count, world->textures );
 798
 799    /* delete the entire block of memory */
 800    /* FIXME: WE CANT DO THIS SHIT ANYMORE, NEED TO DEALLOC FROM ABOVE */
 801 #if 0
 802    vg_linear_clear( world->dynamic_vgl );
 803    vg_linear_clear( world->audio_vgl );
 804 #endif
 805
 806    vg_release_thread_sync();
 807 }
 808
 809 VG_STATIC void world_clean( world_instance *world )
 810 {
 811    memset( &world->meta, 0, sizeof(mdl_context) );
 812
 813    /*
 814     * TODO: Theres probably a better way to do this? */
 815    /*       yep, find all members that can be memsetted to 0. this is probably
 816     *       every member anyway, given the below is just setting to 0
 817     *
 818     *       also: rename clean to init? */
 819
 820    world->textures = NULL;
 821    world->texture_count = 0;
 822    world->surfaces = NULL;
 823    world->surface_count = 0;
 824
 825    world->scene_geo = NULL;
 826    world->scene_no_collide = NULL;
 827    world->scene_lines = NULL;
 828
 829    world->geo_bh = NULL;
 830    world->volume_bh = NULL;
 831    world->audio_bh = NULL;
 832    world->rendering_gate = NULL;
 833
 834    world->water.enabled = 0;
 835
 836    /* default lighting conditions
 837     * -------------------------------------------------------------*/
 838    struct ub_world_lighting *state = &world->ub_lighting;
 839
 840    state->g_light_preview = 0;
 841    state->g_shadow_samples = 8;
 842    state->g_water_fog = 0.04f;
 843
 844    v4_zero( state->g_water_plane );
 845    v4_zero( state->g_depth_bounds );
 846
 847    state->g_shadow_length = 9.50f;
 848    state->g_shadow_spread = 0.65f;
 849
 850    v3_copy( (v3f){0.37f, 0.54f, 0.97f}, state->g_daysky_colour );
 851    v3_copy( (v3f){0.03f, 0.05f, 0.20f}, state->g_nightsky_colour );
 852    v3_copy( (v3f){1.00f, 0.32f, 0.01f}, state->g_sunset_colour );
 853    v3_copy( (v3f){0.13f, 0.17f, 0.35f}, state->g_ambient_colour );
 854    v3_copy( (v3f){0.25f, 0.17f, 0.51f}, state->g_sunset_ambient );
 855    v3_copy( (v3f){1.10f, 0.89f, 0.35f}, state->g_sun_colour );
 856 }
 857
 858 VG_STATIC void world_entities_init( world_instance *world )
 859 {
 860    /* lights */
 861    for( u32 j=0; j<mdl_arrcount(&world->ent_light); j ++ ){
 862       ent_light *light = mdl_arritm( &world->ent_light, j );
 863
 864       m4x3f to_world;
 865       q_m3x3( light->transform.q, to_world );
 866       v3_copy( light->transform.co, to_world[3] );
 867       m4x3_invert_affine( to_world, light->inverse_world );
 868
 869       light->angle_sin_cos[0] = sinf( light->angle * 0.5f );
 870       light->angle_sin_cos[1] = cosf( light->angle * 0.5f );
 871    }
 872
 873    /* gates */
 874    for( u32 j=0; j<mdl_arrcount(&world->ent_gate); j ++ ){
 875       ent_gate *gate = mdl_arritm( &world->ent_gate, j );
 876       gate_transform_update( gate );
 877    }
 878
 879    /* water */
 880    for( u32 j=0; j<mdl_arrcount(&world->ent_water); j++ ){
 881       ent_water *water = mdl_arritm( &world->ent_water, j );
 882       if( world->water.enabled ){
 883          vg_warn( "Multiple water surfaces in level!\n" );
 884          break;
 885       }
 886
 887       world->water.enabled = 1;
 888       water_set_surface( world, water->transform.co[1] );
 889    }
 890 }
 891
 892 VG_STATIC void world_load( world_instance *world, const char *path )
 893 {
 894    world_unload( world );
 895    world_clean( world );
 896
 897    vg_info( "Loading world: %s\n", path );
 898
 899    mdl_open( &world->meta, path, world_global.generic_heap );
 900    mdl_load_metadata_block( &world->meta, world_global.generic_heap );
 901    mdl_load_animation_block( &world->meta, world_global.generic_heap );
 902    mdl_load_mesh_block( &world->meta, world_global.generic_heap );
 903    mdl_load_pack_block( &world->meta, world_global.generic_heap );
 904
 905    mdl_load_array( &world->meta, &world->ent_gate,
 906                    "ent_gate", world_global.generic_heap );
 907    mdl_load_array( &world->meta, &world->ent_spawn,
 908                    "ent_spawn", world_global.generic_heap );
 909    mdl_load_array( &world->meta, &world->ent_light,
 910                    "ent_light", world_global.generic_heap );
 911
 912    mdl_load_array( &world->meta, &world->ent_route_node,
 913                    "ent_route_node", world_global.generic_heap );
 914    mdl_load_array( &world->meta, &world->ent_path_index,
 915                    "ent_path_index", world_global.generic_heap );
 916    mdl_load_array( &world->meta, &world->ent_checkpoint,
 917                    "ent_checkpoint", world_global.generic_heap );
 918    mdl_load_array( &world->meta, &world->ent_route,
 919                    "ent_route", world_global.generic_heap );
 920    mdl_load_array( &world->meta, &world->ent_water,
 921                    "ent_water", world_global.generic_heap );
 922
 923    mdl_close( &world->meta );
 924
 925    /* process resources from pack */
 926    world_process_resources( world );
 927
 928 #if 0
 929    /* dynamic allocations */
 930    world_ents_allocate( world );
 931    world_routes_allocate( world );
 932
 933    /* meta processing */
 934 #endif
 935    world_routes_ent_init( world );
 936    world_entities_init( world );
 937
 938    /* main bulk */
 939    world_generate( world );
 940    world_routes_generate( world );
 941    world_post_process( world );
 942 }
 943
 944 #endif /* WORLD_GEN_H */