bricks

[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( int i=0; i<mdl->info.node_count; i++ )
   {
      mdl_node *pnode = mdl_node_from_id( mdl, i );

      for( int j=0; j<pnode->submesh_count; j++ )
      {
         mdl_submesh *sm = mdl_node_submesh( mdl, pnode, j );
         if( sm->material_id == id )
         {
            m4x3f transform2;
            mdl_node_transform( pnode, 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_material *mat )
{
   if( vg.quality_profile == k_quality_profile_low )
      return;

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

   vg_linear_clear( vg_mem.scratch );

   mdl_context *mfoliage = 
      mdl_load_full( vg_mem.scratch, "models/rs_foliage.mdl");

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

   mdl_node *mblob = mdl_node_from_name( mfoliage, "blob" );
   mdl_submesh *sm_blob = mdl_node_submesh( mfoliage, mblob, 0 );

   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( int 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_material *m1 = ray_hit_material( 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 );
}

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...
    *
    * TODO: 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_trigger,
         k_classtype_particle_box,
         (void*)&world->triggers,
         sizeof(struct trigger_zone)
      },

#if 0
      {
         k_classtype_logic_relay,
         (void*)&world->logic_relays,
         sizeof(struct logic_relay)
      },
#endif

      {
         k_classtype_logic_achievement,
         k_classtype_none,
         (void*)&world->logic_achievements,
         sizeof(struct logic_achievement)
      },
      {
         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)
      },
      {
         k_classtype_soundscape,
         k_classtype_none,
         (void*)&world->soundscapes,
         sizeof(struct soundscape)
      }
   };

   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 );
   }

   logic_bricks_world_gen_allocate( world );

   world->trigger_bh = bh_create( world_global.generic_heap,
                                  &bh_system_triggers,
                                  world,
                                  world->trigger_count,
                                  1 );
}

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 ++;
}

#if 0
VG_STATIC void world_pct_relay( world_instance *world, mdl_node *pnode )
{
   struct logic_relay *relay = &world->logic_relays[ world->relay_count ];
   struct classtype_logic_relay *inf = mdl_get_entdata( world->meta, pnode );

   relay->target_count = 0;

   for( int i=0; i<vg_list_size(relay->targets); i++ )
   {
      if( inf->targets[i] )
      {
         struct relay_target *target = &relay->targets[relay->target_count ++];
         mdl_node *other = mdl_node_from_id( world->meta, inf->targets[i] );
         
         target->classtype = other->classtype;
         target->sub_id = other->sub_uid;
      }
   }

   v3_copy( pnode->co, relay->pos );
   world->relay_count ++;
}
#endif


VG_STATIC void world_pct_achievement( world_instance *world, mdl_node *pnode )
{
   struct logic_achievement *ach = 
      &world->logic_achievements[ world->achievement_count ];
   struct classtype_logic_achievement *inf = 
      mdl_get_entdata( world->meta, pnode );

   v3_copy( pnode->co, ach->pos );
   ach->achievement_id = mdl_pstr( world->meta, inf->pstr_name );
   ach->achieved = 0;

   world->achievement_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 },
#if 0
      { k_classtype_logic_relay, world_pct_relay },
#endif
      { k_classtype_logic_achievement, world_pct_achievement },
      { 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 );
         }
      }
   }
}

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;
}

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( int i=0; i<world->material_count; i++ )
   {
      struct world_material *mat = &world->materials[ i ];

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

      scene_copy_slice( world->scene_geo, &mat->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( int i=0; i<world->material_count; i++ )
   {
      struct world_material *mat = &world->materials[ 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( int j=0; j<world->light_count; j ++ )
            {
               struct world_light *light = &world->lights[j];
               v3f closest;
               closest_point_aabb( light->node->co, bbx, closest );

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

               if( dist > light->inf->range )
                  continue;

               if( (light->inf->type == k_light_type_spot) ||
                   (light->inf->type == k_light_type_spot_nighttime_only) )
               {
                  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 */
   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();

   world_compute_light_indices( world );

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

      u32 size = VG_MAX(world->light_count,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( int i=0; i<world->light_count; i++ )
      {
         struct world_light *light = &world->lights[i];
         struct classtype_world_light *inf = light->inf;

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

         if( (inf->type == k_light_type_spot_nighttime_only) ||
             (inf->type == k_light_type_point_nighttime_only ) )
         {
            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->node->co, light_dst[i*3+1] );
         light_dst[i*3+1][3] = 1.0f/(inf->range*inf->range);

         /* direction + angle */
         q_mulv( light->node->q, (v3f){0.0f,-1.0f,0.0f}, light_dst[i*3+2]);
         light_dst[i*3+2][3] = cosf( inf->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 = world->meta->info.texture_count;
   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( int i=1; i<world->texture_count; i++ )
      {
         mdl_texture *tex = &world->meta->texture_buffer[i];

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

         vg_linear_clear( vg_mem.scratch );
         world->textures[i] = vg_tex2d_new();
         vg_tex2d_set_error();
         vg_tex2d_qoi( world->meta->pack + tex->pack_offset, tex->pack_length,
                       mdl_pstr( world->meta, tex->pstr_name ));
         vg_tex2d_nearest();
         vg_tex2d_repeat();
      }
   }
   vg_release_thread_sync();

   vg_info( "Loading materials\n" );

   u32 size = sizeof(struct world_material) * world->meta->info.material_count;
   world->materials = vg_linear_alloc( world_global.generic_heap, size );
                       
   world->material_count = world->meta->info.material_count;
   memset( world->materials, 0, size );

   for( int i=1; i<world->material_count; i++ )
      world->materials[i].info = world->meta->material_buffer[i];

   /* error material */
   struct world_material *errmat = &world->materials[0];
   v4_copy( (v4f){ 1.0f,0.0f,0.0f,1.0f }, errmat->info.colour );
   v4_copy( (v4f){ 1.0f,0.0f,0.0f,1.0f }, errmat->info.colour1 );
   errmat->info.flags = 0x00;
   errmat->info.pstr_name = 0; /* useless? */
   errmat->info.shader = -1;
   errmat->info.tex_decal = 0;
   errmat->info.tex_diffuse = 0;
   errmat->info.tex_normal = 0;
}

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_gate = 0;
   world_global.current_run_version = 2;
   world_global.active_route_board = 0;

   for( int i=0; i<vg_list_size(world_global.ui_bars); i++ )
   {
      struct route_ui_bar *uib = &world_global.ui_bars[i];
      uib->segment_start = 0;
      uib->segment_count = 0;
      uib->fade_start = 0;
      uib->fade_count = 0;
      uib->fade_timer_start = 0.0;
      uib->xpos = 0.0f;
   }

   /* 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 )
{
   /* clean dangling pointers */
   world->meta = NULL;

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

   world->textures = NULL;
   world->texture_count = 0;
   world->materials = NULL;
   world->material_count = 0;
   
   world->scene_geo = NULL;
   world->scene_no_collide = NULL;
   world->scene_lines = NULL;

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

   world->spawns = NULL;
   world->spawn_count = 0;

   world->audio_things = NULL;
   world->audio_things_count = 0;

   world->triggers = NULL;
   world->trigger_count = 0;

   world->lights = NULL;
   world->light_count = 0;

#if 0
   world->logic_relays = NULL;
   world->relay_count = 0;
#endif

   world->logic_achievements = NULL;
   world->achievement_count = 0;

   world->nodes = NULL;
   world->node_count = 0;

   world->routes = NULL;
   world->route_count = 0;

   world->gates = NULL;
   world->gate_count = 0;

   world->collectors = NULL;
   world->collector_count = 0;

   world->soundscapes = NULL;
   world->soundscape_count = 0;

   world->logic_bricks = NULL;
   world->logic_brick_count = 0;

   world->nonlocal_gates = NULL;
   world->nonlocalgate_count = 0;

   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_load( world_instance *world, const char *path )
{
   world_unload( world );
   world_clean( world );

   world->meta = mdl_load_full( world_global.generic_heap, path );
   vg_info( "Loading world: %s\n", path );

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

   /* dynamic allocations */
   world_ents_allocate( world );
   world_routes_allocate( world );

   /* meta processing */
   world_routes_process( world );
   world_entities_process( world );
   
   /* main bulk */
   world_generate( world );
   world_routes_generate( world );
   world_post_process( world );
}

#endif /* WORLD_GEN_H */