void RB_RenderWorldEffects(void)
{
float elapseTime = backEnd.refdef.frametime / 1000.0;
if (tr.refdef.rdflags & RDF_NOWORLDMODEL || !tr.world || CL_IsRunningInGameCinematic())
{ // no world rendering or no world
return;
}
SetViewportAndScissor();
qglMatrixMode(GL_MODELVIEW);
// qglPushMatrix();
qglLoadMatrixf( backEnd.viewParms.world.modelMatrix );
originContents = ri.CM_PointContents(backEnd.viewParms.or.origin, 0);
if (rainSystem)
{
rainSystem->Update(elapseTime);
rainSystem->Render();
}
if (snowSystem)
{
snowSystem->Update(elapseTime);
snowSystem->Render();
}
// qglMatrixMode(GL_MODELVIEW);
// qglPopMatrix();
}
/*
==================
SCR_DrawScreenField
This will be called twice if rendering in stereo mode
==================
*/
void SCR_DrawScreenField( stereoFrame_t stereoFrame ) {
re.BeginFrame( stereoFrame );
qboolean uiFullscreen = _UI_IsFullscreen();
// if the menu is going to cover the entire screen, we
// don't need to render anything under it
if ( !uiFullscreen ) {
switch( cls.state ) {
default:
Com_Error( ERR_FATAL, "SCR_DrawScreenField: bad cls.state" );
break;
case CA_CINEMATIC:
SCR_DrawCinematic();
break;
case CA_DISCONNECTED:
// force menu up
UI_SetActiveMenu( "mainMenu", NULL );
break;
case CA_CONNECTING:
case CA_CHALLENGING:
case CA_CONNECTED:
// connecting clients will only show the connection dialog
UI_DrawConnect( clc.servername, cls.updateInfoString );
break;
case CA_LOADING:
case CA_PRIMED:
// draw the game information screen and loading progress
CL_CGameRendering( stereoFrame );
break;
case CA_ACTIVE:
if (CL_IsRunningInGameCinematic() || CL_InGameCinematicOnStandBy())
{
SCR_DrawCinematic();
}
else
{
CL_CGameRendering( stereoFrame );
}
break;
}
}
re.ProcessDissolve();
// draw downloading progress bar
// the menu draws next
_UI_Refresh( cls.realtime );
// console draws next
Con_DrawConsole ();
// debug graph can be drawn on top of anything
if ( cl_debuggraph->integer || cl_timegraph->integer ) {
SCR_DrawDebugGraph ();
}
}
/*
=================
CL_CheckForResend
Resend a connect message if the last one has timed out
=================
*/
void CL_CheckForResend( void ) {
int port;
char info[MAX_INFO_STRING];
// if ( cls.state == CA_CINEMATIC )
if ( cls.state == CA_CINEMATIC || CL_IsRunningInGameCinematic())
{
return;
}
// resend if we haven't gotten a reply yet
if ( cls.state < CA_CONNECTING || cls.state > CA_CHALLENGING ) {
return;
}
if ( cls.realtime - clc.connectTime < RETRANSMIT_TIMEOUT ) {
return;
}
clc.connectTime = cls.realtime; // for retransmit requests
clc.connectPacketCount++;
// requesting a challenge
switch ( cls.state ) {
case CA_CONNECTING:
UI_UpdateConnectionString( va("(%i)", clc.connectPacketCount ) );
NET_OutOfBandPrint(NS_CLIENT, clc.serverAddress, "getchallenge");
break;
case CA_CHALLENGING:
// sending back the challenge
port = Cvar_VariableIntegerValue("qport");
UI_UpdateConnectionString( va("(%i)", clc.connectPacketCount ) );
Q_strncpyz( info, Cvar_InfoString( CVAR_USERINFO ), sizeof( info ) );
Info_SetValueForKey( info, "protocol", va("%i", PROTOCOL_VERSION ) );
Info_SetValueForKey( info, "qport", va("%i", port ) );
Info_SetValueForKey( info, "challenge", va("%i", clc.challenge ) );
NET_OutOfBandPrint( NS_CLIENT, clc.serverAddress, "connect \"%s\"", info );
// the most current userinfo has been sent, so watch for any
// newer changes to userinfo variables
cvar_modifiedFlags &= ~CVAR_USERINFO;
break;
default:
Com_Error( ERR_FATAL, "CL_CheckForResend: bad cls.state" );
}
}
/*
==================
CL_CheckTimeout
==================
*/
void CL_CheckTimeout( void ) {
//
// check timeout
//
if ( ( !cl_paused->integer || !sv_paused->integer )
// && cls.state >= CA_CONNECTED && cls.state != CA_CINEMATIC
&& cls.state >= CA_CONNECTED && (cls.state != CA_CINEMATIC && !CL_IsRunningInGameCinematic())
&& cls.realtime - clc.lastPacketTime > cl_timeout->value*1000) {
if (++cl.timeoutcount > 5) { // timeoutcount saves debugger
Com_Printf ("\nServer connection timed out.\n");
CL_Disconnect ();
return;
}
} else {
cl.timeoutcount = 0;
}
}
/*
=================
CL_ReadyToSendPacket
Returns qfalse if we are over the maxpackets limit
and should choke back the bandwidth a bit by not sending
a packet this frame. All the commands will still get
delivered in the next packet, but saving a header and
getting more delta compression will reduce total bandwidth.
=================
*/
qboolean CL_ReadyToSendPacket( void ) {
// don't send anything if playing back a demo
// if ( cls.state == CA_CINEMATIC )
if ( cls.state == CA_CINEMATIC || CL_IsRunningInGameCinematic())
{
return qfalse;
}
// if we don't have a valid gamestate yet, only send
// one packet a second
if ( cls.state != CA_ACTIVE && cls.state != CA_PRIMED
&& cls.realtime - clc.lastPacketSentTime < 1000 ) {
return qfalse;
}
// send every frame for loopbacks
return qtrue;
}
/*
===================
CL_WritePacket
Create and send the command packet to the server
Including both the reliable commands and the usercmds
During normal gameplay, a client packet will contain something like:
4 sequence number
2 qport
4 serverid
4 acknowledged sequence number
4 clc.serverCommandSequence
<optional reliable commands>
1 clc_move or clc_moveNoDelta
1 command count
<count * usercmds>
===================
*/
void CL_WritePacket( void ) {
msg_t buf;
byte data[MAX_MSGLEN];
int i, j;
usercmd_t *cmd, *oldcmd;
usercmd_t nullcmd;
int packetNum;
int oldPacketNum;
int count;
// don't send anything if playing back a demo
// if ( cls.state == CA_CINEMATIC )
if ( cls.state == CA_CINEMATIC || CL_IsRunningInGameCinematic())
{
return;
}
MSG_Init( &buf, data, sizeof(data) );
// write any unacknowledged clientCommands
for ( i = clc.reliableAcknowledge + 1 ; i <= clc.reliableSequence ; i++ ) {
MSG_WriteByte( &buf, clc_clientCommand );
MSG_WriteLong( &buf, i );
MSG_WriteString( &buf, clc.reliableCommands[ i & (MAX_RELIABLE_COMMANDS-1) ] );
}
// we want to send all the usercmds that were generated in the last
// few packet, so even if a couple packets are dropped in a row,
// all the cmds will make it to the server
if ( cl_packetdup->integer < 0 ) {
Cvar_Set( "cl_packetdup", "0" );
} else if ( cl_packetdup->integer > 5 ) {
Cvar_Set( "cl_packetdup", "5" );
}
oldPacketNum = (clc.netchan.outgoingSequence - 1 - cl_packetdup->integer) & PACKET_MASK;
count = cl.cmdNumber - cl.packetCmdNumber[ oldPacketNum ];
if ( count > MAX_PACKET_USERCMDS ) {
count = MAX_PACKET_USERCMDS;
Com_Printf("MAX_PACKET_USERCMDS\n");
}
if ( count >= 1 ) {
// begin a client move command
MSG_WriteByte (&buf, clc_move);
// write the last reliable message we received
MSG_WriteLong( &buf, clc.serverCommandSequence );
// write the current serverId so the server
// can tell if this is from the current gameState
MSG_WriteLong (&buf, cl.serverId);
// write the current time
MSG_WriteLong (&buf, cls.realtime);
// let the server know what the last messagenum we
// got was, so the next message can be delta compressed
// FIXME: this could just be a bit flag, with the message implicit
// from the unreliable ack of the netchan
if (cl_nodelta->integer || !cl.frame.valid) {
MSG_WriteLong (&buf, -1); // no compression
} else {
MSG_WriteLong (&buf, cl.frame.messageNum);
}
// write the cmdNumber so the server can determine which ones it
// has already received
MSG_WriteLong( &buf, cl.cmdNumber );
// write the command count
MSG_WriteByte( &buf, count );
// write all the commands, including the predicted command
memset( &nullcmd, 0, sizeof(nullcmd) );
oldcmd = &nullcmd;
for ( i = 0 ; i < count ; i++ ) {
j = (cl.cmdNumber - count + i + 1) & CMD_MASK;
cmd = &cl.cmds[j];
MSG_WriteDeltaUsercmd (&buf, oldcmd, cmd);
oldcmd = cmd;
}
}
//
// deliver the message
//
packetNum = clc.netchan.outgoingSequence & PACKET_MASK;
cl.packetTime[ packetNum ] = cls.realtime;
cl.packetCmdNumber[ packetNum ] = cl.cmdNumber;
clc.lastPacketSentTime = cls.realtime;
Netchan_Transmit (&clc.netchan, buf.cursize, buf.data);
}
/*
============================
CL_StartHunkUsers
After the server has cleared the hunk, these will need to be restarted
This is the only place that any of these functions are called from
============================
*/
void CL_StartHunkUsers( void ) {
if ( !com_cl_running->integer ) {
return;
}
if ( !cls.rendererStarted ) {
#ifdef _XBOX
//if ((!com_sv_running->integer || com_errorEntered) && !vidRestartReloadMap)
//{
// // free up some memory
// extern void SV_ClearLastLevel(void);
// SV_ClearLastLevel();
//}
#endif
cls.rendererStarted = qtrue;
re.BeginRegistration( &cls.glconfig );
// load character sets
// cls.charSetShader = re.RegisterShaderNoMip( "gfx/2d/bigchars" );
cls.charSetShader = re.RegisterShaderNoMip( "gfx/2d/charsgrid_med" );
cls.whiteShader = re.RegisterShader( "white" );
cls.consoleShader = re.RegisterShader( "console" );
g_console_field_width = cls.glconfig.vidWidth / SMALLCHAR_WIDTH - 2;
kg.g_consoleField.widthInChars = g_console_field_width;
#ifndef _IMMERSION
//-------
// The latest Immersion Force Feedback system initializes here, not through
// win32 input system. Therefore, the window handle is valid :)
//-------
// now that the renderer has started up we know that the global hWnd is now valid,
// so we can now go ahead and (re)setup the input stuff that needs hWnds for DI...
// (especially Force feedback)...
//
static qboolean bOnceOnly = qfalse; // only do once, not every renderer re-start
if (!bOnceOnly)
{
bOnceOnly = qtrue;
extern void Sys_In_Restart_f( void );
Sys_In_Restart_f();
}
#ifdef _XBOX
if (vidRestartReloadMap)
{
int checksum;
CM_LoadMap(va("maps/%s.bsp", cl_mapname->string), qfalse, &checksum);
RE_LoadWorldMap(va("maps/%s.bsp", cl_mapname->string));
vidRestartReloadMap = qfalse;
}
#endif // _XBOX
#endif // _IMMERSION
}
if ( !cls.soundStarted ) {
cls.soundStarted = qtrue;
S_Init();
}
if ( !cls.soundRegistered ) {
cls.soundRegistered = qtrue;
S_BeginRegistration();
}
#ifdef _IMMERSION
if ( !cls.forceStarted ) {
cls.forceStarted = qtrue;
CL_InitFF();
}
#endif // _IMMERSION
#if !defined (_XBOX) //i guess xbox doesn't want the ui loaded all the time?
//we require the ui to be loaded here or else it crashes trying to access the ui on command line map loads
if ( !cls.uiStarted ) {
cls.uiStarted = qtrue;
CL_InitUI();
}
#endif
// if ( !cls.cgameStarted && cls.state > CA_CONNECTED && cls.state != CA_CINEMATIC ) {
if ( !cls.cgameStarted && cls.state > CA_CONNECTED && (cls.state != CA_CINEMATIC && !CL_IsRunningInGameCinematic()) )
{
cls.cgameStarted = qtrue;
CL_InitCGame();
}
}
/*
==================
SCR_DrawScreenField
This will be called twice if rendering in stereo mode
==================
*/
void SCR_DrawScreenField( stereoFrame_t stereoFrame ) {
re.BeginFrame( stereoFrame );
qboolean uiFullscreen = _UI_IsFullscreen();
// wide aspect ratio screens need to have the sides cleared
// unless they are displaying game renderings
if ( uiFullscreen || (cls.state != CA_ACTIVE && cls.state != CA_CINEMATIC) ) {
if ( cls.glconfig.vidWidth * 480 > cls.glconfig.vidHeight * 640 ) {
re.SetColor( g_color_table[0] );
re.DrawStretchPic( 0, 0, cls.glconfig.vidWidth, cls.glconfig.vidHeight, 0, 0, 0, 0, 0 );
re.SetColor( NULL );
}
}
// if the menu is going to cover the entire screen, we
// don't need to render anything under it
if ( !uiFullscreen ) {
switch( cls.state ) {
default:
Com_Error( ERR_FATAL, "SCR_DrawScreenField: bad cls.state" );
break;
case CA_CINEMATIC:
SCR_DrawCinematic();
break;
case CA_DISCONNECTED:
// force menu up
UI_SetActiveMenu( "mainMenu",NULL ); // VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_MAIN );
break;
case CA_CONNECTING:
case CA_CHALLENGING:
case CA_CONNECTED:
// connecting clients will only show the connection dialog
UI_DrawConnect( clc.servername, cls.updateInfoString );
break;
case CA_LOADING:
case CA_PRIMED:
// draw the game information screen and loading progress
CL_CGameRendering( stereoFrame );
// also draw the connection information, so it doesn't
// flash away too briefly on local or lan games
UI_DrawConnectText( clc.servername, cls.updateInfoString );
break;
case CA_ACTIVE:
if (CL_IsRunningInGameCinematic() || CL_InGameCinematicOnStandBy())
{
SCR_DrawCinematic();
}
else
{
CL_CGameRendering( stereoFrame );
}
break;
}
}
re.ProcessDissolve();
// draw downloading progress bar
// the menu draws next
_UI_Refresh( cls.realtime );
// console draws next
Con_DrawConsole ();
// debug graph can be drawn on top of anything
if ( cl_debuggraph->integer || cl_timegraph->integer ) {
SCR_DrawDebugGraph ();
}
}
/*
============================
CL_StartHunkUsers
After the server has cleared the hunk, these will need to be restarted
This is the only place that any of these functions are called from
============================
*/
void CL_StartHunkUsers( void ) {
if ( !com_cl_running->integer ) {
return;
}
if ( !cls.rendererStarted ) {
cls.rendererStarted = qtrue;
re.BeginRegistration( &cls.glconfig );
// load character sets
// cls.charSetShader = re.RegisterShaderNoMip( "gfx/2d/bigchars" );
cls.charSetShader = re.RegisterShaderNoMip( "gfx/2d/charsgrid_med" );
cls.whiteShader = re.RegisterShader( "white" );
cls.consoleShader = re.RegisterShader( "console" );
g_console_field_width = cls.glconfig.vidWidth / SMALLCHAR_WIDTH - 2;
kg.g_consoleField.widthInChars = g_console_field_width;
}
if ( !cls.soundStarted ) {
cls.soundStarted = qtrue;
S_Init();
}
if ( !cls.soundRegistered ) {
cls.soundRegistered = qtrue;
S_BeginRegistration();
}
//we require the ui to be loaded here or else it crashes trying to access the ui on command line map loads
if ( !cls.uiStarted ) {
cls.uiStarted = qtrue;
CL_InitUI();
}
// if ( !cls.cgameStarted && cls.state > CA_CONNECTED && cls.state != CA_CINEMATIC ) {
if ( !cls.cgameStarted && cls.state > CA_CONNECTED && (cls.state != CA_CINEMATIC && !CL_IsRunningInGameCinematic()) )
{
cls.cgameStarted = qtrue;
CL_InitCGame();
}
}
/*
============================
CL_StartHunkUsers
After the server has cleared the hunk, these will need to be restarted
This is the only place that any of these functions are called from
============================
*/
void CL_StartHunkUsers( void ) {
if ( !com_cl_running->integer ) {
return;
}
if ( !cls.rendererStarted ) {
cls.rendererStarted = qtrue;
CL_InitRenderer();
}
if ( !cls.soundStarted ) {
cls.soundStarted = qtrue;
S_Init();
}
if ( !cls.soundRegistered ) {
cls.soundRegistered = qtrue;
S_BeginRegistration();
}
//we require the ui to be loaded here or else it crashes trying to access the ui on command line map loads
if ( !cls.uiStarted ) {
cls.uiStarted = qtrue;
CL_InitUI();
}
// if ( !cls.cgameStarted && cls.state > CA_CONNECTED && cls.state != CA_CINEMATIC ) {
if ( !cls.cgameStarted && cls.state > CA_CONNECTED && (cls.state != CA_CINEMATIC && !CL_IsRunningInGameCinematic()) )
{
cls.cgameStarted = qtrue;
CL_InitCGame();
}
}
/*
============================
CL_StartHunkUsers
After the server has cleared the hunk, these will need to be restarted
This is the only place that any of these functions are called from
============================
*/
void CL_StartHunkUsers( void ) {
if ( !com_cl_running->integer ) {
return;
}
if ( !cls.rendererStarted ) {
#ifdef _XBOX
//if ((!com_sv_running->integer || com_errorEntered) && !vidRestartReloadMap)
//{
// // free up some memory
// extern void SV_ClearLastLevel(void);
// SV_ClearLastLevel();
//}
#endif
cls.rendererStarted = qtrue;
re.BeginRegistration( &cls.glconfig );
// load character sets
// cls.charSetShader = re.RegisterShaderNoMip( "gfx/2d/bigchars" );
cls.charSetShader = re.RegisterShaderNoMip( "gfx/2d/charsgrid_med" );
cls.whiteShader = re.RegisterShader( "white" );
cls.consoleShader = re.RegisterShader( "console" );
g_console_field_width = cls.glconfig.vidWidth / SMALLCHAR_WIDTH - 2;
kg.g_consoleField.widthInChars = g_console_field_width;
}
if ( !cls.soundStarted ) {
cls.soundStarted = qtrue;
S_Init();
}
if ( !cls.soundRegistered ) {
cls.soundRegistered = qtrue;
S_BeginRegistration();
}
#if !defined (_XBOX) //i guess xbox doesn't want the ui loaded all the time?
//we require the ui to be loaded here or else it crashes trying to access the ui on command line map loads
if ( !cls.uiStarted ) {
cls.uiStarted = qtrue;
CL_InitUI();
}
#endif
// if ( !cls.cgameStarted && cls.state > CA_CONNECTED && cls.state != CA_CINEMATIC ) {
if ( !cls.cgameStarted && cls.state > CA_CONNECTED && (cls.state != CA_CINEMATIC && !CL_IsRunningInGameCinematic()) )
{
cls.cgameStarted = qtrue;
CL_InitCGame();
}
}
