X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=world_gen.h;h=a8f148c74f293e0a8b33c4eb878ed1320cfde4ad;hb=000297f007a08b25f458656bfb8dfe4345f2ec32;hp=3290def58a7f7e2010fc602aa74640242cf0131a;hpb=56f320d8ce6e8997370ec8e02fe50ca2d07b67f0;p=carveJwlIkooP6JGAAIwe30JlM.git diff --git a/world_gen.h b/world_gen.h index 3290def..a8f148c 100644 --- a/world_gen.h +++ b/world_gen.h @@ -151,7 +151,7 @@ VG_STATIC void world_ents_allocate( world_instance *world ) struct countable { - enum classtype ct; + enum classtype ct, ct1; void **to_allocate; u32 item_size; int count; @@ -160,33 +160,54 @@ VG_STATIC void world_ents_allocate( world_instance *world ) { { 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_point_light, + 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) } }; @@ -199,7 +220,8 @@ VG_STATIC void world_ents_allocate( world_instance *world ) for( int j=0; jclasstype == 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 ++; @@ -215,7 +237,16 @@ VG_STATIC void world_ents_allocate( world_instance *world ) 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 ) @@ -250,48 +281,20 @@ VG_STATIC void world_pct_audio( 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 ]; @@ -314,6 +317,7 @@ VG_STATIC void world_pct_relay( world_instance *world, mdl_node *pnode ) v3_copy( pnode->co, relay->pos ); world->relay_count ++; } +#endif VG_STATIC void world_pct_achievement( world_instance *world, mdl_node *pnode ) @@ -330,15 +334,30 @@ VG_STATIC void world_pct_achievement( world_instance *world, mdl_node *pnode ) world->achievement_count ++; } -VG_STATIC void world_pct_point_light( world_instance *world, mdl_node *pnode ) +VG_STATIC void world_pct_world_light( world_instance *world, mdl_node *pnode ) { - struct world_light *light = &world->lights[ world->light_count ]; - v3_copy( pnode->co, light->co ); + struct world_light *light = &world->lights[ world->light_count ++ ]; + light->node = pnode; + light->inf = mdl_get_entdata( world->meta, pnode ); - struct classtype_point_light *inf = mdl_get_entdata( world->meta, pnode ); - v4_copy( inf->colour, light->colour ); + q_m3x3( pnode->q, light->inverse_world ); + v3_copy( pnode->co, light->inverse_world[3] ); + m4x3_invert_affine( light->inverse_world, light->inverse_world ); - world->light_count ++; + 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 ) @@ -353,10 +372,12 @@ VG_STATIC void world_entities_process( world_instance *world ) { 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_point_light, world_pct_point_light } + { k_classtype_world_light, world_pct_world_light }, + { k_classtype_nonlocal_gate, world_pct_nonlocal_gate } }; for( int i=0; imeta->info.node_count; i++ ) @@ -376,43 +397,100 @@ VG_STATIC void world_entities_process( world_instance *world ) } } -VG_STATIC void world_scene_compute_light_clusters( world_instance *world, - scene *sc ) +VG_STATIC void world_link_nonlocal_gates( int index_a, int index_b ) { - for( int i=0; ivertex_count; i++ ) - { - scene_vert *vert = &sc->arrvertices[i]; - vert->lights[0] = 255; - vert->lights[1] = 255; - vert->lights[2] = 255; - vert->lights[3] = 255; + vg_info( "Linking non-local gates\n" ); + world_instance *a = &world_global.worlds[ index_a ], + *b = &world_global.worlds[ index_b ]; - float distances[4] = { INFINITY, INFINITY, INFINITY, INFINITY }; + for( int i=0; inonlocalgate_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; jlight_count; j ++ ) + for( int j=0; jnonlocalgate_count; j++ ) { - float dist = v3_dist2( world->lights[j].co, vert->co ); + 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 ); - int best_pos = 4; - for( int k=best_pos-1; k>=0; k -- ) - if( dist < distances[k] ) - best_pos = k; - - if( best_pos < 4 ) + if( !strcmp( ga_name, gb_name ) ) { - for( int k=3; k>best_pos; k -- ) - { - distances[k] = distances[k-1]; - vert->lights[k] = vert->lights[k-1]; - } - - distances[best_pos] = dist; - vert->lights[best_pos] = j; + 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 ) { /* @@ -440,7 +518,6 @@ 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 ); @@ -487,7 +564,6 @@ VG_STATIC void world_generate( world_instance *world ) 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(); @@ -500,6 +576,186 @@ VG_STATIC void world_generate( world_instance *world ) 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; izub_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; jlight_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 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 ) { @@ -508,22 +764,94 @@ VG_STATIC void world_post_process( world_instance *world ) for( int i=0; iaudio_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 */ + + 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; ilight_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 */ @@ -557,40 +885,15 @@ VG_STATIC void world_post_process( world_instance *world ) 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); - render_world_depth( world, &ortho ); + render_world_position( world, &ortho ); glDisable(GL_BLEND); glEnable(GL_DEPTH_TEST); glBindFramebuffer( GL_FRAMEBUFFER, 0 ); - /* 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 ); - - /* add scene lights */ - for( int i=0; ilight_count; i++ ) - { - struct world_light *light = &world->lights[i]; - - v3_muls( light->colour, light->colour[3] * 2.0f, - world->ub_lighting.g_point_light_colours[i] ); - v3_copy( light->co, - world->ub_lighting.g_point_light_positions[i] ); - } - /* upload full buffer */ glBindBuffer( GL_UNIFORM_BUFFER, world->ubo_lighting ); glBufferSubData( GL_UNIFORM_BUFFER, 0, @@ -675,6 +978,10 @@ VG_STATIC void world_unload( world_instance *world ) 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; @@ -709,25 +1016,15 @@ VG_STATIC void world_unload( world_instance *world ) 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; @@ -753,8 +1050,10 @@ VG_STATIC void world_clean( world_instance *world ) 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; @@ -771,33 +1070,38 @@ VG_STATIC void world_clean( world_instance *world ) 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 * -------------------------------------------------------------*/ - 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 )