timings

[carveJwlIkooP6JGAAIwe30JlM.git] / world_gen.h

/*
 * Copyright (C) 2021-2022 Mt.ZERO Software, Harry Godden - All Rights Reserved
 */

#ifndef WORLD_GEN_H
#define WORLD_GEN_H

#include "world.h"

VG_STATIC void world_load( world_instance *world, const char *path );

VG_STATIC void world_add_all_if_material( m4x3f transform, scene *pscene, 
                                          mdl_context *mdl, u32 id )
{
   for( u32 i=0; i<mdl_arrcount(&mdl->meshs); i++ ){
      mdl_mesh *mesh = mdl_arritm( &mdl->meshs, i );

      for( u32 j=0; j<mesh->submesh_count; j++ ){
         mdl_submesh *sm = mdl_arritm( &mdl->submeshs, mesh->submesh_start+j );
         if( sm->material_id == id ){
            m4x3f transform2;
            mdl_transform_m4x3( &mesh->transform, transform2 );
            m4x3_mul( transform, transform2, transform2 );

            scene_add_mdl_submesh( pscene, mdl, sm, transform2 );
         }
      }
   }
}

VG_STATIC void world_add_blob( world_instance *world,
                               scene *pscene, ray_hit *hit )
{
   m4x3f transform;
   v4f qsurface, qrandom;
   v3f axis;

   v3_cross( (v3f){0.0f,1.0f,0.0f}, hit->normal, axis );

   float angle = v3_dot(hit->normal,(v3f){0.0f,1.0f,0.0f});
   q_axis_angle( qsurface, axis, angle );
   q_axis_angle( qrandom, (v3f){0.0f,1.0f,0.0f}, vg_randf()*VG_TAUf );
   q_mul( qsurface, qrandom, qsurface );
   q_m3x3( qsurface, transform );
   v3_copy( hit->pos, transform[3] );

   scene_vert verts[] = 
   {
      { .co = { -1.00f, 0.0f, 0.0f } },
      { .co = {  1.00f, 0.0f, 0.0f } },
      { .co = { -1.00f, 1.2f, 0.0f } },
      { .co = {  1.00f, 1.2f, 0.0f } },
      { .co = { -0.25f, 2.0f, 0.0f } },
      { .co = {  0.25f, 2.0f, 0.0f } }
   };

   const u32 indices[] = { 0,1,3, 0,3,2, 2,3,5, 2,5,4 };

   if( pscene->vertex_count + vg_list_size(verts) > pscene->max_vertices )
      vg_fatal_exit_loop( "Scene vertex buffer overflow" );

   if( pscene->indice_count + vg_list_size(indices) > pscene->max_indices )
      vg_fatal_exit_loop( "Scene index buffer overflow" );

   scene_vert *dst_verts = &pscene->arrvertices[ pscene->vertex_count ];
   u32 *dst_indices      = &pscene->arrindices [ pscene->indice_count ];

   scene_vert *ref       = &world->scene_geo->arrvertices[ hit->tri[0] ];

   for( u32 i=0; i<vg_list_size(verts); i++ )
   {
      scene_vert *pvert = &dst_verts[ i ],
                 *src   = &verts[ i ];

      m4x3_mulv( transform, src->co, pvert->co );
      scene_vert_pack_norm( pvert, transform[1] );

      v2_copy( ref->uv, pvert->uv );
   }

   for( u32 i=0; i<vg_list_size(indices); i++ )
      dst_indices[i] = indices[i] + pscene->vertex_count;

   pscene->vertex_count += vg_list_size(verts);
   pscene->indice_count += vg_list_size(indices);
}

/* Sprinkle foliage models over the map on terrain material */
VG_STATIC void world_apply_procedural_foliage( world_instance *world,
                                               struct world_surface *mat )
{
   if( vg.quality_profile == k_quality_profile_low )
      return;

   vg_info( "Applying foliage (%u)\n", mat->info.pstr_name );

   v3f volume;
   v3_sub( world->scene_geo->bbx[1], world->scene_geo->bbx[0], volume );
   volume[1] = 1.0f;

   int count = 0;

   float area = volume[0]*volume[2];
   u32 particles = 0.08f * area;

   vg_info( "Map area: %f. Max particles: %u\n", area, particles );

   for( u32 i=0; i<particles; i++ ){
      v3f pos;
      v3_mul( volume, (v3f){ vg_randf(), 1000.0f, vg_randf() }, pos );
      pos[1] = 1000.0f;
      v3_add( pos, world->scene_geo->bbx[0], pos );
      
      ray_hit hit;
      hit.dist = INFINITY;

      if( ray_world( world, pos, (v3f){0.0f,-1.0f,0.0f}, &hit )){
         struct world_surface *m1 = ray_hit_surface( world, &hit );
         if((hit.normal[1] > 0.8f) && (m1 == mat) && (hit.pos[1] > 0.0f+10.0f)){
            world_add_blob( world, world->scene_no_collide, &hit );
            count ++;
         }
      }
   }

   vg_info( "%d foliage models added\n", count );
}

#if 0
VG_STATIC void world_ents_allocate( world_instance *world )
{
   vg_info( "Allocating entities\n" );

   /* --count entites to allocate buffers for them.--
    * --maybe in the future we just store these numbers in the model file...--
    *
    *        ... 16.03.23: I HOPE YOUR FUCKING HAPPY
    *        ... 22.03.23: incomprehensible pain
    *        
    * -- use this in world_routes too  --
    *
    */

   struct countable
   {
      enum   classtype ct, ct1;
      void **to_allocate;
      u32    item_size;
      int    count;
   }
   entity_counts[] =
   {
      { 
         k_classtype_spawn, 
         k_classtype_none,
         (void*)&world->spawns,       
         sizeof(struct respawn_point) 
      },
      { 
         k_classtype_audio, 
         k_classtype_none,
         (void*)&world->audio_things, 
         sizeof(struct world_audio_thing) 
      },
      {
         k_classtype_world_light,
         k_classtype_none,
         (void*)&world->lights,
         sizeof(struct world_light)
      },
      {
         k_classtype_nonlocal_gate,
         k_classtype_none,
         (void*)&world->nonlocal_gates,
         sizeof(struct nonlocal_gate)
      },
   };

   for( int i=0; i<vg_list_size(entity_counts); i++ )
      entity_counts[i].count = 0;

   for( int i=0; i<world->meta->info.node_count; i++ )
   {
      mdl_node *pnode = mdl_node_from_id( world->meta, i );
      
      for( int j=0; j<vg_list_size(entity_counts); j ++ )
      {
         if( (pnode->classtype == entity_counts[j].ct) ||
             (pnode->classtype == entity_counts[j].ct1) )
         {
            pnode->sub_uid = entity_counts[j].count;
            entity_counts[j].count ++;
            break;
         }
      }
   }

   for( int i=0; i<vg_list_size(entity_counts); i++ )
   {
      struct countable *counter = &entity_counts[i];
      
      u32 bufsize = counter->item_size*counter->count;
      *counter->to_allocate = vg_linear_alloc( world_global.generic_heap, 
                                               bufsize );
      memset( *counter->to_allocate, 0, bufsize );
   }

   world->volume_bh = bh_create( world_global.generic_heap,
                                  &bh_system_volumes,
                                  world,
                                  world->volume_count,
                                  1 );
}
#endif

#if 0
VG_STATIC void world_pct_spawn( world_instance *world, mdl_node *pnode )
{
   struct respawn_point *rp = &world->spawns[ world->spawn_count ++ ];

   v3_copy( pnode->co, rp->co );
   v4_copy( pnode->q, rp->q );
   rp->name = mdl_pstr( world->meta, pnode->pstr_name );
}

VG_STATIC void world_pct_water( world_instance *world, mdl_node *pnode )
{
   if( world->water.enabled )
   {
      vg_warn( "Multiple water surfaces in level! ('%s')\n", 
               mdl_pstr( world->meta, pnode->pstr_name ));
      return;
   }

   world->water.enabled = 1;
   water_set_surface( world, pnode->co[1] );
}

VG_STATIC void world_pct_audio( world_instance *world, mdl_node *pnode )
{
   struct world_audio_thing *thing = &world->audio_things[
                                      world->audio_things_count ];

   memset( thing, 0, sizeof(struct world_audio_thing) );
   struct classtype_audio *aud = mdl_get_entdata( world->meta, pnode );

   v3_copy( pnode->co, thing->pos );
   
   thing->volume = aud->volume;
   thing->range = pnode->s[0];

   thing->flags = aud->flags;
   thing->temp_embedded_clip.path = mdl_pstr( world->meta, aud->pstr_file );
   thing->temp_embedded_clip.flags = aud->flags;

   audio_clip_load( &thing->temp_embedded_clip, world_global.generic_heap );

   pnode->sub_uid = world->audio_things_count;
   world->audio_things_count ++;
}

VG_STATIC void world_pct_world_light( world_instance *world, mdl_node *pnode )
{
   struct world_light *light = &world->lights[ world->light_count ++ ];
   light->node = pnode;
   light->inf  = mdl_get_entdata( world->meta, pnode );

   q_m3x3( pnode->q,   light->inverse_world );
   v3_copy( pnode->co, light->inverse_world[3] );
   m4x3_invert_affine( light->inverse_world, light->inverse_world );

   light->angle_sin_cos[0] = sinf( light->inf->angle * 0.5f );
   light->angle_sin_cos[1] = cosf( light->inf->angle * 0.5f );
}

VG_STATIC void world_pct_nonlocal_gate( world_instance *world, mdl_node *pnode )
{
   struct nonlocal_gate *gate = &world->nonlocal_gates[ 
                                       world->nonlocalgate_count ++ ];
   struct classtype_gate *inf = mdl_get_entdata( world->meta, pnode );

   gate->working = 0;
   gate->node = pnode;
   gate->target_map_index = 0;
   v2_copy( inf->dims, gate->gate.dims );
}

VG_STATIC void world_entities_process( world_instance *world )
{
   struct entity_instruction
   {
      enum classtype ct;
      void (*process)( world_instance *world, mdl_node *pnode );
   }
   entity_instructions[] = 
   {
      { k_classtype_spawn,    world_pct_spawn },
      { k_classtype_water,    world_pct_water },
      { k_classtype_audio,    world_pct_audio },
      { k_classtype_world_light, world_pct_world_light },
      { k_classtype_nonlocal_gate, world_pct_nonlocal_gate }
   };

   for( int i=0; i<world->meta->info.node_count; i++ )
   {
      mdl_node *pnode = mdl_node_from_id( world->meta, i );

      for( int j=0; j<vg_list_size(entity_instructions); j++ )
      {
         struct entity_instruction *instr = &entity_instructions[j];

         if( pnode->classtype == instr->ct )
         {
            instr->process( world, pnode );
            break;
         }
      }
   }
}
VG_STATIC void world_link_nonlocal_gates( int index_a, int index_b )
{
   vg_info( "Linking non-local gates\n" );
   world_instance *a = &world_global.worlds[ index_a ],
                  *b = &world_global.worlds[ index_b ];

   for( int i=0; i<a->nonlocalgate_count; i++ )
   {
      struct nonlocal_gate *ga = &a->nonlocal_gates[i];
      struct classtype_gate *ga_inf = mdl_get_entdata( a->meta, ga->node );
      const char *ga_name = mdl_pstr( a->meta, ga_inf->target );

      for( int j=0; j<b->nonlocalgate_count; j++ )
      {
         struct nonlocal_gate *gb = &b->nonlocal_gates[j];
         struct classtype_gate *gb_inf = mdl_get_entdata( b->meta, gb->node );
         const char *gb_name = mdl_pstr( b->meta, gb_inf->target );

         if( !strcmp( ga_name, gb_name ) )
         {
            vg_success( "Created longjump for ID '%s'\n", ga_name );

            v4f qYflip;
            q_axis_angle( qYflip, (v3f){0.0f,1.0f,0.0f}, VG_PIf );

            /* TODO: Gates are created very wonkily. refactor. */
            ga->target_map_index = index_b;
            gb->target_map_index = index_a;
            ga->working = 1;
            gb->working = 1;

            v4_copy( ga->node->q,  ga->gate.q[0] );
            v4_copy( gb->node->q,  ga->gate.q[1] );
            v3_copy( ga->node->co, ga->gate.co[0] );
            v3_copy( gb->node->co, ga->gate.co[1] );

            v4_copy( gb->node->q,  gb->gate.q[0] );
            v4_copy( ga->node->q,  gb->gate.q[1] );
            v3_copy( gb->node->co, gb->gate.co[0] );
            v3_copy( ga->node->co, gb->gate.co[1] );

            /* reverse B's direction */
            q_mul( gb->gate.q[0], qYflip, gb->gate.q[0] );
            q_mul( gb->gate.q[1], qYflip, gb->gate.q[1] );
            q_normalize( gb->gate.q[0] );
            q_normalize( gb->gate.q[1] );

            gate_transform_update( &ga->gate );
            gate_transform_update( &gb->gate );
         }
      }
   }
}
#endif

#if 0
VG_STATIC float colour_luminance( v3f v )
{
   return v3_dot( v, (v3f){0.2126f, 0.7152f, 0.0722f} );
}

VG_STATIC float calc_light_influence( world_instance *world, v3f position, 
                                      int light )
{
   struct world_light *world_light = &world->lights[ light ];
   struct classtype_world_light *inf = world_light->inf;

   v3f light_delta;
   v3_sub( world_light->node->co, position, light_delta );
   v3_muls( light_delta, 10.0f, light_delta );

   float quadratic = v3_dot( light_delta, light_delta ),
         attenuation = 1.0f/( 1.0f + quadratic );

   float quadratic_light = attenuation * colour_luminance( inf->colour );

   if( (inf->type == k_light_type_point) ||
       (inf->type == k_light_type_point_nighttime_only) )
   {
      return quadratic_light;
   }
   else if( (inf->type == k_light_type_spot) ||
            (inf->type == k_light_type_spot_nighttime_only) )
   {
      v3f dir;
      q_mulv( world_light->node->q, (v3f){0.0f,1.0f,0.0f}, dir );

      float spot_theta = vg_maxf( 0.0f, v3_dot( light_delta, dir ) ),
            falloff    = spot_theta >= 0.0f? 1.0f: 0.0f;

      return quadratic_light * falloff;
   }
   else
      return 0.0f;
}
#endif

VG_STATIC void world_generate( world_instance *world )
{
   /* 
    * Compile meshes into the world scenes
    */
   world->scene_geo = scene_init( world_global.generic_heap, 320000, 1200000 );

   m4x3f midentity;
   m4x3_identity( midentity );

   /*
    * Generate scene: collidable geometry
    * ----------------------------------------------------------------
    */

   vg_info( "Generating collidable geometry\n" );
   
   for( u32 i=0; i<world->surface_count; i++ ){
      struct world_surface *surf = &world->surfaces[ i ];

      if( surf->info.flags & k_material_flag_collision )
         world_add_all_if_material( midentity, world->scene_geo, 
                                    &world->meta, i );

      scene_copy_slice( world->scene_geo, &surf->sm_geo );
   }

   /* compress that bad boy */
   world->scene_geo = scene_fix( world_global.generic_heap, world->scene_geo );

   vg_acquire_thread_sync();
   {
      scene_upload( world->scene_geo, &world->mesh_geo );
   }
   vg_release_thread_sync();

   /* setup spacial mapping and rigidbody */
   world->geo_bh = scene_bh_create( world_global.generic_heap, 
                                    world->scene_geo );

   v3_zero( world->rb_geo.co );
   q_identity( world->rb_geo.q );

   world->rb_geo.type = k_rb_shape_scene;
   world->rb_geo.inf.scene.bh_scene = world->geo_bh;
   world->rb_geo.is_world = 1;
   rb_init( &world->rb_geo );

   /*
    * Generate scene: non-collidable geometry
    * ----------------------------------------------------------------
    */
   vg_info( "Generating non-collidable geometry\n" );

   world->scene_no_collide = scene_init( world_global.generic_heap, 
                                         200000, 500000 );

   for( u32 i=0; i<world->surface_count; i++ ){
      struct world_surface *mat = &world->surfaces[ i ];

      if( !(mat->info.flags & k_material_flag_collision) ){
         world_add_all_if_material( midentity, world->scene_no_collide, 
                                    &world->meta, i );
      }

      if( mat->info.flags & k_material_flag_grow_grass )
         world_apply_procedural_foliage( world, mat );

      scene_copy_slice( world->scene_no_collide, &mat->sm_no_collide );
   }

   /* upload and free that */
   vg_acquire_thread_sync();
   {
      scene_upload( world->scene_no_collide, &world->mesh_no_collide );
   }
   vg_release_thread_sync();

   vg_linear_del( world_global.generic_heap, world->scene_no_collide );
   world->scene_no_collide = NULL;
}

float fsd_cone_infinite( v3f p, v2f c )
{
   v2f q = { v2_length( (v2f){ p[0], p[2] } ), -p[1] };
   float s = vg_maxf( 0.0f, v2_dot( q, c ) );

   v2f v0;
   v2_muls( c, s, v0 );
   v2_sub( q, v0, v0 );

   float d = v2_length( v0 );
   return d * ((q[0]*c[1]-q[1]*c[0]<0.0f)?-1.0f:1.0f);
}

VG_STATIC void world_compute_light_indices( world_instance *world )
{
   /* light cubes */
   v3f cubes_min, cubes_max;
   v3_muls( world->scene_geo->bbx[0], 1.0f/k_light_cube_size, cubes_min );
   v3_muls( world->scene_geo->bbx[1], 1.0f/k_light_cube_size, cubes_max );

   v3_sub( cubes_min, (v3f){ 0.5f, 0.5f, 0.5f }, cubes_min );
   v3_add( cubes_max, (v3f){ 0.5f, 0.5f, 0.5f }, cubes_max );

   v3_floor( cubes_min, cubes_min );
   v3_floor( cubes_max, cubes_max );

   v3i icubes_min, icubes_max;

   for( int i=0; i<3; i++ ){
      icubes_min[i] = cubes_min[i];
      icubes_max[i] = cubes_max[i];
   }

   v3i icubes_count;
   v3i_sub( icubes_max, icubes_min, icubes_count );
   
   for( int i=0; i<3; i++ ){
      icubes_count[i] = VG_MIN( 128, icubes_count[i]+1 );
      cubes_max[i] = icubes_min[i] + icubes_count[i];
   }

   v3_muls( cubes_min, k_light_cube_size, cubes_min );
   v3_muls( cubes_max, k_light_cube_size, cubes_max );

   for( int i=0; i<3; i++ ){
      float range = cubes_max[i]-cubes_min[i];
      world->ub_lighting.g_cube_inv_range[i] = 1.0f / range;
      world->ub_lighting.g_cube_inv_range[i] *= (float)icubes_count[i];

      vg_info( "cubes[%d]: %d\n", i, icubes_count[i] );
   }

   int total_cubes = icubes_count[0]*icubes_count[1]*icubes_count[2];

   u32 *cubes_index = vg_linear_alloc( world_global.generic_heap, 
                                       total_cubes * sizeof(u32) * 2.0f );
                                       
   vg_info( "Computing light cubes (%d) [%f %f %f] -> [%f %f %f]\n", 
             total_cubes, cubes_min[0], -cubes_min[2], cubes_min[1],
                          cubes_max[0], -cubes_max[2], cubes_max[1] );

   v3_copy( cubes_min, world->ub_lighting.g_cube_min );

   v3f cube_size;
   v3_div( (v3f){1.0f,1.0f,1.0f}, world->ub_lighting.g_cube_inv_range, 
            cube_size );
   float bound_radius = v3_length( cube_size );

   for( int iz = 0; iz<icubes_count[2]; iz ++ ){
      for( int iy = 0; iy<icubes_count[1]; iy++ ){
         for( int ix = 0; ix<icubes_count[0]; ix++ ){
            boxf bbx;
            v3_div( (v3f){ ix, iy, iz }, world->ub_lighting.g_cube_inv_range, 
                  bbx[0] );
            v3_div( (v3f){ ix+1, iy+1, iz+1 }, 
                  world->ub_lighting.g_cube_inv_range, 
                  bbx[1] );

            v3_add( bbx[0], world->ub_lighting.g_cube_min, bbx[0] );
            v3_add( bbx[1], world->ub_lighting.g_cube_min, bbx[1] );

            v3f center;
            v3_add( bbx[0], bbx[1], center );
            v3_muls( center, 0.5f, center );
            
            u32 indices[6] = { 0, 0, 0, 0, 0, 0 };
            u32 count = 0;

            float influences[6] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
            const int N = vg_list_size( influences );

            for( u32 j=0; j<mdl_arrcount(&world->ent_light); j ++ ){
               ent_light *light = mdl_arritm( &world->ent_light, j );
               v3f closest;
               closest_point_aabb( light->transform.co, bbx, closest );

               float dist = v3_dist( closest, light->transform.co ),
                     influence = 1.0f/(dist+1.0f);

               if( dist > light->range )
                  continue;

               if( light->type == k_light_type_spot){
                  v3f local;
                  m4x3_mulv( light->inverse_world, center, local );

                  float r = fsd_cone_infinite( local, light->angle_sin_cos );

                  if( r > bound_radius )
                     continue;
               }

               int best_pos = N;
               for( int k=best_pos-1; k>=0; k -- )
                  if( influence > influences[k] )
                     best_pos = k;

               if( best_pos < N ){
                  for( int k=N-1; k>best_pos; k -- ){
                     influences[k] = influences[k-1];
                     indices[k] = indices[k-1];
                  }

                  influences[best_pos] = influence;
                  indices[best_pos] = j;
               }
            }

            for( int j=0; j<N; j++ )
               if( influences[j] > 0.0f )
                  count ++;

            int base_index = iz * (icubes_count[0]*icubes_count[1]) +
                             iy * (icubes_count[0]) +
                             ix;

            int lower_count = VG_MIN( 3, count );
            u32 packed_index_lower = lower_count;
            packed_index_lower |= indices[0]<<2;
            packed_index_lower |= indices[1]<<12;
            packed_index_lower |= indices[2]<<22;

            int upper_count = VG_MAX( 0, count - lower_count );
            u32 packed_index_upper = upper_count;
            packed_index_upper |= indices[3]<<2;
            packed_index_upper |= indices[4]<<12;
            packed_index_upper |= indices[5]<<22;

            cubes_index[ base_index*2 + 0 ] = packed_index_lower;
            cubes_index[ base_index*2 + 1 ] = packed_index_upper;
         }
      }
   }

   vg_acquire_thread_sync();

   glGenTextures( 1, &world->tex_light_cubes );
   glBindTexture( GL_TEXTURE_3D, world->tex_light_cubes );
   glTexImage3D( GL_TEXTURE_3D, 0, GL_RG32UI,
                 icubes_count[0], icubes_count[1], icubes_count[2],
                 0, GL_RG_INTEGER, GL_UNSIGNED_INT, cubes_index );
   glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
   glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );

   vg_linear_del( world_global.generic_heap, cubes_index );

   vg_release_thread_sync();
}

VG_STATIC int reset_player( int argc, char const *argv[] );
VG_STATIC void world_post_process( world_instance *world )
{
   /* initialize audio if need be */
#if 0
   audio_lock();
   for( int i=0; i<world->audio_things_count; i++ )
   {
      struct world_audio_thing *thingy = &world->audio_things[ i ];

      if( thingy->flags & AUDIO_FLAG_AUTO_START )
      {
         audio_channel *ch = 
            audio_request_channel( &thingy->temp_embedded_clip, thingy->flags );

         audio_channel_edit_volume( ch, thingy->volume, 1 );
         audio_channel_set_spacial( ch, thingy->pos, thingy->range );

         if( !(ch->flags & AUDIO_FLAG_LOOP) )
            ch = audio_relinquish_channel( ch );
      }
   }
   audio_unlock();
#endif

   world_compute_light_indices( world );

   vg_acquire_thread_sync();
   {
      /* create scene lighting buffer */

      u32 size = VG_MAX(mdl_arrcount(&world->ent_light),1) * sizeof(float)*12;
      vg_info( "Upload %ubytes (lighting)\n", size );

      glGenBuffers( 1, &world->tbo_light_entities );
      glBindBuffer( GL_TEXTURE_BUFFER, world->tbo_light_entities );
      glBufferData( GL_TEXTURE_BUFFER, size, NULL, GL_DYNAMIC_DRAW );
      
      /* buffer layout
       *  
       *  colour               position                direction (spots)
       * | .   .   .   .     | .   .   .   .         | .   .   .   .  |
       * | Re  Ge  Be  Night | Xco Yco Zco Range     | Dx  Dy  Dz  Da |
       *
       */

      v4f *light_dst = glMapBuffer( GL_TEXTURE_BUFFER, GL_WRITE_ONLY );
      for( u32 i=0; i<mdl_arrcount(&world->ent_light); i++ ){
         ent_light *light = mdl_arritm( &world->ent_light, i );

         /* colour  + night */
         v3_muls( light->colour, light->colour[3] * 2.0f, light_dst[i*3+0] );
         light_dst[i*3+0][3] = -1.0f;

         if( !light->daytime ){
            u32 hash = (i * 29986577) & 0xff;
            float switch_on = hash;
                  switch_on *= (1.0f/255.0f);

            light_dst[i*3+0][3] = 0.44f + switch_on * 0.015f;
         }
         
         /* position + 1/range^2 */
         v3_copy( light->transform.co, light_dst[i*3+1] );
         light_dst[i*3+1][3] = 1.0f/(light->range*light->range);

         /* direction + angle */
         q_mulv( light->transform.q, (v3f){0.0f,-1.0f,0.0f}, light_dst[i*3+2]);
         light_dst[i*3+2][3] = cosf( light->angle );
      }

      glUnmapBuffer( GL_TEXTURE_BUFFER );

      glGenTextures( 1, &world->tex_light_entities );
      glBindTexture( GL_TEXTURE_BUFFER, world->tex_light_entities );
      glTexBuffer( GL_TEXTURE_BUFFER, GL_RGBA32F, world->tbo_light_entities );

      /* Upload lighting uniform buffer */
      if( world->water.enabled )
         v4_copy( world->water.plane, world->ub_lighting.g_water_plane );

      v4f info_vec;
      v3f *bounds = world->scene_geo->bbx;

      info_vec[0] = bounds[0][0];
      info_vec[1] = bounds[0][2];
      info_vec[2] = 1.0f/ (bounds[1][0]-bounds[0][0]);
      info_vec[3] = 1.0f/ (bounds[1][2]-bounds[0][2]);
      v4_copy( info_vec, world->ub_lighting.g_depth_bounds );

      /* 
       * Rendering the depth map
       */
      camera ortho;

      v3f extent;
      v3_sub( world->scene_geo->bbx[1], world->scene_geo->bbx[0], extent );

      float fl = world->scene_geo->bbx[0][0],
            fr = world->scene_geo->bbx[1][0],
            fb = world->scene_geo->bbx[0][2],
            ft = world->scene_geo->bbx[1][2],
            rl = 1.0f / (fr-fl),
            tb = 1.0f / (ft-fb);

      m4x4_zero( ortho.mtx.p );
      ortho.mtx.p[0][0] = 2.0f * rl;
      ortho.mtx.p[2][1] = 2.0f * tb;
      ortho.mtx.p[3][0] = (fr + fl) * -rl;
      ortho.mtx.p[3][1] = (ft + fb) * -tb;
      ortho.mtx.p[3][3] = 1.0f;
      m4x3_identity( ortho.transform );
      camera_update_view( &ortho );
      camera_finalize( &ortho );

      glDisable(GL_DEPTH_TEST);
      glDisable(GL_BLEND);
      glDisable(GL_CULL_FACE);
      render_fb_bind( &world->heightmap );
      shader_blitcolour_use();
      shader_blitcolour_uColour( (v4f){-9999.0f,-9999.0f,-9999.0f,-9999.0f} );
      render_fsquad();

      glEnable(GL_BLEND);
      glBlendFunc(GL_ONE, GL_ONE);
      glBlendEquation(GL_MAX);

      render_world_position( world, &ortho );
      glDisable(GL_BLEND);
      glEnable(GL_DEPTH_TEST);
      glBindFramebuffer( GL_FRAMEBUFFER, 0 );

      /* upload full buffer */
      glBindBuffer( GL_UNIFORM_BUFFER, world->ubo_lighting );
      glBufferSubData( GL_UNIFORM_BUFFER, 0, 
                       sizeof(struct ub_world_lighting), &world->ub_lighting );
   }

   vg_release_thread_sync();

#if 0
   /*
    * Setup scene collider 
    */
   reset_player( 1, (const char *[]){"start"} );
#endif
}

VG_STATIC void world_process_resources( world_instance *world )
{
   vg_info( "Loading textures\n" );

   world->texture_count = 0;

   world->texture_count = world->meta.textures.count+1;
   world->textures = vg_linear_alloc( world_global.generic_heap,
                                      sizeof(GLuint)*world->texture_count );

   vg_acquire_thread_sync();
   {
      /* error texture */
      world->textures[0] = vg_tex2d_new();
      vg_tex2d_set_error();
      vg_tex2d_nearest();
      vg_tex2d_repeat();

      for( u32 i=0; i<mdl_arrcount(&world->meta.textures); i++ ){
         mdl_texture *tex = mdl_arritm( &world->meta.textures, i );

         if( !tex->file.pack_size ){
            vg_release_thread_sync();
            vg_fatal_exit_loop( "World models must have packed textures!" );
         }

         vg_linear_clear( vg_mem.scratch );
         world->textures[i+1] = vg_tex2d_new();
         vg_tex2d_set_error();
         vg_tex2d_qoi( mdl_arritm( &world->meta.pack, tex->file.pack_offset ),
                       tex->file.pack_size,
                       mdl_pstr( &world->meta, tex->file.pstr_path ));
         vg_tex2d_nearest();
         vg_tex2d_repeat();
      }
   }
   vg_release_thread_sync();

   vg_info( "Loading materials\n" );

   world->surface_count = world->meta.materials.count+1;
   world->surfaces = vg_linear_alloc( world_global.generic_heap,
                           sizeof(struct world_surface)*world->surface_count );

   /* error material */
   struct world_surface *errmat = &world->surfaces[0];
   memset( errmat, 0, sizeof(struct world_surface) );
                       
   for( u32 i=0; i<mdl_arrcount(&world->meta.materials); i++ ){
      world->surfaces[i+1].info = 
         *(mdl_material *)mdl_arritm( &world->meta.materials, i );
   }
}

VG_STATIC void world_unload( world_instance *world )
{
   vg_acquire_thread_sync();

   /* free meshes */
   mesh_free( &world->mesh_route_lines );
   mesh_free( &world->mesh_geo );
   mesh_free( &world->mesh_no_collide );

   glDeleteBuffers( 1, &world->tbo_light_entities );
   glDeleteTextures( 1, &world->tex_light_entities );
   glDeleteTextures( 1, &world->tex_light_cubes );

   /* FIXME: CANT DO THIS HERE */
   world_global.time = 0.0;
   world_global.rewind_from = 0.0;
   world_global.rewind_to = 0.0;
   world_global.last_use = 0.0;
   world_global.active_route_board = 0;

   /* delete textures and meshes */
   glDeleteTextures( world->texture_count, world->textures );

   /* delete the entire block of memory */
   /* FIXME: WE CANT DO THIS SHIT ANYMORE, NEED TO DEALLOC FROM ABOVE */
#if 0
   vg_linear_clear( world->dynamic_vgl );
   vg_linear_clear( world->audio_vgl );
#endif


   vg_release_thread_sync();
}

VG_STATIC void world_clean( world_instance *world )
{
   memset( &world->meta, 0, sizeof(mdl_context) );

   /*
    * TODO: Theres probably a better way to do this? 
    */

   world->textures = NULL;
   world->texture_count = 0;
   world->surfaces = NULL;
   world->surface_count = 0;
   
   world->scene_geo = NULL;
   world->scene_no_collide = NULL;
   world->scene_lines = NULL;

   world->geo_bh = NULL;
   world->volume_bh = NULL;
   world->audio_bh = NULL;

   world->water.enabled = 0;

   /* default lighting conditions 
    * -------------------------------------------------------------*/
   struct ub_world_lighting *state = &world->ub_lighting;

   state->g_light_preview = 0;
   state->g_shadow_samples = 8;
   state->g_water_fog = 0.04f;

   v4_zero( state->g_water_plane );
   v4_zero( state->g_depth_bounds );

   state->g_shadow_length = 9.50f;
   state->g_shadow_spread = 0.65f;

   v3_copy( (v3f){0.37f, 0.54f, 0.97f}, state->g_daysky_colour );
   v3_copy( (v3f){0.03f, 0.05f, 0.20f}, state->g_nightsky_colour );
   v3_copy( (v3f){1.00f, 0.32f, 0.01f}, state->g_sunset_colour );
   v3_copy( (v3f){0.13f, 0.17f, 0.35f}, state->g_ambient_colour );
   v3_copy( (v3f){0.25f, 0.17f, 0.51f}, state->g_sunset_ambient );
   v3_copy( (v3f){1.10f, 0.89f, 0.35f}, state->g_sun_colour );
}

VG_STATIC void world_entities_init( world_instance *world )
{
   /* lights */
   for( u32 j=0; j<mdl_arrcount(&world->ent_light); j ++ ){
      ent_light *light = mdl_arritm( &world->ent_light, j );

      m4x3f to_world;
      q_m3x3( light->transform.q, to_world );
      v3_copy( light->transform.co, to_world[3] );
      m4x3_invert_affine( to_world, light->inverse_world );

      light->angle_sin_cos[0] = sinf( light->angle * 0.5f );
      light->angle_sin_cos[1] = cosf( light->angle * 0.5f );
   }

   /* gates */
   for( u32 j=0; j<mdl_arrcount(&world->ent_gate); j ++ ){
      ent_gate *gate = mdl_arritm( &world->ent_gate, j );
      gate_transform_update( gate );
   }
}

VG_STATIC void world_load( world_instance *world, const char *path )
{
   world_unload( world );
   world_clean( world );

   vg_info( "Loading world: %s\n", path );

   mdl_open( &world->meta, path, world_global.generic_heap );
   mdl_load_metadata_block( &world->meta, world_global.generic_heap );
   mdl_load_animation_block( &world->meta, world_global.generic_heap );
   mdl_load_mesh_block( &world->meta, world_global.generic_heap );
   mdl_load_pack_block( &world->meta, world_global.generic_heap );

   mdl_load_array( &world->meta, &world->ent_gate, 
                   "ent_gate", world_global.generic_heap );
   mdl_load_array( &world->meta, &world->ent_spawn,
                   "ent_spawn", world_global.generic_heap );
   mdl_load_array( &world->meta, &world->ent_light,
                   "ent_light", world_global.generic_heap );

   mdl_load_array( &world->meta, &world->ent_route_node,
                   "ent_route_node", world_global.generic_heap );
   mdl_load_array( &world->meta, &world->ent_path_index,
                   "ent_path_index", world_global.generic_heap );
   mdl_load_array( &world->meta, &world->ent_checkpoint,
                   "ent_checkpoint", world_global.generic_heap );
   mdl_load_array( &world->meta, &world->ent_route,
                   "ent_route", world_global.generic_heap );

   mdl_close( &world->meta );

   /* process resources from pack */
   world_process_resources( world );

#if 0
   /* dynamic allocations */
   world_ents_allocate( world );
   world_routes_allocate( world );

   /* meta processing */
#endif
   world_routes_ent_init( world );
   world_entities_init( world );
   
   /* main bulk */
   world_generate( world );
   world_routes_generate( world );
   world_post_process( world );
}

#endif /* WORLD_GEN_H */