X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=world.h;h=bf58144a3b8727c9b80fc5fea3bfa7752d1fa968;hb=777083e1f715a26d3f68be4ba5bdf2cbcaa84a05;hp=cdf2f16f0c85a901293dbc1cc9dc691c77b235a4;hpb=7758c7efec3956c68294bc914e7524045a2b1bd7;p=carveJwlIkooP6JGAAIwe30JlM.git diff --git a/world.h b/world.h index cdf2f16..bf58144 100644 --- a/world.h +++ b/world.h @@ -1,150 +1,685 @@ +/* + * Copyright (C) 2021-2022 Mt.ZERO Software, Harry Godden - All Rights Reserved + */ + +#include "common.h" + +VG_STATIC int ray_world( v3f pos, v3f dir, ray_hit *hit ); + #ifndef WORLD_H #define WORLD_H -#define VG_3D -#include "vg/vg.h" +#include "vg/vg_loader.h" +#include "network.h" +#include "network_msg.h" #include "scene.h" -#include "terrain.h" #include "render.h" -#include "water.h" +#include "rigidbody.h" +#include "bvh.h" +#include "model.h" +#include "shaders/terrain.h" +#include "shaders/sky.h" +#include "shaders/planeinf.h" #include "shaders/standard.h" +#include "shaders/vblend.h" +#include "shaders/gpos.h" +#include "shaders/fscolour.h" +#include "shaders/alphatest.h" + +typedef struct teleport_gate teleport_gate; + +enum { k_max_ui_segments = 8 }; + +enum { k_max_ui_elements = k_max_ui_segments }; +enum { k_max_element_verts = 10 }; +enum { k_max_element_indices = 20 }; -static struct gworld +enum { k_route_ui_max_verts = k_max_ui_elements*k_max_element_verts }; +enum { k_route_ui_max_indices = k_max_ui_elements*k_max_element_indices }; + +enum logic_type +{ + k_logic_type_relay = 1, + k_logic_type_chance = 2, + k_logic_type_achievement = 3 +}; + +enum geo_type { - scene geo, foliage; - submodel sm_road, sm_terrain; - glmesh skybox; + k_geo_type_solid = 0, + k_geo_type_nonsolid = 1, + k_geo_type_water = 2 +}; + +VG_STATIC struct gworld +{ + /* + * Allocated as system memory + * -------------------------------------------------------------------------- + */ + + /* rendering */ + glmesh skydome; + mdl_submesh dome_upper, dome_lower; + + glmesh mesh_gate_surface; + + double sky_time, sky_rate, sky_target_rate; + + /* water rendering */ + struct + { + struct framebuffer fbreflect, fbdepth; + + boxf depthbounds; + int depth_computed; + + float height; + int enabled; + v4f plane; + } + water; + + /* split flap display */ + struct + { + mdl_submesh *sm_module, *sm_card; + glmesh mesh_base, mesh_display; + + u32 w, h; + float *buffer; + } + sfd; + + /* timing bars, fixed maximum amount */ + struct route_ui_bar + { + GLuint vao, vbo, ebo; + + u32 indices_head; + u32 vertex_head; + + struct route_ui_segment + { + float length; + u32 vertex_start, vertex_count, + index_start, index_count, notches; + } + segments[k_max_ui_segments]; + + u32 segment_start, segment_count, fade_start, fade_count; + double fade_timer_start; + float xpos; + } + ui_bars[16]; + + v3f render_gate_pos; + int active_route_board; + int in_trigger; + + /* This is a small flag we use to changelevel. + * It will not be cleared until all sounds stop playing + */ + int switching_to_new_world; + char world_name[ 64 ]; + + /* + * Dynamically allocated when world_load is called. + * + * the following arrays index somewhere into this linear + * allocator + * + * (world_gen.h) + * -------------------------------------------------------------------------- + */ + void *dynamic_vgl, + *audio_vgl; /* sub buffer of the audio buffer */ + + /* + * Main world .mdl + */ + mdl_context *meta; + + /* + * Materials / textures + */ + + GLuint *textures; + u32 texture_count; + + struct world_material + { + mdl_material info; + mdl_submesh sm_geo, + sm_no_collide; + } + * materials; + u32 material_count; + + /* + * Named safe places to respawn + */ + struct respawn_point + { + v3f co; + v4f q; + const char *name; + } + * spawns; + u32 spawn_count; + + /* + * Audio player entities + */ + struct world_audio_thing + { + v3f pos; + float volume; + u32 flags; + + audio_player player; + audio_clip temp_embedded_clip; + } + * audio_things; + u32 audio_things_count; + + /* + * Relays + */ + struct logic_relay + { + v3f pos; + + struct relay_target + { + u32 sub_id; + enum classtype classtype; + } + targets[4]; + u32 target_count; + } + * logic_relays; + u32 relay_count; + + /* + * Box trigger entities + */ + struct trigger_zone + { + m4x3f transform, inv_transform; + + struct relay_target target; + } + * triggers; + u32 trigger_count; + + /* + * Achievements + */ + struct logic_achievement + { + v3f pos; + const char *achievement_id; + u32 achieved; + } + * logic_achievements; + u32 achievement_count; + + + /* + * Routes (world_routes.h) + * -------------------------------------------------------------------------- + */ + struct route_node + { + v3f co, right, up, h; + u32 next[2]; + + u32 special_type, special_id, current_refs, ref_count; + u32 route_ids[4]; /* Gates can be linked into up to four routes */ + } + *nodes; + u32 node_count; + + struct route + { + u32 track_id; + v4f colour; + + u32 start; + mdl_submesh sm; + + int active; + float factive; + + double best_lap, latest_pass; /* Session */ + + m4x3f scoreboard_transform; + } + *routes; + u32 route_count; + + struct route_gate + { + struct teleport_gate + { + v3f co[2]; + v4f q[2]; + v2f dims; + + m4x3f to_world, recv_to_world, transport; + } + gate; + + u32 node_id; + + struct route_timing + { + u32 version; /* Incremented on every teleport */ + double time; + } + timing; + } + *gates; + u32 gate_count; + + struct route_collector + { + struct route_timing timing; + } + *collectors; + u32 collector_count; + + + /* logic + * ---------------------------------------------------- + */ - v3f tutorial; + u32 active_gate, + current_run_version; + double time, rewind_from, rewind_to, last_use; + + /* world geometry */ + scene *scene_geo, + *scene_no_collide, + *scene_lines; + + struct grind_edge + { + v3f p0, p1; + } + *grind_edges; + u32 grind_edge_count; + + /* spacial mappings */ + bh_tree *audio_bh, + *trigger_bh, + *geo_bh, + *grind_bh; + + /* graphics */ + glmesh mesh_route_lines; + + glmesh mesh_geo, + mesh_no_collide, + mesh_water; + + mdl_submesh sm_foliage_main; + rigidbody rb_geo; } world; -static void render_world( m4x4f projection, m4x3f camera ) + +/* + * API + */ + +VG_STATIC int ray_hit_is_ramp( ray_hit *hit ); +VG_STATIC struct world_material *ray_hit_material( ray_hit *hit ); +VG_STATIC void ray_world_get_tri( ray_hit *hit, v3f tri[3] ); +VG_STATIC int ray_world( v3f pos, v3f dir, ray_hit *hit ); + +/* + * Submodules + */ + +#include "world_routes.h" +#include "world_sfd.h" +#include "world_render.h" +#include "world_water.h" +#include "world_gen.h" +#include "world_gate.h" + +/* + * ----------------------------------------------------------------------------- + * Events + * ----------------------------------------------------------------------------- + */ + +VG_STATIC int world_stop_sound( int argc, const char *argv[] ) { - render_sky( camera ); + /* + * 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; iplayer ) ) + { + u32 cflags = audio_player_get_flags( &at->player ); + audio_player_set_flags( &at->player, cflags | AUDIO_FLAG_KILL ); + } + } + audio_unlock(); - render_terrain( projection ); - scene_bind( &world.geo ); - scene_draw( &world.geo ); + return 0; +} - glDisable(GL_CULL_FACE); - scene_bind( &world.foliage ); - scene_draw( &world.foliage ); - glEnable(GL_CULL_FACE); +VG_STATIC int world_change_world( int argc, const char *argv[] ) +{ + 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 ); + } + + return 0; } -static int ray_world( v3f pos, v3f dir, ray_hit *hit ) +VG_STATIC void world_init(void) { - return bvh_raycast( &world.geo, pos, dir, hit ); + vg_convar_push( (struct vg_convar){ + .name = "water_enable", + .data = &world.water.enabled, + .data_type = k_convar_dtype_i32, + .opt_i32 = { .min=0, .max=1, .clamp=1 }, + .persistent = 0 + }); + + 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.sky_rate = 1.0; + world.sky_target_rate = 1.0; + + shader_terrain_register(); + shader_sky_register(); + shader_planeinf_register(); + shader_gpos_register(); + shader_fscolour_register(); + shader_alphatest_register(); + + vg_info( "Loading world resources\n" ); + + vg_linear_clear( vg_mem.scratch ); + mdl_context *msky = mdl_load_full( vg_mem.scratch, "models/rs_skydome.mdl" ); + + mdl_node *nlower = mdl_node_from_name( msky, "dome_lower" ), + *nupper = mdl_node_from_name( msky, "dome_upper" ); + + world.dome_lower = *mdl_node_submesh( msky, nlower, 0 ); + world.dome_upper = *mdl_node_submesh( msky, nupper, 0 ); + + vg_acquire_thread_sync(); + { + mdl_unpack_glmesh( msky, &world.skydome ); + } + vg_release_thread_sync(); + + /* Other systems */ + vg_info( "Loading other world systems\n" ); + + vg_loader_highwater( world_render_init, NULL, NULL ); + vg_loader_highwater( world_sfd_init, NULL, NULL ); + vg_loader_highwater( world_water_init, NULL, NULL ); + vg_loader_highwater( world_gates_init, NULL, NULL ); + vg_loader_highwater( world_routes_init, NULL, NULL ); + + /* Allocate dynamic world memory arena */ + u32 max_size = 76*1024*1024; + world.dynamic_vgl = vg_create_linear_allocator( vg_mem.rtmemory, max_size, + VG_MEMORY_SYSTEM ); } -static int ray_hit_is_ramp( ray_hit *hit ) +VG_STATIC void world_audio_init(void) { - return hit->tri[0] < world.sm_road.vertex_count; + u32 size = vg_linear_remaining( vg_audio.audio_pool ) + - sizeof(vg_linear_allocator); + + world.audio_vgl = vg_create_linear_allocator( vg_audio.audio_pool, + size, VG_MEMORY_SYSTEM ); } -static void world_init_default(void) +VG_STATIC void world_trigger_achievement( u32 uid ) { - /* Setup scene */ - scene_init( &world.geo ); - model *mworld = vg_asset_read( "models/mp_dev.mdl" ); + struct logic_achievement *ach = &world.logic_achievements[ uid ]; - scene_add_model( &world.geo, mworld, submodel_get( mworld, "mp_dev" ), - (v3f){0.0f,0.0f,0.0f}, 0.0f, 1.0f ); - scene_copy_slice( &world.geo, &world.sm_road ); + if( ach->achieved ) + return; - scene_add_model( &world.geo, mworld, submodel_get( mworld, "terrain" ), - (v3f){0.0f,0.0f,0.0f}, 0.0f, 1.0f ); - scene_copy_slice( &world.geo, &world.sm_terrain ); + steam_set_achievement( ach->achievement_id ); + steam_store_achievements(); - v3_copy( model_marker_get( mworld, "mp_dev_tutorial" )->co, world.tutorial ); + ach->achieved = 1; +} +VG_STATIC void world_run_relay( struct relay_target *rt ); +VG_STATIC void world_trigger_relay( u32 uid ) +{ + struct logic_relay *relay = &world.logic_relays[ uid ]; - /* GATE DEV */ -#if 0 + for( int i=0; itarget_count; i++ ) { - model_marker *ga = model_marker_get(mworld,"gate_a"), - *gb = model_marker_get(mworld,"gate_a_recv"); + world_run_relay( &relay->targets[i] ); + } +} - v3_copy( ga->co, gate_a.co ); - v3_copy( gb->co, gate_b.co ); - v4_copy( ga->q, gate_a.q ); - v4_copy( gb->q, gate_b.q ); - v2_copy( ga->s, gate_a.dims ); - v2_copy( gb->s, gate_b.dims ); +VG_STATIC void world_trigger_audio( u32 uid ) +{ + struct world_audio_thing *wat = &world.audio_things[ uid ]; - gate_a.other = &gate_b; - gate_b.other = &gate_a; + audio_lock(); + audio_player_playclip( &wat->player, + &wat->temp_embedded_clip ); + audio_unlock(); +} - gate_transform_update( &gate_a ); - gate_transform_update( &gate_b ); +VG_STATIC void world_run_relay( struct relay_target *rt ) +{ + struct entity_instruction + { + enum classtype classtype; + void (*p_trigger)( u32 uid ); } -#endif + entity_instructions[] = + { + { k_classtype_logic_achievement, world_trigger_achievement }, + { k_classtype_logic_relay, world_trigger_relay }, + { k_classtype_audio, world_trigger_audio } + }; - /* WATER DEV */ + for( int i=0; ipivot[1] ); + struct entity_instruction *instr = &entity_instructions[i]; + + if( instr->classtype == rt->classtype ) + { + instr->p_trigger( rt->sub_id ); + return; + } } - free( mworld ); - scene_upload( &world.geo ); - bvh_create( &world.geo ); + vg_error( "Don't know how to trigger classtype %d\n", rt->classtype ); +} +VG_STATIC void world_update( v3f pos ) +{ + if( world.switching_to_new_world ) + { + int all_stopped = 1; + audio_lock(); + for( int i=0; iplayer ) ) + { + all_stopped = 0; + break; + } + } + audio_unlock(); + + if( all_stopped ) + { + world.switching_to_new_world = 0; + world_unload(); + world_load(); + } + } - v3f volume; - v3_sub( world.geo.bbx[1], world.geo.bbx[0], volume ); - volume[1] = 1.0f; - m4x3f transform; + 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 ); - for( int i=0;i<100000;i++ ) + world_routes_update(); +#if 0 + world_routes_debug(); +#endif + + if( world.route_count > 0 ) { - v3f pos; - v3_mul( volume, (v3f){ vg_randf(), 1000.0f, vg_randf() }, pos ); - v3_add( pos, world.geo.bbx[0], pos ); - - ray_hit hit; - hit.dist = INFINITY; + int closest = 0; + float min_dist = INFINITY; - if( ray_world( pos, (v3f){0.0f,-1.0f,0.0f}, &hit )) + for( int i=0; i 0.8f && !ray_hit_is_ramp(&hit) ) + float d = v3_dist2( world.routes[i].scoreboard_transform[3], pos ); + + if( d < min_dist ) { - v4f qsurface, qrandom; - v3f axis; + min_dist = d; + closest = i; + } + } - v3_cross( (v3f){0.0f,1.0f,0.0f}, hit.normal, axis ); + if( (world.active_route_board != closest) || network_scores_updated ) + { + network_scores_updated = 0; + world.active_route_board = closest; + + struct route *route = &world.routes[closest]; - 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 ); + u32 id = route->track_id; - v3_copy( hit.pos, transform[3] ); + if( id != 0xffffffff ) + { + struct netmsg_board *local_board = + &scoreboard_client_data.boards[id]; - scene_add_foliage( &world.foliage, mfoliage, - model_get_submodel( mfoliage, 0 ), transform ); + for( int i=0; i<13; i++ ) + { + sfd_encode( i, &local_board->data[27*i] ); + } } } } - free( mfoliage ); - scene_upload( &world.foliage ); + int in_trigger = 0; + for( int i=0; iinv_transform, pos, local ); + + if( (fabsf(local[0]) <= 1.0f) && + (fabsf(local[1]) <= 1.0f) && + (fabsf(local[2]) <= 1.0f) ) + { + in_trigger = 1; + + if( !world.in_trigger ) + { + world_run_relay( &zone->target ); + } + } + + vg_line_boxf_transformed( zone->transform, (boxf){{-1.0f,-1.0f,-1.0f}, + { 1.0f, 1.0f, 1.0f}}, + 0xff00ff00 ); + } + + world.in_trigger = in_trigger; + sfd_update(); +} + +/* + * ----------------------------------------------------------------------------- + * API implementation + * ----------------------------------------------------------------------------- + */ + +VG_STATIC void ray_world_get_tri( ray_hit *hit, v3f tri[3] ) +{ + for( int i=0; i<3; i++ ) + v3_copy( world.scene_geo->arrvertices[ hit->tri[i] ].co, tri[i] ); +} + +VG_STATIC int ray_world( v3f pos, v3f dir, ray_hit *hit ) +{ + return scene_raycast( world.scene_geo, world.geo_bh, pos, dir, hit ); +} + +VG_STATIC struct world_material *world_tri_index_material( u32 index ) +{ + for( int i=1; i= mat->sm_geo.vertex_start) && + (index < mat->sm_geo.vertex_start+mat->sm_geo.vertex_count ) ) + { + return mat; + } + } + + /* error material */ + return &world.materials[0]; +} + +VG_STATIC struct world_material *world_contact_material( rb_ct *ct ) +{ + return world_tri_index_material( ct->element_id ); +} + +VG_STATIC struct world_material *ray_hit_material( ray_hit *hit ) +{ + return world_tri_index_material( hit->tri[0] ); } #endif /* WORLD_H */