struct countable
{
- enum classtype ct;
+ enum classtype ct, ct1;
void **to_allocate;
u32 item_size;
int count;
{
{
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 j=0; j<vg_list_size(entity_counts); j ++ )
{
- if( pnode->classtype == entity_counts[j].ct )
+ if( (pnode->classtype == entity_counts[j].ct) ||
+ (pnode->classtype == entity_counts[j].ct1) )
{
pnode->sub_uid = entity_counts[j].count;
entity_counts[j].count ++;
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 )
v3_copy( pnode->co, thing->pos );
- if( aud->flags & AUDIO_FLAG_SPACIAL_3D )
- thing->volume = aud->volume * pnode->s[0];
- else
- thing->volume = aud->volume;
+ 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.source_mode = k_audio_source_mono;
+ thing->temp_embedded_clip.flags = aud->flags;
- audio_clip_load( &thing->temp_embedded_clip, world_global.audio_heap );
- thing->player.name = mdl_pstr( world->meta, pnode->pstr_name );
- thing->player.enqued = 0;
+ 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_trigger( world_instance *world, mdl_node *pnode )
-{
- struct trigger_zone *trigger = &world->triggers[ world->trigger_count ];
- struct classtype_trigger *inf = mdl_get_entdata( world->meta, pnode );
-
- if( inf->target )
- {
- mdl_node *target_node = mdl_node_from_id( world->meta, inf->target );
-
- trigger->target.sub_id = target_node->sub_uid;
- trigger->target.classtype = target_node->classtype;
- }
- else
- {
- vg_warn( "Trigger with no target...\n" );
- return;
- }
-
- mdl_node_transform( pnode, trigger->transform );
- m4x3_invert_full( trigger->transform, trigger->inv_transform );
-
- world->trigger_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 ];
v3_copy( pnode->co, relay->pos );
world->relay_count ++;
}
+#endif
VG_STATIC void world_pct_achievement( world_instance *world, mdl_node *pnode )
{ k_classtype_spawn, world_pct_spawn },
{ k_classtype_water, world_pct_water },
{ k_classtype_audio, world_pct_audio },
- { k_classtype_trigger, world_pct_trigger },
+#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 }
return 0.0f;
}
-VG_STATIC void world_scene_compute_light_clusters( world_instance *world,
- scene *sc )
-{
- for( int i=0; i<sc->vertex_count; i++ )
- {
- scene_vert *vert = &sc->arrvertices[i];
- vert->lights[0] = 0;
- vert->lights[1] = 1;
- vert->lights[2] = 2;
- vert->lights[3] = 0;
-
- float influences[3] = { 0.0f, 0.0f, 0.0f };
- const int N = vg_list_size( influences );
-
- for( int j=0; j<world->light_count; j ++ )
- {
- float influence = calc_light_influence( world, vert->co, j );
-
- 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];
- vert->lights[k] = vert->lights[k-1];
- }
-
- influences[best_pos] = influence;
- vert->lights[best_pos] = j;
- }
- }
-
- for( int j=0; j<N; j++ )
- {
- if( influences[j] > 0.00000125f )
- vert->lights[3] ++ ;
- }
- }
-}
-
VG_STATIC void world_generate( world_instance *world )
{
/*
scene_copy_slice( world->scene_geo, &mat->sm_geo );
}
- world_scene_compute_light_clusters( world, world->scene_geo );
/* compress that bad boy */
world->scene_geo = scene_fix( world_global.generic_heap, world->scene_geo );
scene_copy_slice( world->scene_no_collide, &mat->sm_no_collide );
}
- world_scene_compute_light_clusters( world, world->scene_no_collide );
/* upload and free that */
vg_acquire_thread_sync();
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 )
{
for( int i=0; i<world->audio_things_count; i++ )
{
struct world_audio_thing *thingy = &world->audio_things[ i ];
-
- audio_player_init( &thingy->player );
- audio_player_set_flags( &thingy->player, thingy->flags );
- audio_player_set_vol( &thingy->player, thingy->volume );
- audio_player_set_pan( &thingy->player, 0.0f );
-
- if( thingy->flags & AUDIO_FLAG_SPACIAL_3D )
- audio_player_set_position( &thingy->player, thingy->pos );
if( thingy->flags & AUDIO_FLAG_AUTO_START )
- audio_player_playclip( &thingy->player, &thingy->temp_embedded_clip );
+ {
+ 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 */
shader_blitcolour_uColour( (v4f){-9999.0f,-9999.0f,-9999.0f,-9999.0f} );
render_fsquad();
- /* todo: hmm?? */
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glBlendEquation(GL_MAX);
glEnable(GL_DEPTH_TEST);
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
-
-
-
- /* 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 );
-
- vg_info( "g_cube_min[%f %f %f]\n",
- world->ub_lighting.g_cube_min[0],
- world->ub_lighting.g_cube_min[1],
- world->ub_lighting.g_cube_min[2] );
- vg_info( "g_cube_inv_range[%f %f %f]\n",
- world->ub_lighting.g_cube_inv_range[0],
- world->ub_lighting.g_cube_inv_range[1],
- world->ub_lighting.g_cube_inv_range[2] );
-
- 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;
- }
- }
- }
-
- glGenTextures( 1, &world->tex_light_cubes ); /* FIXME: glDeleteTextures */
- 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 );
-
-
-
-
-
/* upload full buffer */
glBindBuffer( GL_UNIFORM_BUFFER, world->ubo_lighting );
glBufferSubData( GL_UNIFORM_BUFFER, 0,
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;
vg_release_thread_sync();
}
-VG_STATIC void world_add_global_light( world_instance *world,
- v2f dir, v3f colour )
-{
- int id = world->ub_lighting.g_light_count;
-
- v3_copy( colour, world->ub_lighting.g_light_colours[id] );
- v3_copy( (v3f){ cosf(dir[1]) * cosf(dir[0]),
- sinf(dir[0]),
- sinf(dir[1]) * cosf(dir[0]) },
- world->ub_lighting.g_light_directions[id] );
-
- world->ub_lighting.g_light_count ++;
-}
-
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->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->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;
/* default lighting conditions
* -------------------------------------------------------------*/
- world->ub_lighting.g_light_count = 0;
- world->ub_lighting.g_light_preview = 0;
- world->ub_lighting.g_shadow_samples = 8;
- world->ub_lighting.g_water_fog = 0.04f;
-
- v4_zero( world->ub_lighting.g_water_plane );
- v4_zero( world->ub_lighting.g_depth_bounds );
- v4_zero( world->ub_lighting.g_ambient_colour );
-
- v3_copy( (v3f){ 0.09f, 0.03f, 0.07f }, world->ub_lighting.g_ambient_colour );
+ struct ub_world_lighting *state = &world->ub_lighting;
- world_add_global_light( world, (v2f){ 0.63f, -0.08f },
- (v3f){ 1.36f, 1.35f, 1.01f } );
+ state->g_light_preview = 0;
+ state->g_shadow_samples = 8;
+ state->g_water_fog = 0.04f;
- world_add_global_light( world, (v2f){ -2.60f, -0.13f },
- (v3f){ 0.33f, 0.56f, 0.64f } );
+ v4_zero( state->g_water_plane );
+ v4_zero( state->g_depth_bounds );
- world_add_global_light( world, (v2f){ 2.60f, -0.84f },
- (v3f){ 0.05f, 0.05f, 0.23f } );
+ state->g_shadow_length = 9.50f;
+ state->g_shadow_spread = 0.65f;
- world->ub_lighting.g_light_directions[0][3] = 9.50f;
- world->ub_lighting.g_light_colours[0][3] = 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 )
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff