mirror of
https://github.com/FWGS/xash3d-fwgs
synced 2024-12-01 14:40:28 +01:00
401 lines
9.5 KiB
C
401 lines
9.5 KiB
C
/*
|
|
cl_view.c - player rendering positioning
|
|
Copyright (C) 2009 Uncle Mike
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
*/
|
|
|
|
#include "common.h"
|
|
#include "client.h"
|
|
#include "const.h"
|
|
#include "entity_types.h"
|
|
#include "vgui_draw.h"
|
|
#include "sound.h"
|
|
#include "platform/platform.h" // GL_UpdateSwapInterval
|
|
|
|
/*
|
|
===============
|
|
V_CalcViewRect
|
|
|
|
calc frame rectangle (Quake1 style)
|
|
===============
|
|
*/
|
|
void V_CalcViewRect( void )
|
|
{
|
|
qboolean full = false;
|
|
int sb_lines;
|
|
float size;
|
|
|
|
// intermission is always full screen
|
|
if( cl.intermission ) size = 120.0f;
|
|
else size = scr_viewsize->value;
|
|
|
|
if( size >= 120.0f )
|
|
sb_lines = 0; // no status bar at all
|
|
else if( size >= 110.0f )
|
|
sb_lines = 24; // no inventory
|
|
else sb_lines = 48;
|
|
|
|
if( scr_viewsize->value >= 100.0 )
|
|
{
|
|
full = true;
|
|
size = 100.0f;
|
|
}
|
|
else size = scr_viewsize->value;
|
|
|
|
if( cl.intermission )
|
|
{
|
|
size = 100.0f;
|
|
sb_lines = 0;
|
|
full = true;
|
|
}
|
|
size /= 100.0;
|
|
|
|
clgame.viewport[2] = refState.width * size;
|
|
clgame.viewport[3] = refState.height * size;
|
|
|
|
if( clgame.viewport[3] > refState.height - sb_lines )
|
|
clgame.viewport[3] = refState.height - sb_lines;
|
|
if( clgame.viewport[3] > refState.height )
|
|
clgame.viewport[3] = refState.height;
|
|
|
|
clgame.viewport[0] = ( refState.width - clgame.viewport[2] ) / 2;
|
|
if( full ) clgame.viewport[1] = 0;
|
|
else clgame.viewport[1] = ( refState.height - sb_lines - clgame.viewport[3] ) / 2;
|
|
|
|
}
|
|
|
|
/*
|
|
===============
|
|
V_SetupViewModel
|
|
===============
|
|
*/
|
|
void V_SetupViewModel( void )
|
|
{
|
|
cl_entity_t *view = &clgame.viewent;
|
|
player_info_t *info = &cl.players[cl.playernum];
|
|
|
|
if( !cl.local.weaponstarttime )
|
|
cl.local.weaponstarttime = cl.time;
|
|
|
|
// setup the viewent variables
|
|
view->curstate.colormap = (info->topcolor & 0xFFFF)|((info->bottomcolor << 8) & 0xFFFF);
|
|
view->curstate.number = cl.playernum + 1;
|
|
view->index = cl.playernum + 1;
|
|
view->model = CL_ModelHandle( cl.local.viewmodel );
|
|
view->curstate.modelindex = cl.local.viewmodel;
|
|
view->curstate.sequence = cl.local.weaponsequence;
|
|
view->curstate.rendermode = kRenderNormal;
|
|
|
|
// alias models has another animation methods
|
|
if( view->model && view->model->type == mod_studio )
|
|
{
|
|
view->curstate.animtime = cl.local.weaponstarttime;
|
|
view->curstate.frame = 0.0f;
|
|
}
|
|
}
|
|
|
|
/*
|
|
===============
|
|
V_SetRefParams
|
|
===============
|
|
*/
|
|
void V_SetRefParams( ref_params_t *fd )
|
|
{
|
|
memset( fd, 0, sizeof( ref_params_t ));
|
|
|
|
// probably this is not needs
|
|
VectorCopy( refState.vieworg, fd->vieworg );
|
|
VectorCopy( refState.viewangles, fd->viewangles );
|
|
|
|
fd->frametime = host.frametime;
|
|
fd->time = cl.time;
|
|
|
|
fd->intermission = cl.intermission;
|
|
fd->paused = (cl.paused != 0);
|
|
fd->spectator = (cls.spectator != 0);
|
|
fd->onground = (cl.local.onground != -1);
|
|
fd->waterlevel = cl.local.waterlevel;
|
|
|
|
VectorCopy( cl.simvel, fd->simvel );
|
|
VectorCopy( cl.simorg, fd->simorg );
|
|
|
|
VectorCopy( cl.viewheight, fd->viewheight );
|
|
fd->idealpitch = cl.local.idealpitch;
|
|
|
|
VectorCopy( cl.viewangles, fd->cl_viewangles );
|
|
fd->health = cl.local.health;
|
|
VectorCopy( cl.crosshairangle, fd->crosshairangle );
|
|
fd->viewsize = scr_viewsize->value;
|
|
|
|
VectorCopy( cl.punchangle, fd->punchangle );
|
|
fd->maxclients = cl.maxclients;
|
|
fd->viewentity = cl.viewentity;
|
|
fd->playernum = cl.playernum;
|
|
fd->max_entities = clgame.maxEntities;
|
|
fd->demoplayback = cls.demoplayback;
|
|
fd->hardware = 1; // OpenGL
|
|
|
|
if( cl.first_frame || cl.skip_interp )
|
|
{
|
|
cl.first_frame = false; // now can be unlocked
|
|
fd->smoothing = true; // NOTE: currently this used to prevent ugly un-duck effect while level is changed
|
|
}
|
|
else fd->smoothing = cl.local.pushmsec; // enable smoothing in multiplayer by server request (AMX uses)
|
|
|
|
// get pointers to movement vars and user cmd
|
|
fd->movevars = &clgame.movevars;
|
|
fd->cmd = cl.cmd;
|
|
|
|
// setup viewport
|
|
fd->viewport[0] = clgame.viewport[0];
|
|
fd->viewport[1] = clgame.viewport[1];
|
|
fd->viewport[2] = clgame.viewport[2];
|
|
fd->viewport[3] = clgame.viewport[3];
|
|
|
|
fd->onlyClientDraw = 0; // reset clientdraw
|
|
fd->nextView = 0; // reset nextview
|
|
}
|
|
|
|
/*
|
|
===============
|
|
V_MergeOverviewRefdef
|
|
|
|
merge refdef with overview settings
|
|
===============
|
|
*/
|
|
void V_RefApplyOverview( ref_viewpass_t *rvp )
|
|
{
|
|
ref_overview_t *ov = &clgame.overView;
|
|
float aspect;
|
|
float size_x, size_y;
|
|
vec2_t mins, maxs;
|
|
|
|
if( !CL_IsDevOverviewMode( ))
|
|
return;
|
|
|
|
// NOTE: Xash3D may use 16:9 or 16:10 aspects
|
|
aspect = (float)refState.width / (float)refState.height;
|
|
|
|
size_x = fabs( 8192.0f / ov->flZoom );
|
|
size_y = fabs( 8192.0f / (ov->flZoom * aspect ));
|
|
|
|
// compute rectangle
|
|
ov->xLeft = -(size_x / 2);
|
|
ov->xRight = (size_x / 2);
|
|
ov->yTop = -(size_y / 2);
|
|
ov->yBottom = (size_y / 2);
|
|
|
|
if( CL_IsDevOverviewMode() == 1 )
|
|
{
|
|
Con_NPrintf( 0, " Overview: Zoom %.2f, Map Origin (%.2f, %.2f, %.2f), Z Min %.2f, Z Max %.2f, Rotated %i\n",
|
|
ov->flZoom, ov->origin[0], ov->origin[1], ov->origin[2], ov->zNear, ov->zFar, ov->rotated );
|
|
}
|
|
|
|
VectorCopy( ov->origin, rvp->vieworigin );
|
|
rvp->vieworigin[2] = ov->zFar + ov->zNear;
|
|
Vector2Copy( rvp->vieworigin, mins );
|
|
Vector2Copy( rvp->vieworigin, maxs );
|
|
|
|
mins[!ov->rotated] += ov->xLeft;
|
|
maxs[!ov->rotated] += ov->xRight;
|
|
mins[ov->rotated] += ov->yTop;
|
|
maxs[ov->rotated] += ov->yBottom;
|
|
|
|
rvp->viewangles[0] = 90.0f;
|
|
rvp->viewangles[1] = 90.0f;
|
|
rvp->viewangles[2] = (ov->rotated) ? (ov->flZoom < 0.0f) ? 180.0f : 0.0f : (ov->flZoom < 0.0f) ? -90.0f : 90.0f;
|
|
|
|
SetBits( rvp->flags, RF_DRAW_OVERVIEW );
|
|
|
|
ref.dllFuncs.GL_OrthoBounds( mins, maxs );
|
|
}
|
|
|
|
/*
|
|
=============
|
|
V_GetRefParams
|
|
=============
|
|
*/
|
|
void V_GetRefParams( ref_params_t *fd, ref_viewpass_t *rvp )
|
|
{
|
|
// part1: deniable updates
|
|
VectorCopy( fd->simvel, cl.simvel );
|
|
VectorCopy( fd->simorg, cl.simorg );
|
|
VectorCopy( fd->punchangle, cl.punchangle );
|
|
VectorCopy( fd->viewheight, cl.viewheight );
|
|
|
|
// part2: really used updates
|
|
VectorCopy( fd->crosshairangle, cl.crosshairangle );
|
|
VectorCopy( fd->cl_viewangles, cl.viewangles );
|
|
|
|
// setup ref_viewpass
|
|
rvp->viewport[0] = fd->viewport[0];
|
|
rvp->viewport[1] = fd->viewport[1];
|
|
rvp->viewport[2] = fd->viewport[2];
|
|
rvp->viewport[3] = fd->viewport[3];
|
|
|
|
VectorCopy( fd->vieworg, rvp->vieworigin );
|
|
VectorCopy( fd->viewangles, rvp->viewangles );
|
|
|
|
rvp->viewentity = fd->viewentity;
|
|
|
|
// calc FOV
|
|
rvp->fov_x = bound( 10.0f, cl.local.scr_fov, 150.0f ); // this is a final fov value
|
|
|
|
// first we need to compute FOV and other things that needs for frustum properly work
|
|
rvp->fov_y = V_CalcFov( &rvp->fov_x, clgame.viewport[2], clgame.viewport[3] );
|
|
|
|
// adjust FOV for widescreen
|
|
if( refState.wideScreen && r_adjust_fov->value )
|
|
V_AdjustFov( &rvp->fov_x, &rvp->fov_y, clgame.viewport[2], clgame.viewport[3], false );
|
|
|
|
rvp->flags = 0;
|
|
|
|
if( fd->onlyClientDraw )
|
|
SetBits( rvp->flags, RF_ONLY_CLIENTDRAW );
|
|
SetBits( rvp->flags, RF_DRAW_WORLD );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
V_PreRender
|
|
|
|
==================
|
|
*/
|
|
qboolean V_PreRender( void )
|
|
{
|
|
// too early
|
|
if( !ref.initialized )
|
|
return false;
|
|
|
|
if( host.status == HOST_NOFOCUS )
|
|
return false;
|
|
|
|
if( host.status == HOST_SLEEP )
|
|
return false;
|
|
|
|
// if the screen is disabled (loading plaque is up)
|
|
if( cls.disable_screen )
|
|
{
|
|
if(( host.realtime - cls.disable_screen ) > cl_timeout->value )
|
|
{
|
|
Con_Reportf( "V_PreRender: loading plaque timed out\n" );
|
|
cls.disable_screen = 0.0f;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
ref.dllFuncs.R_BeginFrame( !cl.paused );
|
|
|
|
GL_UpdateSwapInterval( );
|
|
|
|
return true;
|
|
}
|
|
|
|
//============================================================================
|
|
|
|
/*
|
|
==================
|
|
V_RenderView
|
|
|
|
==================
|
|
*/
|
|
void V_RenderView( void )
|
|
{
|
|
ref_params_t rp;
|
|
ref_viewpass_t rvp;
|
|
int viewnum = 0;
|
|
|
|
if( !cl.video_prepped || ( UI_IsVisible() && !cl.background ))
|
|
return; // still loading
|
|
|
|
V_CalcViewRect (); // compute viewport rectangle
|
|
V_SetRefParams( &rp );
|
|
V_SetupViewModel ();
|
|
ref.dllFuncs.R_Set2DMode( false );
|
|
SCR_DirtyScreen();
|
|
ref.dllFuncs.GL_BackendStartFrame ();
|
|
|
|
do
|
|
{
|
|
clgame.dllFuncs.pfnCalcRefdef( &rp );
|
|
V_GetRefParams( &rp, &rvp );
|
|
V_RefApplyOverview( &rvp );
|
|
|
|
if( viewnum == 0 && FBitSet( rvp.flags, RF_ONLY_CLIENTDRAW ))
|
|
{
|
|
ref.dllFuncs.R_ClearScreen();
|
|
}
|
|
|
|
GL_RenderFrame( &rvp );
|
|
S_UpdateFrame( &rvp );
|
|
viewnum++;
|
|
|
|
} while( rp.nextView );
|
|
|
|
// draw debug triangles on a server
|
|
SV_DrawDebugTriangles ();
|
|
ref.dllFuncs.GL_BackendEndFrame ();
|
|
}
|
|
|
|
/*
|
|
==================
|
|
V_PostRender
|
|
|
|
==================
|
|
*/
|
|
void V_PostRender( void )
|
|
{
|
|
static double oldtime;
|
|
qboolean draw_2d = false;
|
|
|
|
ref.dllFuncs.R_AllowFog( false );
|
|
ref.dllFuncs.R_Set2DMode( true );
|
|
|
|
if( cls.state == ca_active && cls.signon == SIGNONS && cls.scrshot_action != scrshot_mapshot )
|
|
{
|
|
SCR_TileClear();
|
|
CL_DrawHUD( CL_ACTIVE );
|
|
VGui_Paint();
|
|
}
|
|
|
|
switch( cls.scrshot_action )
|
|
{
|
|
case scrshot_inactive:
|
|
case scrshot_normal:
|
|
case scrshot_snapshot:
|
|
draw_2d = true;
|
|
break;
|
|
}
|
|
|
|
if( draw_2d )
|
|
{
|
|
SCR_RSpeeds();
|
|
SCR_NetSpeeds();
|
|
SCR_DrawNetGraph();
|
|
SV_DrawOrthoTriangles();
|
|
CL_DrawDemoRecording();
|
|
CL_DrawHUD( CL_CHANGELEVEL );
|
|
ref.dllFuncs.R_ShowTextures();
|
|
ref.dllFuncs.R_ShowTree();
|
|
Con_DrawConsole();
|
|
UI_UpdateMenu( host.realtime );
|
|
Con_DrawVersion();
|
|
Con_DrawDebug(); // must be last
|
|
|
|
S_ExtraUpdate();
|
|
}
|
|
|
|
SCR_MakeScreenShot();
|
|
ref.dllFuncs.R_AllowFog( true );
|
|
ref.dllFuncs.R_EndFrame();
|
|
}
|