/*
=================
R_CreateSurfaceGridMesh
=================
*/
static srfGridMesh_t *R_CreateSurfaceGridMesh( int width, int height,
srfVert_t ctrl[ MAX_GRID_SIZE ][ MAX_GRID_SIZE ],
float errorTable[ 2 ][ MAX_GRID_SIZE ],
int numTriangles, srfTriangle_t triangles[ SHADER_MAX_TRIANGLES ] )
{
int i, j, size;
srfVert_t *vert;
vec3_t tmpVec;
srfGridMesh_t *grid;
// copy the results out to a grid
size = sizeof( *grid );
if ( r_stitchCurves->integer )
{
grid = (srfGridMesh_t*)/*ri.Hunk_Alloc */ Com_Allocate( size );
Com_Memset( grid, 0, size );
grid->widthLodError = (float*)/*ri.Hunk_Alloc */ Com_Allocate( width * 4 );
Com_Memcpy( grid->widthLodError, errorTable[ 0 ], width * 4 );
grid->heightLodError = (float*)/*ri.Hunk_Alloc */ Com_Allocate( height * 4 );
Com_Memcpy( grid->heightLodError, errorTable[ 1 ], height * 4 );
grid->numTriangles = numTriangles;
grid->triangles = (srfTriangle_t*) Com_Allocate( grid->numTriangles * sizeof( srfTriangle_t ) );
Com_Memcpy( grid->triangles, triangles, numTriangles * sizeof( srfTriangle_t ) );
grid->numVerts = ( width * height );
grid->verts = (srfVert_t*) Com_Allocate( grid->numVerts * sizeof( srfVert_t ) );
}
else
{
grid = (srfGridMesh_t*) ri.Hunk_Alloc( size, ha_pref::h_low );
Com_Memset( grid, 0, size );
grid->widthLodError = (float*) ri.Hunk_Alloc( width * 4, ha_pref::h_low );
Com_Memcpy( grid->widthLodError, errorTable[ 0 ], width * 4 );
grid->heightLodError = (float*) ri.Hunk_Alloc( height * 4, ha_pref::h_low );
Com_Memcpy( grid->heightLodError, errorTable[ 1 ], height * 4 );
grid->numTriangles = numTriangles;
grid->triangles = (srfTriangle_t*) ri.Hunk_Alloc( grid->numTriangles * sizeof( srfTriangle_t ), ha_pref::h_low );
Com_Memcpy( grid->triangles, triangles, numTriangles * sizeof( srfTriangle_t ) );
grid->numVerts = ( width * height );
grid->verts = (srfVert_t*) ri.Hunk_Alloc( grid->numVerts * sizeof( srfVert_t ), ha_pref::h_low );
}
grid->width = width;
grid->height = height;
grid->surfaceType = surfaceType_t::SF_GRID;
ClearBounds( grid->bounds[ 0 ], grid->bounds[ 1 ] );
for ( i = 0; i < width; i++ )
{
for ( j = 0; j < height; j++ )
{
vert = &grid->verts[ j * width + i ];
*vert = ctrl[ j ][ i ];
AddPointToBounds( vert->xyz, grid->bounds[ 0 ], grid->bounds[ 1 ] );
}
}
// compute local origin and bounds
VectorAdd( grid->bounds[ 0 ], grid->bounds[ 1 ], grid->origin );
VectorScale( grid->origin, 0.5f, grid->origin );
VectorSubtract( grid->bounds[ 0 ], grid->origin, tmpVec );
grid->radius = VectorLength( tmpVec );
VectorCopy( grid->origin, grid->lodOrigin );
grid->lodRadius = grid->radius;
//
return grid;
}
/*
=================
RB_ShadowTessEnd
triangleFromEdge[ v1 ][ v2 ]
set triangle from edge( v1, v2, tri )
if ( facing[ triangleFromEdge[ v1 ][ v2 ] ] && !facing[ triangleFromEdge[ v2 ][ v1 ] ) {
}
=================
*/
void RB_ShadowTessEnd( void ) {
int i;
int numTris;
vec3_t lightDir;
GLboolean rgba[4];
// we can only do this if we have enough space in the vertex buffers
if ( tess.numVertexes >= SHADER_MAX_VERTEXES / 2 ) {
return;
}
if ( glConfig.stencilBits < 4 ) {
return;
}
VectorCopy( backEnd.currentEntity->lightDir, lightDir );
// project vertexes away from light direction
for ( i = 0 ; i < tess.numVertexes ; i++ ) {
VectorMA( tess.xyz[i], -512, lightDir, tess.xyz[i+tess.numVertexes] );
}
// decide which triangles face the light
Com_Memset( numEdgeDefs, 0, 4 * tess.numVertexes );
numTris = tess.numIndexes / 3;
for ( i = 0 ; i < numTris ; i++ ) {
int i1, i2, i3;
vec3_t d1, d2, normal;
float *v1, *v2, *v3;
float d;
i1 = tess.indexes[ i*3 + 0 ];
i2 = tess.indexes[ i*3 + 1 ];
i3 = tess.indexes[ i*3 + 2 ];
v1 = tess.xyz[ i1 ];
v2 = tess.xyz[ i2 ];
v3 = tess.xyz[ i3 ];
VectorSubtract( v2, v1, d1 );
VectorSubtract( v3, v1, d2 );
CrossProduct( d1, d2, normal );
d = DotProduct( normal, lightDir );
if ( d > 0 ) {
facing[ i ] = 1;
} else {
facing[ i ] = 0;
}
// create the edges
R_AddEdgeDef( i1, i2, facing[ i ] );
R_AddEdgeDef( i2, i3, facing[ i ] );
R_AddEdgeDef( i3, i1, facing[ i ] );
}
// draw the silhouette edges
GL_Bind( tr.whiteImage );
qglEnable( GL_CULL_FACE );
GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO );
qglColor3f( 0.2f, 0.2f, 0.2f );
// don't write to the color buffer
qglGetBooleanv(GL_COLOR_WRITEMASK, rgba);
qglColorMask( GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE );
qglEnable( GL_STENCIL_TEST );
qglStencilFunc( GL_ALWAYS, 1, 255 );
// mirrors have the culling order reversed
if ( backEnd.viewParms.isMirror ) {
qglCullFace( GL_FRONT );
qglStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
R_RenderShadowEdges();
qglCullFace( GL_BACK );
qglStencilOp( GL_KEEP, GL_KEEP, GL_DECR );
R_RenderShadowEdges();
} else {
qglCullFace( GL_BACK );
qglStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
R_RenderShadowEdges();
qglCullFace( GL_FRONT );
qglStencilOp( GL_KEEP, GL_KEEP, GL_DECR );
R_RenderShadowEdges();
}
// reenable writing to the color buffer
qglColorMask(rgba[0], rgba[1], rgba[2], rgba[3]);
}
/*
===================
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, key;
// don't send anything if playing back a demo
if ( clc.demoplaying || clc.state == CA_CINEMATIC ) {
return;
}
Com_Memset( &nullcmd, 0, sizeof(nullcmd) );
oldcmd = &nullcmd;
MSG_Init( &buf, data, sizeof(data) );
MSG_Bitstream( &buf );
// write the current serverId so the server
// can tell if this is from the current gameState
MSG_WriteLong( &buf, cl.serverId );
// write the last message we received, which can
// be used for delta compression, and is also used
// to tell if we dropped a gamestate
MSG_WriteLong( &buf, clc.serverMessageSequence );
// write the last reliable message we received
MSG_WriteLong( &buf, clc.serverCommandSequence );
// 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.outPackets[ oldPacketNum ].p_cmdNumber;
if ( count > MAX_PACKET_USERCMDS ) {
count = MAX_PACKET_USERCMDS;
Com_Printf("MAX_PACKET_USERCMDS\n");
}
#ifdef USE_VOIP
if (clc.voipOutgoingDataSize > 0)
{
if((clc.voipFlags & VOIP_SPATIAL) || Com_IsVoipTarget(clc.voipTargets, sizeof(clc.voipTargets), -1))
{
MSG_WriteByte (&buf, clc_voipOpus);
MSG_WriteByte (&buf, clc.voipOutgoingGeneration);
MSG_WriteLong (&buf, clc.voipOutgoingSequence);
MSG_WriteByte (&buf, clc.voipOutgoingDataFrames);
MSG_WriteData (&buf, clc.voipTargets, sizeof(clc.voipTargets));
MSG_WriteByte(&buf, clc.voipFlags);
MSG_WriteShort (&buf, clc.voipOutgoingDataSize);
MSG_WriteData (&buf, clc.voipOutgoingData, clc.voipOutgoingDataSize);
// If we're recording a demo, we have to fake a server packet with
// this VoIP data so it gets to disk; the server doesn't send it
// back to us, and we might as well eliminate concerns about dropped
// and misordered packets here.
if(clc.demorecording && !clc.demowaiting)
{
const int voipSize = clc.voipOutgoingDataSize;
msg_t fakemsg;
byte fakedata[MAX_MSGLEN];
MSG_Init (&fakemsg, fakedata, sizeof (fakedata));
MSG_Bitstream (&fakemsg);
MSG_WriteLong (&fakemsg, clc.reliableAcknowledge);
MSG_WriteByte (&fakemsg, svc_voipOpus);
MSG_WriteShort (&fakemsg, clc.clientNum);
MSG_WriteByte (&fakemsg, clc.voipOutgoingGeneration);
MSG_WriteLong (&fakemsg, clc.voipOutgoingSequence);
MSG_WriteByte (&fakemsg, clc.voipOutgoingDataFrames);
MSG_WriteShort (&fakemsg, clc.voipOutgoingDataSize );
MSG_WriteBits (&fakemsg, clc.voipFlags, VOIP_FLAGCNT);
MSG_WriteData (&fakemsg, clc.voipOutgoingData, voipSize);
MSG_WriteByte (&fakemsg, svc_EOF);
CL_WriteDemoMessage (&fakemsg, 0);
}
clc.voipOutgoingSequence += clc.voipOutgoingDataFrames;
clc.voipOutgoingDataSize = 0;
clc.voipOutgoingDataFrames = 0;
}
else
{
// We have data, but no targets. Silently discard all data
clc.voipOutgoingDataSize = 0;
clc.voipOutgoingDataFrames = 0;
}
}
#endif
if ( count >= 1 ) {
if ( cl_showSend->integer ) {
Com_Printf( "(%i)", count );
}
// begin a client move command
if ( cl_nodelta->integer || !cl.snap.valid || clc.demowaiting
|| clc.serverMessageSequence != cl.snap.messageNum ) {
MSG_WriteByte (&buf, clc_moveNoDelta);
} else {
MSG_WriteByte (&buf, clc_move);
}
// write the command count
MSG_WriteByte( &buf, count );
// use the checksum feed in the key
key = clc.checksumFeed;
// also use the message acknowledge
key ^= clc.serverMessageSequence;
// also use the last acknowledged server command in the key
key ^= MSG_HashKey(clc.serverCommands[ clc.serverCommandSequence & (MAX_RELIABLE_COMMANDS-1) ], 32);
// write all the commands, including the predicted command
for ( i = 0 ; i < count ; i++ ) {
j = (cl.cmdNumber - count + i + 1) & CMD_MASK;
cmd = &cl.cmds[j];
MSG_WriteDeltaUsercmdKey (&buf, key, oldcmd, cmd);
oldcmd = cmd;
}
}
//
// deliver the message
//
packetNum = clc.netchan.outgoingSequence & PACKET_MASK;
cl.outPackets[ packetNum ].p_realtime = cls.realtime;
cl.outPackets[ packetNum ].p_serverTime = oldcmd->serverTime;
cl.outPackets[ packetNum ].p_cmdNumber = cl.cmdNumber;
clc.lastPacketSentTime = cls.realtime;
if ( cl_showSend->integer ) {
Com_Printf( "%i ", buf.cursize );
}
CL_Netchan_Transmit (&clc.netchan, &buf);
}
static void DrawSkyBox( shader_t *shader )
{
int i;
sky_min = 0;
sky_max = 1;
Com_Memset( s_skyTexCoords, 0, sizeof( s_skyTexCoords ) );
for (i=0 ; i<6 ; i++)
{
int sky_mins_subd[2], sky_maxs_subd[2];
int s, t;
sky_mins[0][i] = floor( sky_mins[0][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
sky_mins[1][i] = floor( sky_mins[1][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
sky_maxs[0][i] = ceil( sky_maxs[0][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
sky_maxs[1][i] = ceil( sky_maxs[1][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
if ( ( sky_mins[0][i] >= sky_maxs[0][i] ) ||
( sky_mins[1][i] >= sky_maxs[1][i] ) )
{
continue;
}
sky_mins_subd[0] = sky_mins[0][i] * HALF_SKY_SUBDIVISIONS;
sky_mins_subd[1] = sky_mins[1][i] * HALF_SKY_SUBDIVISIONS;
sky_maxs_subd[0] = sky_maxs[0][i] * HALF_SKY_SUBDIVISIONS;
sky_maxs_subd[1] = sky_maxs[1][i] * HALF_SKY_SUBDIVISIONS;
if ( sky_mins_subd[0] < -HALF_SKY_SUBDIVISIONS )
sky_mins_subd[0] = -HALF_SKY_SUBDIVISIONS;
else if ( sky_mins_subd[0] > HALF_SKY_SUBDIVISIONS )
sky_mins_subd[0] = HALF_SKY_SUBDIVISIONS;
if ( sky_mins_subd[1] < -HALF_SKY_SUBDIVISIONS )
sky_mins_subd[1] = -HALF_SKY_SUBDIVISIONS;
else if ( sky_mins_subd[1] > HALF_SKY_SUBDIVISIONS )
sky_mins_subd[1] = HALF_SKY_SUBDIVISIONS;
if ( sky_maxs_subd[0] < -HALF_SKY_SUBDIVISIONS )
sky_maxs_subd[0] = -HALF_SKY_SUBDIVISIONS;
else if ( sky_maxs_subd[0] > HALF_SKY_SUBDIVISIONS )
sky_maxs_subd[0] = HALF_SKY_SUBDIVISIONS;
if ( sky_maxs_subd[1] < -HALF_SKY_SUBDIVISIONS )
sky_maxs_subd[1] = -HALF_SKY_SUBDIVISIONS;
else if ( sky_maxs_subd[1] > HALF_SKY_SUBDIVISIONS )
sky_maxs_subd[1] = HALF_SKY_SUBDIVISIONS;
//
// iterate through the subdivisions
//
for ( t = sky_mins_subd[1]+HALF_SKY_SUBDIVISIONS; t <= sky_maxs_subd[1]+HALF_SKY_SUBDIVISIONS; t++ )
{
for ( s = sky_mins_subd[0]+HALF_SKY_SUBDIVISIONS; s <= sky_maxs_subd[0]+HALF_SKY_SUBDIVISIONS; s++ )
{
MakeSkyVec( ( s - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS,
( t - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS,
i,
s_skyTexCoords[t][s],
s_skyPoints[t][s] );
}
}
DrawSkySide( shader->sky.outerbox[i],
sky_mins_subd,
sky_maxs_subd );
}
}
/*
====================
CL_CgameSystemCalls
The cgame module is making a system call
====================
*/
intptr_t CL_CgameSystemCalls( intptr_t *args ) {
switch( args[0] ) {
case CG_PRINT:
Com_Printf( "%s", VMA(1) );
return 0;
case CG_FATAL_ERROR:
Com_Error( ERR_DROP, "%s", VMA(1) );
return 0;
case CG_MILLISECONDS:
return Sys_Milliseconds();
case CG_CVAR_REGISTER:
Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] );
return 0;
case CG_CVAR_UPDATE:
Cvar_Update( VMA(1) );
return 0;
case CG_CVAR_SET:
Cvar_Set( VMA(1), VMA(2) );
return 0;
case CG_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] );
return 0;
case CG_ARGC:
return Cmd_Argc();
case CG_ARGV:
Cmd_ArgvBuffer( args[1], VMA(2), args[3] );
return 0;
case CG_ARGVI:
return atoi( Cmd_Argv( args[1] ) );
case CG_ARGS:
Cmd_ArgsBuffer( VMA(1), args[2] );
return 0;
case CG_CMD_EXECUTETEXT:
Cbuf_ExecuteText( args[1], VMA(2) );
return 0;
case CG_FS_FOPENFILE:
return FS_FOpenFileByMode( VMA(1), VMA(2), args[3] );
case CG_FS_READ:
FS_Read( VMA(1), args[2], args[3] );
return 0;
case CG_FS_WRITE:
FS_Write( VMA(1), args[2], args[3] );
return 0;
case CG_FS_FCLOSEFILE:
FS_FCloseFile( args[1] );
return 0;
case CG_SENDCONSOLECOMMAND:
Cbuf_AddText( VMA(1) );
return 0;
case CG_FORWARDCOMMAND:
VM_Call( uivm, UI_CONSOLE_COMMAND, cls.realtime );
return 0;
case CG_ADDCOMMAND:
CL_AddCgameCommand( VMA(1) );
return 0;
case CG_REMOVECOMMAND:
Cmd_RemoveCommand( VMA(1) );
return 0;
case CG_SENDCLIENTCOMMAND:
CL_AddReliableCommand( VMA(1) );
return 0;
case CG_UPDATESCREEN:
// this is used during lengthy level loading, so pump message loop
// Com_EventLoop(); // FIXME: if a server restarts here, BAD THINGS HAPPEN!
// We can't call Com_EventLoop here, a restart will crash and this _does_ happen
// if there is a map change while we are downloading at pk3.
// ZOID
SCR_UpdateScreen();
return 0;
case CG_CM_LOADMAP:
CL_CM_LoadMap( VMA(1) );
return 0;
case CG_CM_NUMINLINEMODELS:
return CM_NumInlineModels();
case CG_CM_INLINEMODEL:
return CM_InlineModel( args[1] );
case CG_CM_TEMPBOXMODEL:
return CM_TempBoxModel( VMA(1), VMA(2), /*int capsule*/ qfalse );
case CG_CM_TEMPCAPSULEMODEL:
return CM_TempBoxModel( VMA(1), VMA(2), /*int capsule*/ qtrue );
case CG_CM_POINTCONTENTS:
return CM_PointContents( VMA(1), args[2] );
case CG_CM_TRANSFORMEDPOINTCONTENTS:
return CM_TransformedPointContents( VMA(1), args[2], VMA(3), VMA(4) );
case CG_CM_BOXTRACE:
CM_BoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qfalse );
return 0;
case CG_CM_CAPSULETRACE:
CM_BoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qtrue );
return 0;
case CG_CM_TRANSFORMEDBOXTRACE:
CM_TransformedBoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], VMA(8), VMA(9), /*int capsule*/ qfalse );
return 0;
case CG_CM_TRANSFORMEDCAPSULETRACE:
CM_TransformedBoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], VMA(8), VMA(9), /*int capsule*/ qtrue );
return 0;
case CG_CM_MARKFRAGMENTS:
return re.MarkFragments( args[1], VMA(2), VMA(3), args[4], VMA(5), args[6], VMA(7) );
case CG_S_STARTSOUND:
S_StartSound( VMA(1), args[2], args[3], args[4] );
return 0;
case CG_S_STARTLOCALSOUND:
S_StartLocalSound( args[1], args[2] );
return 0;
case CG_S_CLEARLOOPINGSOUNDS:
S_ClearLoopingSounds(args[1]);
return 0;
case CG_S_ADDLOOPINGSOUND:
S_AddLoopingSound( args[1], VMA(2), VMA(3), args[4] );
return 0;
case CG_S_ADDREALLOOPINGSOUND:
S_AddRealLoopingSound( args[1], VMA(2), VMA(3), args[4] );
return 0;
case CG_S_STOPLOOPINGSOUND:
S_StopLoopingSound( args[1] );
return 0;
case CG_S_UPDATEENTITYPOSITION:
S_UpdateEntityPosition( args[1], VMA(2) );
return 0;
case CG_S_RESPATIALIZE:
S_Respatialize( args[1], VMA(2), VMA(3), args[4] );
return 0;
case CG_S_REGISTERSOUND:
return S_RegisterSound( VMA(1), args[2] );
case CG_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack( VMA(1), VMA(2) );
return 0;
case CG_R_LOADWORLDMAP:
CL_R_LoadWorld( VMA( 1 ) );
return 0;
case CG_R_REGISTERMODEL:
return re.RegisterModel( VMA(1) );
case CG_R_REGISTERSKIN:
return re.RegisterSkin( VMA(1) );
case CG_R_REGISTERSHADER:
return re.RegisterShader( VMA(1) );
case CG_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip( VMA(1) );
case CG_R_REGISTERFONT:
return re.RegisterFont( VMA(1) );
case CG_R_CLEARSCENE:
re.ClearScene();
return 0;
case CG_R_BUILDPOSE:
{
animGroupTransition_t trans;
trans.animGroup = 0;
trans.interp = 0;
return re.BuildPose( args[1], VMA( 2 ), args[3], VMA( 4 ), args[5], NULL, 0, NULL, 0, &trans, 1 );
}
case CG_R_BUILDPOSE2:
return re.BuildPose( args[1], VMA( 2 ), 2, VMA( 3 ), 2, VMA( 4 ), 2, VMA( 5 ), 2, VMA( 6 ), 2 );
case CG_R_BUILDPOSE3:
return re.BuildPose( args[1], VMA( 2 ), 1, 0, 0, VMA( 3 ), 1, 0, 0, VMA( 4 ), 1 );
case CG_R_LERPTAGFROMPOSE:
return re.LerpTagFromPose( VMA( 1 ), args[2], args[3], VMA( 4 ) );
case CG_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( VMA(1) );
return 0;
case CG_R_ADDPOLYTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA(3), 1 );
return 0;
case CG_R_ADDPOLYSTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA(3), args[4] );
return 0;
case CG_R_MENUBEGINSURF:
re.MenuBeginSurf( args[1] );
return 0;
case CG_R_MENUENDSURF:
re.MenuEndSurf();
return 0;
case CG_R_LIGHTFORPOINT:
return re.LightForPoint( VMA(1), VMA(2), VMA(3), VMA(4) );
case CG_R_ADDLIGHTTOSCENE:
re.AddLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
return 0;
case CG_R_ADDADDITIVELIGHTTOSCENE:
re.AddAdditiveLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
return 0;
case CG_R_RENDERSCENE:
re.RenderScene( VMA(1) );
return 0;
case CG_R_SETCOLOR:
re.SetColor( VMA(1) );
return 0;
case CG_R_DRAWSTRETCHPIC:
re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), NULL, VMF(5), VMF(6), VMF(7), VMF(8), args[9] );
return 0;
case CG_R_SHAPECREATE:
{
curve_t * c = VMA(1);
int n = args[3];
int i;
for ( i=0; i<n; i++ ) {
c->pts = (vec2_t*)VM_ArgPtr((intptr_t)c->pts);
c->uvs = (vec2_t*)VM_ArgPtr((intptr_t)c->uvs);
c->colors = (vec4_t*)VM_ArgPtr((intptr_t)c->colors);
c->indices = (short*)VM_ArgPtr((intptr_t)c->indices );
}
return re.ShapeCreate( c, VMA( 2 ), n );
}
case CG_R_SHAPEDRAW:
re.ShapeDraw( args[1], args[2], VMA( 3 ) );
return 0;
case CG_R_RENDERTEXT:
CL_RenderText( VMA(1), VMF(2), VMA(3), VMA(4), args[5], (args[6])>>16, args[6]&0xFFFF, args[7], args[8], 0, args[9], VMA(10) );
return 0;
case CG_R_GETFONT:
memcpy( VMA(3), re.GetFontFromFontSet( args[1], VMF(2) ), sizeof(fontInfo_t) );
return 0;
case CG_R_ROUNDRECT:
SCR_FillRect( VMF(1), VMF(2), VMF(3), VMF(4), VMA(5), args[6] );
return 0;
case CG_R_MODELBOUNDS:
re.ModelBounds( args[1], VMA(2), VMA(3) );
return 0;
case CG_R_LERPTAG:
return re.LerpTag( VMA(1), args[2], args[3], args[4], VMF(5), VMA(6) );
case CG_GETGLCONFIG:
CL_GetGlconfig( VMA(1) );
return 0;
case CG_GETGAMESTATE:
CL_GetGameState( VMA(1) );
return 0;
case CG_GETCURRENTSNAPSHOTNUMBER:
CL_GetCurrentSnapshotNumber( VMA(1), VMA(2) );
return 0;
case CG_GETSNAPSHOT:
return CL_GetSnapshot( args[1], VMA(2) );
case CG_GETSERVERCOMMAND:
return CL_GetServerCommand( args[1] );
case CG_GETCURRENTCMDNUMBER:
return CL_GetCurrentCmdNumber();
case CG_GETUSERCMD:
return CL_GetUserCmd( args[1], VMA(2) );
case CG_SETUSERCMDVALUE:
CL_SetUserCmdValue( args[1], VMF(2) );
return 0;
case CG_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case CG_KEY_ISDOWN:
return Key_IsDown( args[1] );
case CG_KEY_GETCATCHER:
return Key_GetCatcher();
case CG_KEY_SETCATCHER:
Key_SetCatcher( args[1] );
return 0;
case CG_KEY_GETKEY:
return Key_GetKey( VMA(1) );
case CG_MEMSET:
Com_Memset( VMA(1), args[2], args[3] );
return 0;
case CG_MEMCPY:
Com_Memcpy( VMA(1), VMA(2), args[3] );
return 0;
case CG_STRNCPY:
strncpy( VMA(1), VMA(2), args[3] );
return args[1];
case CG_SIN:
return FloatAsInt( sin( VMF(1) ) );
case CG_COS:
return FloatAsInt( cos( VMF(1) ) );
case CG_ATAN2:
return FloatAsInt( atan2( VMF(1), VMF(2) ) );
case CG_SQRT:
return FloatAsInt( sqrt( VMF(1) ) );
case CG_FLOOR:
return FloatAsInt( floor( VMF(1) ) );
case CG_CEIL:
return FloatAsInt( ceil( VMF(1) ) );
case CG_ACOS: return FloatAsInt( Q_acos( VMF(1) ) );
case CG_FMOD: return FloatAsInt( fmod( VMF(1),VMF(2) ) );
case CG_POW: return FloatAsInt( pow( VMF(1),VMF(2) ) );
case CG_ATAN: return FloatAsInt( atan( VMF(1) ) );
case CG_TAN: return FloatAsInt( tan( VMF(1)) );
case CG_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine( VMA(1) );
case CG_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle( VMA(1) );
case CG_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle( args[1] );
case CG_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle( args[1], VMA(2) );
case CG_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine( args[1], VMA(2), VMA(3) );
case CG_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case CG_REAL_TIME:
return Com_RealTime( VMA(1) );
case CG_SNAPVECTOR:
Sys_SnapVector( VMA(1) );
return 0;
case CG_UPDATEGAMESTATE:
return CL_UpdateGameState( VMA(1) );
case CG_CIN_PLAYCINEMATIC:
return CIN_PlayCinematic(VMA(1), args[2], args[3], args[4], args[5], args[6]);
case CG_CIN_STOPCINEMATIC:
return CIN_StopCinematic(args[1]);
case CG_CIN_RUNCINEMATIC:
return CIN_RunCinematic(args[1]);
case CG_CIN_DRAWCINEMATIC:
CIN_DrawCinematic(args[1]);
return 0;
case CG_CIN_SETEXTENTS:
CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
return 0;
case CG_R_REMAP_SHADER:
//ToDo: remove this trap
return 0;
/*
case CG_LOADCAMERA:
return loadCamera(VMA(1));
case CG_STARTCAMERA:
startCamera(args[1]);
return 0;
case CG_GETCAMERAINFO:
return getCameraInfo(args[1], VMA(2), VMA(3));
*/
case CG_GET_ENTITY_TOKEN:
return re.GetEntityToken( VMA(1), args[2] );
case CG_R_INPVS:
return re.inPVS( VMA(1), VMA(2) );
case CG_Q_rand:
return Rand_NextUInt32( &cl.db.rand );
case CG_SQL_LOADDB:
{
char * buffer;
int length;
length = FS_ReadFile( VMA(1), &buffer );
if ( length > 0 ) {
sql_exec( &cl.db, buffer );
FS_FreeFile(buffer);
}
return 0;
} break;
case CG_SQL_EXEC: return sql_exec( &cl.db, VMA(1) );
case CG_SQL_PREPARE: return sql_prepare( &cl.db, VMA(1) ) != 0;
case CG_SQL_BIND: return sql_bind( &cl.db, args );
case CG_SQL_BINDTEXT: return sql_bindtext( &cl.db, args[1], VMA(2) );
case CG_SQL_BINDINT: return sql_bindint( &cl.db, args[1], args[2] );
case CG_SQL_BINDARGS:
{
int i,n = Cmd_Argc();
for ( i=1; i<n; i++ )
{
if ( !sql_bindtext( &cl.db, i, Cmd_Argv( i ) ) )
return 0;
}
} return 1;
case CG_SQL_STEP: return sql_step( &cl.db );
case CG_SQL_COLUMNCOUNT: return sql_columncount( &cl.db );
case CG_SQL_COLUMNASTEXT:
Q_strncpyz( VMA(1), sql_columnastext( &cl.db, args[3] ), args[2] );
break;
case CG_SQL_COLUMNASINT: return sql_columnasint( &cl.db, args[1] );
case CG_SQL_COLUMNNAME:
Q_strncpyz( VMA(1), sql_columnname( &cl.db, args[3] ), args[2] );
break;
case CG_SQL_DONE: return sql_done( &cl.db );
case CG_SQL_COMPILE: return sql_compile( &cl.db, VMA(1) );
case CG_SQL_RUN:
{
char * buffer = VMA(1);
int size = args[2];
int id = args[3];
int i;
formatInfo_t * stmt = (formatInfo_t*)cl.db.stmts_byindex[ id ];
if ( stmt ) {
sqlData_t params[ 3 ];
const char * r;
for ( i=0; i<3; i++ ) {
params[ i ].format = INTEGER;
params[ i ].payload.integer = args[ 4+i ];
}
r = sql_eval( &cl.db, stmt->print, 0, 0, 0, 0, params, 0 ).string;
Q_strncpyz( buffer, r, size );
} else {
buffer[ 0 ] = '\0';
}
} break;
default:
assert(0); // bk010102
Com_Error( ERR_DROP, "Bad cgame system trap: %i", args[0] );
}
return 0;
}
static void CL_ParseGamestate( msg_t *msg )
{
int i;
entityState_t *es;
int newnum;
entityState_t nullstate;
int cmd;
char *s;
Con_Close();
clc.connectPacketCount = 0;
// wipe local client state
CL_ClearState();
// a gamestate always marks a server command sequence
clc.serverCommandSequence = MSG_ReadLong( msg );
// parse all the configstrings and baselines
cl.gameState.dataCount = 1; // leave a 0 at the beginning for uninitialized configstrings
while ( 1 ) {
cmd = MSG_ReadByte( msg );
if ( cmd == svc_EOF ) {
break;
}
if ( cmd == svc_configstring ) {
int len;
i = MSG_ReadShort( msg );
if ( i < 0 || i >= MAX_CONFIGSTRINGS ) {
Com_Error( ERR_DROP, "configstring > MAX_CONFIGSTRINGS" );
}
s = MSG_ReadBigString( msg );
len = strlen( s );
if ( len + 1 + cl.gameState.dataCount > MAX_GAMESTATE_CHARS ) {
Com_Error( ERR_DROP, "MAX_GAMESTATE_CHARS exceeded" );
}
// append it to the gameState string buffer
cl.gameState.stringOffsets[ i ] = cl.gameState.dataCount;
Com_Memcpy( cl.gameState.stringData + cl.gameState.dataCount, s, len + 1 );
cl.gameState.dataCount += len + 1;
} else if ( cmd == svc_baseline ) {
newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
if ( newnum < 0 || newnum >= MAX_GENTITIES ) {
Com_Error( ERR_DROP, "Baseline number out of range: %i", newnum );
}
Com_Memset (&nullstate, 0, sizeof(nullstate));
es = &cl.entityBaselines[ newnum ];
MSG_ReadDeltaEntity( msg, &nullstate, es, newnum );
} else {
Com_Error( ERR_DROP, "CL_ParseGamestate: bad command byte" );
}
}
clc.clientNum = MSG_ReadLong(msg);
// read the checksum feed
clc.checksumFeed = MSG_ReadLong( msg );
#if defined(USE_CURL)
// Parse values for cURL downloads
CL_ParseServerInfo();
#endif
// parse serverId and other cvars
CL_SystemInfoChanged();
// reinitialize the filesystem if the game directory has changed
FS_ConditionalRestart( clc.checksumFeed );
// This used to call CL_StartHunkUsers, but now we enter the download state before loading the cgame
CL_InitDownloads();
// make sure the game starts
Cvar_Set( "cl_paused", "0" );
}
const void *R_MME_CaptureShotCmd( const void *data ) {
const captureCommand_t *cmd = (const captureCommand_t *)data;
if (!cmd->name[0])
return (const void *)(cmd + 1);
shotData.take = qtrue;
shotData.fps = cmd->fps;
shotData.dofFocus = cmd->focus;
shotData.dofRadius = cmd->radius;
if (strcmp( cmd->name, shotData.main.name) || mme_screenShotFormat->modified || mme_screenShotAlpha->modified ) {
/* Also reset the the other data */
blurData.control.totalIndex = 0;
if ( workAlign )
Com_Memset( workAlign, 0, workUsed );
Com_sprintf( shotData.main.name, sizeof( shotData.main.name ), "%s", cmd->name );
Com_sprintf( shotData.depth.name, sizeof( shotData.depth.name ), "%s.depth", cmd->name );
Com_sprintf( shotData.stencil.name, sizeof( shotData.stencil.name ), "%s.stencil", cmd->name );
mme_screenShotFormat->modified = qfalse;
mme_screenShotAlpha->modified = qfalse;
if (!Q_stricmp(mme_screenShotFormat->string, "jpg")) {
shotData.main.format = mmeShotFormatJPG;
} else if (!Q_stricmp(mme_screenShotFormat->string, "tga")) {
shotData.main.format = mmeShotFormatTGA;
} else if (!Q_stricmp(mme_screenShotFormat->string, "png")) {
shotData.main.format = mmeShotFormatPNG;
} else if (!Q_stricmp(mme_screenShotFormat->string, "avi")) {
shotData.main.format = mmeShotFormatAVI;
} else if (!Q_stricmp(mme_screenShotFormat->string, "pipe")) {
shotData.main.format = mmeShotFormatPIPE;
} else {
shotData.main.format = mmeShotFormatTGA;
}
//grayscale works fine only with compressed avi :(
if ((shotData.main.format != mmeShotFormatAVI && shotData.main.format != mmeShotFormatPIPE) || !mme_aviFormat->integer) {
shotData.depth.format = mmeShotFormatPNG;
shotData.stencil.format = mmeShotFormatPNG;
} else if (shotData.main.format == mmeShotFormatAVI) {
shotData.depth.format = mmeShotFormatAVI;
shotData.stencil.format = mmeShotFormatAVI;
} else if (shotData.main.format == mmeShotFormatPIPE) {
shotData.depth.format = mmeShotFormatPIPE;
shotData.stencil.format = mmeShotFormatPIPE;
}
if ((shotData.main.format == mmeShotFormatAVI && !mme_aviFormat->integer) || shotData.main.format == mmeShotFormatPIPE) {
shotData.main.type = mmeShotTypeBGR;
} else {
shotData.main.type = mmeShotTypeRGB;
}
if ( mme_screenShotAlpha->integer ) {
if ( shotData.main.format == mmeShotFormatPNG )
shotData.main.type = mmeShotTypeRGBA;
else if ( shotData.main.format == mmeShotFormatTGA )
shotData.main.type = mmeShotTypeRGBA;
}
shotData.main.counter = -1;
shotData.depth.type = mmeShotTypeGray;
shotData.depth.counter = -1;
shotData.stencil.type = mmeShotTypeGray;
shotData.stencil.counter = -1;
}
return (const void *)(cmd + 1);
}
/*
==================
RB_TakeVideoFrameCmd
==================
*/
const void *RB_TakeVideoFrameCmd( const void *data )
{
const videoFrameCommand_t *cmd;
byte *cBuf;
size_t memcount, linelen;
int padwidth, avipadwidth, padlen, avipadlen;
GLint packAlign;
cmd = (const videoFrameCommand_t *)data;
qglGetIntegerv(GL_PACK_ALIGNMENT, &packAlign);
linelen = cmd->width * 3;
// Alignment stuff for glReadPixels
padwidth = PAD(linelen, packAlign);
padlen = padwidth - linelen;
// AVI line padding
avipadwidth = PAD(linelen, AVI_LINE_PADDING);
avipadlen = avipadwidth - linelen;
cBuf = PADP(cmd->captureBuffer, packAlign);
qglReadPixels(0, 0, cmd->width, cmd->height, GL_RGB,
GL_UNSIGNED_BYTE, cBuf);
memcount = padwidth * cmd->height;
// gamma correct
if(glConfig.deviceSupportsGamma)
R_GammaCorrect(cBuf, memcount);
if(cmd->motionJpeg)
{
memcount = RE_SaveJPGToBuffer(cmd->encodeBuffer, linelen * cmd->height,
r_aviMotionJpegQuality->integer,
cmd->width, cmd->height, cBuf, padlen);
ri.CL_WriteAVIVideoFrame(cmd->encodeBuffer, memcount);
}
else
{
byte *lineend, *memend;
byte *srcptr, *destptr;
srcptr = cBuf;
destptr = cmd->encodeBuffer;
memend = srcptr + memcount;
// swap R and B and remove line paddings
while(srcptr < memend)
{
lineend = srcptr + linelen;
while(srcptr < lineend)
{
*destptr++ = srcptr[2];
*destptr++ = srcptr[1];
*destptr++ = srcptr[0];
srcptr += 3;
}
Com_Memset(destptr, '\0', avipadlen);
destptr += avipadlen;
srcptr += padlen;
}
ri.CL_WriteAVIVideoFrame(cmd->encodeBuffer, avipadwidth * cmd->height);
}
return (const void *)(cmd + 1);
}
/*
=================
SV_CheckDRDoS
DRDoS stands for "Distributed Reflected Denial of Service".
See here: http://www.lemuria.org/security/application-drdos.html
Returns qfalse if we're good. qtrue return value means we need to block.
If the address isn't NA_IP, it's automatically denied.
=================
*/
qboolean SV_CheckDRDoS(netadr_t from)
{
netadr_t exactFrom;
int i;
floodBan_t *ban;
int oldestBan;
int oldestBanTime;
int globalCount;
int specificCount;
receipt_t *receipt;
int oldest;
int oldestTime;
static int lastGlobalLogTime = 0;
// Usually the network is smart enough to not allow incoming UDP packets
// with a source address being a spoofed LAN address. Even if that's not
// the case, sending packets to other hosts in the LAN is not a big deal.
// NA_LOOPBACK qualifies as a LAN address.
if (Sys_IsLANAddress(from)) { return qfalse; }
exactFrom = from;
if (from.type == NA_IP) {
from.ip[3] = 0; // xx.xx.xx.0
}
else {
// So we got a connectionless packet but it's not IPv4, so
// what is it? I don't care, it doesn't matter, we'll just block it.
// This probably won't even happen.
return qtrue;
}
// This quick exit strategy while we're being bombarded by getinfo/getstatus requests
// directed at a specific IP address doesn't really impact server performance.
// The code below does its duty very quickly if we're handling a flood packet.
ban = &svs.infoFloodBans[0];
oldestBan = 0;
oldestBanTime = 0x7fffffff;
for (i = 0; i < MAX_INFO_FLOOD_BANS; i++, ban++) {
if (svs.time - ban->time < 120000 && // Two minute ban.
NET_CompareBaseAdr(from, ban->adr)) {
ban->count++;
if (!ban->flood && ((svs.time - ban->time) >= 3000) && ban->count <= 5) {
Com_DPrintf("Unban info flood protect for address %s, they're not flooding\n",
NET_AdrToString(exactFrom));
Com_Memset(ban, 0, sizeof(floodBan_t));
oldestBan = i;
break;
}
if (ban->count >= 180) {
Com_DPrintf("Renewing info flood ban for address %s, received %i getinfo/getstatus requests in %i milliseconds\n",
NET_AdrToString(exactFrom), ban->count, svs.time - ban->time);
ban->time = svs.time;
ban->count = 0;
ban->flood = qtrue;
}
return qtrue;
}
if (ban->time < oldestBanTime) {
oldestBanTime = ban->time;
oldestBan = i;
}
}
// Count receipts in last 2 seconds.
globalCount = 0;
specificCount = 0;
receipt = &svs.infoReceipts[0];
oldest = 0;
oldestTime = 0x7fffffff;
for (i = 0; i < MAX_INFO_RECEIPTS; i++, receipt++) {
if (receipt->time + 2000 > svs.time) {
if (receipt->time) {
// When the server starts, all receipt times are at zero. Furthermore,
// svs.time is close to zero. We check that the receipt time is already
// set so that during the first two seconds after server starts, queries
// from the master servers don't get ignored. As a consequence a potentially
// unlimited number of getinfo+getstatus responses may be sent during the
// first frame of a server's life.
globalCount++;
}
if (NET_CompareBaseAdr(from, receipt->adr)) {
specificCount++;
}
}
if (receipt->time < oldestTime) {
oldestTime = receipt->time;
oldest = i;
}
}
if (specificCount >= 3) { // Already sent 3 to this IP in last 2 seconds.
Com_Printf("Possible DRDoS attack to address %s, putting into temporary getinfo/getstatus ban list\n",
NET_AdrToString(exactFrom));
ban = &svs.infoFloodBans[oldestBan];
ban->adr = from;
ban->time = svs.time;
ban->count = 0;
ban->flood = qfalse;
return qtrue;
}
if (globalCount == MAX_INFO_RECEIPTS) { // All receipts happened in last 2 seconds.
// Detect time wrap where the server sets time back to zero. Problem
// is that we're using a static variable here that doesn't get zeroed out when
// the time wraps. TTimo's way of doing this is casting everything including
// the difference to unsigned int, but I think that's confusing to the programmer.
if (svs.time < lastGlobalLogTime) {
lastGlobalLogTime = 0;
}
if (lastGlobalLogTime + 1000 <= svs.time) { // Limit one log every second.
Com_Printf("Detected flood of arbitrary getinfo/getstatus connectionless packets\n");
lastGlobalLogTime = svs.time;
}
return qtrue;
}
receipt = &svs.infoReceipts[oldest];
receipt->adr = from;
receipt->time = svs.time;
return qfalse;
}
/*
===============
GLimp_SetMode
===============
*/
static rserr_t GLimp_SetMode(int mode, qboolean fullscreen, qboolean noborder)
{
const char *glstring;
int perChannelColorBits;
int colorBits, depthBits, stencilBits;
//int samples;
int i = 0;
Uint32 flags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
SDL_DisplayMode desktopMode;
int display = 0;
int x = SDL_WINDOWPOS_UNDEFINED, y = SDL_WINDOWPOS_UNDEFINED;
Com_Printf( "Initializing OpenGL display\n");
if ( r_allowResize->integer && !fullscreen )
flags |= SDL_WINDOW_RESIZABLE;
// If a window exists, note its display index
if( screen != NULL )
display = SDL_GetWindowDisplayIndex( screen );
if( SDL_GetDesktopDisplayMode( display, &desktopMode ) == 0 )
{
displayAspect = (float)desktopMode.w / (float)desktopMode.h;
Com_Printf( "Display aspect: %.3f\n", displayAspect );
}
else
{
Com_Memset( &desktopMode, 0, sizeof( SDL_DisplayMode ) );
Com_Printf( "Cannot determine display aspect, assuming 1.333\n" );
}
Com_Printf( "...setting mode %d:", mode );
if (mode == -2)
{
// use desktop video resolution
if( desktopMode.h > 0 )
{
glConfig.vidWidth = desktopMode.w;
glConfig.vidHeight = desktopMode.h;
}
else
{
glConfig.vidWidth = 640;
glConfig.vidHeight = 480;
Com_Printf( "Cannot determine display resolution, assuming 640x480\n" );
}
//glConfig.windowAspect = (float)glConfig.vidWidth / (float)glConfig.vidHeight;
}
else if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, /*&glConfig.windowAspect,*/ mode ) )
{
Com_Printf( " invalid mode\n" );
return RSERR_INVALID_MODE;
}
Com_Printf( " %d %d\n", glConfig.vidWidth, glConfig.vidHeight);
// Center window
if( r_centerWindow->integer && !fullscreen )
{
x = ( desktopMode.w / 2 ) - ( glConfig.vidWidth / 2 );
y = ( desktopMode.h / 2 ) - ( glConfig.vidHeight / 2 );
}
// Destroy existing state if it exists
if( opengl_context != NULL )
{
SDL_GL_DeleteContext( opengl_context );
opengl_context = NULL;
}
if( screen != NULL )
{
SDL_GetWindowPosition( screen, &x, &y );
ri->Printf( PRINT_DEVELOPER, "Existing window at %dx%d before being destroyed\n", x, y );
SDL_DestroyWindow( screen );
screen = NULL;
}
if( fullscreen )
{
flags |= SDL_WINDOW_FULLSCREEN;
glConfig.isFullscreen = qtrue;
}
else
{
if( noborder )
flags |= SDL_WINDOW_BORDERLESS;
glConfig.isFullscreen = qfalse;
}
colorBits = r_colorbits->value;
if ((!colorBits) || (colorBits >= 32))
colorBits = 24;
if (!r_depthbits->value)
depthBits = 24;
else
depthBits = r_depthbits->value;
stencilBits = r_stencilbits->value;
//samples = r_ext_multisample->value;
for (i = 0; i < 16; i++)
{
int testColorBits, testDepthBits, testStencilBits;
// 0 - default
// 1 - minus colorBits
// 2 - minus depthBits
// 3 - minus stencil
if ((i % 4) == 0 && i)
{
// one pass, reduce
switch (i / 4)
{
case 2 :
if (colorBits == 24)
colorBits = 16;
break;
case 1 :
if (depthBits == 24)
depthBits = 16;
else if (depthBits == 16)
depthBits = 8;
case 3 :
if (stencilBits == 24)
stencilBits = 16;
else if (stencilBits == 16)
stencilBits = 8;
}
}
testColorBits = colorBits;
testDepthBits = depthBits;
testStencilBits = stencilBits;
if ((i % 4) == 3)
{ // reduce colorBits
if (testColorBits == 24)
testColorBits = 16;
}
if ((i % 4) == 2)
{ // reduce depthBits
if (testDepthBits == 24)
testDepthBits = 16;
else if (testDepthBits == 16)
testDepthBits = 8;
}
if ((i % 4) == 1)
{ // reduce stencilBits
if (testStencilBits == 24)
testStencilBits = 16;
else if (testStencilBits == 16)
testStencilBits = 8;
else
testStencilBits = 0;
}
if (testColorBits == 24)
perChannelColorBits = 8;
else
perChannelColorBits = 4;
#ifdef __sgi /* Fix for SGIs grabbing too many bits of color */
if (perChannelColorBits == 4)
perChannelColorBits = 0; /* Use minimum size for 16-bit color */
/* Need alpha or else SGIs choose 36+ bit RGB mode */
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 1);
#endif
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, testDepthBits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, testStencilBits );
/*SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, samples );*/
if(r_stereo->integer)
{
glConfig.stereoEnabled = qtrue;
SDL_GL_SetAttribute(SDL_GL_STEREO, 1);
}
else
{
glConfig.stereoEnabled = qfalse;
SDL_GL_SetAttribute(SDL_GL_STEREO, 0);
}
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
// If not allowing software GL, demand accelerated
if( !r_allowSoftwareGL->integer )
SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 );
if( ( screen = SDL_CreateWindow( CLIENT_WINDOW_TITLE, x, y,
glConfig.vidWidth, glConfig.vidHeight, flags ) ) == NULL )
{
ri->Printf( PRINT_DEVELOPER, "SDL_CreateWindow failed: %s\n", SDL_GetError( ) );
continue;
}
if( fullscreen )
{
SDL_DisplayMode mode;
switch( testColorBits )
{
case 16: mode.format = SDL_PIXELFORMAT_RGB565; break;
case 24: mode.format = SDL_PIXELFORMAT_RGB24; break;
default: ri->Printf( PRINT_DEVELOPER, "testColorBits is %d, can't fullscreen\n", testColorBits ); continue;
}
mode.w = glConfig.vidWidth;
mode.h = glConfig.vidHeight;
mode.refresh_rate = glConfig.displayFrequency = ri->Cvar_VariableIntegerValue( "r_displayRefresh" );
mode.driverdata = NULL;
if( SDL_SetWindowDisplayMode( screen, &mode ) < 0 )
{
ri->Printf( PRINT_DEVELOPER, "SDL_SetWindowDisplayMode failed: %s\n", SDL_GetError( ) );
continue;
}
}
SDL_SetWindowTitle( screen, CLIENT_WINDOW_TITLE );
if( ( opengl_context = SDL_GL_CreateContext( screen ) ) == NULL )
{
Com_Printf( "SDL_GL_CreateContext failed: %s\n", SDL_GetError( ) );
continue;
}
qglClearColor( 0, 0, 0, 1 );
qglClear( GL_COLOR_BUFFER_BIT );
SDL_GL_SwapWindow( screen );
SDL_GL_SetSwapInterval( r_swapInterval->integer );
glConfig.colorBits = testColorBits;
glConfig.depthBits = testDepthBits;
glConfig.stencilBits = testStencilBits;
Com_Printf( "Using %d color bits, %d depth, %d stencil display.\n",
glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits );
break;
}
if (!GLimp_DetectAvailableModes())
{
return RSERR_UNKNOWN;
}
glstring = (char *) qglGetString (GL_RENDERER);
Com_Printf( "GL_RENDERER: %s\n", glstring );
return RSERR_OK;
}
qboolean R_LoadMD5(model_t *mod, void *buffer, int bufferSize, const char *modName)
{
int i, j, k;
md5Model_t *md5;
md5Bone_t *bone;
md5Surface_t *surf;
srfTriangle_t *tri;
md5Vertex_t *v;
md5Weight_t *weight;
int version;
shader_t *sh;
char *buf_p = ( char * ) buffer;
char *token;
vec3_t boneOrigin;
quat_t boneQuat;
mat4_t boneMat;
int numRemaining;
growList_t sortedTriangles;
growList_t vboTriangles;
growList_t vboSurfaces;
int numBoneReferences;
int boneReferences[MAX_BONES];
// skip MD5Version indent string
(void) COM_ParseExt2(&buf_p, qfalse);
// check version
token = COM_ParseExt2(&buf_p, qfalse);
version = atoi(token);
if (version != MD5_VERSION)
{
Ren_Warning("R_LoadMD5: %s has wrong version (%i should be %i)\n", modName, version, MD5_VERSION);
return qfalse;
}
mod->type = MOD_MD5;
mod->dataSize += sizeof(md5Model_t);
md5 = mod->md5 = ri.Hunk_Alloc(sizeof(md5Model_t), h_low);
// skip commandline <arguments string>
token = COM_ParseExt2(&buf_p, qtrue);
token = COM_ParseExt2(&buf_p, qtrue);
// Ren_Print("%s\n", token);
// parse numJoints <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numJoints"))
{
Ren_Warning("R_LoadMD5: expected 'numJoints' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
md5->numBones = atoi(token);
// parse numMeshes <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numMeshes"))
{
Ren_Warning("R_LoadMD5: expected 'numMeshes' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
md5->numSurfaces = atoi(token);
//Ren_Print("R_LoadMD5: '%s' has %i surfaces\n", modName, md5->numSurfaces);
if (md5->numBones < 1)
{
Ren_Warning("R_LoadMD5: '%s' has no bones\n", modName);
return qfalse;
}
if (md5->numBones > MAX_BONES)
{
Ren_Warning("R_LoadMD5: '%s' has more than %i bones (%i)\n", modName, MAX_BONES, md5->numBones);
return qfalse;
}
//Ren_Print("R_LoadMD5: '%s' has %i bones\n", modName, md5->numBones);
// parse all the bones
md5->bones = ri.Hunk_Alloc(sizeof(*bone) * md5->numBones, h_low);
// parse joints {
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "joints"))
{
Ren_Warning("R_LoadMD5: expected 'joints' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "{"))
{
Ren_Warning("R_LoadMD5: expected '{' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (i = 0, bone = md5->bones; i < md5->numBones; i++, bone++)
{
token = COM_ParseExt2(&buf_p, qtrue);
Q_strncpyz(bone->name, token, sizeof(bone->name));
//Ren_Print("R_LoadMD5: '%s' has bone '%s'\n", modName, bone->name);
token = COM_ParseExt2(&buf_p, qfalse);
bone->parentIndex = atoi(token);
//Ren_Print("R_LoadMD5: '%s' has bone '%s' with parent index %i\n", modName, bone->name, bone->parentIndex);
if (bone->parentIndex >= md5->numBones)
{
Ren_Drop("R_LoadMD5: '%s' has bone '%s' with bad parent index %i while numBones is %i", modName,
bone->name, bone->parentIndex, md5->numBones);
}
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (j = 0; j < 3; j++)
{
token = COM_ParseExt2(&buf_p, qfalse);
boneOrigin[j] = atof(token);
}
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
Ren_Warning("R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (j = 0; j < 3; j++)
{
token = COM_ParseExt2(&buf_p, qfalse);
boneQuat[j] = atof(token);
}
QuatCalcW(boneQuat);
mat4_from_quat(boneMat, boneQuat);
VectorCopy(boneOrigin, bone->origin);
quat_copy(boneQuat, bone->rotation);
MatrixSetupTransformFromQuat(bone->inverseTransform, boneQuat, boneOrigin);
mat4_inverse_self(bone->inverseTransform);
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
}
// parse }
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "}"))
{
Ren_Warning("R_LoadMD5: expected '}' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// parse all the surfaces
if (md5->numSurfaces < 1)
{
Ren_Warning("R_LoadMD5: '%s' has no surfaces\n", modName);
return qfalse;
}
//Ren_Print("R_LoadMD5: '%s' has %i surfaces\n", modName, md5->numSurfaces);
md5->surfaces = ri.Hunk_Alloc(sizeof(*surf) * md5->numSurfaces, h_low);
for (i = 0, surf = md5->surfaces; i < md5->numSurfaces; i++, surf++)
{
// parse mesh {
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "mesh"))
{
Ren_Warning("R_LoadMD5: expected 'mesh' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "{"))
{
Ren_Warning("R_LoadMD5: expected '{' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// change to surface identifier
surf->surfaceType = SF_MD5;
// give pointer to model for Tess_SurfaceMD5
surf->model = md5;
// parse shader <name>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "shader"))
{
Ren_Warning("R_LoadMD5: expected 'shader' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
Q_strncpyz(surf->shader, token, sizeof(surf->shader));
//Ren_Print("R_LoadMD5: '%s' uses shader '%s'\n", modName, surf->shader);
// FIXME .md5mesh meshes don't have surface names
// lowercase the surface name so skin compares are faster
//Q_strlwr(surf->name);
//Ren_Print("R_LoadMD5: '%s' has surface '%s'\n", modName, surf->name);
// register the shaders
sh = R_FindShader(surf->shader, SHADER_3D_DYNAMIC, qtrue);
if (sh->defaultShader)
{
surf->shaderIndex = 0;
}
else
{
surf->shaderIndex = sh->index;
}
// parse numVerts <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numVerts"))
{
Ren_Warning("R_LoadMD5: expected 'numVerts' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
surf->numVerts = atoi(token);
if (surf->numVerts > SHADER_MAX_VERTEXES)
{
Ren_Drop("R_LoadMD5: '%s' has more than %i verts on a surface (%i)",
modName, SHADER_MAX_VERTEXES, surf->numVerts);
}
surf->verts = ri.Hunk_Alloc(sizeof(*v) * surf->numVerts, h_low);
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
// skip vert <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "vert"))
{
Ren_Warning("R_LoadMD5: expected 'vert' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
(void) COM_ParseExt2(&buf_p, qfalse);
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (k = 0; k < 2; k++)
{
token = COM_ParseExt2(&buf_p, qfalse);
v->texCoords[k] = atof(token);
}
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
Ren_Warning("R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
v->firstWeight = atoi(token);
token = COM_ParseExt2(&buf_p, qfalse);
v->numWeights = atoi(token);
if (v->numWeights > MAX_WEIGHTS)
{
Ren_Drop("R_LoadMD5: vertex %i requires more than %i weights on surface (%i) in model '%s'",
j, MAX_WEIGHTS, i, modName);
}
}
// parse numTris <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numTris"))
{
Ren_Warning("R_LoadMD5: expected 'numTris' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
surf->numTriangles = atoi(token);
if (surf->numTriangles > SHADER_MAX_TRIANGLES)
{
Ren_Drop("R_LoadMD5: '%s' has more than %i triangles on a surface (%i)",
modName, SHADER_MAX_TRIANGLES, surf->numTriangles);
}
surf->triangles = ri.Hunk_Alloc(sizeof(*tri) * surf->numTriangles, h_low);
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
// skip tri <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "tri"))
{
Ren_Warning("R_LoadMD5: expected 'tri' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
(void) COM_ParseExt2(&buf_p, qfalse);
for (k = 0; k < 3; k++)
{
token = COM_ParseExt2(&buf_p, qfalse);
tri->indexes[k] = atoi(token);
}
}
// parse numWeights <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numWeights"))
{
Ren_Warning("R_LoadMD5: expected 'numWeights' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
surf->numWeights = atoi(token);
surf->weights = ri.Hunk_Alloc(sizeof(*weight) * surf->numWeights, h_low);
for (j = 0, weight = surf->weights; j < surf->numWeights; j++, weight++)
{
// skip weight <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "weight"))
{
Ren_Warning("R_LoadMD5: expected 'weight' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
(void) COM_ParseExt2(&buf_p, qfalse);
token = COM_ParseExt2(&buf_p, qfalse);
weight->boneIndex = atoi(token);
token = COM_ParseExt2(&buf_p, qfalse);
weight->boneWeight = atof(token);
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (k = 0; k < 3; k++)
{
token = COM_ParseExt2(&buf_p, qfalse);
weight->offset[k] = atof(token);
}
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
Ren_Warning("R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
}
// parse }
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "}"))
{
Ren_Warning("R_LoadMD5: expected '}' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// loop trough all vertices and set up the vertex weights
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
v->weights = ri.Hunk_Alloc(sizeof(*v->weights) * v->numWeights, h_low);
for (k = 0; k < v->numWeights; k++)
{
v->weights[k] = surf->weights + (v->firstWeight + k);
}
}
}
// loading is done now calculate the bounding box and tangent spaces
ClearBounds(md5->bounds[0], md5->bounds[1]);
for (i = 0, surf = md5->surfaces; i < md5->numSurfaces; i++, surf++)
{
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
vec3_t tmpVert;
md5Weight_t *w;
VectorClear(tmpVert);
for (k = 0, w = v->weights[0]; k < v->numWeights; k++, w++)
{
vec3_t offsetVec;
bone = &md5->bones[w->boneIndex];
QuatTransformVector(bone->rotation, w->offset, offsetVec);
VectorAdd(bone->origin, offsetVec, offsetVec);
VectorMA(tmpVert, w->boneWeight, offsetVec, tmpVert);
}
VectorCopy(tmpVert, v->position);
AddPointToBounds(tmpVert, md5->bounds[0], md5->bounds[1]);
}
// calc tangent spaces
#if 1
{
const float *v0, *v1, *v2;
const float *t0, *t1, *t2;
vec3_t tangent;
vec3_t binormal;
vec3_t normal;
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
VectorClear(v->tangent);
VectorClear(v->binormal);
VectorClear(v->normal);
}
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
v0 = surf->verts[tri->indexes[0]].position;
v1 = surf->verts[tri->indexes[1]].position;
v2 = surf->verts[tri->indexes[2]].position;
t0 = surf->verts[tri->indexes[0]].texCoords;
t1 = surf->verts[tri->indexes[1]].texCoords;
t2 = surf->verts[tri->indexes[2]].texCoords;
#if 1
R_CalcTangentSpace(tangent, binormal, normal, v0, v1, v2, t0, t1, t2);
#else
R_CalcNormalForTriangle(normal, v0, v1, v2);
R_CalcTangentsForTriangle(tangent, binormal, v0, v1, v2, t0, t1, t2);
#endif
for (k = 0; k < 3; k++)
{
float *v;
v = surf->verts[tri->indexes[k]].tangent;
VectorAdd(v, tangent, v);
v = surf->verts[tri->indexes[k]].binormal;
VectorAdd(v, binormal, v);
v = surf->verts[tri->indexes[k]].normal;
VectorAdd(v, normal, v);
}
}
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
VectorNormalize(v->tangent);
VectorNormalize(v->binormal);
VectorNormalize(v->normal);
}
}
#else
{
int k;
float bb, s, t;
vec3_t bary;
vec3_t faceNormal;
md5Vertex_t *dv[3];
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
dv[0] = &surf->verts[tri->indexes[0]];
dv[1] = &surf->verts[tri->indexes[1]];
dv[2] = &surf->verts[tri->indexes[2]];
R_CalcNormalForTriangle(faceNormal, dv[0]->position, dv[1]->position, dv[2]->position);
// calculate barycentric basis for the triangle
bb = (dv[1]->texCoords[0] - dv[0]->texCoords[0]) * (dv[2]->texCoords[1] - dv[0]->texCoords[1]) - (dv[2]->texCoords[0] - dv[0]->texCoords[0]) * (dv[1]->texCoords[1] -
dv[0]->texCoords[1]);
if (fabs(bb) < 0.00000001f)
{
continue;
}
// do each vertex
for (k = 0; k < 3; k++)
{
// calculate s tangent vector
s = dv[k]->texCoords[0] + 10.0f;
t = dv[k]->texCoords[1];
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->tangent[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->tangent[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->tangent[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->tangent, dv[k]->position, dv[k]->tangent);
VectorNormalize(dv[k]->tangent);
// calculate t tangent vector (binormal)
s = dv[k]->texCoords[0];
t = dv[k]->texCoords[1] + 10.0f;
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->binormal[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->binormal[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->binormal[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->binormal, dv[k]->position, dv[k]->binormal);
VectorNormalize(dv[k]->binormal);
// calculate the normal as cross product N=TxB
#if 0
CrossProduct(dv[k]->tangent, dv[k]->binormal, dv[k]->normal);
VectorNormalize(dv[k]->normal);
// Gram-Schmidt orthogonalization process for B
// compute the cross product B=NxT to obtain
// an orthogonal basis
CrossProduct(dv[k]->normal, dv[k]->tangent, dv[k]->binormal);
if (DotProduct(dv[k]->normal, faceNormal) < 0)
{
VectorInverse(dv[k]->normal);
//VectorInverse(dv[k]->tangent);
//VectorInverse(dv[k]->binormal);
}
#else
VectorAdd(dv[k]->normal, faceNormal, dv[k]->normal);
#endif
}
}
#if 1
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
//VectorNormalize(v->tangent);
//VectorNormalize(v->binormal);
VectorNormalize(v->normal);
}
#endif
}
#endif
#if 0
// do another extra smoothing for normals to avoid flat shading
for (j = 0; j < surf->numVerts; j++)
{
for (k = 0; k < surf->numVerts; k++)
{
if (j == k)
{
continue;
}
if (VectorCompare(surf->verts[j].position, surf->verts[k].position))
{
VectorAdd(surf->verts[j].normal, surf->verts[k].normal, surf->verts[j].normal);
}
}
VectorNormalize(surf->verts[j].normal);
}
#endif
}
// split the surfaces into VBO surfaces by the maximum number of GPU vertex skinning bones
Com_InitGrowList(&vboSurfaces, 10);
for (i = 0, surf = md5->surfaces; i < md5->numSurfaces; i++, surf++)
{
// sort triangles
Com_InitGrowList(&sortedTriangles, 1000);
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
skelTriangle_t *sortTri = Com_Allocate(sizeof(*sortTri));
for (k = 0; k < 3; k++)
{
sortTri->indexes[k] = tri->indexes[k];
sortTri->vertexes[k] = &surf->verts[tri->indexes[k]];
}
sortTri->referenced = qfalse;
Com_AddToGrowList(&sortedTriangles, sortTri);
}
//qsort(sortedTriangles.elements, sortedTriangles.currentElements, sizeof(void *), CompareTrianglesByBoneReferences);
#if 0
for (j = 0; j < sortedTriangles.currentElements; j++)
{
int b[MAX_WEIGHTS * 3];
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
for (k = 0; k < 3; k++)
{
v = sortTri->vertexes[k];
for (l = 0; l < MAX_WEIGHTS; l++)
{
b[k * 3 + l] = (l < v->numWeights) ? v->weights[l]->boneIndex : 9999;
}
qsort(b, MAX_WEIGHTS * 3, sizeof(int), CompareBoneIndices);
//Ren_Print("bone indices: %i %i %i %i\n", b[k * 3 + 0], b[k * 3 + 1], b[k * 3 + 2], b[k * 3 + 3]);
}
}
#endif
numRemaining = sortedTriangles.currentElements;
while (numRemaining)
{
numBoneReferences = 0;
Com_Memset(boneReferences, 0, sizeof(boneReferences));
Com_InitGrowList(&vboTriangles, 1000);
for (j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
if (sortTri->referenced)
{
continue;
}
if (AddTriangleToVBOTriangleList(&vboTriangles, sortTri, &numBoneReferences, boneReferences))
{
sortTri->referenced = qtrue;
}
}
if (!vboTriangles.currentElements)
{
Ren_Warning("R_LoadMD5: could not add triangles to a remaining VBO surfaces for model '%s'\n", modName);
Com_DestroyGrowList(&vboTriangles);
break;
}
AddSurfaceToVBOSurfacesList(&vboSurfaces, &vboTriangles, md5, surf, i, numBoneReferences, boneReferences);
numRemaining -= vboTriangles.currentElements;
Com_DestroyGrowList(&vboTriangles);
}
for (j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
Com_Dealloc(sortTri);
}
Com_DestroyGrowList(&sortedTriangles);
}
// move VBO surfaces list to hunk
md5->numVBOSurfaces = vboSurfaces.currentElements;
md5->vboSurfaces = ri.Hunk_Alloc(md5->numVBOSurfaces * sizeof(*md5->vboSurfaces), h_low);
for (i = 0; i < md5->numVBOSurfaces; i++)
{
md5->vboSurfaces[i] = ( srfVBOMD5Mesh_t * ) Com_GrowListElement(&vboSurfaces, i);
}
Com_DestroyGrowList(&vboSurfaces);
return qtrue;
}
/*
===============
R_Init
===============
*/
void R_Init( void ) {
int err;
int i;
byte *ptr;
ri.Printf( PRINT_ALL, "----- R_Init -----\n" );
// clear all our internal state
Com_Memset( &tr, 0, sizeof( tr ) );
Com_Memset( &backEnd, 0, sizeof( backEnd ) );
Com_Memset( &tess, 0, sizeof( tess ) );
// Swap_Init();
if ( (intptr_t)tess.xyz & 15 ) {
Com_Printf( "WARNING: tess.xyz not 16 byte aligned\n" );
}
Com_Memset( tess.constantColor255, 255, sizeof( tess.constantColor255 ) );
//
// init function tables
//
for ( i = 0; i < FUNCTABLE_SIZE; i++ )
{
tr.sinTable[i] = sin( DEG2RAD( i * 360.0f / ( ( float ) ( FUNCTABLE_SIZE - 1 ) ) ) );
tr.squareTable[i] = ( i < FUNCTABLE_SIZE/2 ) ? 1.0f : -1.0f;
tr.sawToothTable[i] = (float)i / FUNCTABLE_SIZE;
tr.inverseSawToothTable[i] = 1.0f - tr.sawToothTable[i];
if ( i < FUNCTABLE_SIZE / 2 )
{
if ( i < FUNCTABLE_SIZE / 4 )
{
tr.triangleTable[i] = ( float ) i / ( FUNCTABLE_SIZE / 4 );
}
else
{
tr.triangleTable[i] = 1.0f - tr.triangleTable[i-FUNCTABLE_SIZE / 4];
}
}
else
{
tr.triangleTable[i] = -tr.triangleTable[i-FUNCTABLE_SIZE/2];
}
}
R_InitFogTable();
R_NoiseInit();
R_Register();
max_polys = r_maxpolys->integer;
if (max_polys < MAX_POLYS)
max_polys = MAX_POLYS;
max_polyverts = r_maxpolyverts->integer;
if (max_polyverts < MAX_POLYVERTS)
max_polyverts = MAX_POLYVERTS;
ptr = ri.Hunk_Alloc( sizeof( *backEndData[0] ) + sizeof(srfPoly_t) * max_polys + sizeof(polyVert_t) * max_polyverts, h_low);
backEndData[0] = (backEndData_t *) ptr;
backEndData[0]->polys = (srfPoly_t *) ((char *) ptr + sizeof( *backEndData[0] ));
backEndData[0]->polyVerts = (polyVert_t *) ((char *) ptr + sizeof( *backEndData[0] ) + sizeof(srfPoly_t) * max_polys);
if ( r_smp->integer ) {
ptr = ri.Hunk_Alloc( sizeof( *backEndData[1] ) + sizeof(srfPoly_t) * max_polys + sizeof(polyVert_t) * max_polyverts, h_low);
backEndData[1] = (backEndData_t *) ptr;
backEndData[1]->polys = (srfPoly_t *) ((char *) ptr + sizeof( *backEndData[1] ));
backEndData[1]->polyVerts = (polyVert_t *) ((char *) ptr + sizeof( *backEndData[1] ) + sizeof(srfPoly_t) * max_polys);
} else {
backEndData[1] = NULL;
}
R_ToggleSmpFrame();
InitOpenGL();
R_InitImages();
R_InitShaders();
R_InitSkins();
R_ModelInit();
R_InitFreeType();
err = qglGetError();
if ( err != GL_NO_ERROR )
ri.Printf (PRINT_ALL, "glGetError() = 0x%x\n", err);
ri.Printf( PRINT_ALL, "----- finished R_Init -----\n" );
}
/*
==================
CL_ParseGamestate
==================
*/
void CL_ParseGamestate( msg_t *msg ) {
int i;
entityState_t *es;
int newnum;
entityState_t nullstate;
int cmd;
char *s;
Con_Close();
clc.connectPacketCount = 0;
// wipe local client state
CL_ClearState();
#ifdef _DONETPROFILE_
int startBytes,endBytes;
startBytes=msg->readcount;
#endif
// a gamestate always marks a server command sequence
clc.serverCommandSequence = MSG_ReadLong( msg );
// parse all the configstrings and baselines
cl.gameState.dataCount = 1; // leave a 0 at the beginning for uninitialized configstrings
while ( 1 ) {
cmd = MSG_ReadByte( msg );
if ( cmd == svc_EOF ) {
break;
}
if ( cmd == svc_configstring ) {
int len, start;
start = msg->readcount;
i = MSG_ReadShort( msg );
if ( i < 0 || i >= MAX_CONFIGSTRINGS ) {
Com_Error( ERR_DROP, "configstring > MAX_CONFIGSTRINGS" );
}
s = MSG_ReadBigString( msg );
if (cl_shownet->integer >= 2)
{
Com_Printf("%3i: %d: %s\n", start, i, s);
}
/*
if (i == CS_SERVERINFO)
{ //get the special value here
char *f = strstr(s, "g_debugMelee");
if (f)
{
while (*f && *f != '\\')
{ //find the \ after it
f++;
}
if (*f == '\\')
{ //got it
int i = 0;
f++;
while (*f && *f != '\\' && i < 128)
{
hiddenCvarVal[i] = *f;
i++;
f++;
}
hiddenCvarVal[i] = 0;
//resume here
s = f;
}
}
}
*/
len = strlen( s );
if ( len + 1 + cl.gameState.dataCount > MAX_GAMESTATE_CHARS ) {
Com_Error( ERR_DROP, "MAX_GAMESTATE_CHARS exceeded" );
}
// append it to the gameState string buffer
cl.gameState.stringOffsets[ i ] = cl.gameState.dataCount;
Com_Memcpy( cl.gameState.stringData + cl.gameState.dataCount, s, len + 1 );
cl.gameState.dataCount += len + 1;
} else if ( cmd == svc_baseline ) {
newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
if ( newnum < 0 || newnum >= MAX_GENTITIES ) {
Com_Error( ERR_DROP, "Baseline number out of range: %i", newnum );
}
Com_Memset (&nullstate, 0, sizeof(nullstate));
es = &cl.entityBaselines[ newnum ];
MSG_ReadDeltaEntity( msg, &nullstate, es, newnum );
} else {
Com_Error( ERR_DROP, "CL_ParseGamestate: bad command byte" );
}
}
clc.clientNum = MSG_ReadLong(msg);
// read the checksum feed
clc.checksumFeed = MSG_ReadLong( msg );
CL_ParseRMG ( msg ); //rwwRMG - get info for it from the server
#ifdef _DONETPROFILE_
endBytes=msg->readcount;
// ClReadProf().AddField("svc_gamestate",endBytes-startBytes);
#endif
// parse serverId and other cvars
CL_SystemInfoChanged();
// parse useful values out of CS_SERVERINFO
CL_ParseServerInfo();
// reinitialize the filesystem if the game directory has changed
if( FS_ConditionalRestart( clc.checksumFeed ) ) {
// don't set to true because we yet have to start downloading
// enabling this can cause double loading of a map when connecting to
// a server which has a different game directory set
//clc.downloadRestart = qtrue;
}
// This used to call CL_StartHunkUsers, but now we enter the download state before loading the
// cgame
CL_InitDownloads();
// make sure the game starts
Cvar_Set( "cl_paused", "0" );
}
/*
=================
VM_LoadQVM
Load a .qvm file
=================
*/
vmHeader_t *VM_LoadQVM( vm_t *vm, qboolean alloc, qboolean unpure)
{
int dataLength;
int i;
char filename[MAX_QPATH];
union {
vmHeader_t *h;
void *v;
} header;
// load the image
Com_sprintf( filename, sizeof(filename), "vm/%s.qvm", vm->name );
Com_Printf( "Loading vm file %s...\n", filename );
FS_ReadFileDir(filename, vm->searchPath, unpure, &header.v);
if ( !header.h ) {
Com_Printf( "Failed.\n" );
VM_Free( vm );
Com_Printf(S_COLOR_YELLOW "Warning: Couldn't open VM file %s\n", filename);
return NULL;
}
// show where the qvm was loaded from
FS_Which(filename, vm->searchPath);
// mecwerks: also set to running on ios if loading from an IOS pakfile
FS_iOSCheck(filename, vm->searchPath);
if( LittleLong( header.h->vmMagic ) == VM_MAGIC_VER2 ) {
Com_Printf( "...which has vmMagic VM_MAGIC_VER2\n" );
// byte swap the header
for ( i = 0 ; i < sizeof( vmHeader_t ) / 4 ; i++ ) {
((int *)header.h)[i] = LittleLong( ((int *)header.h)[i] );
}
// validate
if ( header.h->jtrgLength < 0
|| header.h->bssLength < 0
|| header.h->dataLength < 0
|| header.h->litLength < 0
|| header.h->codeLength <= 0 )
{
VM_Free(vm);
FS_FreeFile(header.v);
Com_Printf(S_COLOR_YELLOW "Warning: %s has bad header\n", filename);
return NULL;
}
} else if( LittleLong( header.h->vmMagic ) == VM_MAGIC ) {
// byte swap the header
// sizeof( vmHeader_t ) - sizeof( int ) is the 1.32b vm header size
for ( i = 0 ; i < ( sizeof( vmHeader_t ) - sizeof( int ) ) / 4 ; i++ ) {
((int *)header.h)[i] = LittleLong( ((int *)header.h)[i] );
}
// validate
if ( header.h->bssLength < 0
|| header.h->dataLength < 0
|| header.h->litLength < 0
|| header.h->codeLength <= 0 )
{
VM_Free(vm);
FS_FreeFile(header.v);
Com_Printf(S_COLOR_YELLOW "Warning: %s has bad header\n", filename);
return NULL;
}
} else {
VM_Free( vm );
FS_FreeFile(header.v);
Com_Printf(S_COLOR_YELLOW "Warning: %s does not have a recognisable "
"magic number in its header\n", filename);
return NULL;
}
// round up to next power of 2 so all data operations can
// be mask protected
dataLength = header.h->dataLength + header.h->litLength +
header.h->bssLength;
for ( i = 0 ; dataLength > ( 1 << i ) ; i++ ) {
}
dataLength = 1 << i;
if(alloc)
{
// allocate zero filled space for initialized and uninitialized data
vm->dataBase = Hunk_Alloc(dataLength, h_high);
vm->dataMask = dataLength - 1;
}
else
{
// clear the data, but make sure we're not clearing more than allocated
if(vm->dataMask + 1 != dataLength)
{
VM_Free(vm);
FS_FreeFile(header.v);
Com_Printf(S_COLOR_YELLOW "Warning: Data region size of %s not matching after "
"VM_Restart()\n", filename);
return NULL;
}
Com_Memset(vm->dataBase, 0, dataLength);
}
// copy the intialized data
Com_Memcpy( vm->dataBase, (byte *)header.h + header.h->dataOffset,
header.h->dataLength + header.h->litLength );
// byte swap the longs
for ( i = 0 ; i < header.h->dataLength ; i += 4 ) {
*(int *)(vm->dataBase + i) = LittleLong( *(int *)(vm->dataBase + i ) );
}
if(header.h->vmMagic == VM_MAGIC_VER2)
{
int previousNumJumpTableTargets = vm->numJumpTableTargets;
header.h->jtrgLength &= ~0x03;
vm->numJumpTableTargets = header.h->jtrgLength >> 2;
Com_Printf("Loading %d jump table targets\n", vm->numJumpTableTargets);
if(alloc)
{
vm->jumpTableTargets = Hunk_Alloc(header.h->jtrgLength, h_high);
}
else
{
if(vm->numJumpTableTargets != previousNumJumpTableTargets)
{
VM_Free(vm);
FS_FreeFile(header.v);
Com_Printf(S_COLOR_YELLOW "Warning: Jump table size of %s not matching after "
"VM_Restart()\n", filename);
return NULL;
}
Com_Memset(vm->jumpTableTargets, 0, header.h->jtrgLength);
}
Com_Memcpy(vm->jumpTableTargets, (byte *) header.h + header.h->dataOffset +
header.h->dataLength + header.h->litLength, header.h->jtrgLength);
// byte swap the longs
for ( i = 0 ; i < header.h->jtrgLength ; i += 4 ) {
*(int *)(vm->jumpTableTargets + i) = LittleLong( *(int *)(vm->jumpTableTargets + i ) );
}
}
/*
==============
Sys_ClearExecBuffer
==============
*/
static void Sys_ClearExecBuffer( void )
{
execBufferPointer = execBuffer;
Com_Memset( execArgv, 0, sizeof( execArgv ) );
execArgc = 0;
}
//===========================================================================
// predicts the movement
// assumes regular bounding box sizes
// NOTE: out of water jumping is not included
// NOTE: grappling hook is not included
//
// Parameter: origin : origin to start with
// presencetype : presence type to start with
// velocity : velocity to start with
// cmdmove : client command movement
// cmdframes : number of frame cmdmove is valid
// maxframes : maximum number of predicted frames
// frametime : duration of one predicted frame
// stopevent : events that stop the prediction
// stopareanum : stop as soon as entered this area
// Returns: aas_clientmove_t
// Changes Globals: -
//===========================================================================
int AAS_ClientMovementPrediction(struct aas_clientmove_s *move,
int entnum, vec3_t origin,
int presencetype, int onground,
vec3_t velocity, vec3_t cmdmove,
int cmdframes,
int maxframes, float frametime,
int stopevent, int stopareanum,
vec3_t mins, vec3_t maxs, int visualize)
{
float phys_friction, phys_stopspeed, phys_gravity, phys_waterfriction;
float phys_watergravity;
float phys_walkaccelerate, phys_airaccelerate, phys_swimaccelerate;
float phys_maxwalkvelocity, phys_maxcrouchvelocity, phys_maxswimvelocity;
float phys_maxstep, phys_maxsteepness, phys_jumpvel, friction;
float gravity, delta, maxvel, wishspeed, accelerate;
//float velchange, newvel;
int n, i, j, pc, step, swimming, ax, crouch, event, jump_frame, areanum;
int areas[20], numareas;
vec3_t points[20];
vec3_t org, end, feet, start, stepend, lastorg, wishdir;
vec3_t frame_test_vel, old_frame_test_vel, left_test_vel;
vec3_t up = {0, 0, 1};
aas_plane_t *plane, *plane2;
aas_trace_t trace, steptrace;
if (frametime <= 0) frametime = 0.1f;
//
phys_friction = aassettings.phys_friction;
phys_stopspeed = aassettings.phys_stopspeed;
phys_gravity = aassettings.phys_gravity;
phys_waterfriction = aassettings.phys_waterfriction;
phys_watergravity = aassettings.phys_watergravity;
phys_maxwalkvelocity = aassettings.phys_maxwalkvelocity;// * frametime;
phys_maxcrouchvelocity = aassettings.phys_maxcrouchvelocity;// * frametime;
phys_maxswimvelocity = aassettings.phys_maxswimvelocity;// * frametime;
phys_walkaccelerate = aassettings.phys_walkaccelerate;
phys_airaccelerate = aassettings.phys_airaccelerate;
phys_swimaccelerate = aassettings.phys_swimaccelerate;
phys_maxstep = aassettings.phys_maxstep;
phys_maxsteepness = aassettings.phys_maxsteepness;
phys_jumpvel = aassettings.phys_jumpvel * frametime;
//
Com_Memset(move, 0, sizeof(aas_clientmove_t));
Com_Memset(&trace, 0, sizeof(aas_trace_t));
//start at the current origin
VectorCopy(origin, org);
org[2] += 0.25;
//velocity to test for the first frame
VectorScale(velocity, frametime, frame_test_vel);
//
jump_frame = -1;
//predict a maximum of 'maxframes' ahead
for (n = 0; n < maxframes; n++)
{
swimming = AAS_Swimming(org);
//get gravity depending on swimming or not
gravity = swimming ? phys_watergravity : phys_gravity;
//apply gravity at the START of the frame
frame_test_vel[2] = frame_test_vel[2] - (gravity * 0.1 * frametime);
//if on the ground or swimming
if (onground || swimming)
{
friction = swimming ? phys_friction : phys_waterfriction;
//apply friction
VectorScale(frame_test_vel, 1/frametime, frame_test_vel);
AAS_ApplyFriction(frame_test_vel, friction, phys_stopspeed, frametime);
VectorScale(frame_test_vel, frametime, frame_test_vel);
} //end if
crouch = qfalse;
//apply command movement
if (n < cmdframes)
{
ax = 0;
maxvel = phys_maxwalkvelocity;
accelerate = phys_airaccelerate;
VectorCopy(cmdmove, wishdir);
if (onground)
{
if (cmdmove[2] < -300)
{
crouch = qtrue;
maxvel = phys_maxcrouchvelocity;
} //end if
//if not swimming and upmove is positive then jump
if (!swimming && cmdmove[2] > 1)
{
//jump velocity minus the gravity for one frame + 5 for safety
frame_test_vel[2] = phys_jumpvel - (gravity * 0.1 * frametime) + 5;
jump_frame = n;
//jumping so air accelerate
accelerate = phys_airaccelerate;
} //end if
else
{
accelerate = phys_walkaccelerate;
} //end else
ax = 2;
} //end if
if (swimming)
{
maxvel = phys_maxswimvelocity;
accelerate = phys_swimaccelerate;
ax = 3;
} //end if
else
{
wishdir[2] = 0;
} //end else
//
wishspeed = VectorNormalize(wishdir);
if (wishspeed > maxvel) wishspeed = maxvel;
VectorScale(frame_test_vel, 1/frametime, frame_test_vel);
AAS_Accelerate(frame_test_vel, frametime, wishdir, wishspeed, accelerate);
VectorScale(frame_test_vel, frametime, frame_test_vel);
/*
for (i = 0; i < ax; i++)
{
velchange = (cmdmove[i] * frametime) - frame_test_vel[i];
if (velchange > phys_maxacceleration) velchange = phys_maxacceleration;
else if (velchange < -phys_maxacceleration) velchange = -phys_maxacceleration;
newvel = frame_test_vel[i] + velchange;
//
if (frame_test_vel[i] <= maxvel && newvel > maxvel) frame_test_vel[i] = maxvel;
else if (frame_test_vel[i] >= -maxvel && newvel < -maxvel) frame_test_vel[i] = -maxvel;
else frame_test_vel[i] = newvel;
} //end for
*/
} //end if
if (crouch)
{
presencetype = PRESENCE_CROUCH;
} //end if
else if (presencetype == PRESENCE_CROUCH)
{
if (AAS_PointPresenceType(org) & PRESENCE_NORMAL)
{
presencetype = PRESENCE_NORMAL;
} //end if
} //end else
//save the current origin
VectorCopy(org, lastorg);
//move linear during one frame
VectorCopy(frame_test_vel, left_test_vel);
j = 0;
do
{
VectorAdd(org, left_test_vel, end);
//trace a bounding box
trace = AAS_TraceClientBBox(org, end, presencetype, entnum);
//
//#ifdef AAS_MOVE_DEBUG
if (visualize)
{
if (trace.startsolid) botimport.Print(PRT_MESSAGE, "PredictMovement: start solid\n");
AAS_DebugLine(org, trace.endpos, LINECOLOR_RED);
} //end if
//#endif //AAS_MOVE_DEBUG
//
if (stopevent & (SE_ENTERAREA|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER|SE_TOUCHCLUSTERPORTAL))
{
numareas = AAS_TraceAreas(org, trace.endpos, areas, points, 20);
for (i = 0; i < numareas; i++)
{
if (stopevent & SE_ENTERAREA)
{
if (areas[i] == stopareanum)
{
VectorCopy(points[i], move->endpos);
VectorScale(frame_test_vel, 1/frametime, move->velocity);
move->endarea = areas[i];
move->trace = trace;
move->stopevent = SE_ENTERAREA;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
//NOTE: if not the first frame
if ((stopevent & SE_TOUCHJUMPPAD) && n)
{
if (aasworld.areasettings[areas[i]].contents & AREACONTENTS_JUMPPAD)
{
VectorCopy(points[i], move->endpos);
VectorScale(frame_test_vel, 1/frametime, move->velocity);
move->endarea = areas[i];
move->trace = trace;
move->stopevent = SE_TOUCHJUMPPAD;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
if (stopevent & SE_TOUCHTELEPORTER)
{
if (aasworld.areasettings[areas[i]].contents & AREACONTENTS_TELEPORTER)
{
VectorCopy(points[i], move->endpos);
move->endarea = areas[i];
VectorScale(frame_test_vel, 1/frametime, move->velocity);
move->trace = trace;
move->stopevent = SE_TOUCHTELEPORTER;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
if (stopevent & SE_TOUCHCLUSTERPORTAL)
{
if (aasworld.areasettings[areas[i]].contents & AREACONTENTS_CLUSTERPORTAL)
{
VectorCopy(points[i], move->endpos);
move->endarea = areas[i];
VectorScale(frame_test_vel, 1/frametime, move->velocity);
move->trace = trace;
move->stopevent = SE_TOUCHCLUSTERPORTAL;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
} //end for
} //end if
//
if (stopevent & SE_HITBOUNDINGBOX)
{
if (AAS_ClipToBBox(&trace, org, trace.endpos, presencetype, mins, maxs))
{
VectorCopy(trace.endpos, move->endpos);
move->endarea = AAS_PointAreaNum(move->endpos);
VectorScale(frame_test_vel, 1/frametime, move->velocity);
move->trace = trace;
move->stopevent = SE_HITBOUNDINGBOX;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
//move the entity to the trace end point
VectorCopy(trace.endpos, org);
//if there was a collision
if (trace.fraction < 1.0)
{
//get the plane the bounding box collided with
plane = AAS_PlaneFromNum(trace.planenum);
//
if (stopevent & SE_HITGROUNDAREA)
{
if (DotProduct(plane->normal, up) > phys_maxsteepness)
{
VectorCopy(org, start);
start[2] += 0.5;
if (AAS_PointAreaNum(start) == stopareanum)
{
VectorCopy(start, move->endpos);
move->endarea = stopareanum;
VectorScale(frame_test_vel, 1/frametime, move->velocity);
move->trace = trace;
move->stopevent = SE_HITGROUNDAREA;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
} //end if
//assume there's no step
step = qfalse;
//if it is a vertical plane and the bot didn't jump recently
if (plane->normal[2] == 0 && (jump_frame < 0 || n - jump_frame > 2))
{
//check for a step
VectorMA(org, -0.25, plane->normal, start);
VectorCopy(start, stepend);
start[2] += phys_maxstep;
steptrace = AAS_TraceClientBBox(start, stepend, presencetype, entnum);
//
if (!steptrace.startsolid)
{
plane2 = AAS_PlaneFromNum(steptrace.planenum);
if (DotProduct(plane2->normal, up) > phys_maxsteepness)
{
VectorSubtract(end, steptrace.endpos, left_test_vel);
left_test_vel[2] = 0;
frame_test_vel[2] = 0;
//#ifdef AAS_MOVE_DEBUG
if (visualize)
{
if (steptrace.endpos[2] - org[2] > 0.125)
{
VectorCopy(org, start);
start[2] = steptrace.endpos[2];
AAS_DebugLine(org, start, LINECOLOR_BLUE);
} //end if
} //end if
//#endif //AAS_MOVE_DEBUG
org[2] = steptrace.endpos[2];
step = qtrue;
} //end if
} //end if
} //end if
//
if (!step)
{
//velocity left to test for this frame is the projection
//of the current test velocity into the hit plane
VectorMA(left_test_vel, -DotProduct(left_test_vel, plane->normal),
plane->normal, left_test_vel);
//store the old velocity for landing check
VectorCopy(frame_test_vel, old_frame_test_vel);
//test velocity for the next frame is the projection
//of the velocity of the current frame into the hit plane
VectorMA(frame_test_vel, -DotProduct(frame_test_vel, plane->normal),
plane->normal, frame_test_vel);
//check for a landing on an almost horizontal floor
if (DotProduct(plane->normal, up) > phys_maxsteepness)
{
onground = qtrue;
} //end if
if (stopevent & SE_HITGROUNDDAMAGE)
{
delta = 0;
if (old_frame_test_vel[2] < 0 &&
frame_test_vel[2] > old_frame_test_vel[2] &&
!onground)
{
delta = old_frame_test_vel[2];
} //end if
else if (onground)
{
delta = frame_test_vel[2] - old_frame_test_vel[2];
} //end else
if (delta)
{
delta = delta * 10;
delta = delta * delta * 0.0001;
if (swimming) delta = 0;
// never take falling damage if completely underwater
/*
if (ent->waterlevel == 3) return;
if (ent->waterlevel == 2) delta *= 0.25;
if (ent->waterlevel == 1) delta *= 0.5;
*/
if (delta > 40)
{
VectorCopy(org, move->endpos);
move->endarea = AAS_PointAreaNum(org);
VectorCopy(frame_test_vel, move->velocity);
move->trace = trace;
move->stopevent = SE_HITGROUNDDAMAGE;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
} //end if
} //end if
} //end if
//extra check to prevent endless loop
if (++j > 20) return qfalse;
//while there is a plane hit
} while(trace.fraction < 1.0);
//if going down
if (frame_test_vel[2] <= 10)
{
//check for a liquid at the feet of the bot
VectorCopy(org, feet);
feet[2] -= 22;
pc = AAS_PointContents(feet);
//get event from pc
event = SE_NONE;
if (pc & CONTENTS_LAVA) event |= SE_ENTERLAVA;
if (pc & CONTENTS_SLIME) event |= SE_ENTERSLIME;
if (pc & CONTENTS_WATER) event |= SE_ENTERWATER;
//
areanum = AAS_PointAreaNum(org);
if (aasworld.areasettings[areanum].contents & AREACONTENTS_LAVA)
event |= SE_ENTERLAVA;
if (aasworld.areasettings[areanum].contents & AREACONTENTS_SLIME)
event |= SE_ENTERSLIME;
if (aasworld.areasettings[areanum].contents & AREACONTENTS_WATER)
event |= SE_ENTERWATER;
//if in lava or slime
if (event & stopevent)
{
VectorCopy(org, move->endpos);
move->endarea = areanum;
VectorScale(frame_test_vel, 1/frametime, move->velocity);
move->stopevent = event & stopevent;
move->presencetype = presencetype;
move->endcontents = pc;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
//
onground = AAS_OnGround(org, presencetype, entnum);
//if onground and on the ground for at least one whole frame
if (onground)
{
if (stopevent & SE_HITGROUND)
{
VectorCopy(org, move->endpos);
move->endarea = AAS_PointAreaNum(org);
VectorScale(frame_test_vel, 1/frametime, move->velocity);
move->trace = trace;
move->stopevent = SE_HITGROUND;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
else if (stopevent & SE_LEAVEGROUND)
{
VectorCopy(org, move->endpos);
move->endarea = AAS_PointAreaNum(org);
VectorScale(frame_test_vel, 1/frametime, move->velocity);
move->trace = trace;
move->stopevent = SE_LEAVEGROUND;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end else if
else if (stopevent & SE_GAP)
{
aas_trace_t gaptrace;
VectorCopy(org, start);
VectorCopy(start, end);
end[2] -= 48 + aassettings.phys_maxbarrier;
gaptrace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
//if solid is found the bot cannot walk any further and will not fall into a gap
if (!gaptrace.startsolid)
{
//if it is a gap (lower than one step height)
if (gaptrace.endpos[2] < org[2] - aassettings.phys_maxstep - 1)
{
if (!(AAS_PointContents(end) & CONTENTS_WATER))
{
VectorCopy(lastorg, move->endpos);
move->endarea = AAS_PointAreaNum(lastorg);
VectorScale(frame_test_vel, 1/frametime, move->velocity);
move->trace = trace;
move->stopevent = SE_GAP;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
} //end if
} //end else if
} //end for
//
VectorCopy(org, move->endpos);
move->endarea = AAS_PointAreaNum(org);
VectorScale(frame_test_vel, 1/frametime, move->velocity);
move->stopevent = SE_NONE;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
//
return qtrue;
} //end of the function AAS_ClientMovementPrediction
/*
@@@@@@@@@@@@@@@@@@@@@
RE_RenderScene
Draw a 3D view into a part of the window, then return
to 2D drawing.
Rendering a scene may require multiple views to be rendered
to handle mirrors,
@@@@@@@@@@@@@@@@@@@@@
*/
void RE_RenderScene( const refdef_t *fd ) {
viewParms_t parms;
int startTime;
if ( !tr.registered ) {
return;
}
GLimp_LogComment( "====== RE_RenderScene =====\n" );
if ( r_norefresh->integer ) {
return;
}
startTime = ri.Milliseconds();
if (!tr.world && !( fd->rdflags & RDF_NOWORLDMODEL ) ) {
ri.Error (ERR_DROP, "R_RenderScene: NULL worldmodel");
}
Com_Memcpy( tr.refdef.text, fd->text, sizeof( tr.refdef.text ) );
tr.refdef.x = fd->x;
tr.refdef.y = fd->y;
tr.refdef.width = fd->width;
tr.refdef.height = fd->height;
tr.refdef.fov_x = fd->fov_x;
tr.refdef.fov_y = fd->fov_y;
VectorCopy( fd->vieworg, tr.refdef.vieworg );
VectorCopy( fd->viewaxis[0], tr.refdef.viewaxis[0] );
VectorCopy( fd->viewaxis[1], tr.refdef.viewaxis[1] );
VectorCopy( fd->viewaxis[2], tr.refdef.viewaxis[2] );
tr.refdef.time = fd->time;
tr.refdef.rdflags = fd->rdflags;
// copy the areamask data over and note if it has changed, which
// will force a reset of the visible leafs even if the view hasn't moved
tr.refdef.areamaskModified = qfalse;
if ( ! (tr.refdef.rdflags & RDF_NOWORLDMODEL) ) {
int areaDiff;
int i;
// compare the area bits
areaDiff = 0;
for (i = 0 ; i < MAX_MAP_AREA_BYTES/4 ; i++) {
areaDiff |= ((int *)tr.refdef.areamask)[i] ^ ((int *)fd->areamask)[i];
((int *)tr.refdef.areamask)[i] = ((int *)fd->areamask)[i];
}
if ( areaDiff ) {
// a door just opened or something
tr.refdef.areamaskModified = qtrue;
}
}
// derived info
tr.refdef.floatTime = tr.refdef.time * 0.001f;
tr.refdef.numDrawSurfs = r_firstSceneDrawSurf;
tr.refdef.drawSurfs = backEndData[tr.smpFrame]->drawSurfs;
tr.refdef.num_entities = r_numentities - r_firstSceneEntity;
tr.refdef.entities = &backEndData[tr.smpFrame]->entities[r_firstSceneEntity];
tr.refdef.num_dlights = r_numdlights - r_firstSceneDlight;
tr.refdef.dlights = &backEndData[tr.smpFrame]->dlights[r_firstSceneDlight];
tr.refdef.numPolys = r_numpolys - r_firstScenePoly;
tr.refdef.polys = &backEndData[tr.smpFrame]->polys[r_firstScenePoly];
// turn off dynamic lighting globally by clearing all the
// dlights if it needs to be disabled or if vertex lighting is enabled
if ( r_dynamiclight->integer == 0 ||
r_vertexLight->integer == 1 ||
glConfig.hardwareType == GLHW_PERMEDIA2 ) {
tr.refdef.num_dlights = 0;
}
// a single frame may have multiple scenes draw inside it --
// a 3D game view, 3D status bar renderings, 3D menus, etc.
// They need to be distinguished by the light flare code, because
// the visibility state for a given surface may be different in
// each scene / view.
tr.frameSceneNum++;
tr.sceneCount++;
// setup view parms for the initial view
//
// set up viewport
// The refdef takes 0-at-the-top y coordinates, so
// convert to GL's 0-at-the-bottom space
//
Com_Memset( &parms, 0, sizeof( parms ) );
parms.viewportX = tr.refdef.x;
parms.viewportY = glConfig.vidHeight - ( tr.refdef.y + tr.refdef.height );
parms.viewportWidth = tr.refdef.width;
parms.viewportHeight = tr.refdef.height;
parms.isPortal = qfalse;
parms.fovX = tr.refdef.fov_x;
parms.fovY = tr.refdef.fov_y;
parms.stereoFrame = tr.refdef.stereoFrame;
VectorCopy( fd->vieworg, parms.or.origin );
VectorCopy( fd->viewaxis[0], parms.or.axis[0] );
VectorCopy( fd->viewaxis[1], parms.or.axis[1] );
VectorCopy( fd->viewaxis[2], parms.or.axis[2] );
VectorCopy( fd->vieworg, parms.pvsOrigin );
R_RenderView( &parms );
// the next scene rendered in this frame will tack on after this one
r_firstSceneDrawSurf = tr.refdef.numDrawSurfs;
r_firstSceneEntity = r_numentities;
r_firstSceneDlight = r_numdlights;
r_firstScenePoly = r_numpolys;
tr.frontEndMsec += ri.Milliseconds() - startTime;
}
//============================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//============================================================================
script_t *LoadScriptFile(const char *filename)
{
#ifdef BOTLIB
fileHandle_t fp;
char pathname[MAX_QPATH];
#else
FILE *fp;
#endif
int length;
void *buffer;
script_t *script;
#ifdef BOTLIB
if (strlen(basefolder))
Com_sprintf(pathname, sizeof(pathname), "%s/%s", basefolder, filename);
else
Com_sprintf(pathname, sizeof(pathname), "%s", filename);
length = botimport.FS_FOpenFile( pathname, &fp, FS_READ );
if (!fp) return NULL;
#else
fp = fopen(filename, "rb");
if (!fp) return NULL;
length = FileLength(fp);
#endif
buffer = GetClearedMemory(sizeof(script_t) + length + 1);
script = (script_t *) buffer;
Com_Memset(script, 0, sizeof(script_t));
strcpy(script->filename, filename);
script->buffer = (char *) buffer + sizeof(script_t);
script->buffer[length] = 0;
script->length = length;
//pointer in script buffer
script->script_p = script->buffer;
//pointer in script buffer before reading token
script->lastscript_p = script->buffer;
//pointer to end of script buffer
script->end_p = &script->buffer[length];
//set if there's a token available in script->token
script->tokenavailable = 0;
//
script->line = 1;
script->lastline = 1;
//
SetScriptPunctuations(script, NULL);
//
#ifdef BOTLIB
botimport.FS_Read(script->buffer, length, fp);
botimport.FS_FCloseFile(fp);
#else
if (fread(script->buffer, length, 1, fp) != 1)
{
FreeMemory(buffer);
script = NULL;
} //end if
fclose(fp);
#endif
//
script->length = COM_Compress(script->buffer);
return script;
} //end of the function LoadScriptFile
static intptr_t CL_UISystemCalls( intptr_t* args )
{
switch( args[0] ) {
case UI_ERROR:
Com_Error( ERR_DROP, "%s", (const char*)VMA(1) );
return 0;
case UI_PRINT:
Com_Printf( "%s", (const char*)VMA(1) );
return 0;
case UI_MILLISECONDS:
return Sys_Milliseconds();
case UI_CVAR_REGISTER:
Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] );
return 0;
case UI_CVAR_UPDATE:
Cvar_Update( VMA(1) );
return 0;
case UI_CVAR_SET:
Cvar_Set( VMA(1), VMA(2) );
return 0;
case UI_CVAR_VARIABLEVALUE:
return PASSFLOAT( Cvar_VariableValue( VMA(1) ) );
case UI_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] );
return 0;
case UI_CVAR_SETVALUE:
Cvar_SetValue( VMA(1), VMF(2) );
return 0;
case UI_CVAR_RESET:
Cvar_Reset( VMA(1) );
return 0;
case UI_CVAR_CREATE:
Cvar_Get( VMA(1), VMA(2), args[3] );
return 0;
case UI_CVAR_INFOSTRINGBUFFER:
Cvar_InfoStringBuffer( args[1], VMA(2), args[3] );
return 0;
case UI_ARGC:
return Cmd_Argc();
case UI_ARGV:
Cmd_ArgvBuffer( args[1], VMA(2), args[3] );
return 0;
case UI_CMD_EXECUTETEXT:
Cbuf_AddText( VMA(2) );
return 0;
case UI_FS_FOPENFILE:
return FS_FOpenFileByMode( VMA(1), VMA(2), (fsMode_t)args[3] );
case UI_FS_READ:
FS_Read2( VMA(1), args[2], args[3] );
return 0;
case UI_FS_WRITE:
FS_Write( VMA(1), args[2], args[3] );
return 0;
case UI_FS_FCLOSEFILE:
FS_FCloseFile( args[1] );
return 0;
case UI_FS_GETFILELIST:
return FS_GetFileList( VMA(1), VMA(2), VMA(3), args[4] );
case UI_FS_SEEK:
return FS_Seek( args[1], args[2], args[3] );
case UI_R_REGISTERMODEL:
return re.RegisterModel( VMA(1) );
case UI_R_REGISTERSKIN:
return re.RegisterSkin( VMA(1) );
case UI_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip( VMA(1) );
case UI_R_CLEARSCENE:
re.ClearScene();
return 0;
case UI_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( VMA(1) );
return 0;
case UI_R_ADDPOLYTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA(3), 1 );
return 0;
case UI_R_ADDLIGHTTOSCENE:
re.AddLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
return 0;
case UI_R_RENDERSCENE:
re.RenderScene( VMA(1) );
return 0;
case UI_R_SETCOLOR:
re.SetColor( VMA(1) );
return 0;
case UI_R_DRAWSTRETCHPIC:
re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9] );
return 0;
case UI_R_MODELBOUNDS:
re.ModelBounds( args[1], VMA(2), VMA(3) );
return 0;
case UI_UPDATESCREEN:
SCR_UpdateScreen();
return 0;
case UI_CM_LERPTAG:
re.LerpTag( VMA(1), args[2], args[3], args[4], VMF(5), VMA(6) );
return 0;
case UI_S_REGISTERSOUND:
return S_RegisterSound( VMA(1) );
case UI_S_STARTLOCALSOUND:
S_StartLocalSound( args[1], args[2] );
return 0;
case UI_KEY_KEYNUMTOSTRINGBUF:
Key_KeynumToStringBuf( args[1], VMA(2), args[3] );
return 0;
case UI_KEY_GETBINDINGBUF:
Key_GetBindingBuf( args[1], VMA(2), args[3] );
return 0;
case UI_KEY_SETBINDING:
Key_SetBinding( args[1], VMA(2) );
return 0;
case UI_KEY_ISDOWN:
return Key_IsDown( args[1] );
case UI_KEY_GETOVERSTRIKEMODE:
return Key_GetOverstrikeMode();
case UI_KEY_SETOVERSTRIKEMODE:
Key_SetOverstrikeMode( (args[1] != 0) );
return 0;
case UI_KEY_CLEARSTATES:
Key_ClearStates();
return 0;
case UI_KEY_GETCATCHER:
return Key_GetCatcher();
case UI_KEY_SETCATCHER:
Key_SetCatcher( args[1] );
return 0;
case UI_GETCLIPBOARDDATA:
CL_GetClipboardData( VMA(1), args[2] );
return 0;
case UI_GETCLIENTSTATE:
GetClientState( VMA(1) );
return 0;
case UI_GETGLCONFIG:
CL_GetGlconfig( VMA(1) );
return 0;
case UI_GETCONFIGSTRING:
return GetConfigString( args[1], VMA(2), args[3] );
case UI_LAN_LOADCACHEDSERVERS:
LAN_LoadCachedServers();
return 0;
case UI_LAN_SAVECACHEDSERVERS:
LAN_SaveServersToCache();
return 0;
case UI_LAN_ADDSERVER:
return LAN_AddServer(args[1], VMA(2), VMA(3));
case UI_LAN_REMOVESERVER:
LAN_RemoveServer(args[1], VMA(2));
return 0;
case UI_LAN_GETPINGQUEUECOUNT:
return LAN_GetPingQueueCount();
case UI_LAN_CLEARPING:
LAN_ClearPing( args[1] );
return 0;
case UI_LAN_GETPING:
LAN_GetPing( args[1], VMA(2), args[3], VMA(4) );
return 0;
case UI_LAN_GETPINGINFO:
LAN_GetPingInfo( args[1], VMA(2), args[3] );
return 0;
case UI_LAN_GETSERVERCOUNT:
return LAN_GetServerCount(args[1]);
case UI_LAN_GETSERVERADDRESSSTRING:
LAN_GetServerAddressString( args[1], args[2], VMA(3), args[4] );
return 0;
case UI_LAN_GETSERVERINFO:
LAN_GetServerInfo( args[1], args[2], VMA(3), args[4] );
return 0;
case UI_LAN_GETSERVERPING:
return LAN_GetServerPing( args[1], args[2] );
case UI_LAN_MARKSERVERVISIBLE:
LAN_MarkServerVisible( args[1], args[2], args[3] );
return 0;
case UI_LAN_SERVERISVISIBLE:
return LAN_ServerIsVisible( args[1], args[2] );
case UI_LAN_UPDATEVISIBLEPINGS:
return LAN_UpdateVisiblePings( args[1] );
case UI_LAN_RESETPINGS:
LAN_ResetPings( args[1] );
return 0;
case UI_LAN_SERVERSTATUS:
return LAN_GetServerStatus( VMA(1), VMA(2), args[3] );
case UI_LAN_COMPARESERVERS:
return LAN_CompareServers( args[1], args[2], args[3], args[4], args[5] );
case UI_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case UI_GET_CDKEY:
CLUI_GetCDKey( VMA(1), args[2] );
return 0;
case UI_SET_CDKEY:
CLUI_SetCDKey( VMA(1) );
return 0;
case UI_SET_PBCLSTATUS:
return 0;
case UI_R_REGISTERFONT:
return re.RegisterFont( VMA(1), args[2], VMA(3) );
case UI_MEMSET:
Com_Memset( VMA(1), args[2], args[3] );
return 0;
case UI_MEMCPY:
Com_Memcpy( VMA(1), VMA(2), args[3] );
return 0;
case UI_STRNCPY:
strncpy( VMA(1), VMA(2), args[3] );
return args[1];
case UI_SIN:
return PASSFLOAT( sin( VMF(1) ) );
case UI_COS:
return PASSFLOAT( cos( VMF(1) ) );
case UI_ATAN2:
return PASSFLOAT( atan2( VMF(1), VMF(2) ) );
case UI_SQRT:
return PASSFLOAT( sqrt( VMF(1) ) );
case UI_FLOOR:
return PASSFLOAT( floor( VMF(1) ) );
case UI_CEIL:
return PASSFLOAT( ceil( VMF(1) ) );
case UI_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case UI_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack( VMA(1), VMA(2));
return 0;
case UI_REAL_TIME:
return Com_RealTime( VMA(1) );
case UI_CIN_PLAYCINEMATIC:
Com_DPrintf("UI_CIN_PlayCinematic\n");
return CIN_PlayCinematic(VMA(1), args[2], args[3], args[4], args[5], args[6]);
case UI_CIN_STOPCINEMATIC:
return CIN_StopCinematic(args[1]);
case UI_CIN_RUNCINEMATIC:
return CIN_RunCinematic(args[1]);
case UI_CIN_DRAWCINEMATIC:
CIN_DrawCinematic(args[1]);
return 0;
case UI_CIN_SETEXTENTS:
CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
return 0;
case UI_VERIFY_CDKEY:
return CL_CDKeyValidate(VMA(1), VMA(2));
default:
Com_Error( ERR_DROP, "Bad UI system trap: %i", args[0] );
}
return 0;
}
//============================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//============================================================================
int PS_ReadToken(script_t *script, token_t *token)
{
//if there is a token available (from UnreadToken)
if (script->tokenavailable)
{
script->tokenavailable = 0;
Com_Memcpy(token, &script->token, sizeof(token_t));
return 1;
} //end if
//save script pointer
script->lastscript_p = script->script_p;
//save line counter
script->lastline = script->line;
//clear the token stuff
Com_Memset(token, 0, sizeof(token_t));
//start of the white space
script->whitespace_p = script->script_p;
token->whitespace_p = script->script_p;
//read unusefull stuff
if (!PS_ReadWhiteSpace(script)) return 0;
//end of the white space
script->endwhitespace_p = script->script_p;
token->endwhitespace_p = script->script_p;
//line the token is on
token->line = script->line;
//number of lines crossed before token
token->linescrossed = script->line - script->lastline;
//if there is a leading double quote
if (*script->script_p == '\"')
{
if (!PS_ReadString(script, token, '\"')) return 0;
} //end if
//if an literal
else if (*script->script_p == '\'')
{
//if (!PS_ReadLiteral(script, token)) return 0;
if (!PS_ReadString(script, token, '\'')) return 0;
} //end if
//if there is a number
else if ((*script->script_p >= '0' && *script->script_p <= '9') ||
(*script->script_p == '.' &&
(*(script->script_p + 1) >= '0' && *(script->script_p + 1) <= '9')))
{
if (!PS_ReadNumber(script, token)) return 0;
} //end if
//if this is a primitive script
else if (script->flags & SCFL_PRIMITIVE)
{
return PS_ReadPrimitive(script, token);
} //end else if
//if there is a name
else if ((*script->script_p >= 'a' && *script->script_p <= 'z') ||
(*script->script_p >= 'A' && *script->script_p <= 'Z') ||
*script->script_p == '_')
{
if (!PS_ReadName(script, token)) return 0;
} //end if
//check for punctuations
else if (!PS_ReadPunctuation(script, token))
{
ScriptError(script, "can't read token");
return 0;
} //end if
//copy the token into the script structure
Com_Memcpy(&script->token, token, sizeof(token_t));
//succesfully read a token
return 1;
} //end of the function PS_ReadToken
static void DrawSkyBox( shader_t *shader )
{
int i;
sky_min = 0;
sky_max = 1;
Com_Memset( s_skyTexCoords, 0, sizeof( s_skyTexCoords ) );
// set up for drawing
tess.multiDrawPrimitives = 0;
tess.numIndexes = 0;
tess.numVertexes = 0;
tess.attribsSet = 0;
GL_State( GLS_DEFAULT );
for ( i = 0; i < 6; i++ )
{
int sky_mins_subd[ 2 ], sky_maxs_subd[ 2 ];
int s, t;
sky_mins[ 0 ][ i ] = floor( sky_mins[ 0 ][ i ] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
sky_mins[ 1 ][ i ] = floor( sky_mins[ 1 ][ i ] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
sky_maxs[ 0 ][ i ] = ceil( sky_maxs[ 0 ][ i ] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
sky_maxs[ 1 ][ i ] = ceil( sky_maxs[ 1 ][ i ] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
if ( ( sky_mins[ 0 ][ i ] >= sky_maxs[ 0 ][ i ] ) || ( sky_mins[ 1 ][ i ] >= sky_maxs[ 1 ][ i ] ) )
{
continue;
}
sky_mins_subd[ 0 ] = sky_mins[ 0 ][ i ] * HALF_SKY_SUBDIVISIONS;
sky_mins_subd[ 1 ] = sky_mins[ 1 ][ i ] * HALF_SKY_SUBDIVISIONS;
sky_maxs_subd[ 0 ] = sky_maxs[ 0 ][ i ] * HALF_SKY_SUBDIVISIONS;
sky_maxs_subd[ 1 ] = sky_maxs[ 1 ][ i ] * HALF_SKY_SUBDIVISIONS;
if ( sky_mins_subd[ 0 ] < -HALF_SKY_SUBDIVISIONS )
{
sky_mins_subd[ 0 ] = -HALF_SKY_SUBDIVISIONS;
}
else if ( sky_mins_subd[ 0 ] > HALF_SKY_SUBDIVISIONS )
{
sky_mins_subd[ 0 ] = HALF_SKY_SUBDIVISIONS;
}
if ( sky_mins_subd[ 1 ] < -HALF_SKY_SUBDIVISIONS )
{
sky_mins_subd[ 1 ] = -HALF_SKY_SUBDIVISIONS;
}
else if ( sky_mins_subd[ 1 ] > HALF_SKY_SUBDIVISIONS )
{
sky_mins_subd[ 1 ] = HALF_SKY_SUBDIVISIONS;
}
if ( sky_maxs_subd[ 0 ] < -HALF_SKY_SUBDIVISIONS )
{
sky_maxs_subd[ 0 ] = -HALF_SKY_SUBDIVISIONS;
}
else if ( sky_maxs_subd[ 0 ] > HALF_SKY_SUBDIVISIONS )
{
sky_maxs_subd[ 0 ] = HALF_SKY_SUBDIVISIONS;
}
if ( sky_maxs_subd[ 1 ] < -HALF_SKY_SUBDIVISIONS )
{
sky_maxs_subd[ 1 ] = -HALF_SKY_SUBDIVISIONS;
}
else if ( sky_maxs_subd[ 1 ] > HALF_SKY_SUBDIVISIONS )
{
sky_maxs_subd[ 1 ] = HALF_SKY_SUBDIVISIONS;
}
// iterate through the subdivisions
for ( t = sky_mins_subd[ 1 ] + HALF_SKY_SUBDIVISIONS; t <= sky_maxs_subd[ 1 ] + HALF_SKY_SUBDIVISIONS; t++ )
{
for ( s = sky_mins_subd[ 0 ] + HALF_SKY_SUBDIVISIONS; s <= sky_maxs_subd[ 0 ] + HALF_SKY_SUBDIVISIONS; s++ )
{
MakeSkyVec( ( s - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS,
( t - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS,
i, s_skyTexCoords[ t ][ s ], s_skyPoints[ t ][ s ] );
}
}
//DrawSkySide(shader->sky.outerbox[sky_texorder[i]], sky_mins_subd, sky_maxs_subd);
// only add indexes for first stage
FillCloudySkySide( sky_mins_subd, sky_maxs_subd, qtrue );
}
Tess_UpdateVBOs( tess.attribsSet );
Tess_DrawElements();
}
/*
==================
SV_UserMove
The message usually contains all the movement commands
that were in the last three packets, so that the information
in dropped packets can be recovered.
On very fast clients, there may be multiple usercmd packed into
each of the backup packets.
==================
*/
static void SV_UserMove( client_t *cl, msg_t *msg, qboolean delta ) {
int i, key;
int cmdCount;
usercmd_t nullcmd;
usercmd_t cmds[MAX_PACKET_USERCMDS];
usercmd_t *cmd, *oldcmd;
if ( delta ) {
cl->deltaMessage = cl->messageAcknowledge;
} else {
cl->deltaMessage = -1;
}
cmdCount = MSG_ReadByte( msg );
if ( cmdCount < 1 ) {
Com_Printf( "cmdCount < 1\n" );
return;
}
if ( cmdCount > MAX_PACKET_USERCMDS ) {
Com_Printf( "cmdCount > MAX_PACKET_USERCMDS\n" );
return;
}
// use the checksum feed in the key
key = sv.checksumFeed;
// also use the message acknowledge
key ^= cl->messageAcknowledge;
// also use the last acknowledged server command in the key
key ^= Com_HashKey(cl->reliableCommands[ cl->reliableAcknowledge & (MAX_RELIABLE_COMMANDS-1) ], 32);
Com_Memset( &nullcmd, 0, sizeof(nullcmd) );
oldcmd = &nullcmd;
for ( i = 0 ; i < cmdCount ; i++ ) {
cmd = &cmds[i];
MSG_ReadDeltaUsercmdKey( msg, key, oldcmd, cmd );
oldcmd = cmd;
}
// save time for ping calculation
// With sv_pingFix enabled we store the time of the first acknowledge, instead of the last. And we use a time value that is not limited by sv_fps.
if ( !sv_pingFix->integer || cl->frames[ cl->messageAcknowledge & PACKET_MASK ].messageAcked == -1 )
cl->frames[ cl->messageAcknowledge & PACKET_MASK ].messageAcked = (sv_pingFix->integer ? Sys_Milliseconds() : svs.time);
// if this is the first usercmd we have received
// this gamestate, put the client into the world
if ( cl->state == CS_PRIMED ) {
SV_SendServerCommand(cl, "print \"^1[ ^7This server is running JK2MV ^1v^7" JK2MV_VERSION " ^1| ^7http://jk2mv.org ^1]\n\"");
SV_ClientEnterWorld( cl, &cmds[0] );
// the moves can be processed normaly
}
//
if (sv_pure->integer != 0 && cl->pureAuthentic == 0) {
SV_DropClient( cl, "Cannot validate pure client!");
return;
}
if ( cl->state != CS_ACTIVE ) {
cl->deltaMessage = -1;
return;
}
// usually, the first couple commands will be duplicates
// of ones we have previously received, but the servertimes
// in the commands will cause them to be immediately discarded
for ( i = 0 ; i < cmdCount ; i++ ) {
// if this is a cmd from before a map_restart ignore it
if ( cmds[i].serverTime > cmds[cmdCount-1].serverTime ) {
continue;
}
// extremely lagged or cmd from before a map_restart
//if ( cmds[i].serverTime > sv.time + 3000 ) {
// continue;
//}
// don't execute if this is an old cmd which is already executed
// these old cmds are included when cl_packetdup > 0
if ( cmds[i].serverTime <= cl->lastUsercmd.serverTime ) {
continue;
}
SV_ClientThink (cl - svs.clients, &cmds[ i ]);
}
}
/*
===================
CL_GetServerCommand
Set up argc/argv for the given command
===================
*/
qboolean CL_GetServerCommand( int serverCommandNumber ) {
char *s;
char *cmd;
static char bigConfigString[BIG_INFO_STRING];
int argc;
// if we have irretrievably lost a reliable command, drop the connection
if ( serverCommandNumber <= clc.serverCommandSequence - MAX_RELIABLE_COMMANDS ) {
// when a demo record was started after the client got a whole bunch of
// reliable commands then the client never got those first reliable commands
if ( clc.demoplaying )
return qfalse;
Com_Error( ERR_DROP, "CL_GetServerCommand: a reliable command was cycled out" );
return qfalse;
}
if ( serverCommandNumber > clc.serverCommandSequence ) {
Com_Error( ERR_DROP, "CL_GetServerCommand: requested a command not received" );
return qfalse;
}
s = CL_GetReliableServerCommand( serverCommandNumber );
clc.lastExecutedServerCommand = serverCommandNumber;
Com_DPrintf( "serverCommand: %i : %s\n", serverCommandNumber, s );
rescan:
Cmd_TokenizeString( s );
cmd = Cmd_Argv(0);
argc = Cmd_Argc();
if ( !strcmp( cmd, "disconnect" ) ) {
// https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=552
// allow server to indicate why they were disconnected
if ( argc >= 2 )
Com_Error (ERR_SERVERDISCONNECT, va( "Server Disconnected - %s", Cmd_Argv( 1 ) ) );
else
Com_Error (ERR_SERVERDISCONNECT,"Server disconnected\n");
}
if ( !strcmp( cmd, "bcs0" ) ) {
Com_sprintf( bigConfigString, BIG_INFO_STRING, "cs %s \"%s", Cmd_Argv(1), Cmd_Argv(2) );
return qfalse;
}
if ( !strcmp( cmd, "bcs1" ) ) {
s = Cmd_Argv(2);
if( strlen(bigConfigString) + strlen(s) >= BIG_INFO_STRING ) {
Com_Error( ERR_DROP, "bcs exceeded BIG_INFO_STRING" );
}
strcat( bigConfigString, s );
return qfalse;
}
if ( !strcmp( cmd, "bcs2" ) ) {
s = Cmd_Argv(2);
if( strlen(bigConfigString) + strlen(s) + 1 >= BIG_INFO_STRING ) {
Com_Error( ERR_DROP, "bcs exceeded BIG_INFO_STRING" );
}
strcat( bigConfigString, s );
strcat( bigConfigString, "\"" );
s = bigConfigString;
goto rescan;
}
if ( !strcmp( cmd, "cs" ) ) {
CL_ConfigstringModified();
// reparse the string, because CL_ConfigstringModified may have done another Cmd_TokenizeString()
Cmd_TokenizeString( s );
return qtrue;
}
if ( !strcmp( cmd, "up" ) ) {
if( serverCommandNumber <= clc.lastSnapServerCmdNum )
return qtrue;
CL_TableUpdateRow();
return qtrue;
}
if ( !strcmp( cmd, "de" ) ) {
if( serverCommandNumber <= clc.lastSnapServerCmdNum )
return qtrue;
CL_TableDeleteRow();
return qtrue;
}
if ( !strcmp( cmd, "in" ) ) {
if( serverCommandNumber <= clc.lastSnapServerCmdNum )
return qtrue;
CL_TableInsertRow();
return qtrue;
}
if ( !strcmp( cmd, "map_restart" ) ) {
// clear notify lines and outgoing commands before passing
// the restart to the cgame
Con_ClearNotify();
Com_Memset( cl.cmds, 0, sizeof( cl.cmds ) );
return qtrue;
}
// the clientLevelShot command is used during development
// to generate 128*128 screenshots from the intermission
// point of levels for the menu system to use
// we pass it along to the cgame to make apropriate adjustments,
// but we also clear the console and notify lines here
if ( !strcmp( cmd, "clientLevelShot" ) ) {
// don't do it if we aren't running the server locally,
// otherwise malicious remote servers could overwrite
// the existing thumbnails
if ( !com_sv_running->integer ) {
return qfalse;
}
// close the console
Con_Close();
// take a special screenshot next frame
Cbuf_AddText( "wait ; wait ; wait ; wait ; screenshot levelshot\n" );
return qtrue;
}
// we may want to put a "connect to other server" command here
// cgame can now act on the command
return qtrue;
}
/*
=====================
SV_DropClient
Called when the player is totally leaving the server, either willingly
or unwillingly. This is NOT called if the entire server is quiting
or crashing -- SV_FinalMessage() will handle that
=====================
*/
void SV_DropClient( client_t *drop, const char *reason ) {
int i;
challenge_t *challenge;
if ( drop->state == CS_ZOMBIE ) {
return; // already dropped
}
if (drop->netchan.remoteAddress.type != NA_BOT) {
// see if we already have a challenge for this ip
challenge = &svs.challenges[0];
for (i = 0; i < MAX_CHALLENGES; i++, challenge++) {
if (NET_CompareAdr(drop->netchan.remoteAddress, challenge->adr)) {
Com_Memset(challenge, 0, sizeof(*challenge));
break;
}
}
}
if ( !drop->gentity || !(drop->gentity->r.svFlags & SVF_BOT) ) {
// see if we already have a challenge for this ip
challenge = &svs.challenges[0];
for (i = 0 ; i < MAX_CHALLENGES ; i++, challenge++) {
if ( NET_CompareAdr( drop->netchan.remoteAddress, challenge->adr ) ) {
challenge->connected = qfalse;
break;
}
}
}
// Kill any download
SV_CloseDownload( drop );
// tell everyone why they got dropped
SV_SendServerCommand( NULL, "print \"%s" S_COLOR_WHITE " %s\n\"", drop->name, reason );
Com_DPrintf( "Going to CS_ZOMBIE for %s\n", drop->name );
drop->state = CS_ZOMBIE; // become free in a few seconds
// call the prog function for removing a client
// this will remove the body, among other things
VM_Call( gvm, GAME_CLIENT_DISCONNECT, drop - svs.clients );
// add the disconnect command
SV_SendServerCommand( drop, "disconnect" );
if ( drop->netchan.remoteAddress.type == NA_BOT ) {
SV_BotFreeClient( drop - svs.clients );
}
// nuke user info
SV_SetUserinfo( drop - svs.clients, "" );
// if this was the last client on the server, send a heartbeat
// to the master so it is known the server is empty
// send a heartbeat now so the master will get up to date info
// if there is already a slot for this ip, reuse it
int players = 0;
for (i = 0; i < sv_maxclients->integer; i++) {
if (svs.clients[i].state >= CS_CONNECTED && svs.clients[i].netchan.remoteAddress.type != NA_BOT) {
players++;
}
}
for (i=0 ; i < sv_maxclients->integer ; i++ ) {
if ( svs.clients[i].state >= CS_CONNECTED ) {
break;
}
}
if ( i == sv_maxclients->integer ) {
SV_Heartbeat_f();
}
}
/*
==================
CL_ParseGamestate
==================
*/
void CL_ParseGamestate( msg_t *msg ) {
int i;
entityState_t *es;
int newnum;
entityState_t nullstate;
int cmd;
char *s;
char oldGame[MAX_QPATH];
Con_Close();
clc.connectPacketCount = 0;
// wipe local client state
CL_ClearState();
// a gamestate always marks a server command sequence
clc.serverCommandSequence = MSG_ReadLong( msg );
// parse all the configstrings and baselines
cl.gameState.dataCount = 1; // leave a 0 at the beginning for uninitialized configstrings
while ( 1 ) {
cmd = MSG_ReadByte( msg );
#ifdef ELITEFORCE
if ( ( msg->compat && cmd <= 0 ) || cmd == svc_EOF )
#else
if ( cmd == svc_EOF )
#endif
break;
if ( cmd == svc_configstring ) {
int len;
i = MSG_ReadShort( msg );
if ( i < 0 || i >= MAX_CONFIGSTRINGS ) {
Com_Error( ERR_DROP, "configstring > MAX_CONFIGSTRINGS" );
}
s = MSG_ReadBigString( msg );
len = strlen( s );
if ( len + 1 + cl.gameState.dataCount > MAX_GAMESTATE_CHARS ) {
Com_Error( ERR_DROP, "MAX_GAMESTATE_CHARS exceeded" );
}
// append it to the gameState string buffer
cl.gameState.stringOffsets[ i ] = cl.gameState.dataCount;
Com_Memcpy( cl.gameState.stringData + cl.gameState.dataCount, s, len + 1 );
cl.gameState.dataCount += len + 1;
} else if ( cmd == svc_baseline ) {
newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
if ( newnum < 0 || newnum >= MAX_GENTITIES ) {
Com_Error( ERR_DROP, "Baseline number out of range: %i", newnum );
}
Com_Memset (&nullstate, 0, sizeof(nullstate));
es = &cl.entityBaselines[ newnum ];
MSG_ReadDeltaEntity( msg, &nullstate, es, newnum );
} else {
Com_Error( ERR_DROP, "CL_ParseGamestate: bad command byte" );
}
}
#ifdef ELITEFORCE
if(!msg->compat)
#endif
clc.clientNum = MSG_ReadLong(msg);
// read the checksum feed
#ifdef ELITEFORCE
if(!clc.demoplaying || !msg->compat)
#endif
clc.checksumFeed = MSG_ReadLong( msg );
// save old gamedir
Cvar_VariableStringBuffer("fs_game", oldGame, sizeof(oldGame));
// parse useful values out of CS_SERVERINFO
CL_ParseServerInfo();
// parse serverId and other cvars
CL_SystemInfoChanged();
// stop recording now so the demo won't have an unnecessary level load at the end.
if(cl_autoRecordDemo->integer && clc.demorecording)
CL_StopRecord_f();
// reinitialize the filesystem if the game directory has changed
if(!cl_oldGameSet && (Cvar_Flags("fs_game") & CVAR_MODIFIED))
{
cl_oldGameSet = qtrue;
Q_strncpyz(cl_oldGame, oldGame, sizeof(cl_oldGame));
}
FS_ConditionalRestart(clc.checksumFeed, qfalse);
// This used to call CL_StartHunkUsers, but now we enter the download state before loading the
// cgame
CL_InitDownloads();
// make sure the game starts
Cvar_Set( "cl_paused", "0" );
}
/*
================
SV_SendClientGameState
Sends the first message from the server to a connected client.
This will be sent on the initial connection and upon each new map load.
It will be resent if the client acknowledges a later message but has
the wrong gamestate.
================
*/
void SV_SendClientGameState( client_t *client ) {
int start;
entityState_t *base, nullstate;
msg_t msg;
byte msgBuffer[MAX_MSGLEN];
// MW - my attempt to fix illegible server message errors caused by
// packet fragmentation of initial snapshot.
while(client->state&&client->netchan.unsentFragments)
{
// send additional message fragments if the last message
// was too large to send at once
Com_Printf ("[ISM]SV_SendClientGameState() [2] for %s, writing out old fragments\n", client->name);
SV_Netchan_TransmitNextFragment(&client->netchan);
}
Com_DPrintf ("SV_SendClientGameState() for %s\n", client->name);
Com_DPrintf( "Going from CS_CONNECTED to CS_PRIMED for %s\n", client->name );
if (client->state == CS_CONNECTED)
client->state = CS_PRIMED;
client->pureAuthentic = 0;
// when we receive the first packet from the client, we will
// notice that it is from a different serverid and that the
// gamestate message was not just sent, forcing a retransmit
client->gamestateMessageNum = client->netchan.outgoingSequence;
MSG_Init( &msg, msgBuffer, sizeof( msgBuffer ) );
// NOTE, MRE: all server->client messages now acknowledge
// let the client know which reliable clientCommands we have received
MSG_WriteLong( &msg, client->lastClientCommand );
// send any server commands waiting to be sent first.
// we have to do this cause we send the client->reliableSequence
// with a gamestate and it sets the clc.serverCommandSequence at
// the client side
SV_UpdateServerCommandsToClient( client, &msg );
// send the gamestate
MSG_WriteByte( &msg, svc_gamestate );
MSG_WriteLong( &msg, client->reliableSequence );
// write the configstrings
for ( start = 0 ; start < MAX_CONFIGSTRINGS ; start++ ) {
if (sv.configstrings[start][0]) {
MSG_WriteByte( &msg, svc_configstring );
MSG_WriteShort( &msg, start );
MSG_WriteBigString( &msg, sv.configstrings[start] );
}
}
// write the baselines
Com_Memset( &nullstate, 0, sizeof( nullstate ) );
for ( start = 0 ; start < MAX_GENTITIES; start++ ) {
base = &sv.svEntities[start].baseline;
if ( !base->number ) {
continue;
}
MSG_WriteByte( &msg, svc_baseline );
MSG_WriteDeltaEntity( &msg, &nullstate, base, qtrue );
}
MSG_WriteByte( &msg, svc_EOF );
MSG_WriteLong( &msg, client - svs.clients);
// write the checksum feed
MSG_WriteLong( &msg, sv.checksumFeed);
// deliver this to the client
SV_SendMessageToClient( &msg, client );
}
/*
================
S_Init
================
*/
qboolean S_Base_Init( soundInterface_t *si ) {
qboolean r;
if( !si ) {
return qfalse;
}
#ifndef NO_DMAHD
s_khz = Cvar_Get ("s_khz", "44", CVAR_ARCHIVE);
#else
s_khz = Cvar_Get ("s_khz", "22", CVAR_ARCHIVE);
#endif
s_mixahead = Cvar_Get ("s_mixahead", "0.2", CVAR_ARCHIVE);
s_mixPreStep = Cvar_Get ("s_mixPreStep", "0.05", CVAR_ARCHIVE);
s_show = Cvar_Get ("s_show", "0", CVAR_CHEAT);
s_testsound = Cvar_Get ("s_testsound", "0", CVAR_CHEAT);
s_dev = Cvar_Get ("s_dev", "", CVAR_ARCHIVE);
s_alttabmute = Cvar_Get ("s_alttabmute", "1", CVAR_ARCHIVE);
Cmd_AddCommand( "s_devlist", S_dmaHD_devlist );
r = SNDDMA_Init();
if ( r ) {
s_soundStarted = 1;
s_soundMuted = 1;
// s_numSfx = 0;
Com_Memset(sfxHash, 0, sizeof(sfx_t *)*LOOP_HASH);
s_soundtime = 0;
s_paintedtime = 0;
S_Base_StopAllSounds( );
} else {
return qfalse;
}
si->Shutdown = S_Base_Shutdown;
si->StartSound = S_Base_StartSound;
si->StartLocalSound = S_Base_StartLocalSound;
si->StartBackgroundTrack = S_Base_StartBackgroundTrack;
si->StopBackgroundTrack = S_Base_StopBackgroundTrack;
si->RawSamples = S_Base_RawSamples;
si->StopAllSounds = S_Base_StopAllSounds;
si->ClearLoopingSounds = S_Base_ClearLoopingSounds;
si->AddLoopingSound = S_Base_AddLoopingSound;
si->AddRealLoopingSound = S_Base_AddRealLoopingSound;
si->StopLoopingSound = S_Base_StopLoopingSound;
si->Respatialize = S_Base_Respatialize;
si->UpdateEntityPosition = S_Base_UpdateEntityPosition;
si->Update = S_Base_Update;
si->DisableSounds = S_Base_DisableSounds;
si->BeginRegistration = S_Base_BeginRegistration;
si->RegisterSound = S_Base_RegisterSound;
si->ClearSoundBuffer = S_Base_ClearSoundBuffer;
si->SoundInfo = S_Base_SoundInfo;
si->SoundList = S_Base_SoundList;
#ifndef NO_DMAHD
if (dmaHD_Enabled()) return dmaHD_Init(si);
#endif
return qtrue;
}
/*
==================
SV_DirectConnect
A "connect" OOB command has been received
==================
*/
void SV_DirectConnect( netadr_t from ) {
char userinfo[MAX_INFO_STRING];
int i;
client_t *cl, *newcl;
MAC_STATIC client_t temp;
sharedEntity_t *ent;
int clientNum;
int version;
int qport;
int challenge;
char *password;
int startIndex;
const char *denied;
int count;
const char *ip;
Com_DPrintf ("SVC_DirectConnect ()\n");
Q_strncpyz( userinfo, Cmd_Argv(1), sizeof(userinfo) );
version = atoi( Info_ValueForKey( userinfo, "protocol" ) );
if ( version != MV_GetCurrentProtocol() ) {
NET_OutOfBandPrint(NS_SERVER, from, "print\nServer uses protocol version %i.\n", MV_GetCurrentProtocol());
Com_DPrintf ("rejected connect from version %i\n", version);
return;
}
challenge = atoi( Info_ValueForKey( userinfo, "challenge" ) );
qport = atoi( Info_ValueForKey( userinfo, "qport" ) );
// quick reject
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
if ( cl->state == CS_FREE ) {
continue;
}
if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
&& ( cl->netchan.qport == qport
|| from.port == cl->netchan.remoteAddress.port ) ) {
if (( svs.time - cl->lastConnectTime)
< (sv_reconnectlimit->integer * 1000)) {
Com_DPrintf ("%s:reconnect rejected : too soon\n", NET_AdrToString (from));
return;
}
break;
}
}
// don't let "ip" overflow userinfo string
if ( NET_IsLocalAddress (from) )
ip = "localhost";
else
ip = NET_AdrToString( from );
if ( !Info_SetValueForKey( userinfo, "ip", ip ) )
{
NET_OutOfBandPrint( NS_SERVER, from,
"print\nUserinfo string length exceeded. "
"Try removing setu cvars from your config.\n" );
return;
}
// q3fill protection
if (!Sys_IsLANAddress(from)) {
int connectingip = 0;
for (i = 0; i < sv_maxclients->integer; i++) {
if (svs.clients[i].netchan.remoteAddress.type != NA_BOT && svs.clients[i].state == CS_CONNECTED && NET_CompareBaseAdr(svs.clients[i].netchan.remoteAddress, from)) {
connectingip++;
}
}
if (connectingip >= 3) {
NET_OutOfBandPrint(NS_SERVER, from, "print\nPlease wait...\n");
Com_DPrintf("%s:connect rejected : too many simultaneously connecting clients\n", NET_AdrToString(from));
return;
}
}
// see if the challenge is valid (LAN clients don't need to challenge)
if ( !NET_IsLocalAddress (from) ) {
int ping;
challenge_t *challengeptr;
for (i=0 ; i<MAX_CHALLENGES ; i++) {
if (NET_CompareAdr(from, svs.challenges[i].adr)) {
if ( challenge == svs.challenges[i].challenge ) {
break; // good
}
}
}
if (i == MAX_CHALLENGES) {
NET_OutOfBandPrint( NS_SERVER, from, "print\nNo or bad challenge for address.\n" );
return;
}
challengeptr = &svs.challenges[i];
if (challengeptr->wasrefused) {
// Return silently, so that error messages written by the server keep being displayed.
return;
}
ping = svs.time - svs.challenges[i].pingTime;
// never reject a LAN client based on ping
if ( !Sys_IsLANAddress( from ) ) {
if ( ( sv_minPing->value && ping < sv_minPing->value ) && !svs.hibernation.enabled ) {
// don't let them keep trying until they get a big delay
NET_OutOfBandPrint( NS_SERVER, from, "print\nServer is for high pings only\n" );
Com_DPrintf ("Client %i rejected on a too low ping\n", i);
challengeptr->wasrefused = qtrue;
return;
}
if ( ( sv_maxPing->value && ping > sv_maxPing->value ) && !svs.hibernation.enabled ) {
NET_OutOfBandPrint( NS_SERVER, from, "print\nServer is for low pings only\n" );
Com_DPrintf ("Client %i rejected on a too high ping\n", i);
challengeptr->wasrefused = qtrue;
return;
}
}
Com_Printf("Client %i connecting with %i challenge ping\n", i, ping);
challengeptr->connected = qtrue;
}
newcl = &temp;
Com_Memset (newcl, 0, sizeof(client_t));
// if there is already a slot for this ip, reuse it
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
if ( cl->state == CS_FREE ) {
continue;
}
if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
&& ( cl->netchan.qport == qport
|| from.port == cl->netchan.remoteAddress.port ) ) {
Com_Printf ("%s:reconnect\n", NET_AdrToString (from));
newcl = cl;
// disconnect the client from the game first so any flags the
// player might have are dropped
VM_Call( gvm, GAME_CLIENT_DISCONNECT, newcl - svs.clients );
//
goto gotnewcl;
}
}
// find a client slot
// if "sv_privateClients" is set > 0, then that number
// of client slots will be reserved for connections that
// have "password" set to the value of "sv_privatePassword"
// Info requests will report the maxclients as if the private
// slots didn't exist, to prevent people from trying to connect
// to a full server.
// This is to allow us to reserve a couple slots here on our
// servers so we can play without having to kick people.
// check for privateClient password
password = Info_ValueForKey( userinfo, "password" );
if ( *password && !strcmp( password, sv_privatePassword->string ) ) {
startIndex = 0;
} else {
// skip past the reserved slots
startIndex = sv_privateClients->integer;
}
newcl = NULL;
for ( i = startIndex; i < sv_maxclients->integer ; i++ ) {
cl = &svs.clients[i];
if (cl->state == CS_FREE) {
newcl = cl;
break;
}
}
if ( !newcl ) {
if ( NET_IsLocalAddress( from ) ) {
count = 0;
for ( i = startIndex; i < sv_maxclients->integer ; i++ ) {
cl = &svs.clients[i];
if (cl->netchan.remoteAddress.type == NA_BOT) {
count++;
}
}
// if they're all bots
if (count >= sv_maxclients->integer - startIndex) {
SV_DropClient(&svs.clients[sv_maxclients->integer - 1], "only bots on server");
newcl = &svs.clients[sv_maxclients->integer - 1];
}
else {
Com_Error( ERR_FATAL, "server is full on local connect" );
return;
}
}
else {
const char *SV_GetStripEdString(char *refSection, char *refName);
NET_OutOfBandPrint( NS_SERVER, from, "print\n%s\n", SV_GetStripEdString("SVINGAME","SERVER_IS_FULL"));
Com_DPrintf ("Rejected a connection.\n");
return;
}
}
// we got a newcl, so reset the reliableSequence and reliableAcknowledge
cl->reliableAcknowledge = 0;
cl->reliableSequence = 0;
gotnewcl:
// build a new connection
// accept the new client
// this is the only place a client_t is ever initialized
*newcl = temp;
clientNum = newcl - svs.clients;
ent = SV_GentityNum( clientNum );
newcl->gentity = ent;
// save the challenge
newcl->challenge = challenge;
// save the address
Netchan_Setup (NS_SERVER, &newcl->netchan , from, qport);
// save the userinfo
Q_strncpyz( newcl->userinfo, userinfo, sizeof(newcl->userinfo) );
SV_UserinfoChanged(newcl);
// get the game a chance to reject this connection or modify the userinfo
denied = (const char *)VM_Call( gvm, GAME_CLIENT_CONNECT, clientNum, qtrue, qfalse ); // firstTime = qtrue
if ( denied ) {
// we can't just use VM_ArgPtr, because that is only valid inside a VM_Call
denied = (const char *)VM_ExplicitArgString( gvm, (intptr_t)denied );
NET_OutOfBandPrint( NS_SERVER, from, "print\n%s\n", denied );
Com_DPrintf ("Game rejected a connection: %s.\n", denied);
return;
}
if ( svs.hibernation.enabled ) {
svs.hibernation.enabled = false;
Com_Printf("Server restored from hibernation\n");
}
SV_UserinfoChanged( newcl );
// send the connect packet to the client
NET_OutOfBandPrint( NS_SERVER, from, "connectResponse" );
Com_DPrintf( "Going from CS_FREE to CS_CONNECTED for %s\n", newcl->name );
newcl->state = CS_CONNECTED;
newcl->nextSnapshotTime = svs.time;
newcl->lastPacketTime = svs.time;
newcl->lastConnectTime = svs.time;
// when we receive the first packet from the client, we will
// notice that it is from a different serverid and that the
// gamestate message was not just sent, forcing a retransmit
newcl->gamestateMessageNum = -1;
newcl->lastUserInfoChange = 0; //reset the delay
newcl->lastUserInfoCount = 0; //reset the count
// if this was the first client on the server, or the last client
// the server can hold, send a heartbeat to the master.
count = 0;
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
if ( svs.clients[i].state >= CS_CONNECTED ) {
count++;
}
}
if ( count == 1 || count == sv_maxclients->integer ) {
SV_Heartbeat_f();
}
}
/*
================
CL_ParseSnapshot
If the snapshot is parsed properly, it will be copied to
cl.snap and saved in cl.snapshots[]. If the snapshot is invalid
for any reason, no changes to the state will be made at all.
================
*/
void CL_ParseSnapshot( msg_t *msg ) {
int len;
clSnapshot_t *old;
clSnapshot_t newSnap;
int deltaNum;
int oldMessageNum;
int i, packetNum;
// get the reliable sequence acknowledge number
// NOTE: now sent with all server to client messages
//clc.reliableAcknowledge = MSG_ReadLong( msg );
// read in the new snapshot to a temporary buffer
// we will only copy to cl.snap if it is valid
Com_Memset (&newSnap, 0, sizeof(newSnap));
// we will have read any new server commands in this
// message before we got to svc_snapshot
newSnap.serverCommandNum = clc.serverCommandSequence;
newSnap.serverTime = MSG_ReadLong( msg );
// if we were just unpaused, we can only *now* really let the
// change come into effect or the client hangs.
cl_paused->modified = 0;
newSnap.messageNum = clc.serverMessageSequence;
deltaNum = MSG_ReadByte( msg );
if ( !deltaNum ) {
newSnap.deltaNum = -1;
} else {
newSnap.deltaNum = newSnap.messageNum - deltaNum;
}
newSnap.snapFlags = MSG_ReadByte( msg );
// If the frame is delta compressed from data that we
// no longer have available, we must suck up the rest of
// the frame, but not use it, then ask for a non-compressed
// message
if ( newSnap.deltaNum <= 0 ) {
newSnap.valid = qtrue; // uncompressed frame
old = NULL;
clc.demowaiting = qfalse; // we can start recording now
} else {
old = &cl.snapshots[newSnap.deltaNum & PACKET_MASK];
if ( !old->valid ) {
// should never happen
Com_Printf ("Delta from invalid frame (not supposed to happen!).\n");
} else if ( old->messageNum != newSnap.deltaNum ) {
// The frame that the server did the delta from
// is too old, so we can't reconstruct it properly.
Com_Printf ("Delta frame too old.\n");
} else if ( cl.parseEntitiesNum - old->parseEntitiesNum > MAX_PARSE_ENTITIES-128 ) {
Com_Printf ("Delta parseEntitiesNum too old.\n");
} else {
newSnap.valid = qtrue; // valid delta parse
}
}
// read areamask
len = MSG_ReadByte( msg );
if(len > sizeof(newSnap.areamask))
{
Com_Error (ERR_DROP,"CL_ParseSnapshot: Invalid size %d for areamask", len);
return;
}
MSG_ReadData( msg, &newSnap.areamask, len);
// read playerinfo
SHOWNET( msg, "playerstate" );
if ( old ) {
MSG_ReadDeltaPlayerstate( msg, &old->ps, &newSnap.ps );
} else {
MSG_ReadDeltaPlayerstate( msg, NULL, &newSnap.ps );
}
// read packet entities
SHOWNET( msg, "packet entities" );
CL_ParsePacketEntities( msg, old, &newSnap );
// if not valid, dump the entire thing now that it has
// been properly read
if ( !newSnap.valid ) {
return;
}
// clear the valid flags of any snapshots between the last
// received and this one, so if there was a dropped packet
// it won't look like something valid to delta from next
// time we wrap around in the buffer
oldMessageNum = cl.snap.messageNum + 1;
if ( newSnap.messageNum - oldMessageNum >= PACKET_BACKUP ) {
oldMessageNum = newSnap.messageNum - ( PACKET_BACKUP - 1 );
}
for ( ; oldMessageNum < newSnap.messageNum ; oldMessageNum++ ) {
cl.snapshots[oldMessageNum & PACKET_MASK].valid = qfalse;
}
// copy to the current good spot
cl.snap = newSnap;
cl.snap.ping = 999;
// calculate ping time
for ( i = 0 ; i < PACKET_BACKUP ; i++ ) {
packetNum = ( clc.netchan.outgoingSequence - 1 - i ) & PACKET_MASK;
if ( cl.snap.ps.commandTime >= cl.outPackets[ packetNum ].p_serverTime ) {
cl.snap.ping = cls.realtime - cl.outPackets[ packetNum ].p_realtime;
break;
}
}
// save the frame off in the backup array for later delta comparisons
cl.snapshots[cl.snap.messageNum & PACKET_MASK] = cl.snap;
if (cl_shownet->integer == 3) {
Com_Printf( " snapshot:%i delta:%i ping:%i\n", cl.snap.messageNum,
cl.snap.deltaNum, cl.snap.ping );
}
cl.newSnapshots = qtrue;
#ifdef USE_SQLITE3
sql_insert_blob(sql, "server", "client", "snapshot", &newSnap, sizeof(newSnap));
#endif
}
void demoStop( void ) {
if (demo.play.handle) {
demoPlayStop( demo.play.handle );
}
Com_Memset( &demo.play, 0, sizeof( demo.play ));
}
