X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=world.h;h=acfd462d4d2cb1e8746ee081d8ae1bec64fedf81;hb=2e4531dfd7bd0d9a0776fda1a62653806d85eb3b;hp=16b0e98986260a6d1bda96c0e62c4d5b7af5af87;hpb=192990d6d24e53749ca046fef808a63cf162ab8a;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/world.h b/world.h
index 16b0e98..acfd462 100644
--- a/world.h
+++ b/world.h
@@ -24,6 +24,7 @@ typedef struct world_instance world_instance;
 #include "shaders/scene_vertex_blend.h"
 #include "shaders/scene_terrain.h"
 #include "shaders/scene_depth.h"
+#include "shaders/scene_position.h"
 
 #include "shaders/model_sky.h"
 
@@ -52,6 +53,8 @@ enum geo_type
    k_geo_type_water = 2
 };
 
+static const float k_light_cube_size = 8.0f;
+
 struct world_instance 
 {
    /* This is a small flag we use to changelevel.
@@ -78,26 +81,45 @@ struct world_instance
    /* STD140 */
    struct ub_world_lighting
    {
-      /* v3f (padded) */
-      v4f g_light_colours[3],
-          g_light_directions[3],
-          g_ambient_colour;
+      v4f g_cube_min,
+          g_cube_inv_range;
 
       v4f g_water_plane,
           g_depth_bounds;
 
+      v4f g_daysky_colour;
+      v4f g_nightsky_colour;
+      v4f g_sunset_colour;
+      v4f g_ambient_colour;
+      v4f g_sunset_ambient;
+      v4f g_sun_colour;
+      v4f g_sun_dir;
+
       float g_water_fog;
-      int g_light_count;
+      float g_time;
+      float g_shadow_length;
+      float g_shadow_spread;
+
+      float g_time_of_day;
+      float g_day_phase;
+      float g_sunset_phase;
+
       int g_light_preview;
       int g_shadow_samples;
 
-      v4f g_point_light_positions[32];
-      v4f g_point_light_colours[32];
+      int g_debug_indices;
+      int g_debug_complexity;
    }
    ub_lighting;
    GLuint ubo_lighting;
    int    ubo_bind_point;
 
+   GLuint tbo_light_entities,
+          tex_light_entities,
+          tex_light_cubes;
+
+   v3i light_cubes;
+
    struct framebuffer heightmap;
 
    /*
@@ -148,64 +170,53 @@ struct world_instance
    struct world_audio_thing
    {
       v3f pos;
-      float volume;
+      float volume, range;
       u32 flags;
-
-      audio_player player;
       audio_clip temp_embedded_clip;
    }
    * audio_things;
    u32 audio_things_count;
 
-   /*
-    * Relays
-    */
-   struct logic_relay
+   struct soundscape
    {
-      v3f pos;
-
-      struct relay_target
-      {
-         u32 sub_id;
-         enum classtype classtype;
-      }
-      targets[4];
-      u32 target_count;
+      /* locking */
+      audio_channel *channels[4];
+      
+      /* accessable without locking */
+      v3f spawn_position;
+
+      u32 usage_count;
+      u32 max_instances;
+      u32 allow_transitions;
+      float transition_duration;
+      const char *label;
    }
-   * logic_relays;
-   u32 relay_count;
+   * soundscapes;
+   u32 soundscape_count;
 
    /*
-    * Box trigger entities
+    * Box volume entities
     */
-   struct trigger_zone
+   struct world_volume
    {
       m4x3f transform, inv_transform;
-
-      struct relay_target target;
-   }
-   * triggers;
-   u32 trigger_count;
-
-   /*
-    * Achievements
-    */
-   struct logic_achievement
-   {
-      v3f pos;
-      const char *achievement_id;
-      u32 achieved;
+      mdl_node *node;
    }
-   * logic_achievements;
-   u32 achievement_count;
+   * volumes;
+   u32 volume_count;
 
    /* 
     * Lights
     */
    struct world_light
    {
-      v3f co;
-      v4f colour;
+      mdl_node *node;
+      struct classtype_world_light *inf;
+      m4x3f inverse_world;
+      v2f angle_sin_cos;
+
+      /* enabled.. etc? 
+       * TODO: we should order entities in the binary by their type */
    }
    * lights;
    u32 light_count;
@@ -296,7 +307,7 @@ struct world_instance
 
    /* spacial mappings */
    bh_tree *audio_bh,
-           *trigger_bh,
+           *volume_bh,
            *geo_bh;
 
    /* graphics */
@@ -314,8 +325,7 @@ VG_STATIC struct world_global
     * Allocated as system memory
     * --------------------------------------------------------------------------
     */
-   void *generic_heap,
-        *audio_heap;  /* sub buffer of the audio buffer */
+   void *generic_heap;
 
    /* rendering */
    glmesh skydome;
@@ -372,7 +382,7 @@ VG_STATIC struct world_global
 
    v3f render_gate_pos;
    int active_route_board;
-   int in_trigger;
+   int in_volume;
 
    int switching_to_new_world;
 
@@ -411,6 +421,7 @@ int ray_world( world_instance *world, v3f pos, v3f dir, ray_hit *hit );
 #include "world_sfd.h"
 #include "world_render.h"
 #include "world_water.h"
+#include "world_volumes.h"
 #include "world_gen.h"
 #include "world_gate.h"
 
@@ -423,74 +434,11 @@ int ray_world( world_instance *world, v3f pos, v3f dir, ray_hit *hit );
 VG_STATIC int world_stop_sound( int argc, const char *argv[] )
 {
    world_instance *world = get_active_world();
-
-   /* 
-    * None of our world audio runs as one shots, they always have a player.
-    * Therefore it is safe to delete clip data after the players are
-    * disconnected
-    */
-   audio_lock();
-   for( int i=0; i<world->audio_things_count; i++ )
-   {
-      struct world_audio_thing *at = &world->audio_things[i];
-
-      if( audio_player_is_playing( &at->player ) )
-      {
-         u32 cflags = audio_player_get_flags( &at->player );
-         audio_player_set_flags( &at->player, cflags | AUDIO_FLAG_KILL );
-      }
-   }
-   audio_unlock();
-
-   return 0;
-}
-
-VG_STATIC int world_change_world( int argc, const char *argv[] )
-{
-#if 0
-   world_instance *world = get_active_world();
-
-   if( argc == 0 )
-   {
-      vg_info( "%s\n", world.world_name );
-      return 0;
-   }
-   else
-   {
-      vg_info( "Switching world...\n" );
-      strcpy( world.world_name, argv[0] );
-      world.switching_to_new_world = 1;
-      world_stop_sound( 0, NULL );
-   }
-#endif
-
    return 0;
 }
 
 VG_STATIC void world_init(void)
 {
-#if 0
-   vg_var_push( (struct vg_var){
-      .name = "water_enable",
-      .data = &world.water.enabled,
-      .data_type = k_var_dtype_i32,
-      .opt_i32 = { .min=0, .max=1, .clamp=1 },
-      .persistent = 0
-   });
-#endif
-
-	vg_function_push( (struct vg_cmd)
-   {
-		.name = "world_stop_sound",
-		.function = world_stop_sound
-	});
-
-	vg_function_push( (struct vg_cmd)
-   {
-		.name = "world",
-		.function = world_change_world
-	});
-
    world_global.sky_rate = 1.0;
    world_global.sky_target_rate = 1.0;
 
@@ -499,6 +447,7 @@ VG_STATIC void world_init(void)
    shader_scene_vertex_blend_register();
    shader_scene_terrain_register();
    shader_scene_depth_register();
+   shader_scene_position_register();
 
    shader_model_sky_register();
 
@@ -532,114 +481,44 @@ VG_STATIC void world_init(void)
                                                            VG_MEMORY_SYSTEM );
 }
 
-VG_STATIC void world_audio_init(void)
-{
-   u32 size = vg_linear_remaining( vg_audio.audio_pool ) 
-               - sizeof(vg_linear_allocator);
-
-   world_global.audio_heap = vg_create_linear_allocator( vg_audio.audio_pool, 
-                                                         size, 
-                                                         VG_MEMORY_SYSTEM );
-}
-
-VG_STATIC void world_trigger_achievement( world_instance *world, u32 uid )
-{
-   struct logic_achievement *ach = &world->logic_achievements[ uid ];
-
-   if( ach->achieved )
-      return;
-
-   steam_set_achievement( ach->achievement_id );
-   steam_store_achievements();
-
-   ach->achieved = 1;
-}
-
-VG_STATIC void world_run_relay( world_instance *world, 
-                                struct relay_target *rt );
-
-VG_STATIC void world_trigger_relay( world_instance *world, u32 uid )
-{
-   struct logic_relay *relay = &world->logic_relays[ uid ];
-
-   for( int i=0; i<relay->target_count; i++ )
-   {
-      world_run_relay( world, &relay->targets[i] );
-   }
-}
-
-VG_STATIC void world_trigger_audio( world_instance *world, u32 uid )
+VG_STATIC void world_update( world_instance *world, v3f pos )
 {
-   struct world_audio_thing *wat = &world->audio_things[ uid ];
+   /* TEMP!!!!!! */
+   static double g_time = 0.0;
+   g_time += vg.time_delta * (1.0/(k_day_length*60.0));
 
-   audio_lock();
-   audio_player_playclip( &wat->player, 
-                          &wat->temp_embedded_clip );
-   audio_unlock();
-}
 
-VG_STATIC void world_run_relay( world_instance *world,
-                                struct relay_target *rt )
-{
-   struct entity_instruction
-   {
-      enum classtype classtype;
-      void (*p_trigger)( world_instance *world, u32 uid );
-   }
-   entity_instructions[] =
-   {
-      { k_classtype_logic_achievement, world_trigger_achievement },
-      { k_classtype_logic_relay, world_trigger_relay },
-      { k_classtype_audio, world_trigger_audio }
-   };
+   struct ub_world_lighting *state = &world->ub_lighting;
 
-   for( int i=0; i<vg_list_size(entity_instructions); i++ )
-   {
-      struct entity_instruction *instr = &entity_instructions[i];
+   state->g_time = g_time;
+   state->g_debug_indices = k_debug_light_indices;
+   state->g_light_preview = k_light_preview;
+   state->g_debug_complexity = k_debug_light_complexity;
 
-      if( instr->classtype == rt->classtype )
-      {
-         instr->p_trigger( world, rt->sub_id );
-         return;
-      }
-   }
+   state->g_time_of_day = vg_fractf( g_time );
+   state->g_day_phase   = cosf( state->g_time_of_day * VG_PIf * 2.0f );
+   state->g_sunset_phase= cosf( state->g_time_of_day * VG_PIf * 4.0f + VG_PIf );
 
-   vg_error( "Don't know how to trigger classtype %d\n", rt->classtype );
-}
+   state->g_day_phase    =       state->g_day_phase    * 0.5f + 0.5f;
+   state->g_sunset_phase = powf( state->g_sunset_phase * 0.5f + 0.5f, 6.0f );
 
-VG_STATIC void world_update( world_instance *world, v3f pos )
-{
-#if 0
-   if( world.switching_to_new_world )
-   {
-      int all_stopped = 1;
+   float a = state->g_time_of_day * VG_PIf * 2.0f;
+   state->g_sun_dir[0] = sinf( a );
+   state->g_sun_dir[1] = cosf( a );
+   state->g_sun_dir[2] = 0.2f;
+   v3_normalize( state->g_sun_dir );
 
-      audio_lock();
-      for( int i=0; i<world.audio_things_count; i++ )
-      {
-         struct world_audio_thing *at = &world.audio_things[i];
 
-         if( audio_player_is_playing( &at->player ) )
-         {
-            all_stopped = 0;
-            break;
-         }
-      }
-      audio_unlock();
 
-      if( all_stopped )
-      {
-         world.switching_to_new_world = 0;
-         world_unload();
-         vg_loader_start( world_load );
-         return;
-      }
-   }
+   glBindBuffer( GL_UNIFORM_BUFFER, world->ubo_lighting );
+   glBufferSubData( GL_UNIFORM_BUFFER, 0, 
+                    sizeof(struct ub_world_lighting), &world->ub_lighting );
+   /* TEMP!!!!!! */
 
-   world.sky_time += world.sky_rate * vg.time_delta;
-   world.sky_rate = vg_lerp( world.sky_rate, world.sky_target_rate, 
-                                 vg.time_delta * 5.0 );
-#endif
+   world_global.sky_time += world_global.sky_rate * vg.time_delta;
+   world_global.sky_rate = vg_lerp( world_global.sky_rate, 
+                                    world_global.sky_target_rate, 
+                                    vg.time_delta * 5.0 );
 
    world_routes_update( world );
 #if 0
@@ -684,11 +563,58 @@ VG_STATIC void world_update( world_instance *world, v3f pos )
          }
       }
    }
+   
+   /* TODO: Bvh */
+
+   static float random_accum = 0.0f;
+   random_accum += vg.time_delta;
+
+   u32 random_ticks = 0;
+
+   while( random_accum > 0.1f )
+   {
+      random_accum -= 0.1f;
+      random_ticks ++;
+   }
 
-   int in_trigger = 0;
-   for( int i=0; i<world->trigger_count; i++ )
+   float radius = 25.0f;
+   boxf volume_proximity;
+   v3_add( pos, (v3f){ radius, radius, radius }, volume_proximity[1] );
+   v3_sub( pos, (v3f){ radius, radius, radius }, volume_proximity[0] );
+
+   bh_iter it;
+   bh_iter_init( 0, &it );
+   int idx;
+
+   int in_volume = 0;
+
+   while( bh_next( world->volume_bh, &it, volume_proximity, &idx ) )
    {
-      struct trigger_zone *zone = &world->triggers[i];
+      struct world_volume *zone = &world->volumes[idx];
+
+      if( zone->node->classtype == k_classtype_volume_audio )
+      {
+         vg_line_boxf_transformed( zone->transform, (boxf){{-1.0f,-1.0f,-1.0f},
+                                                           { 1.0f, 1.0f, 1.0f}}, 
+                                                           0xff00c0ff );
+#if 0
+         for( int j=0; j<random_ticks; j++ )
+         {
+            logic_packet packet;
+            packet.location = zone->target_logic_brick;
+            packet.function = 0;
+
+            packet.type = k_mdl_128bit_datatype_vec3;
+            packet.data._v4f[0] = vg_randf()*2.0f-1.0f;
+            packet.data._v4f[1] = vg_randf()*2.0f-1.0f;
+            packet.data._v4f[2] = vg_randf()*2.0f-1.0f;
+            m4x3_mulv( zone->transform, packet.data._v4f, packet.data._v4f );
+
+            logic_bricks_send_packet( world, &packet );
+         }
+#endif
+         continue;
+      }
 
       v3f local;
       m4x3_mulv( zone->inv_transform, pos, local );
@@ -697,37 +623,76 @@ VG_STATIC void world_update( world_instance *world, v3f pos )
           (fabsf(local[1]) <= 1.0f) &&
           (fabsf(local[2]) <= 1.0f) )
       {
-         in_trigger = 1;
+         in_volume = 1;
 
-         if( !world_global.in_trigger )
+         if( !world_global.in_volume )
          {
-            world_run_relay( world, &zone->target );
+#if 0
+            logic_packet packet;
+            packet.location = zone->target_logic_brick;
+            packet.function = 0;
+
+            packet.type = k_mdl_128bit_datatype_vec3;
+            v3_copy( pos, packet.data._v4f );
+
+            logic_bricks_send_packet( world, &packet );
+#endif
          }
+         
+         vg_line_boxf_transformed( zone->transform, (boxf){{-1.0f,-1.0f,-1.0f},
+                                                           { 1.0f, 1.0f, 1.0f}}, 
+                                                           0xff00ff00 );
+      }
+      else
+      {
+         vg_line_boxf_transformed( zone->transform, (boxf){{-1.0f,-1.0f,-1.0f},
+                                                           { 1.0f, 1.0f, 1.0f}}, 
+                                                           0xff0000ff );
       }
-
-      vg_line_boxf_transformed( zone->transform, (boxf){{-1.0f,-1.0f,-1.0f},
-                                                        { 1.0f, 1.0f, 1.0f}}, 
-                                                        0xff00ff00 );
    }
 
-   for( int i=0; i<world->light_count; i++ )
+   if( k_debug_light_indices )
    {
-      struct world_light *light = &world->lights[i];
+      for( int i=0; i<world->light_count; i++ )
+      {
+         struct world_light *light = &world->lights[i];
+         struct classtype_world_light *inf = light->inf;
 
-      u32 colour = 0xff000000;
-      u8 r = light->colour[0] * 255.0f,
-         g = light->colour[1] * 255.0f,
-         b = light->colour[2] * 255.0f;
+         u32 colour = 0xff000000;
+         u8 r = inf->colour[0] * 255.0f,
+            g = inf->colour[1] * 255.0f,
+            b = inf->colour[2] * 255.0f;
 
-      colour |= r;
-      colour |= g << 8;
-      colour |= b << 16;
+         colour |= r;
+         colour |= g << 8;
+         colour |= b << 16;
 
-      vg_line_pt3( light->co, 0.25f, colour );
+         vg_line_pt3( light->node->co, 0.25f, colour );
+      }
    }
 
-   world_global.in_trigger = in_trigger;
+   world_global.in_volume = in_volume;
    sfd_update();
+
+   /* process soundscape transactions */
+   audio_lock();
+   for( int i=0; i<world->soundscape_count; i++ )
+   {
+      struct soundscape *s = &world->soundscapes[i];
+      s->usage_count = 0;
+
+      for( int j=0; j<s->max_instances; j++ )
+      {
+         if( s->channels[j] )
+         {
+            if( audio_channel_finished(s->channels[j]) )
+               s->channels[j] = audio_relinquish_channel( s->channels[j] );
+            else
+               s->usage_count ++;
+         }
+      }
+   }
+   audio_unlock();
 }
 
 /*