/*
===============
V_MergeOverviewRefdef
merge refdef with overview settings
===============
*/
void V_MergeOverviewRefdef( ref_params_t *fd )
{
ref_overview_t *ov = &clgame.overView;
float aspect;
float size_x, size_y;
vec2_t mins, maxs;
if( !gl_overview->integer ) return;
// NOTE: Xash3D may use 16:9 or 16:10 aspects
aspect = (float)glState.width / (float)glState.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->xTop = -(size_y / 2);
ov->xBottom = (size_y / 2);
if( gl_overview->integer == 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, fd->vieworg );
fd->vieworg[2] = ov->zFar + ov->zNear;
Vector2Copy( fd->vieworg, mins );
Vector2Copy( fd->vieworg, maxs );
mins[!ov->rotated] += ov->xLeft;
maxs[!ov->rotated] += ov->xRight;
mins[ov->rotated] += ov->xTop;
maxs[ov->rotated] += ov->xBottom;
fd->viewangles[0] = 90.0f;
fd->viewangles[1] = 90.0f;
fd->viewangles[2] = (ov->rotated) ? (ov->flZoom < 0.0f) ? 180.0f : 0.0f : (ov->flZoom < 0.0f) ? -90.0f : 90.0f;
Mod_SetOrthoBounds( mins, maxs );
}
/*
==================
CL_ParsePacketEntities
An svc_packetentities has just been parsed, deal with the
rest of the data stream.
==================
*/
void CL_ParsePacketEntities( sizebuf_t *msg, qboolean delta )
{
frame_t *newframe, *oldframe;
int oldindex, newnum, oldnum;
int oldpacket, newpacket;
cl_entity_t *player;
entity_state_t *oldent;
int i, count;
// save first uncompressed packet as timestamp
if( cls.changelevel && !delta && cls.demorecording )
CL_WriteDemoJumpTime();
// first, allocate packet for new frame
count = BF_ReadWord( msg );
newpacket = cl.parsecountmod;
newframe = &cl.frames[newpacket];
// allocate parse entities
newframe->first_entity = cls.next_client_entities;
newframe->num_entities = 0;
newframe->valid = true; // assume valid
if( delta )
{
int subtracted;
oldpacket = BF_ReadByte( msg );
subtracted = ((( cls.netchan.incoming_sequence & 0xFF ) - oldpacket ) & 0xFF );
if( subtracted == 0 )
{
Host_Error( "CL_DeltaPacketEntities: update too old, connection dropped.\n" );
return;
}
if( subtracted >= CL_UPDATE_MASK )
{
// we can't use this, it is too old
Con_NPrintf( 2, "^3Warning:^1 delta frame is too old^7\n" );
CL_FlushEntityPacket( msg );
return;
}
oldframe = &cl.frames[oldpacket & CL_UPDATE_MASK];
if(( cls.next_client_entities - oldframe->first_entity ) > ( cls.num_client_entities - 128 ))
{
Con_NPrintf( 2, "^3Warning:^1 delta frame is too old^7\n" );
CL_FlushEntityPacket( msg );
return;
}
}
else
{
// this is a full update that we can start delta compressing from now
oldframe = NULL;
oldpacket = -1; // delta too old or is initial message
cl.force_send_usercmd = true; // send reply
cls.demowaiting = false; // we can start recording now
}
// mark current delta state
cl.validsequence = cls.netchan.incoming_sequence;
oldent = NULL;
oldindex = 0;
if( !oldframe )
{
oldnum = MAX_ENTNUMBER;
}
else
{
if( oldindex >= oldframe->num_entities )
{
oldnum = MAX_ENTNUMBER;
}
else
{
oldent = &cls.packet_entities[(oldframe->first_entity+oldindex) % cls.num_client_entities];
oldnum = oldent->number;
}
}
while( 1 )
{
newnum = BF_ReadWord( msg );
if( !newnum ) break; // end of packet entities
if( BF_CheckOverflow( msg ))
Host_Error( "CL_ParsePacketEntities: read overflow\n" );
while( oldnum < newnum )
{
// one or more entities from the old packet are unchanged
CL_DeltaEntity( msg, newframe, oldnum, oldent, true );
oldindex++;
if( oldindex >= oldframe->num_entities )
{
oldnum = MAX_ENTNUMBER;
}
else
{
oldent = &cls.packet_entities[(oldframe->first_entity+oldindex) % cls.num_client_entities];
oldnum = oldent->number;
}
}
if( oldnum == newnum )
{
// delta from previous state
CL_DeltaEntity( msg, newframe, newnum, oldent, false );
oldindex++;
if( oldindex >= oldframe->num_entities )
{
oldnum = MAX_ENTNUMBER;
}
else
{
oldent = &cls.packet_entities[(oldframe->first_entity+oldindex) % cls.num_client_entities];
oldnum = oldent->number;
}
continue;
}
if( oldnum > newnum )
{
// delta from baseline ?
CL_DeltaEntity( msg, newframe, newnum, NULL, false );
continue;
}
}
// any remaining entities in the old frame are copied over
while( oldnum != MAX_ENTNUMBER )
{
// one or more entities from the old packet are unchanged
CL_DeltaEntity( msg, newframe, oldnum, oldent, true );
oldindex++;
if( oldindex >= oldframe->num_entities )
{
oldnum = MAX_ENTNUMBER;
}
else
{
oldent = &cls.packet_entities[(oldframe->first_entity+oldindex) % cls.num_client_entities];
oldnum = oldent->number;
}
}
cl.frame = *newframe;
if( !cl.frame.valid ) return;
player = CL_GetLocalPlayer();
if( cls.state != ca_active )
{
// client entered the game
cls.state = ca_active;
cl.force_refdef = true;
cls.changelevel = false; // changelevel is done
cls.changedemo = false; // changedemo is done
SCR_MakeLevelShot(); // make levelshot if needs
Cvar_SetFloat( "scr_loading", 0.0f ); // reset progress bar
if(( cls.demoplayback || cls.disable_servercount != cl.servercount ) && cl.video_prepped )
SCR_EndLoadingPlaque(); // get rid of loading plaque
}
// update local player states
clgame.dllFuncs.pfnTxferLocalOverrides( &player->curstate, &newframe->local.client );
// update state for all players
for( i = 0; i < cl.maxclients; i++ )
{
cl_entity_t *ent = CL_GetEntityByIndex( i + 1 );
if( !ent ) continue;
clgame.dllFuncs.pfnProcessPlayerState( &newframe->playerstate[i], &ent->curstate );
newframe->playerstate[i].number = ent->index;
}
cl.frame = *newframe;
}
/*
===================
CL_WritePacket
Create and send the command packet to the server
Including both the reliable commands and the usercmds
===================
*/
void CL_WritePacket( void )
{
sizebuf_t buf;
qboolean send_command = false;
byte data[MAX_CMD_BUFFER];
int i, from, to, key, size;
int numbackup = 2;
int numcmds;
int newcmds;
int cmdnumber;
// don't send anything if playing back a demo
if( cls.demoplayback || cls.state == ca_cinematic )
return;
if( cls.state == ca_disconnected || cls.state == ca_connecting )
return;
CL_ComputePacketLoss ();
#ifndef _DEBUG
if( cl_cmdrate->value < MIN_CMD_RATE )
{
Cvar_SetFloat( "cl_cmdrate", MIN_CMD_RATE );
}
#endif
Q_memset( data, 0, MAX_CMD_BUFFER );
BF_Init( &buf, "ClientData", data, sizeof( data ));
// Determine number of backup commands to send along
numbackup = bound( 0, cl_cmdbackup->integer, MAX_BACKUP_COMMANDS );
if( cls.state == ca_connected ) numbackup = 0;
// Check to see if we can actually send this command
// In single player, send commands as fast as possible
// Otherwise, only send when ready and when not choking bandwidth
if(( cl.maxclients == 1 ) || ( NET_IsLocalAddress( cls.netchan.remote_address ) && !host_limitlocal->integer ))
send_command = true;
else if(( host.realtime >= cls.nextcmdtime ) && Netchan_CanPacket( &cls.netchan ))
send_command = true;
if( cl.force_send_usercmd )
{
send_command = true;
cl.force_send_usercmd = false;
}
if(( cls.netchan.outgoing_sequence - cls.netchan.incoming_acknowledged ) >= CL_UPDATE_MASK )
{
if(( host.realtime - cls.netchan.last_received ) > CONNECTION_PROBLEM_TIME )
{
Con_NPrintf( 1, "^3Warning:^1 Connection Problem^7\n" );
cl.validsequence = 0;
}
}
if( cl_nodelta->integer )
{
cl.validsequence = 0;
}
// send a userinfo update if needed
if( userinfo->modified )
{
BF_WriteByte( &cls.netchan.message, clc_userinfo );
BF_WriteString( &cls.netchan.message, Cvar_Userinfo( ));
}
if( send_command )
{
int outgoing_sequence;
if( cl_cmdrate->integer > 0 )
cls.nextcmdtime = host.realtime + ( 1.0f / cl_cmdrate->value );
else cls.nextcmdtime = host.realtime; // always able to send right away
if( cls.lastoutgoingcommand == -1 )
{
outgoing_sequence = cls.netchan.outgoing_sequence;
cls.lastoutgoingcommand = cls.netchan.outgoing_sequence;
}
else outgoing_sequence = cls.lastoutgoingcommand + 1;
// begin a client move command
BF_WriteByte( &buf, clc_move );
// save the position for a checksum byte
key = BF_GetRealBytesWritten( &buf );
BF_WriteByte( &buf, 0 );
// write packet lossage percentation
BF_WriteByte( &buf, cls.packet_loss );
// say how many backups we'll be sending
BF_WriteByte( &buf, numbackup );
// how many real commands have queued up
newcmds = ( cls.netchan.outgoing_sequence - cls.lastoutgoingcommand );
// put an upper/lower bound on this
newcmds = bound( 0, newcmds, MAX_TOTAL_CMDS );
if( cls.state == ca_connected ) newcmds = 0;
BF_WriteByte( &buf, newcmds );
numcmds = newcmds + numbackup;
from = -1;
for( i = numcmds - 1; i >= 0; i-- )
{
cmdnumber = ( cls.netchan.outgoing_sequence - i ) & CL_UPDATE_MASK;
to = cmdnumber;
CL_WriteUsercmd( &buf, from, to );
from = to;
if( BF_CheckOverflow( &buf ))
Host_Error( "CL_Move, overflowed command buffer (%i bytes)\n", MAX_CMD_BUFFER );
}
// calculate a checksum over the move commands
size = BF_GetRealBytesWritten( &buf ) - key - 1;
buf.pData[key] = CRC32_BlockSequence( buf.pData + key + 1, size, cls.netchan.outgoing_sequence );
// message we are constructing.
i = cls.netchan.outgoing_sequence & CL_UPDATE_MASK;
// determine if we need to ask for a new set of delta's.
if( cl.validsequence && (cls.state == ca_active) && !( cls.demorecording && cls.demowaiting ))
{
cl.delta_sequence = cl.validsequence;
BF_WriteByte( &buf, clc_delta );
BF_WriteByte( &buf, cl.validsequence & 0xFF );
}
else
{
// request delta compression of entities
cl.delta_sequence = -1;
}
if( BF_CheckOverflow( &buf ))
{
Host_Error( "CL_Move, overflowed command buffer (%i bytes)\n", MAX_CMD_BUFFER );
}
// remember outgoing command that we are sending
cls.lastoutgoingcommand = cls.netchan.outgoing_sequence;
// composite the rest of the datagram..
if( BF_GetNumBitsWritten( &cls.datagram ) <= BF_GetNumBitsLeft( &buf ))
BF_WriteBits( &buf, BF_GetData( &cls.datagram ), BF_GetNumBitsWritten( &cls.datagram ));
BF_Clear( &cls.datagram );
// deliver the message (or update reliable)
Netchan_Transmit( &cls.netchan, BF_GetNumBytesWritten( &buf ), BF_GetData( &buf ));
}
else
{
// increment sequence number so we can detect that we've held back packets.
cls.netchan.outgoing_sequence++;
}
if( cls.demorecording )
{
// Back up one because we've incremented outgoing_sequence each frame by 1 unit
cmdnumber = ( cls.netchan.outgoing_sequence - 1 ) & CL_UPDATE_MASK;
CL_WriteDemoUserCmd( cmdnumber );
}
// update download/upload slider.
Netchan_UpdateProgress( &cls.netchan );
}
