#include "skaterift.h"
typedef struct camera camera;
-
-struct camera
-{
+struct camera{
/* Input */
v3f angles;
v3f pos;
}
mtx,
mtx_prev;
-}
-static main_camera, gate_camera;
+};
VG_STATIC void camera_lerp_angles( v3f a, v3f b, float t, v3f d )
{
* VG event preupdate
*/
void temp_update_playermodel(void);
-VG_STATIC void global_skateshop_preupdate(void)
-{
+VG_STATIC void global_skateshop_preupdate(void){
float rate = vg_minf( 1.0f, vg.time_frame_delta * 2.0f );
- global_skateshop.factive = vg_lerpf( global_skateshop.factive,
- global_skateshop.active, rate );
+ int active = 0;
+ if( skaterift.activity == k_skaterift_skateshop )
+ active = 1;
+
+ vg_slewf( &global_skateshop.factive, active,
+ vg.time_frame_delta * (1.0f/0.5f) );
- if( !global_skateshop.active ) return;
+ if( !active ) return;
+ /* input filter */
world_instance *world = world_current_instance();
ent_skateshop *shop = global_skateshop.ptr_ent;
v3f dir = {0.0f,-1.0f,0.0f};
mdl_transform_vector( &ref->transform, dir, dir );
m3x3_mulv( localplayer.invbasis, dir, dir );
- player_vector_angles( localplayer.cam_override_angles, dir, 1.0f, 0.0f );
+ player_vector_angles( global_skateshop.cam.angles, dir, 1.0f, 0.0f );
v3f lookat;
if( shop->type == k_skateshop_type_boardshop ||
shop->type == k_skateshop_type_worldshop ){
ent_marker *display = mdl_arritm( &world->ent_marker,
mdl_entity_id_id(shop->boards.id_display) );
-
v3_sub( display->transform.co, localplayer.rb.co, lookat );
-
}
- else if( shop->type == k_skateshop_type_charshop ){
+ else if( shop->type == k_skateshop_type_charshop )
v3_sub( ref->transform.co, localplayer.rb.co, lookat );
- }
- else{
+ else
vg_fatal_error( "Unknown store (%u)\n", shop->type );
- }
q_axis_angle( localplayer.rb.q, (v3f){0.0f,1.0f,0.0f},
atan2f(lookat[0],lookat[2]) );
- v3_copy( ref->transform.co, localplayer.cam_override_pos );
- localplayer.cam_override_fov = ref->fov;
- localplayer.cam_override_strength = global_skateshop.factive;
+ v3_copy( ref->transform.co, global_skateshop.cam.pos );
+ global_skateshop.cam.fov = ref->fov;
/* input */
if( shop->type == k_skateshop_type_boardshop ){
}
}
-VG_STATIC void skateshop_render_boardshop(void)
-{
+VG_STATIC void skateshop_render_boardshop(void){
world_instance *world = world_current_instance();
ent_skateshop *shop = global_skateshop.ptr_ent;
struct board_pose pose = {0};
m4x3f mmdl;
mdl_transform_m4x3( &xform, mmdl );
- render_board( &main_camera, world, board, mmdl,
+ render_board( &skaterift.cam, world, board, mmdl,
&pose, k_board_shader_entity );
fade_out:;
float scale = 0.2f,
thickness = 0.03f;
- font3d_bind( &gui.font, &main_camera );
+ font3d_bind( &gui.font, &skaterift.cam );
shader_model_font_uColour( (v4f){1.0f,1.0f,1.0f,1.0f} );
/* Selection counter
i+=highscore_intl( buf+i, addon_count(k_addon_type_board), 3 );
buf[i++] = '\0';
- font3d_simple_draw( &gui.font, 0, buf, &main_camera, mmdl );
+ font3d_simple_draw( &gui.font, 0, buf, &skaterift.cam, mmdl );
}
else{
font3d_simple_draw( &gui.font, 0,
- "Nothing installed", &main_camera, mmdl );
+ "Nothing installed", &skaterift.cam, mmdl );
}
u16 cache_id = skateshop_selected_cache_id();
mlocal[3][2] = 0.0f;
m4x3_mul( mtext, mlocal, mmdl );
font3d_simple_draw( &gui.font, 0, global_skateshop.render.item_title,
- &main_camera, mmdl );
+ &skaterift.cam, mmdl );
/* Author name
* ----------------------------------------------------------------- */
mlocal[3][2] = 0.0f;
m4x3_mul( mtext, mlocal, mmdl );
font3d_simple_draw( &gui.font, 0, global_skateshop.render.item_desc,
- &main_camera, mmdl );
+ &skaterift.cam, mmdl );
SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
}
m4x3f mtext,mlocal,mtextmdl;
mdl_transform_m4x3( &mark_info->transform, mtext );
- font3d_bind( &gui.font, &main_camera );
+ font3d_bind( &gui.font, &skaterift.cam );
shader_model_font_uColour( (v4f){1.0f,1.0f,1.0f,1.0f} );
float scale = 0.2f, thickness = 0.015f, scale1 = 0.08f;
mlocal[3][1] = 0.1f;
mlocal[3][2] = 0.0f;
m4x3_mul( mtext, mlocal, mtextmdl );
- font3d_simple_draw( &gui.font, 0, buftext, &main_camera, mtextmdl );
+ font3d_simple_draw( &gui.font, 0, buftext, &skaterift.cam, mtextmdl );
m3x3_setdiagonalv3( mlocal, (v3f){ scale1, scale1, thickness } );
mlocal[3][0] = -font3d_string_width( &gui.font, 0, bufsubtext );
mlocal[3][0] *= scale1*0.5f;
mlocal[3][1] = -scale1*0.3f;
m4x3_mul( mtext, mlocal, mtextmdl );
- font3d_simple_draw( &gui.font, 0, bufsubtext, &main_camera, mtextmdl );
+ font3d_simple_draw( &gui.font, 0, bufsubtext, &skaterift.cam, mtextmdl );
/* pointcloud */
m4x3f mmdl;
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glDisable(GL_DEPTH_TEST);
- pointcloud_render( world, &main_camera, mmdl );
+ pointcloud_render( world, &skaterift.cam, mmdl );
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
}
/*
* World: render event
*/
-VG_STATIC void skateshop_render(void)
-{
- if( !global_skateshop.active ) return;
+VG_STATIC void skateshop_render(void){
+ if( skaterift.activity != k_skaterift_skateshop ) return;
ent_skateshop *shop = global_skateshop.ptr_ent;
ent_skateshop *shop = mdl_arritm( &world->ent_skateshop, index );
vg_info( "skateshop_call\n" );
- if( menu.active ) return;
+ if( skaterift.activity != k_skaterift_default ) return;
if( !vg_loader_availible() ) return;
if( call->function == k_ent_function_trigger ){
- if( localplayer.subsystem != k_player_subsystem_walk ){
- return;
- }
+ if( localplayer.subsystem != k_player_subsystem_walk ) return;
vg_info( "Entering skateshop\n" );
localplayer.immobile = 1;
menu.disable_open = 1;
- global_skateshop.active = 1;
+ skaterift.activity = k_skaterift_skateshop;
v3_zero( localplayer.rb.v );
v3_zero( localplayer.rb.w );
/*
* Entity logic: exit event
*/
-VG_STATIC void global_skateshop_exit(void)
-{
+VG_STATIC void global_skateshop_exit(void){
vg_info( "exit skateshop\n" );
localplayer.immobile = 0;
- global_skateshop.active = 0;
+ skaterift.activity = k_skaterift_default;
menu.disable_open = 0;
- srinput.ignore_input_frames = 2;
+ srinput.enabled = 0;
}
#endif /* ENT_SKATESHOP_C */
struct{
v3f look_target;
ent_skateshop *ptr_ent;
-
- int active;
float factive;
struct shop_view_slot{
u32 world_reg;
}
render;
+
+ camera cam;
}
static global_skateshop={.render={.reg_id=0xffffffff,.world_reg=0xffffffff}};
float axis_states[ k_sraxis_max ][2];
v2f joystick_states[ k_srjoystick_max ][2];
u8 button_states[ k_srbind_max ][2];
- u32 ignore_input_frames;
+ u32 enabled;
}
static srinput;
static int buttons_filter_fixed(void)
{
- if( srinput.ignore_input_frames ) return 1;
+ if( !srinput.enabled ) return 1;
if( vg_ui.wants_mouse ) return 1;
if( vg.engine_stage == k_engine_stage_update_fixed )
static void skaterift_preupdate_inputs(void)
{
- if( srinput.ignore_input_frames )
- srinput.ignore_input_frames --;
-
for( u32 i=0; i<k_srbind_max; i++ ){
srinput.button_states[i][1] = srinput.button_states[i][0];
srinput.button_states[i][0] = 0;
#define MENU_STACK_SIZE 8
struct {
- int active, credits_open;
+ int credits_open;
int disable_open;
u32 page, /* current page index */
}
}
-static void menu_init(void)
-{
+static void menu_close(void){
+ skaterift.activity = k_skaterift_default;
+ menu.page_depth = 0;
+ menu.page = 0xffffffff;
+ srinput.enabled = 0;
+}
+
+static void menu_init(void){
void *alloc = vg_mem.rtmemory;
mdl_open( &menu.model, "models/rs_menu.mdl", alloc );
vg_info( "menu_back_page()\n" );
menu.page_depth --;
if( menu.page_depth == 0 ){
- menu.active = 0;
- menu.page = 0xffffffff;
+ menu_close();
}
else{
menu.page = menu.page_stack[ menu.page_depth ].page;
}
else if( MDL_CONST_PSTREQ( &menu.model, q, "reset_nearest" ) ){
localplayer_cmd_respawn( 0, NULL );
-
- menu.page_depth = 0;
- menu.active = 0;
- menu.page = 0xffffffff;
+ menu_close();
}
else if( MDL_CONST_PSTREQ( &menu.model, q, "reset_home" ) ){
world_static.active_world = 0;
world_static.active_trigger_volume_count = 0;
localplayer.viewable_world = world_current_instance();
localplayer_cmd_respawn( 1, (const char *[]){"start"} );
-
- menu.page_depth = 0;
- menu.active = 0;
- menu.page = 0xffffffff;
+ menu_close();
}
else if( MDL_CONST_PSTREQ( &menu.model, q, "credits" ) ){
menu.credits_open = 1;
/*
* Run from vg_gui every frame
*/
-static void menu_update(void)
-{
+static void menu_update(void){
if( workshop_form.page != k_workshop_form_hidden ){
return;
}
}
if( button_down( k_srbind_mopen ) ){
- if( !menu.active && !menu.disable_open ){
- menu.active = 1;
+ if( skaterift.activity == k_skaterift_default ){
+ skaterift.activity = k_skaterift_menu;
menu.page = 0xffffffff;
menu_open_page( "Main Menu" );
return;
}
}
- if( !menu.active ) return;
-
+ if( skaterift.activity != k_skaterift_menu ) return;
enum menu_input_mode prev_mode = menu.input_mode;
/* get buttons inputs
/*
* Run from vg_gui when active
*/
-VG_STATIC void menu_render(void)
-{
+VG_STATIC void menu_render(void){
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
VG_STATIC void player_apply_transport_to_cam( m4x3f transport )
{
- /* FIXME: Applies to main_camera directly! */
+ /* FIXME: Applies to skaterift.cam directly! */
/* Pre-emptively edit the camera matrices so that the motion vectors
* are correct */
m4x4f transport_4;
m4x3_invert_affine( transport, transport_i );
m4x3_expand( transport_i, transport_4 );
- m4x4_mul( main_camera.mtx.pv, transport_4, main_camera.mtx.pv );
- m4x4_mul( main_camera.mtx.v, transport_4, main_camera.mtx.v );
+ m4x4_mul( skaterift.cam.mtx.pv, transport_4, skaterift.cam.mtx.pv );
+ m4x4_mul( skaterift.cam.mtx.v, transport_4, skaterift.cam.mtx.v );
/* we want the regular transform here no the inversion */
m4x3_expand( transport, transport_4 );
- m4x4_mul( gate_camera.mtx.pv, transport_4, gate_camera.mtx.pv );
- m4x4_mul( gate_camera.mtx.v, transport_4, gate_camera.mtx.v );
+ m4x4_mul( world_gates.cam.mtx.pv, transport_4, world_gates.cam.mtx.pv );
+ m4x4_mul( world_gates.cam.mtx.v, transport_4, world_gates.cam.mtx.v );
}
__attribute__ ((deprecated))
g_player_debugger[2] = 300;
g_player_debugger[3] = 16;
+ player__debugtext( 2, "director" );
+ player__debugtext( 1, "activity: %s",
+ (const char *[]){ [k_skaterift_menu] = "menu",
+ [k_skaterift_replay] = "replay",
+ [k_skaterift_skateshop] = "shop",
+ [k_skaterift_default] = "default"
+ } [skaterift.activity] );
+ player__debugtext( 1, "time_rate: %.4f", skaterift.time_rate );
+
+ player__debugtext( 2, "player_instance[%p]", player );
player__debugtext( 1, "angles: " PRINTF_v3f( player->cam.angles ) );
player__debugtext( 1, "basis: " PRINTF_v4f( player->qbasis ) );
*/
camera cam;
struct player_cam_controller cam_control;
-
- v3f cam_override_pos;
- v3f cam_override_angles;
- float cam_override_fov;
- float cam_override_strength;
f32 cam_trackshake;
float cam_velocity_influence,
struct board_pose board_pose;
- /*
- * Replay
- * -------------------------------------------------
- */
- replay_buffer replay;
-
/*
* Subsystems
* -------------------------------------------------
player->cam_land_punch_v );
v3_add( player->cam_land_punch, player->cam.pos, player->cam.pos );
- /* override camera */
- player->cam.angles[0] =
- vg_alerpf( player->cam.angles[0], player->cam_override_angles[0],
- player->cam_override_strength );
- player->cam.angles[1] =
- vg_lerpf ( player->cam.angles[1], player->cam_override_angles[1],
- player->cam_override_strength );
- v3_lerp( player->cam.pos, player->cam_override_pos,
- player->cam_override_strength, player->cam.pos );
- player->cam.fov = vg_lerpf( player->cam.fov, player->cam_override_fov,
- player->cam_override_strength );
-
-
if( k_cinema >= 0.0001f ){
ent_camera *cam = NULL;
f32 min_dist = k_cinema;
_player_post_animate[ player->subsystem ]( player );
}
-VG_STATIC void player_animate_from_replay( player_instance *player ){
+VG_STATIC void player_animate_from_replay( player_instance *player,
+ replay_buffer *replay ){
/* TODO: frame blending */
-
player_animation res;
- replay_frame *frame = player->replay.cursor_frame;
+ replay_frame *frame = replay->cursor_frame;
if( frame ){
memcpy( &res, &frame->anim, sizeof(frame->anim) );
memcpy( &frame->board_pose, &player->board_pose,
sizeof(player->board_pose) );
- v3_copy( frame->cam_pos, player->cam_override_pos );
- v3_copy( frame->cam_angles, player->cam_override_angles );
- player->cam_override_fov = frame->cam_fov;
- player->cam_override_strength = 1.0f;
}
else return;
skeleton_apply_pose( sk, res.pose, k_anim_apply_absolute );
}
-VG_STATIC void player_record_replay( player_instance *player, int force ){
- /* replay recorder */
- replay_buffer *replay = &player->replay;
-
+VG_STATIC
+void player_record_replay_frame( player_instance *player,
+ replay_buffer *replay, int force_gamestate ){
f64 delta = 9999999.9,
statedelta = 9999999.9;
k_gamestate_rate = 0.5;
u16 gamestates = 0;
- if( statedelta > k_gamestate_rate || force /* or switching */ ){
+ if( statedelta > k_gamestate_rate || force_gamestate /* or switching */ ){
gamestates = 1;
}
}
VG_STATIC void player__pre_render( player_instance *player ){
- if( player->replay.control == k_replay_control_none ){
- player->cam_override_strength = 0.0f;
- player_animate( player );
-
- if( button_down( k_srbind_reset ) && !player->immobile ){
- audio_lock();
- audio_oneshot( &audio_rewind[4], 1.0f, 0.0f );
- audio_unlock();
-
- player_record_replay( player, 1 );
- player->replay.control = k_replay_control_scrub;
- }
- else
- player_record_replay( player, 0 );
- }
- else {
- player->cam_override_strength = 1.0f-skaterift.time_rate;
- player_replay_control_update( player );
- player_animate_from_replay( player );
- }
-
+ player_animate( player );
player__cam_iterate( player );
/* shadowing/ao info */
render_fb_inverse_ratio( gpipeline.fb_main, inverse );
- inverse[2] = main_camera.farz-main_camera.nearz;
+ inverse[2] = skaterift.cam.farz-skaterift.cam.nearz;
shader_model_board_view_uInverseRatioDepth( inverse );
render_fb_inverse_ratio( NULL, inverse );
render_fb_bind_texture( gpipeline.fb_main, 2, 1 );
v3f inverse;
render_fb_inverse_ratio( gpipeline.fb_main, inverse );
- inverse[2] = main_camera.farz-main_camera.nearz;
+ inverse[2] = skaterift.cam.farz-skaterift.cam.nearz;
shader_model_character_view_uInverseRatioDepth( inverse );
render_fb_inverse_ratio( NULL, inverse );
replay->control = k_replay_control_none;
}
-VG_STATIC void local_replay_init( u32 bytes ){
- localplayer.replay.data = vg_linear_alloc( vg_mem.rtmemory, bytes );
- localplayer.replay.size = bytes;
- replay_clear( &localplayer.replay );
-}
-
replay_gamestate *replay_frame_gamestate( replay_frame *frame, u16 index ){
void *baseptr = frame;
}
VG_STATIC void player_replay_control_update( player_instance *player ){
+#if 0
f64 speed = 1.0;
f64 target = player->replay.cursor;
return;
}
}
+#endif
}
VG_STATIC void replay_debug_info( player_instance *player ){
+#if 0
player__debugtext( 2, "replay info" );
replay_buffer *replay = &player->replay;
len = end - start;
player__debugtext( 1, "cursor: %.2fs / %.2fs\n", cur, len );
+#endif
}
VG_STATIC void replay_imgui( player_instance *player ){
+#if 0
if( player->replay.control == k_replay_control_none ) return;
replay_buffer *replay = &player->replay;
snprintf( buffer, 128, "-%.2fs\n", len );
ui_text( bar, buffer, 1, k_ui_align_middle_left, 0 );
ui_text( bar, "0s", 1, k_ui_align_middle_right, 0 );
+#endif
}
#endif /* PLAYER_REPLAY_C */
static struct player_avatar localplayer_avatar;
-int main( int argc, char *argv[] )
-{
+int main( int argc, char *argv[] ){
vg_mem.use_libc_malloc = 0;
vg_set_mem_quota( 160*1024*1024 );
vg_enter( argc, argv, "Voyager Game Engine" );
return 0;
}
-VG_STATIC void vg_launch_opt(void)
-{
-}
+VG_STATIC void vg_launch_opt(void){}
-VG_STATIC void vg_preload(void)
-{
+VG_STATIC void vg_preload(void){
skaterift_read_savedata();
vg_info(" Copyright . . . -----, ,----- ,---. .---. \n" );
vg_loader_step( network_init, network_end );
}
-VG_STATIC void load_playermodels(void)
-{
+VG_STATIC void load_playermodels(void){
/* FIXME: hack */
shader_model_character_view_register();
shader_model_board_view_register();
}
}
-VG_STATIC void vg_load(void)
-{
+VG_STATIC void vg_load(void){
vg_console_reg_cmd( "changeworld", skaterift_change_world_command, NULL );
vg_loader_step( render_init, NULL );
vg_loader_step( load_playermodels, NULL );
/* player setup */
- local_replay_init( (1024*1024*1)/2 );
+ u32 bytes = (1024*1024*1)/2;
+ skaterift.replay.data = vg_linear_alloc( vg_mem.rtmemory, bytes );
+ skaterift.replay.size = bytes;
+ replay_clear( &skaterift.replay );
+
player__create( &localplayer );
player_avatar_load( &localplayer_avatar, "models/ch_none.mdl" );
player__use_avatar( &localplayer, &localplayer_avatar );
vg_async_call( async_call_ready, NULL, 0 );
}
-VG_STATIC void draw_origin_axis(void)
-{
+VG_STATIC void draw_origin_axis(void){
vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 1.0f, 0.0f, 0.0f }, 0xffff0000 );
vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 1.0f, 0.0f }, 0xff00ff00 );
vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 0.0f, 1.0f }, 0xff0000ff );
}
-
static void skaterift_change_world_preupdate(void);
-VG_STATIC void vg_update(void)
-{
+
+/*
+ * UPDATE LOOP
+ * ---------------------------------------------------------------------------*/
+
+VG_STATIC void vg_pre_update(void){
+ srinput.enabled = 1;
+
steam_update();
skaterift_preupdate_inputs();
if( skaterift.op == k_async_op_clientloading ) return;
-
- if( world_loader.state == k_world_loader_preload ){
+ if( world_loader.state == k_world_loader_preload )
skaterift_change_world_preupdate();
- }
draw_origin_axis();
network_update();
+
+ /* time rate */
+ f32 target = 1;
+ if( skaterift.activity & (k_skaterift_replay|k_skaterift_menu) )
+ target = 0;
+
+ vg_slewf( &skaterift.time_rate, target, vg.time_frame_delta * 6.0f );
+ vg.time_rate = vg_smoothstepf( skaterift.time_rate );
+
+ if( button_down( k_srbind_reset ) ){
+ if( skaterift.activity == k_skaterift_default ){
+ skaterift.activity = k_skaterift_replay;
+ }
+ }
player__pre_update( &localplayer );
global_skateshop_preupdate();
world_update( world_current_instance(), localplayer.rb.co );
audio_ambient_sprites_update( world_current_instance(), localplayer.rb.co );
- //gui_helper_action( localplayer.input_use, "\x7f Hello \x1f""A \x1e\x84" );
}
-VG_STATIC void vg_update_fixed(void)
-{
+VG_STATIC void vg_fixed_update(void){
if( skaterift.op == k_async_op_clientloading ) return;
world_routes_fixedupdate( world_current_instance() );
vehicle_update_fixed();
}
-VG_STATIC void vg_update_post(void){
+VG_STATIC void vg_post_update(void){
if( skaterift.op == k_async_op_clientloading ) return;
player__post_update( &localplayer );
vg_dsp.echo_distances[sample_index] = dist;
v3f ears = { 1.0f,0.0f,0.0f };
- m3x3_mulv( main_camera.transform, ears, ears );
+ m3x3_mulv( skaterift.cam.transform, ears, ears );
v3_copy( ears, vg_audio.external_listener_ears );
- v3_copy( main_camera.transform[3], vg_audio.external_listener_pos );
+ v3_copy( skaterift.cam.transform[3], vg_audio.external_listener_pos );
if( localplayer.gate_waiting ){
m4x3_mulv( localplayer.gate_waiting->transport,
v3_copy( localplayer.rb.v, vg_audio.external_lister_velocity );
audio_unlock();
- int replay_open = localplayer.replay.control != k_replay_control_none?1:0;
-
- f32 target = (1-(menu.active||replay_open));
- vg_slewf( &skaterift.time_rate, target, vg.time_frame_delta * 6.0f );
-
- vg.time_rate = skaterift.time_rate;
vehicle_update_post();
}
-VG_STATIC void vg_framebuffer_resize( int w, int h )
-{
+/*
+ * RENDERING
+ * ---------------------------------------------------------------------------*/
+
+VG_STATIC void vg_framebuffer_resize( int w, int h ){
render_fb_resize();
}
-VG_STATIC void present_view_with_post_processing(void)
-{
+VG_STATIC void present_view_with_post_processing(void){
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
glViewport( 0,0, vg.window_x, vg.window_y );
shader_blitblur_uInverseRatio( inverse );
v2f override;
- if( menu.active )
+ if( skaterift.activity == k_skaterift_menu )
v2_muls( (v2f){ 0.04f, 0.001f }, 1.0f-skaterift.time_rate, override );
else
v2_zero( override );
render_fsquad();
}
-VG_STATIC void render_player_transparent(void)
-{
+VG_STATIC void render_player_transparent(void){
static camera small_cam; /* DOES NOT NEED TO BE STATIC BUT MINGW
SAIS OTHERWISE */
- m4x3_copy( main_camera.transform, small_cam.transform );
+ m4x3_copy( skaterift.cam.transform, small_cam.transform );
- small_cam.fov = main_camera.fov;
+ small_cam.fov = skaterift.cam.fov;
small_cam.nearz = 0.05f;
small_cam.farz = 60.0f;
player__render( &small_cam, &localplayer );
}
-VG_STATIC void render_scene(void)
-{
+VG_STATIC void render_scene(void){
render_fb_bind( gpipeline.fb_main, 1 );
glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT );
}
}
- render_world( view_world, &main_camera, 0 );
+ render_world( view_world, &skaterift.cam, 0 );
- render_water_texture( view_world, &main_camera, 0 );
+ render_water_texture( view_world, &skaterift.cam, 0 );
render_fb_bind( gpipeline.fb_main, 1 );
- render_water_surface( view_world, &main_camera );
+ render_water_surface( view_world, &skaterift.cam );
}
-VG_STATIC void render_scene_gate_subview(void)
-{
+VG_STATIC void render_scene_gate_subview(void){
render_fb_bind( gpipeline.fb_main, 1 );
world_instance *view_world = localplayer.viewable_world;
if( !view_world ) return; /* ??? */
int depth = 1;
if( localplayer.gate_waiting ) depth = 0;
- render_world_gates( view_world, &main_camera, depth );
+ render_world_gates( view_world, &skaterift.cam, depth );
}
-VG_STATIC void render_main_game(void)
-{
- player__pre_render( &localplayer );
- main_camera.fov = localplayer.cam.fov;
- v3_copy( localplayer.cam.pos, main_camera.pos );
- v3_copy( localplayer.cam.angles, main_camera.angles );
+VG_STATIC void skaterift_composite_maincamera(void){
+ camera_lerp( &localplayer.cam, &global_skateshop.cam,
+ vg_smoothstepf(global_skateshop.factive), &skaterift.cam );
- main_camera.nearz = 0.1f;
- main_camera.farz = 2100.0f;
+ skaterift.cam.nearz = 0.1f;
+ skaterift.cam.farz = 2100.0f;
- camera_update_transform( &main_camera );
+ camera_update_transform( &skaterift.cam );
if( localplayer.gate_waiting ){
- m3x3_mul( localplayer.basis_gate, main_camera.transform,
- main_camera.transform );
+ m3x3_mul( localplayer.basis_gate, skaterift.cam.transform,
+ skaterift.cam.transform );
}
else{
- m3x3_mul( localplayer.basis, main_camera.transform,
- main_camera.transform );
+ m3x3_mul( localplayer.basis, skaterift.cam.transform,
+ skaterift.cam.transform );
}
- camera_update_view( &main_camera );
- camera_update_projection( &main_camera );
- camera_finalize( &main_camera );
+ camera_update_view( &skaterift.cam );
+ camera_update_projection( &skaterift.cam );
+ camera_finalize( &skaterift.cam );
+}
- /* ========== Begin Frame ========== */
+VG_STATIC void render_main_game(void){
+ player__pre_render( &localplayer );
+ skaterift_composite_maincamera();
render_scene();
render_scene_gate_subview();
present_view_with_post_processing();
- /* =========== End Frame =========== */
}
-VG_STATIC void vg_render(void)
-{
+VG_STATIC void vg_render(void){
if( skaterift.op == k_async_op_clientloading ){
_vg_loader_render();
return;
glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
render_main_game();
-
- m4x4_copy( main_camera.mtx.pv, vg.pv );
+ m4x4_copy( skaterift.cam.mtx.pv, vg.pv );
/* Other shite */
glDisable(GL_BLEND);
gui_draw();
}
-VG_STATIC void vg_gui(void)
-{
+VG_STATIC void vg_gui(void){
if( skaterift.op == k_async_op_clientloading ) return;
menu_update();
- if( menu.active ){
+ if( skaterift.activity == k_skaterift_menu ){
glClear( GL_DEPTH_BUFFER_BIT );
menu_render();
}
op;
f32 time_rate;
+ camera cam;
+ replay_buffer replay;
+
+ enum skaterift_activity {
+ k_skaterift_default = 0x00,
+ k_skaterift_replay = 0x01,
+ k_skaterift_skateshop = 0x02,
+ k_skaterift_menu = 0x04
+ }
+ activity;
}
static skaterift = { .op = k_async_op_clientloading, .time_rate = 1.0f };
#include "vehicle.h"
-VG_STATIC int spawn_car( int argc, const char *argv[] )
-{
+VG_STATIC int spawn_car( int argc, const char *argv[] ){
v3f ra, rb, rx;
- v3_copy( main_camera.pos, ra );
- v3_muladds( ra, main_camera.transform[2], -10.0f, rb );
+ v3_copy( skaterift.cam.pos, ra );
+ v3_muladds( ra, skaterift.cam.transform[2], -10.0f, rb );
float t;
if( spherecast_world( world_current_instance(), ra, rb,
glEnable( GL_DEPTH_TEST );
glDisable( GL_BLEND );
- render_world( localplayer.viewable_world, &main_camera, 1 );
+ render_world( localplayer.viewable_world, &skaterift.cam, 1 );
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
glViewport( 0,0, vg.window_x, vg.window_y );
}
/* update gate camera */
- gate_camera.fov = cam->fov;
- gate_camera.nearz = 0.1f;
- gate_camera.farz = 2000.0f;
+ world_gates.cam.fov = cam->fov;
+ world_gates.cam.nearz = 0.1f;
+ world_gates.cam.farz = 2000.0f;
- m4x3_mul( gate->transport, cam->transform, gate_camera.transform );
- camera_update_view( &gate_camera );
- camera_update_projection( &gate_camera );
+ m4x3_mul( gate->transport, cam->transform, world_gates.cam.transform );
+ camera_update_view( &world_gates.cam );
+ camera_update_projection( &world_gates.cam );
/* Add special clipping plane to projection */
v4f surface;
q_mulv( gate->q[1], (v3f){0.0f,0.0f,-1.0f}, surface );
surface[3] = v3_dot( surface, gate->co[1] );
- m4x3_mulp( gate_camera.transform_inverse, surface, surface );
+ m4x3_mulp( world_gates.cam.transform_inverse, surface, surface );
surface[3] = -fabsf(surface[3]);
if( dist < -0.5f )
- m4x4_clip_projection( gate_camera.mtx.p, surface );
+ m4x4_clip_projection( world_gates.cam.mtx.p, surface );
/* Ready to draw with new camrea */
- camera_finalize( &gate_camera );
+ camera_finalize( &world_gates.cam );
- vg_line_point( gate_camera.transform[3], 0.3f, 0xff00ff00 );
+ vg_line_point( world_gates.cam.transform[3], 0.3f, 0xff00ff00 );
{
shader_model_gate_use();
shader_model_gate_uPv( cam->mtx.pv );
glStencilMask( 0x00 );
}
- render_world( world_inside, &gate_camera, layer_depth );
+ render_world( world_inside, &world_gates.cam, layer_depth );
{
glDisable( GL_STENCIL_TEST );
- render_water_texture( world_inside, &gate_camera, layer_depth );
+ render_water_texture( world_inside, &world_gates.cam, layer_depth );
render_fb_bind( gpipeline.fb_main, 1 );
glEnable( GL_STENCIL_TEST );
- render_water_surface( world_inside, &gate_camera );
+ render_water_surface( world_inside, &world_gates.cam );
glStencilMask( 0xFF );
glStencilFunc( GL_ALWAYS, 1, 0xFF );
#ifndef WORLD_GATE_H
#define WORLD_GATE_H
+#include "camera.h"
#include "world.h"
#include "shaders/model_gate.h"
struct world_gates{
glmesh mesh;
mdl_submesh sm_surface, sm_marker[4];
+ camera cam;
}
static world_gates;
projects / carveJwlIkooP6JGAAIwe30JlM.git / commitdiff