/*
=================
CG_DrawActiveFrame
Generates and draws a game scene and status information at the given time.
=================
*/
void CG_DrawActiveFrame( int serverTime, stereoFrame_t stereoView, qboolean demoPlayback ) {
int inwater;
cg.cld = 0; // NERVE - SMF - reset clientDamage
#ifdef DEBUGTIME_ENABLED
int dbgTime = trap_Milliseconds(),elapsed;
int dbgCnt = 0;
#endif
cg.time = serverTime;
cg.demoPlayback = demoPlayback;
// update cvars
CG_UpdateCvars();
/*
// RF, if we should force a weapon, then do so
if( !cg.weaponSelect ) {
if (cg_loadWeaponSelect.integer > 0) {
cg.weaponSelect = cg_loadWeaponSelect.integer;
cg.weaponSelectTime = cg.time;
trap_Cvar_Set( "cg_loadWeaponSelect", "0" ); // turn it off
}
}
*/
#ifdef DEBUGTIME_ENABLED
CG_Printf( "\n" );
#endif
DEBUGTIME
// if we are only updating the screen as a loading
// pacifier, don't even try to read snapshots
if ( cg.infoScreenText[0] != 0 ) {
CG_DrawInformation();
return;
}
// any looped sounds will be respecified as entities
// are added to the render list
trap_S_ClearLoopingSounds( qfalse );
DEBUGTIME
// clear all the render lists
trap_R_ClearScene();
DEBUGTIME
// set up cg.snap and possibly cg.nextSnap
CG_ProcessSnapshots();
DEBUGTIME
// if we haven't received any snapshots yet, all
// we can draw is the information screen
if ( !cg.snap || ( cg.snap->snapFlags & SNAPFLAG_NOT_ACTIVE ) ) {
CG_DrawInformation();
return;
}
if ( cg.weaponSelect == WP_FG42SCOPE || cg.weaponSelect == WP_SNOOPERSCOPE || cg.weaponSelect == WP_SNIPERRIFLE ) {
float spd;
spd = VectorLength( cg.snap->ps.velocity );
if ( spd > 180.0f ) {
switch ( cg.weaponSelect ) {
case WP_FG42SCOPE:
CG_FinishWeaponChange( cg.weaponSelect, WP_FG42 );
break;
case WP_SNOOPERSCOPE:
CG_FinishWeaponChange( cg.weaponSelect, WP_GARAND );
break;
case WP_SNIPERRIFLE:
CG_FinishWeaponChange( cg.weaponSelect, WP_MAUSER );
break;
}
}
}
DEBUGTIME
if ( !cg.lightstylesInited ) {
CG_SetupDlightstyles();
}
DEBUGTIME
// if we have been told not to render, don't
if ( cg_norender.integer ) {
return;
}
// this counter will be bumped for every valid scene we generate
cg.clientFrame++;
// update cg.predictedPlayerState
CG_PredictPlayerState();
DEBUGTIME
// decide on third person view
cg.renderingThirdPerson = cg_thirdPerson.integer /*|| (cg.snap->ps.stats[STAT_HEALTH] <= 0)*/;
// build cg.refdef
inwater = CG_CalcViewValues();
CG_CalcShakeCamera();
CG_ApplyShakeCamera();
DEBUGTIME
// RF, draw the skyboxportal
CG_DrawSkyBoxPortal();
DEBUGTIME
if ( inwater ) {
CG_UnderwaterSounds();
}
DEBUGTIME
// first person blend blobs, done after AnglesToAxis
if ( !cg.renderingThirdPerson ) {
CG_DamageBlendBlob();
}
DEBUGTIME
// build the render lists
if ( !cg.hyperspace ) {
CG_AddPacketEntities(); // adter calcViewValues, so predicted player state is correct
CG_AddMarks();
DEBUGTIME
// Rafael particles
CG_AddParticles();
// done.
DEBUGTIME
CG_AddLocalEntities();
DEBUGTIME
}
/*
=================
CG_DrawActiveFrame
Generates and draws a game scene and status information at the given time.
=================
*/
void CG_DrawActiveFrame( int serverTime, stereoFrame_t stereoView, qboolean demoPlayback ) {
int inwater;
cg.time = serverTime;
cg.demoPlayback = demoPlayback;
// update cvars
CG_UpdateCvars();
// if we are only updating the screen as a loading
// pacifier, don't even try to read snapshots
if ( cg.infoScreenText[0] != 0 ) {
CG_DrawInformation();
return;
}
// any looped sounds will be respecified as entities
// are added to the render list
trap_S_ClearLoopingSounds(qfalse);
// clear all the render lists
trap_R_ClearScene();
// set up cg.snap and possibly cg.nextSnap
CG_ProcessSnapshots();
// if we haven't received any snapshots yet, all
// we can draw is the information screen
if ( !cg.snap || ( cg.snap->snapFlags & SNAPFLAG_NOT_ACTIVE ) ) {
CG_DrawInformation();
return;
}
// let the client system know what our weapon and zoom settings are
trap_SetUserCmdValue( cg.weaponSelect, cg.zoomSensitivity );
// this counter will be bumped for every valid scene we generate
cg.clientFrame++;
// update cg.predictedPlayerState
CG_PredictPlayerState();
// decide on third person view
cg.renderingThirdPerson = cg_thirdPerson.integer || (cg.snap->ps.stats[STAT_HEALTH] <= 0);
// build cg.refdef
inwater = CG_CalcViewValues();
// first person blend blobs, done after AnglesToAxis
if ( !cg.renderingThirdPerson ) {
CG_DamageBlendBlob();
}
// build the render lists
if ( !cg.hyperspace ) {
CG_AddPacketEntities(); // adter calcViewValues, so predicted player state is correct
CG_AddMarks();
CG_AddParticles ();
CG_AddLocalEntities();
}
CG_AddViewWeapon( &cg.predictedPlayerState );
// add buffered sounds
CG_PlayBufferedSounds();
// play buffered voice chats
CG_PlayBufferedVoiceChats();
// finish up the rest of the refdef
if ( cg.testModelEntity.hModel ) {
CG_AddTestModel();
}
cg.refdef.time = cg.time;
memcpy( cg.refdef.areamask, cg.snap->areamask, sizeof( cg.refdef.areamask ) );
// warning sounds when powerup is wearing off
CG_PowerupTimerSounds();
// update audio positions
trap_S_Respatialize( cg.snap->ps.clientNum, cg.refdef.vieworg, cg.refdef.viewaxis, inwater );
// make sure the lagometerSample and frame timing isn't done twice when in stereo
if ( stereoView != STEREO_RIGHT ) {
cg.frametime = cg.time - cg.oldTime;
if ( cg.frametime < 0 ) {
cg.frametime = 0;
}
cg.oldTime = cg.time;
CG_AddLagometerFrameInfo();
}
if (cg_timescale.value != cg_timescaleFadeEnd.value) {
if (cg_timescale.value < cg_timescaleFadeEnd.value) {
cg_timescale.value += cg_timescaleFadeSpeed.value * ((float)cg.frametime) / 1000;
if (cg_timescale.value > cg_timescaleFadeEnd.value)
cg_timescale.value = cg_timescaleFadeEnd.value;
}
else {
cg_timescale.value -= cg_timescaleFadeSpeed.value * ((float)cg.frametime) / 1000;
if (cg_timescale.value < cg_timescaleFadeEnd.value)
cg_timescale.value = cg_timescaleFadeEnd.value;
}
if (cg_timescaleFadeSpeed.value) {
trap_Cvar_Set("timescale", va("%f", cg_timescale.value));
}
}
// actually issue the rendering calls
CG_DrawActive( stereoView );
if ( cg_stats.integer ) {
CG_Printf( "cg.clientFrame:%i\n", cg.clientFrame );
}
}
/*
=================
CG_DrawActiveFrame
Generates and draws a game scene and status information at the given time.
=================
*/
void CG_DrawActiveFrame( int serverTime, stereoFrame_t stereoView, qboolean demoPlayback ) {
int inwater;
qboolean renderClientViewport[MAX_SPLITVIEW];
int i;
cg.time = serverTime;
cg.demoPlayback = demoPlayback;
// update cvars
CG_UpdateCvars();
// if we are only updating the screen as a loading
// pacifier, don't even try to read snapshots
if ( cg.infoScreenText[0] != 0 ) {
CG_DrawInformation();
return;
}
// any looped sounds will be respecified as entities
// are added to the render list
trap_S_ClearLoopingSounds(qfalse);
// clear all the render lists
trap_R_ClearScene();
// set up cg.snap and possibly cg.nextSnap
CG_ProcessSnapshots();
// if we haven't received any snapshots yet, all
// we can draw is the information screen
if ( !cg.snap || ( cg.snap->snapFlags & SNAPFLAG_NOT_ACTIVE ) ) {
CG_DrawInformation();
return;
}
// this counter will be bumped for every valid scene we generate
cg.clientFrame++;
// Use single camera/viewport at intermission
for (i = 0; i < CG_MaxSplitView(); i++) {
if (cg.snap->lcIndex[i] != -1 && cg.snap->pss[i].pm_type != PM_INTERMISSION) {
// client present and not at intermission, keep viewports separate.
break;
}
}
cg.singleCamera = (cg.snap->numPSs > 1) && (i == CG_MaxSplitView());
cg.numViewports = 0;
for (i = 0; i < CG_MaxSplitView(); i++) {
if (cg.snap->lcIndex[i] == -1) {
renderClientViewport[i] = qfalse;
continue;
}
cg.cur_localClientNum = i;
cg.cur_lc = &cg.localClients[i];
cg.cur_ps = &cg.snap->pss[cg.snap->lcIndex[i]];
// Check if viewport should be drawn.
if ( cg.singleCamera && cg.numViewports >= 1 ) {
renderClientViewport[i] = qfalse;
} else {
cg.numViewports++;
renderClientViewport[i] = qtrue;
}
// let the client system know what our weapon and zoom settings are
trap_SetUserCmdValue( cg.cur_lc->weaponSelect, cg.cur_lc->zoomSensitivity, cg.cur_localClientNum );
// update cg.predictedPlayerState
CG_PredictPlayerState();
// Remove expired console lines
if( cg.cur_lc->consoleLines[ 0 ].time + cg_consoleLatency.integer < cg.time && cg_consoleLatency.integer > 0 ) {
CG_RemoveNotifyLine( cg.cur_lc );
}
}
// If all local clients dropped out from playing still draw main local client.
if (cg.numViewports == 0) {
cg.numViewports = 1;
renderClientViewport[0] = qtrue;
}
// play lead change annoucement and time/frag limit warnings
CG_CheckGameSounds();
// add buffered sounds
CG_PlayBufferedSounds();
#ifdef MISSIONPACK
// play buffered voice chats
CG_PlayBufferedVoiceChats();
#endif
for (i = 0, cg.viewport = -1; i < CG_MaxSplitView(); i++) {
if (!renderClientViewport[i]) {
continue;
}
cg.viewport++;
cg.cur_localClientNum = i;
cg.cur_lc = &cg.localClients[i];
cg.cur_ps = &cg.snap->pss[cg.snap->lcIndex[i]];
// decide on third person view
cg.cur_lc->renderingThirdPerson = cg_thirdPerson[cg.cur_localClientNum].integer || (cg.cur_ps->stats[STAT_HEALTH] <= 0);
CG_PB_ClearPolyBuffers();
// build cg.refdef
inwater = CG_CalcViewValues();
CG_SetupFrustum();
// first person blend blobs, done after AnglesToAxis
if ( !cg.cur_lc->renderingThirdPerson ) {
CG_DamageBlendBlob();
}
// build the render lists
if ( !cg.cur_lc->hyperspace ) {
CG_AddPacketEntities(); // adter calcViewValues, so predicted player state is correct
CG_AddMarks();
CG_AddParticles ();
CG_AddLocalEntities();
CG_AddAtmosphericEffects();
}
CG_AddViewWeapon( &cg.cur_lc->predictedPlayerState );
// finish up the rest of the refdef
if ( cg.testModelEntity.hModel ) {
CG_AddTestModel();
}
cg.refdef.time = cg.time;
memcpy( cg.refdef.areamask, cg.snap->areamask, sizeof( cg.refdef.areamask ) );
// warning sounds when powerup is wearing off
CG_PowerupTimerSounds();
// update audio positions
trap_S_Respatialize( cg.cur_ps->clientNum, cg.refdef.vieworg, cg.refdef.viewaxis, inwater, !cg.cur_lc->renderingThirdPerson );
// make sure the lagometerSample and frame timing isn't done twice when in stereo
if ( stereoView != STEREO_RIGHT && cg.viewport == 0 ) {
cg.frametime = cg.time - cg.oldTime;
if ( cg.frametime < 0 ) {
cg.frametime = 0;
}
cg.oldTime = cg.time;
CG_AddLagometerFrameInfo();
}
if (cg_timescale.value != cg_timescaleFadeEnd.value) {
if (cg_timescale.value < cg_timescaleFadeEnd.value) {
cg_timescale.value += cg_timescaleFadeSpeed.value * ((float)cg.frametime) / 1000;
if (cg_timescale.value > cg_timescaleFadeEnd.value)
cg_timescale.value = cg_timescaleFadeEnd.value;
}
else {
cg_timescale.value -= cg_timescaleFadeSpeed.value * ((float)cg.frametime) / 1000;
if (cg_timescale.value < cg_timescaleFadeEnd.value)
cg_timescale.value = cg_timescaleFadeEnd.value;
}
if (cg_timescaleFadeSpeed.value) {
trap_Cvar_Set("timescale", va("%f", cg_timescale.value));
}
}
// actually issue the rendering calls
CG_DrawActive( stereoView );
}
// load any models that have been deferred if a scoreboard is shown
if ( !CG_AnyScoreboardShowing() ) {
cg.deferredPlayerLoading = 0;
} else if ( ++cg.deferredPlayerLoading > 10 ) {
CG_LoadDeferredPlayers();
}
if (cg.numViewports != 1) {
// Setup single viewport
cg.numViewports = 1;
cg.viewport = 0;
// calculate size of viewport
CG_CalcVrect();
}
// Not drawing single client view.
cg.cur_lc = NULL;
cg.cur_ps = NULL;
cg.cur_localClientNum = -1;
// Draw over all viewports
CG_DrawScreen2D( stereoView );
if ( cg_stats.integer ) {
CG_Printf( "cg.clientFrame:%i\n", cg.clientFrame );
}
}
/*
=================
CG_DrawActiveFrame
Generates and draws a game scene and status information at the given time.
=================
*/
void CG_DrawActiveFrame( int serverTime, stereoFrame_t stereoView, qboolean demoPlayback ) {
int inwater;
int mpSetup; // NERVE - SMF
#ifdef DEBUGTIME_ENABLED
int dbgTime=trap_Milliseconds(),elapsed;
int dbgCnt=0;
#endif
cg.time = serverTime;
cg.demoPlayback = demoPlayback;
// update cvars
CG_UpdateCvars();
#ifdef DEBUGTIME_ENABLED
CG_Printf("\n");
#endif
DEBUGTIME
// if we are only updating the screen as a loading
// pacifier, don't even try to read snapshots
if ( cg.infoScreenText[0] != 0 ) {
CG_DrawInformation();
return;
}
// any looped sounds will be respecified as entities
// are added to the render list
trap_S_ClearLoopingSounds(qfalse);
DEBUGTIME
// clear all the render lists
trap_R_ClearScene();
DEBUGTIME
// set up cg.snap and possibly cg.nextSnap
CG_ProcessSnapshots();
DEBUGTIME
// if we haven't received any snapshots yet, all
// we can draw is the information screen
if ( !cg.snap || ( cg.snap->snapFlags & SNAPFLAG_NOT_ACTIVE ) ) {
CG_DrawInformation();
return;
}
// check for server set weapons we might not know about
// (FIXME: this is a hack for the time being since a scripted "selectweapon" does
// not hit the first snap, the server weapon set in cg_playerstate.c line 219 doesn't
// do the trick)
if( !cg.weaponSelect && cg.snap->ps.weapon) {
cg.weaponSelect = cg.snap->ps.weapon;
cg.weaponSelectTime = cg.time;
}
//----(SA) nerve uses this for snooper/sniper
if (cg.weaponSelect == WP_FG42SCOPE) {
float spd;
spd = VectorLength(cg.snap->ps.velocity);
if (spd > 180.0f)
CG_FinishWeaponChange(WP_FG42SCOPE, WP_FG42);
}
DEBUGTIME
if(!cg.lightstylesInited)
CG_SetupDlightstyles();
DEBUGTIME
// if we have been told not to render, don't
if (cg_norender.integer) {
return;
}
// this counter will be bumped for every valid scene we generate
cg.clientFrame++;
// update cg.predictedPlayerState
CG_PredictPlayerState();
DEBUGTIME
// decide on third person view
cg.renderingThirdPerson = cg_thirdPerson.integer || (cg.snap->ps.stats[STAT_HEALTH] <= 0);
// build cg.refdef
inwater = CG_CalcViewValues();
DEBUGTIME
// RF, draw the skyboxportal
CG_DrawSkyBoxPortal();
DEBUGTIME
if(inwater)
CG_UnderwaterSounds();
DEBUGTIME
// first person blend blobs, done after AnglesToAxis
if ( !cg.renderingThirdPerson ) {
CG_DamageBlendBlob();
}
DEBUGTIME
// build the render lists
if ( !cg.hyperspace ) {
CG_AddPacketEntities(); // adter calcViewValues, so predicted player state is correct
CG_AddMarks();
DEBUGTIME
// Rafael particles
CG_AddParticles ();
// done.
DEBUGTIME
CG_AddLocalEntities();
DEBUGTIME
}
/*
=================
CG_DrawActiveFrame
Generates and draws a game scene and status information at the given time.
=================
*/
void CG_DrawActiveFrame( int serverTime, stereoFrame_t stereoView, qboolean demoPlayback ) {
int inwater;
cg.time = serverTime;
cg.demoPlayback = demoPlayback;
if (cg.snap && ui_myteam.integer != cg.snap->ps.persistant[PERS_TEAM])
{
trap_Cvar_Set ( "ui_myteam", va("%i", cg.snap->ps.persistant[PERS_TEAM]) );
}
// update cvars
CG_UpdateCvars();
// if we are only updating the screen as a loading
// pacifier, don't even try to read snapshots
if ( cg.infoScreenText[0] != 0 ) {
CG_DrawInformation();
return;
}
trap_FX_AdjustTime( cg.time, cg.refdef.vieworg, cg.refdef.viewaxis );
CG_RunLightStyles();
// any looped sounds will be respecified as entities
// are added to the render list
trap_S_ClearLoopingSounds(qfalse);
// clear all the render lists
trap_R_ClearScene();
// set up cg.snap and possibly cg.nextSnap
CG_ProcessSnapshots();
trap_ROFF_UpdateEntities();
// if we haven't received any snapshots yet, all
// we can draw is the information screen
if ( !cg.snap || ( cg.snap->snapFlags & SNAPFLAG_NOT_ACTIVE ) ) {
CG_DrawInformation();
return;
}
// let the client system know what our weapon and zoom settings are
if (cg.snap && cg.snap->ps.saberLockTime > cg.time)
{
trap_SetUserCmdValue( cg.weaponSelect, 0.01, cg.forceSelect, cg.itemSelect );
}
else if (cg.snap && cg.snap->ps.usingATST)
{
trap_SetUserCmdValue( cg.weaponSelect, 0.2, cg.forceSelect, cg.itemSelect );
}
else
{
trap_SetUserCmdValue( cg.weaponSelect, cg.zoomSensitivity, cg.forceSelect, cg.itemSelect );
}
// this counter will be bumped for every valid scene we generate
cg.clientFrame++;
// update cg.predictedPlayerState
CG_PredictPlayerState();
// decide on third person view
cg.renderingThirdPerson = cg_thirdPerson.integer || (cg.snap->ps.stats[STAT_HEALTH] <= 0);
if (cg.snap->ps.stats[STAT_HEALTH] > 0 && (cg.predictedPlayerState.weapon == WP_SABER || cg.predictedPlayerState.usingATST ||
cg.predictedPlayerState.forceHandExtend == HANDEXTEND_KNOCKDOWN || cg.predictedPlayerState.fallingToDeath))
{
cg.renderingThirdPerson = 1;
}
else if (cg.snap->ps.zoomMode)
{ //always force first person when zoomed
cg.renderingThirdPerson = 0;
}
// build cg.refdef
inwater = CG_CalcViewValues();
CG_CalcScreenEffects();
// first person blend blobs, done after AnglesToAxis
if ( !cg.renderingThirdPerson ) {
CG_DamageBlendBlob();
}
// build the render lists
if ( !cg.hyperspace ) {
CG_AddPacketEntities(); // adter calcViewValues, so predicted player state is correct
CG_AddMarks();
CG_AddParticles ();
CG_AddLocalEntities();
}
CG_AddViewWeapon( &cg.predictedPlayerState );
if ( !cg.hyperspace)
{
trap_FX_AddScheduledEffects();
}
// add buffered sounds
CG_PlayBufferedSounds();
// play buffered voice chats
CG_PlayBufferedVoiceChats();
// finish up the rest of the refdef
if ( cg.testModelEntity.hModel ) {
CG_AddTestModel();
}
cg.refdef.time = cg.time;
memcpy( cg.refdef.areamask, cg.snap->areamask, sizeof( cg.refdef.areamask ) );
// warning sounds when powerup is wearing off
CG_PowerupTimerSounds();
// if there are any entities flagged as sound trackers and attached to other entities, update their sound pos
CG_UpdateSoundTrackers();
if (gCGHasFallVector)
{
vec3_t lookAng;
VectorSubtract(cg.snap->ps.origin, cg.refdef.vieworg, lookAng);
VectorNormalize(lookAng);
vectoangles(lookAng, lookAng);
VectorCopy(gCGFallVector, cg.refdef.vieworg);
AnglesToAxis(lookAng, cg.refdef.viewaxis);
}
// update audio positions
trap_S_Respatialize( cg.snap->ps.clientNum, cg.refdef.vieworg, cg.refdef.viewaxis, inwater );
// make sure the lagometerSample and frame timing isn't done twice when in stereo
if ( stereoView != STEREO_RIGHT ) {
cg.frametime = cg.time - cg.oldTime;
if ( cg.frametime < 0 ) {
cg.frametime = 0;
}
cg.oldTime = cg.time;
CG_AddLagometerFrameInfo();
}
if (cg_timescale.value != cg_timescaleFadeEnd.value) {
if (cg_timescale.value < cg_timescaleFadeEnd.value) {
cg_timescale.value += cg_timescaleFadeSpeed.value * ((float)cg.frametime) / 1000;
if (cg_timescale.value > cg_timescaleFadeEnd.value)
cg_timescale.value = cg_timescaleFadeEnd.value;
}
else {
cg_timescale.value -= cg_timescaleFadeSpeed.value * ((float)cg.frametime) / 1000;
if (cg_timescale.value < cg_timescaleFadeEnd.value)
cg_timescale.value = cg_timescaleFadeEnd.value;
}
if (cg_timescaleFadeSpeed.value) {
trap_Cvar_Set("timescale", va("%f", cg_timescale.value));
}
}
// actually issue the rendering calls
CG_DrawActive( stereoView );
if ( cg_stats.integer ) {
CG_Printf( "cg.clientFrame:%i\n", cg.clientFrame );
}
}
void CG_DemosDrawActiveFrame( int serverTime, stereoFrame_t stereoView ) {
int deltaTime;
qboolean hadSkip;
qboolean captureFrame;
float captureFPS;
float frameSpeed;
int blurTotal, blurIndex;
float blurFraction;
float stereoSep = CG_Cvar_Get( "r_stereoSeparation" );
int inwater, entityNum;
if (!demo.initDone) {
if ( !cg.snap ) {
demoProcessSnapShots( qtrue );
}
if ( !cg.snap ) {
CG_Error( "No Initial demo snapshot found" );
}
demoPlaybackInit();
}
cg.demoPlayback = 2;
// update cvars
CG_UpdateCvars();
// if we are only updating the screen as a loading
// pacifier, don't even try to read snapshots
if ( cg.loading ) {
CG_DrawInformation();
return;
}
captureFrame = demo.capture.active && !demo.play.paused;
if ( captureFrame ) {
trap_MME_BlurInfo( &blurTotal, &blurIndex );
captureFPS = mov_captureFPS.value;
if ( blurTotal > 0) {
captureFPS *= blurTotal;
blurFraction = blurIndex / (float)blurTotal;
} else {
blurFraction = 0;
}
} else {
}
/* Forward the demo */
deltaTime = serverTime - demo.serverTime;
if (deltaTime > 50)
deltaTime = 50;
demo.serverTime = serverTime;
demo.serverDeltaTime = 0.001 * deltaTime;
cg.oldTime = cg.time;
cg.oldTimeFraction = cg.timeFraction;
if (demo.play.time < 0) {
demo.play.time = demo.play.fraction = 0;
}
demo.play.oldTime = demo.play.time;
/* Handle the music */
if ( demo.play.paused ) {
if ( lastMusicStart >= 0)
demoSynchMusic( -1, 0 );
} else {
int musicStart = (demo.play.time - mov_musicStart.value * 1000 );
if ( musicStart <= 0 ) {
if (lastMusicStart >= 0 )
demoSynchMusic( -1, 0 );
} else {
if ( demo.play.time != demo.play.lastTime || lastMusicStart < 0)
demoSynchMusic( musicStart, 0 );
}
}
/* forward the time a bit till the moment of capture */
if ( captureFrame && demo.capture.locked && demo.play.time < demo.capture.start ) {
int left = demo.capture.start - demo.play.time;
if ( left > 2000) {
left -= 1000;
captureFrame = qfalse;
} else if (left > 5) {
captureFrame = qfalse;
left = 5;
}
demo.play.time += left;
} else if ( captureFrame && demo.loop.total && blurTotal ) {
float loopFraction = demo.loop.index / (float)demo.loop.total;
demo.play.time = demo.loop.start;
demo.play.fraction = demo.loop.range * loopFraction;
demo.play.time += (int)demo.play.fraction;
demo.play.fraction -= (int)demo.play.fraction;
} else if (captureFrame) {
float frameDelay = 1000.0f / captureFPS;
demo.play.fraction += frameDelay * demo.play.speed;
demo.play.time += (int)demo.play.fraction;
demo.play.fraction -= (int)demo.play.fraction;
} else if ( demo.find ) {
demo.play.time = demo.play.oldTime + 20;
demo.play.fraction = 0;
if ( demo.play.paused )
demo.find = findNone;
} else if (!demo.play.paused) {
float delta = demo.play.fraction + deltaTime * demo.play.speed;
demo.play.time += (int)delta;
demo.play.fraction = delta - (int)delta;
}
demo.play.lastTime = demo.play.time;
if ( demo.loop.total && captureFrame && blurTotal ) {
//Delay till we hit the right part at the start
int time;
float timeFraction;
if ( demo.loop.lineDelay && !blurIndex ) {
time = demo.loop.start - demo.loop.lineDelay;
timeFraction = 0;
if ( demo.loop.lineDelay > 8 )
demo.loop.lineDelay -= 8;
else
demo.loop.lineDelay = 0;
captureFrame = qfalse;
} else {
if ( blurIndex == blurTotal - 1 ) {
//We'll restart back to the start again
demo.loop.lineDelay = 2000;
if ( ++demo.loop.index >= demo.loop.total ) {
demo.loop.total = 0;
}
}
time = demo.loop.start;
timeFraction = demo.loop.range * blurFraction;
}
time += (int)timeFraction;
timeFraction -= (int)timeFraction;
lineAt( time, timeFraction, &demo.line.time, &cg.timeFraction, &frameSpeed );
} else {
lineAt( demo.play.time, demo.play.fraction, &demo.line.time, &cg.timeFraction, &frameSpeed );
}
/* Set the correct time */
cg.time = trap_MME_SeekTime( demo.line.time );
/* cg.time is shifted ahead a bit to correct some issues.. */
frameSpeed *= demo.play.speed;
cg.frametime = (cg.time - cg.oldTime) + (cg.timeFraction - cg.oldTimeFraction);
if (cg.frametime < 0) {
int i;
cg.frametime = 0;
hadSkip = qtrue;
cg.oldTime = cg.time;
cg.oldTimeFraction = cg.timeFraction;
CG_InitLocalEntities();
CG_InitMarkPolys();
CG_ClearParticles ();
trap_FX_Reset( );
trap_R_DecalReset();
cg.centerPrintTime = 0;
cg.damageTime = 0;
cg.powerupTime = 0;
cg.rewardTime = 0;
cg.scoreFadeTime = 0;
cg.lastKillTime = 0;
cg.attackerTime = 0;
cg.soundTime = 0;
cg.itemPickupTime = 0;
cg.itemPickupBlendTime = 0;
cg.weaponSelectTime = 0;
cg.headEndTime = 0;
cg.headStartTime = 0;
cg.v_dmg_time = 0;
cg.rewardCount[0] = 0;
cg.rewardStack = 0;
cg.rewardTime = 0;
trap_S_ClearLoopingSounds(qtrue);
for (i = 0; i < MAX_CHATBOX_ITEMS; i++)
cg.chatItems[i].time = 0;
} else if (cg.frametime > 100) {
hadSkip = qtrue;
} else {
hadSkip = qfalse;
}
/* Make sure the random seed is the same each time we hit this frame */
srand( (cg.time % 10000000) + cg.timeFraction * 1000);
/* Prepare to render the screen */
trap_S_ClearLoopingSounds(qfalse);
trap_R_ClearScene();
/* Update demo related information */
trap_SetUserCmdValue( cg.weaponSelect, 1 );
demoProcessSnapShots( hadSkip );
if ( !cg.snap ) {
CG_DrawInformation();
return;
}
CG_PreparePacketEntities( );
CG_DemosUpdatePlayer( );
chaseUpdate( demo.play.time, demo.play.fraction );
cameraUpdate( demo.play.time, demo.play.fraction );
dofUpdate( demo.play.time, demo.play.fraction );
demoEffectUpdate( demo.play.time, demo.play.fraction );
cg.clientFrame++;
// update cg.predictedPlayerState
CG_InterpolatePlayerState( qfalse );
BG_PlayerStateToEntityState( &cg.predictedPlayerState, &cg.predictedPlayerEntity.currentState, qfalse );
if ( cg.cpma.detected ) {
if ( cg.predictedPlayerState.pm_type >= 4 )
cg.predictedPlayerEntity.currentState.eType = ET_INVISIBLE;
}
cg.predictedPlayerEntity.currentValid = qtrue;
VectorCopy( cg.predictedPlayerEntity.currentState.pos.trBase, cg.predictedPlayerEntity.lerpOrigin );
VectorCopy( cg.predictedPlayerEntity.currentState.apos.trBase, cg.predictedPlayerEntity.lerpAngles );
inwater = demoSetupView();
CG_TileClear();
trap_FX_Begin( cg.time, cg.timeFraction );
scriptRun( hadSkip );
CG_AddPacketEntities();
CG_AddMarks();
CG_AddParticles ();
CG_AddLocalEntities();
if ( cg.playerCent == &cg.predictedPlayerEntity ) {
// warning sounds when powerup is wearing off
CG_PowerupTimerSounds();
CG_AddViewWeapon( &cg.predictedPlayerState );
} else if ( cg.playerCent && cg.playerCent->currentState.number < MAX_CLIENTS ) {
CG_AddViewWeaponDirect( cg.playerCent );
}
trap_S_UpdateEntityPosition(ENTITYNUM_NONE, cg.refdef.vieworg);
CG_PlayBufferedSounds();
CG_PlayBufferedVoiceChats();
cg.refdef.time = cg.time;
memcpy( cg.refdef.areamask, cg.snap->areamask, sizeof( cg.refdef.areamask ) );
/* Render some extra demo related stuff */
if (!captureFrame) {
switch (demo.editType) {
case editCamera:
cameraDraw( demo.play.time, demo.play.fraction );
break;
case editChase:
chaseDraw( demo.play.time, demo.play.fraction );
break;
case editDof:
dofDraw( demo.play.time, demo.play.fraction );
break;
case editEffect:
demoEffectDraw( demo.play.time, demo.play.fraction );
break;
}
/* Add bounding boxes for easy aiming */
if ( demo.editType && ( demo.cmd.buttons & BUTTON_ATTACK) && ( demo.cmd.buttons & BUTTON_AFFIRMATIVE) ) {
int i;
centity_t *targetCent;
for (i = 0;i<MAX_GENTITIES;i++) {
targetCent = demoTargetEntity( i );
if (targetCent) {
vec3_t container, traceStart, traceImpact, forward;
const float *color;
demoCentityBoxSize( targetCent, container );
VectorSubtract( demo.viewOrigin, targetCent->lerpOrigin, traceStart );
AngleVectors( demo.viewAngles, forward, 0, 0 );
if (BoxTraceImpact( traceStart, forward, container, traceImpact )) {
color = colorRed;
} else {
color = colorYellow;
}
demoDrawBox( targetCent->lerpOrigin, container, color );
}
}
}
if ( mov_gridStep.value > 0 && mov_gridRange.value > 0) {
vec4_t color;
vec3_t offset;
qhandle_t shader = trap_R_RegisterShader( "mme/gridline" );
color[0] = color[1] = color[2] = 1;
color[3] = 0;
offset[0] = offset[1] = offset[2] = 0;
Q_parseColor( mov_gridColor.string, ospColors, color );
demoDrawGrid( demo.viewOrigin, color, offset, mov_gridWidth.value, mov_gridStep.value, mov_gridRange.value, shader );
}
}
if (frameSpeed > 5)
frameSpeed = 5;
trap_S_UpdateScale( frameSpeed );
if (cg.playerCent && cg.predictedPlayerState.pm_type == PM_INTERMISSION) {
entityNum = cg.snap->ps.clientNum;
} else if (cg.playerCent) {
entityNum = cg.playerCent->currentState.number;
} else {
entityNum = ENTITYNUM_NONE;
}
trap_S_Respatialize( entityNum, cg.refdef.vieworg, cg.refdef.viewaxis, inwater);
trap_FX_End();
if (captureFrame && stereoSep > 0.0f)
trap_Cvar_Set("r_stereoSeparation", va("%f", -stereoSep));
trap_MME_TimeFraction(cg.timeFraction);
trap_R_RenderScene( &cg.refdef );
if ( demo.viewType == viewChase && cg.playerCent && ( cg.playerCent->currentState.number < MAX_CLIENTS ) )
CG_Draw2D();
// CG_DrawSmallString( 0, 0, va( "height %d", cg.playerCent->pe.viewHeight ), 1 );
if (captureFrame) {
char fileName[MAX_OSPATH];
Com_sprintf( fileName, sizeof( fileName ), "capture/%s/%s", mme_demoFileName.string, mov_captureName.string );
trap_MME_Capture( fileName, captureFPS, demo.viewFocus, demo.viewRadius );
if ( mov_captureCamera.integer )
demoAddViewPos( fileName, demo.viewOrigin, demo.viewAngles, demo.viewFov );
} else {
if (demo.editType && !cg.playerCent)
demoDrawCrosshair();
hudDraw();
if (demo.editType) {
demoDrawProgress(trap_MME_ProgressTime());
}
}
//checkCaptureEnd:
if ( demo.capture.active && demo.capture.locked && demo.play.time > demo.capture.end ) {
Com_Printf( "Capturing ended\n" );
if (demo.autoLoad) {
trap_SendConsoleCommand( "disconnect\n" );
}
demo.capture.active = qfalse;
}
}
/*
=================
CG_DrawActiveFrame
Generates and draws a game scene and status information at the given time.
=================
*/
void CG_DrawActiveFrame( int serverTime, stereoFrame_t stereoView, qbool demoPlayback ) {
int inwater;
cg.time = serverTime;
//unlagged - lag simulation #1
// adjust the clock to reflect latent snaps
cg.time -= cg_latentSnaps.integer * (1000 / sv_fps.integer);
//unlagged - lag simulation #1
cg.demoPlayback = demoPlayback;
// update cvars
CG_UpdateCvars();
// if we are only updating the screen as a loading
// pacifier, don't even try to read snapshots
if ( cg.infoScreenText[0] != 0 ) {
CG_DrawInformation();
return;
}
// any looped sounds will be respecified as entities
// are added to the render list
trap_S_ClearLoopingSounds(qfalse);
// clear all the render lists
trap_R_ClearScene();
// set up cg.snap and possibly cg.nextSnap
CG_ProcessSnapshots();
// if we haven't received any snapshots yet, all
// we can draw is the information screen
if ( !cg.snap || ( cg.snap->snapFlags & SNAPFLAG_NOT_ACTIVE ) ) {
CG_DrawInformation();
return;
}
// let the client system know what our weapon and zoom settings are
trap_SetUserCmdValue( cg.weaponSelect, cg.zoomSensitivity );
// WP_SEC_PISTOL 's special value has been transmitted.
// Restore cg.weaponSelect
if (cg.weaponSelect == WP_SEC_PISTOL)
cg.weaponSelect = cg._weaponSelect;
// this counter will be bumped for every valid scene we generate
cg.clientFrame++;
// check if duel start sound has to be played
if(cg.roundstarttime && cg.roundstarttime <= cg.time && cgs.gametype == GT_DUEL) {
cg.introstart = cg.roundstarttime;
cg.introend = cg.introstart + DU_INTRO_CAM + DU_INTRO_DRAW;
cg.roundstarttime = 0;
// cycle through the start tracks
trap_S_StartLocalSound( cgs.media.duelstart[cg.duelstartsound], CHAN_ANNOUNCER );
cg.duelstartsound++;
if(cg.duelstartsound == 5)
cg.duelstartsound = 0;
}
// update cg.predictedPlayerState
CG_PredictPlayerState();
// decide on third person view
cg.renderingThirdPerson = cg_thirdPerson.integer || cg.introstart || (cgs.deathcam && (cg.snap->ps.stats[STAT_HEALTH] <= 0)
&& !(cg.snap->ps.pm_flags & PMF_SUICIDE) && !(cg.snap->ps.pm_flags & PMF_FOLLOW)
&& (cg.snap->ps.pm_type != PM_CHASECAM) && (cgs.gametype != GT_DUEL));
// build cg.refdef
inwater = CG_CalcViewValues();
// build cg_frustum, from cg.refdef
CG_SetupFrustum();
// first person blend blobs, done after AnglesToAxis
if ( !cg.renderingThirdPerson ) {
CG_DamageBlendBlob();
}
// build the render lists
if ( !cg.hyperspace ) {
CG_AddPacketEntities(); // adter calcViewValues, so predicted player state is correct
CG_AddMarks();
CG_AddLocalEntities();
}
CG_AddViewWeapon( &cg.predictedPlayerState );
// add buffered sounds
CG_PlayBufferedSounds();
// finish up the rest of the refdef
if ( cg.testModelEntity.hModel ) {
CG_AddTestModel();
}
cg.refdef.time = cg.time;
memcpy( cg.refdef.areamask, cg.snap->areamask, sizeof( cg.refdef.areamask ) );
// update audio positions
trap_S_Respatialize( cg.snap->ps.clientNum, cg.refdef.vieworg, cg.refdef.viewaxis, inwater );
// make sure the lagometerSample and frame timing isn't done twice when in stereo
if ( stereoView != STEREO_RIGHT ) {
cg.frametime = cg.time - cg.oldTime;
if ( cg.frametime < 0 ) {
cg.frametime = 0;
}
cg.oldTime = cg.time;
CG_AddLagometerFrameInfo();
}
if (cg_timescale.value != cg_timescaleFadeEnd.value) {
if (cg_timescale.value < cg_timescaleFadeEnd.value) {
cg_timescale.value += cg_timescaleFadeSpeed.value * ((float)cg.frametime) / 1000;
if (cg_timescale.value > cg_timescaleFadeEnd.value)
cg_timescale.value = cg_timescaleFadeEnd.value;
}
else {
cg_timescale.value -= cg_timescaleFadeSpeed.value * ((float)cg.frametime) / 1000;
if (cg_timescale.value < cg_timescaleFadeEnd.value)
cg_timescale.value = cg_timescaleFadeEnd.value;
}
if (cg_timescaleFadeSpeed.value) {
trap_Cvar_Set("timescale", va("%f", cg_timescale.value));
}
}
// actually issue the rendering calls
CG_DrawActive( stereoView );
if ( cg_stats.integer ) {
CG_Printf( "cg.clientFrame:%i\n", cg.clientFrame );
}
}
void CG_DrawActiveFrame( int serverTime, stereoFrame_t stereoView ) {
qboolean inwater = qfalse;
cg.time = serverTime;
CG_BuildSolidList();
// update cvars
CG_UpdateCvars();
// if we are only updating the screen as a loading
// pacifier, don't even try to read snapshots
if ( cg.infoScreenText[0] != 0 ) {
CG_DrawInformation();
return;
}
// any looped sounds will be respecified as entities
// are added to the render list
cgi_S_ClearLoopingSounds();
// clear all the render lists
cgi_R_ClearScene();
// set up cg.snap and possibly cg.nextSnap
CG_ProcessSnapshots();
// if we haven't received any snapshots yet, all
// we can draw is the information screen
if ( !cg.snap ) {
CG_DrawInformation();
return;
}
// let the client system know what our weapon and zoom settings are
cgi_SetUserCmdValue( cg.weaponSelect, cg.refdef.fov_y / 75.0 );
// this counter will be bumped for every valid scene we generate
cg.clientFrame++;
// update cg.predicted_player_state
CG_PredictPlayerState();
// decide on third person view
cg.renderingThirdPerson = cg_thirdPerson.integer || (cg.snap->ps.stats[STAT_HEALTH] <= 0);
if ( in_camera )
{
// The camera takes over the view
CGCam_RenderScene();
}
else
{
//Finish any fading that was happening
CGCam_UpdateFade();
// build cg.refdef
inwater = CG_CalcViewValues();
}
//This is done from the vieworg to get origin for non-attenuated sounds
cgi_S_UpdateAmbientSet( CG_ConfigString( CS_AMBIENT_SET ), cg.refdef.vieworg );
// first person blend blobs, done after AnglesToAxis
if ( !cg.renderingThirdPerson ) {
CG_DamageBlendBlob();
}
// build the render lists
if ( !cg.hyperspace ) {
CG_AddPacketEntities(); // adter calcViewValues, so predicted player state is correct
CG_AddMarks();
CG_AddLocalEntities();
}
// Don't draw the in-view weapon when in camera mode
if ( !in_camera && !cg_pano.integer )
CG_AddViewWeapon( &cg.predicted_player_state );
// finish up the rest of the refdef
if ( cg.testModelEntity.hModel ) {
CG_AddTestModel();
}
cg.refdef.time = cg.time;
memcpy( cg.refdef.areamask, cg.snap->areamask, sizeof( cg.refdef.areamask ) );
// update audio positions
cgi_S_Respatialize( cg.snap->ps.clientNum, cg.refdef.vieworg, cg.refdef.viewaxis, inwater );
// warning sounds when powerup is wearing off
CG_PowerupTimerSounds();
// make sure the lagometerSample and frame timing isn't done twice when in stereo
if ( stereoView != STEREO_RIGHT ) {
cg.frametime = cg.time - cg.oldTime;
cg.oldTime = cg.time;
}
//Add all effects
if (cg.frametime >= 0) {
FX_Add();
}
if ( cg_pano.integer ) { // let's grab a panorama!
cg.levelShot = qtrue; //hide the 2d
VectorClear(cg.refdefViewAngles);
cg.refdefViewAngles[YAW] = -360 * cg_pano.integer/cg_panoNumShots.integer; //choose angle
AnglesToAxis( cg.refdefViewAngles, cg.refdef.viewaxis );
CG_DrawActive( stereoView );
cg.levelShot = qfalse;
} else {
// actually issue the rendering calls
CG_DrawActive( stereoView );
}
}
void CG_RenderView( float frameTime, float realFrameTime, int realTime, unsigned int serverTime, float stereo_separation, unsigned int extrapolationTime, bool flipped )
{
refdef_t *rd = &cg.view.refdef;
// update time
cg.realTime = realTime;
cg.frameTime = frameTime;
cg.realFrameTime = realFrameTime;
cg.frameCount++;
cg.time = serverTime;
if( !cgs.precacheDone || !cg.frame.valid )
{
CG_Precache();
CG_DrawLoading();
return;
}
{
float snapTime = ( cg.frame.serverTime - cg.oldFrame.serverTime );
if( !snapTime )
snapTime = cgs.snapFrameTime;
// moved this from CG_Init here
cgs.extrapolationTime = extrapolationTime;
if( cg.oldFrame.serverTime == cg.frame.serverTime )
cg.lerpfrac = 1.0f;
else
cg.lerpfrac = ( (double)( cg.time - cgs.extrapolationTime ) - (double)cg.oldFrame.serverTime ) / (double)snapTime;
if( cgs.extrapolationTime )
{
cg.xerpTime = 0.001f * ( (double)cg.time - (double)cg.frame.serverTime );
cg.oldXerpTime = 0.001f * ( (double)cg.time - (double)cg.oldFrame.serverTime );
if( cg.time >= cg.frame.serverTime )
{
cg.xerpSmoothFrac = (double)( cg.time - cg.frame.serverTime ) / (double)( cgs.extrapolationTime );
clamp( cg.xerpSmoothFrac, 0.0f, 1.0f );
}
else
{
cg.xerpSmoothFrac = (double)( cg.frame.serverTime - cg.time ) / (double)( cgs.extrapolationTime );
clamp( cg.xerpSmoothFrac, -1.0f, 0.0f );
cg.xerpSmoothFrac = 1.0f - cg.xerpSmoothFrac;
}
clamp_low( cg.xerpTime, -( cgs.extrapolationTime * 0.001f ) );
//clamp( cg.xerpTime, -( cgs.extrapolationTime * 0.001f ), ( cgs.extrapolationTime * 0.001f ) );
//clamp( cg.oldXerpTime, 0, ( ( snapTime + cgs.extrapolationTime ) * 0.001f ) );
}
else
{
cg.xerpTime = 0.0f;
cg.xerpSmoothFrac = 0.0f;
}
}
if( cg_showClamp->integer )
{
if( cg.lerpfrac > 1.0f )
CG_Printf( "high clamp %f\n", cg.lerpfrac );
else if( cg.lerpfrac < 0.0f )
CG_Printf( "low clamp %f\n", cg.lerpfrac );
}
clamp( cg.lerpfrac, 0.0f, 1.0f );
if( !cgs.configStrings[CS_WORLDMODEL][0] )
{
CG_AddLocalSounds();
trap_R_DrawStretchPic( 0, 0, cgs.vidWidth, cgs.vidHeight, 0, 0, 1, 1, colorBlack, cgs.shaderWhite );
trap_S_Update( vec3_origin, vec3_origin, axis_identity, cgs.clientInfo[cgs.playerNum].name );
return;
}
// bring up the game menu after reconnecting
if( !cgs.tv && !cgs.demoPlaying ) {
if( ISREALSPECTATOR() && !cg.firstFrame ) {
if( !cgs.gameMenuRequested ) {
trap_Cmd_ExecuteText( EXEC_NOW, "gamemenu\n" );
}
cgs.gameMenuRequested = true;
}
}
if( !cg.viewFrameCount )
cg.firstViewRealTime = cg.realTime;
CG_FlashGameWindow(); // notify player of important game events
CG_CalcVrect(); // find sizes of the 3d drawing screen
CG_TileClear(); // clear any dirty part of the background
CG_ChaseCamButtons();
CG_RunLightStyles();
CG_ClearFragmentedDecals();
trap_R_ClearScene();
if( CG_DemoCam_Update() )
CG_SetupViewDef( &cg.view, CG_DemoCam_GetViewType(), flipped );
else
CG_SetupViewDef( &cg.view, VIEWDEF_PLAYERVIEW, flipped );
CG_LerpEntities(); // interpolate packet entities positions
CG_CalcViewWeapon( &cg.weapon );
CG_FireEvents( false );
CG_AddEntities();
CG_AddViewWeapon( &cg.weapon );
CG_AddLocalEntities();
CG_AddParticles();
CG_AddDlights();
CG_AddShadeBoxes();
CG_AddDecals();
CG_AddPolys();
CG_AddLightStyles();
#ifndef PUBLIC_BUILD
CG_AddTest();
#endif
// offset vieworg appropriately if we're doing stereo separation
VectorMA( cg.view.origin, stereo_separation, &cg.view.axis[AXIS_RIGHT], rd->vieworg );
// never let it sit exactly on a node line, because a water plane can
// disappear when viewed with the eye exactly on it.
// the server protocol only specifies to 1/16 pixel, so add 1/16 in each axis
rd->vieworg[0] += 1.0/PM_VECTOR_SNAP;
rd->vieworg[1] += 1.0/PM_VECTOR_SNAP;
rd->vieworg[2] += 1.0/PM_VECTOR_SNAP;
AnglesToAxis( cg.view.angles, rd->viewaxis );
rd->rdflags = CG_RenderFlags();
// warp if underwater
if( rd->rdflags & RDF_UNDERWATER )
{
float phase = rd->time * 0.001 * WAVE_FREQUENCY * M_TWOPI;
float v = WAVE_AMPLITUDE * ( sin( phase ) - 1.0 ) + 1;
rd->fov_x *= v;
rd->fov_y *= v;
}
CG_AddLocalSounds();
CG_SetSceneTeamColors(); // update the team colors in the renderer
trap_R_RenderScene( &cg.view.refdef );
cg.oldAreabits = true;
trap_S_Update( cg.view.origin, cg.view.velocity, cg.view.axis, cgs.clientInfo[cgs.playerNum].name );
CG_Draw2D();
CG_ResetTemporaryBoneposesCache(); // clear for next frame
cg.viewFrameCount++;
}