#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"
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.
/* 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;
/*
struct world_audio_thing
{
v3f pos;
- float volume;
+ float volume, range;
u32 flags;
+#if 0
audio_player player;
+#endif
+
audio_clip temp_embedded_clip;
}
* audio_things;
u32 audio_things_count;
+#if 0
/*
- * Relays
+ * Relays [ DEPRECATED ]
*/
struct logic_relay
{
}
* logic_relays;
u32 relay_count;
+#endif
+
+ struct soundscape
+ {
+ /* 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;
+ }
+ * soundscapes;
+ u32 soundscape_count;
+
+ struct logic_brick_ref
+ {
+ mdl_node *node;
+ float usage;
+ u32 internal_id; /* used for things like soundscapes where another
+ allocation is made on top */
+ }
+ * logic_bricks;
+ u32 logic_brick_count;
/*
* Box trigger entities
struct trigger_zone
{
m4x3f transform, inv_transform;
-
- struct relay_target target;
+
+ u32 target_logic_brick;
+ enum classtype classtype;
}
* triggers;
u32 trigger_count;
*/
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;
* Allocated as system memory
* --------------------------------------------------------------------------
*/
- void *generic_heap,
- *audio_heap; /* sub buffer of the audio buffer */
+ void *generic_heap;
/* rendering */
glmesh skydome;
#include "world_sfd.h"
#include "world_render.h"
#include "world_water.h"
+#include "world_logic_bricks.h"
#include "world_gen.h"
#include "world_gate.h"
* Therefore it is safe to delete clip data after the players are
* disconnected
*/
+#if 0
audio_lock();
for( int i=0; i<world->audio_things_count; i++ )
{
}
}
audio_unlock();
+#endif
return 0;
}
shader_scene_vertex_blend_register();
shader_scene_terrain_register();
shader_scene_depth_register();
+ shader_scene_position_register();
shader_model_sky_register();
VG_STATIC void world_audio_init(void)
{
+#if 0
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 );
+#endif
}
+#if 0
VG_STATIC void world_trigger_achievement( world_instance *world, u32 uid )
{
struct logic_achievement *ach = &world->logic_achievements[ uid ];
ach->achieved = 1;
}
+#endif
+#if 0
VG_STATIC void world_run_relay( world_instance *world,
struct relay_target *rt );
world_run_relay( world, &relay->targets[i] );
}
}
+#endif
+#if 0
VG_STATIC void world_trigger_audio( world_instance *world, u32 uid )
{
struct world_audio_thing *wat = &world->audio_things[ uid ];
&wat->temp_embedded_clip );
audio_unlock();
}
+#endif
+#if 0
VG_STATIC void world_run_relay( world_instance *world,
struct relay_target *rt )
{
{
{ k_classtype_logic_achievement, world_trigger_achievement },
{ k_classtype_logic_relay, world_trigger_relay },
- { k_classtype_audio, world_trigger_audio }
+ { k_classtype_audio, world_trigger_audio },
+ { k_classtype_logic_wire, logic_bricks_trigger_brick }
};
for( int i=0; i<vg_list_size(entity_instructions); i++ )
vg_error( "Don't know how to trigger classtype %d\n", rt->classtype );
}
+#endif
VG_STATIC void world_update( world_instance *world, v3f pos )
{
+ /* TEMP!!!!!! */
+ static double g_time = 0.0;
+ g_time += vg.time_delta * (1.0/(k_day_length*60.0));
+
+
+ struct ub_world_lighting *state = &world->ub_lighting;
+
+ 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;
+
+ 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 );
+
+ 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 );
+
+ 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 );
+
+
+
+ glBindBuffer( GL_UNIFORM_BUFFER, world->ubo_lighting );
+ glBufferSubData( GL_UNIFORM_BUFFER, 0,
+ sizeof(struct ub_world_lighting), &world->ub_lighting );
+ /* TEMP!!!!!! */
+
+
#if 0
if( world.switching_to_new_world )
{
}
}
- 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
}
}
}
+
+ /* 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++ )
{
struct trigger_zone *zone = &world->triggers[i];
+ 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 );
+ continue;
+ }
+
v3f local;
m4x3_mulv( zone->inv_transform, pos, local );
if( !world_global.in_trigger )
{
- world_run_relay( world, &zone->target );
+ 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 );
}
}
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;
sfd_update();
+
+ if( debug_logic_bricks )
+ logic_bricks_debug( world );
+
+ /* 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();
}
/*
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff