void CCommandFuncs::Vid(const char* szParameters)
{
#if 0
// ripped from the renderware sdk
CGameSettings * gameSettings = CCore::GetSingleton ( ).GetGame ( )->GetSettings();
if ( strlen(szParameters) == 0 )
{
VideoMode vidModemInfo;
int vidMode, numVidModes, currentVidMode;
numVidModes = gameSettings->GetNumVideoModes();
currentVidMode = gameSettings->GetCurrentVideoMode();
// Add the available video modes to the dialog
for (vidMode = 0; vidMode < numVidModes; vidMode++)
{
gameSettings->GetVideoModeInfo(&vidModemInfo, vidMode);
SString strMode ( "%d: %lu x %lu x %lu %s %s",
vidMode, vidModemInfo.width, vidModemInfo.height,
vidModemInfo.depth,
vidModemInfo.flags & rwVIDEOMODEEXCLUSIVE ?
"(Fullscreen)" : "",
currentVidMode == vidMode ? "(Current)" : "" );
CCore::GetSingleton ().GetConsole ()->Printf ( strMode );
}
CCore::GetSingleton ().GetConsole ()->Printf( "* Syntax: vid <mode>" );
}
else
{
// Make sure no mod is loaded
if ( !CCore::GetSingleton ().GetModManager ()->IsLoaded () )
{
// Grab the device window and what mode to switch to
int iParameter = atoi ( szParameters );
// Change the video mode
GetVideoModeManager ()->ChangeVideoMode ( iParameter );
// Grab viewport settings
int iViewportX = CCore::GetSingleton ().GetGraphics()->GetViewportWidth ();
int iViewportY = CCore::GetSingleton ().GetGraphics()->GetViewportHeight ();
// Re-create all CGUI windows, for correct absolute sizes that depend on the (new) screen resolution
CCore::GetSingleton ().GetLocalGUI ()->DestroyWindows ();
CCore::GetSingleton ().GetGUI ()->SetResolution ( (float) iViewportX, (float) iViewportY );
CCore::GetSingleton ().GetLocalGUI ()->CreateWindows ();
// Reload console, serverbrowser and chat settings (removed in DestroyWindows)
g_pCore->ApplyConsoleSettings ();
g_pCore->ApplyMenuSettings ();
}
else
{
g_pCore->GetConsole ()->Echo ( "vid: Please disconnect before changing video mode" );
}
}
#endif
}
void CDeathFX::CreateHumanDeathFX()
{
CSFXMgr* psfxMgr = g_pGameClientShell->GetSFXMgr();
if (!psfxMgr) return;
CGameSettings* pSettings = g_pInterfaceMgr->GetSettings();
if (!pSettings || !pSettings->Gore()) return;
GIBCREATESTRUCT gib;
m_pClientDE->AlignRotation(&(gib.rRot), &m_vDir, LTNULL);
LTFLOAT fDamage = VEC_MAG(m_vDir);
VEC_COPY(gib.vPos, m_vPos);
VEC_SET(gib.vMinVel, 50.0f, 100.0f, 50.0f);
VEC_MULSCALAR(gib.vMinVel, gib.vMinVel, fDamage);
VEC_SET(gib.vMaxVel, 100.0f, 200.0f, 100.0f);
VEC_MULSCALAR(gib.vMaxVel, gib.vMaxVel, fDamage);
gib.fLifeTime = 20.0f;
gib.fFadeTime = 7.0f;
gib.nGibFlags = 0;
gib.bRotate = LTTRUE;
gib.nCode = m_eCode;
gib.eModelId = m_eModelId;
gib.eModelStyle = m_eModelStyle;
gib.bSubGibs = LTTRUE;
gib.bBloodSplats = LTTRUE;
SetupGibTypes(gib);
psfxMgr->CreateSFX(SFX_GIB_ID, &gib);
}
void CCommandFuncs::Window ( const char* szParameters )
{
#if 0
// Make sure no mod is loaded
if ( !CCore::GetSingleton ().GetModManager ()->IsLoaded () )
{
CGameSettings * gameSettings = CCore::GetSingleton ( ).GetGame ( )->GetSettings();
unsigned int currentMode = gameSettings->GetCurrentVideoMode();
if ( currentMode == 0 )
{
GetVideoModeManager ()->ChangeVideoMode ( VIDEO_MODE_FULLSCREEN );
g_pCore->GetLocalGUI()->GetMainMenu ()->RefreshPositions();
}
else
{
// Run "vid 0"
Vid ( "0" );
}
}
else
{
g_pCore->GetConsole ()->Echo ( "window: Please disconnect first" );
}
#endif
}
void CGibFX::CreateLingeringSmoke(int nIndex)
{
CSFXMgr* psfxMgr = g_pGameClientShell->GetSFXMgr();
if (!psfxMgr) return;
CGameSettings* pSettings = g_pInterfaceMgr->GetSettings();
if (!pSettings) return;
uint8 nDetailLevel = pSettings->SpecialFXSetting();
if (nDetailLevel == RS_LOW) return;
SMCREATESTRUCT sm;
char* pTexture = "Sprites\\SmokeTest.spr";
VEC_SET(sm.vColor1, 100.0f, 100.0f, 100.0f);
VEC_SET(sm.vColor2, 125.0f, 125.0f, 125.0f);
VEC_SET(sm.vMinDriftVel, -10.0f, 25.0f, -10.0f);
VEC_SET(sm.vMaxDriftVel, 10.0f, 50.0f, 10.0f);
LTFLOAT fVolumeRadius = 10.0f;
LTFLOAT fLifeTime = GetRandom(m_fLifeTime * 0.75f, m_fLifeTime);
LTFLOAT fRadius = 1500;
LTFLOAT fParticleCreateDelta = 0.1f;
LTFLOAT fMinParticleLife = 1.0f;
LTFLOAT fMaxParticleLife = 5.0f;
uint8 nNumParticles = 3;
LTBOOL bIgnoreWind = LTFALSE;
if (IsLiquid(m_eCode))
{
GetLiquidColorRange(m_eCode, &sm.vColor1, &sm.vColor2);
pTexture = DEFAULT_BUBBLE_TEXTURE;
fRadius = 750.0f;
bIgnoreWind = LTTRUE;
fMinParticleLife = 1.0f;
fMaxParticleLife = 1.5f;
}
sm.vPos = m_Emitters[nIndex].m_vPos;
sm.hServerObj = m_hGib[nIndex];
sm.fVolumeRadius = fVolumeRadius;
sm.fLifeTime = fLifeTime;
sm.fRadius = fRadius;
sm.fParticleCreateDelta = fParticleCreateDelta;
sm.fMinParticleLife = fMinParticleLife;
sm.fMaxParticleLife = fMaxParticleLife;
sm.nNumParticles = nNumParticles;
sm.bIgnoreWind = bIgnoreWind;
sm.hstrTexture = m_pClientDE->CreateString(pTexture);
psfxMgr->CreateSFX(SFX_SMOKE_ID, &sm);
m_pClientDE->FreeString(sm.hstrTexture);
}
void CGibFX::CreateMiniBloodExplosion(int nIndex)
{
// Add a mini blood explosion...
CSFXMgr* psfxMgr = g_pGameClientShell->GetSFXMgr();
if (!psfxMgr) return;
CGameSettings* pSettings = g_pInterfaceMgr->GetSettings();
if (!pSettings) return;
uint8 nDetailLevel = pSettings->SpecialFXSetting();
if (nDetailLevel == RS_LOW) return;
char* szBlood[2] = { "SpecialFX\\ParticleTextures\\Blood_1.dtx",
"SpecialFX\\ParticleTextures\\Blood_2.dtx" };
PARTICLESHOWERCREATESTRUCT ps;
ps.vPos = m_Emitters[nIndex].m_vPos;
ps.vPos.y += 30.0f;
ps.vDir.Init(0, 100, 0);
VEC_SET(ps.vColor1, 200.0f, 200.0f, 200.0f);
VEC_SET(ps.vColor2, 255.0f, 255.0f, 255.0f);
ps.pTexture = szBlood[GetRandom(0,1)];;
ps.nParticles = 50;
ps.fDuration = 1.0f;
ps.fEmissionRadius = 0.3f;
ps.fRadius = 800.0f;
ps.fGravity = PSFX_DEFAULT_GRAVITY;
if (IsLiquid(m_eCode))
{
ps.vDir *= 3.0f;
ps.fEmissionRadius = 0.2f;
ps.fRadius = 700.0f;
}
psfxMgr->CreateSFX(SFX_PARTICLESHOWER_ID, &ps);
// Play appropriate sound...
char* pSound = GetGibDieSound();
if (pSound)
{
g_pClientSoundMgr->PlaySoundFromPos(ps.vPos, pSound, 300.0f,
SOUNDPRIORITY_MISC_LOW);
}
}
///////////////////////////////////////////////////////////////
//
// CVideoModeManager::SaveCVars
//
// Saves from next
//
///////////////////////////////////////////////////////////////
void CVideoModeManager::SaveCVars ( void )
{
m_pGameSettings->SetCurrentVideoMode ( m_iNextVideoMode, true );
CVARS_SET ( "display_windowed", m_bNextWindowed );
CVARS_SET ( "display_fullscreen_style", m_iNextFullscreenStyle );
CVARS_SET ( "multimon_fullscreen_minimize", m_bCurrentFullScreenMinimize );
}
void CFolderGame::OnFocus(LTBOOL bFocus)
{
CGameSettings *pSettings = g_pInterfaceMgr->GetSettings();
if (bFocus)
{
m_bGore = pSettings->Gore();
m_nDifficulty = g_pGameClientShell->GetDifficulty();
m_bFadeBodies = g_pGameClientShell->GetFadeBodies();
m_nSubtitles = (int)g_vtSubtitles.GetFloat();
m_bAlwaysRun = pSettings->RunLock();
m_nLayout = (int)g_vtHUDLayout.GetFloat();
m_nHeadBob = (int)(10.0f * GetConsoleFloat("HeadBob",1.0f));
m_nWeaponSway = (int)(10.0f * GetConsoleFloat("WeaponSway",1.0f));
m_nPickupMsgDur = (int)(2.0f * GetConsoleFloat("PickupMessageDuration",5.0f));
m_bObjMessages = ( GetConsoleInt("ObjectiveMessages",1) > 0 );
UpdateData(LTFALSE);
}
else
{
UpdateData();
pSettings->SetBoolVar("Gore",m_bGore);
g_vtSubtitles.WriteFloat((LTFLOAT)m_nSubtitles);
g_vtHUDLayout.WriteFloat((LTFLOAT)m_nLayout);
WriteConsoleInt("Difficulty",m_nDifficulty);
g_pGameClientShell->SetDifficulty((GameDifficulty)m_nDifficulty);
WriteConsoleInt("FadeBodies",(int)m_bFadeBodies);
g_pGameClientShell->SetFadeBodies(m_bFadeBodies);
pSettings->SetBoolVar("RunLock",m_bAlwaysRun);
WriteConsoleFloat("HeadBob",((LTFLOAT)m_nHeadBob / 10.0f));
WriteConsoleFloat("WeaponSway",((LTFLOAT)m_nWeaponSway / 10.0f));
WriteConsoleFloat("PickupMessageDuration",((LTFLOAT)m_nPickupMsgDur / 2.0f));
WriteConsoleInt("ObjectiveMessages",m_bObjMessages);
g_pLTClient->WriteConfigFile("autoexec.cfg");
}
CBaseFolder::OnFocus(bFocus);
}
// Change in focus
void CFolderControls::OnFocus(LTBOOL bFocus)
{
CGameSettings *pSettings = g_pInterfaceMgr->GetSettings();
if (bFocus)
{
// Load the folder options from the console
m_bUseJoystick=pSettings->UseJoystick();
CFolderJoystick *pJoy = (CFolderJoystick *)m_pFolderMgr->GetFolderFromID(FOLDER_ID_JOYSTICK);
if (!pJoy->IsJoystickConfigured()) m_bUseJoystick = LTFALSE;
m_pJoystickCtrl->Enable(m_bUseJoystick);
UpdateData(LTFALSE);
}
else
{
UpdateData();
CGameSettings *pSettings = g_pInterfaceMgr->GetSettings();
pSettings->SetBoolVar("UseJoystick",m_bUseJoystick);
if (m_bUseJoystick)
{
char strJoystick[128];
memset (strJoystick, 0, 128);
LTRESULT result = g_pLTClient->GetDeviceName (DEVICETYPE_JOYSTICK, strJoystick, 127);
if (result == LT_OK)
{
char strConsole[256];
sprintf (strConsole, "EnableDevice \"%s\"", strJoystick);
g_pLTClient->RunConsoleString (strConsole);
}
else
{
pSettings->SetBoolVar("UseJoystick",LTFALSE);
}
}
// Just to be safe save the config incase anything changed...
g_pLTClient->WriteConfigFile("autoexec.cfg");
}
CBaseFolder::OnFocus(bFocus);
}
CClientSound* CClientSoundManager::PlayGTASFX3D ( eAudioLookupIndex containerIndex, int iBankIndex, int iAudioIndex, const CVector& vecPosition, bool bLoop )
{
if ( !GetSFXStatus ( containerIndex ) )
return NULL;
void* pAudioData;
unsigned int uiAudioLength;
if ( !g_pGame->GetAudioContainer ()->GetAudioData ( containerIndex, iBankIndex, iAudioIndex, pAudioData, uiAudioLength ) )
return NULL;
CClientSound* pSound = PlaySound3D ( pAudioData, uiAudioLength, vecPosition, bLoop );
if ( pSound )
{
CGameSettings * gameSettings = g_pGame->GetSettings ();
pSound->SetVolume ( gameSettings->GetSFXVolume () / 255.0f );
}
return pSound;
}
unsigned int CSFXMgr::GetDynArrayMaxNum(uint8 nIndex)
{
if (0 <= nIndex && nIndex < DYN_ARRAY_SIZE)
{
// Use detail setting for bullet holes...
if (nIndex == SFX_MARK_ID)
{
CGameSettings* pSettings = g_pInterfaceMgr->GetSettings();
if (pSettings)
{
return int(pSettings->NumBulletHoles() + 1);
}
}
return s_nDynArrayMaxNums[nIndex];
}
return 0;
}
void CChat::Output(const char* szText, bool bColorCoded)
{
CChatLine* pLine = NULL;
const char* szRemainingText = szText;
CColor color = m_TextColor;
// Allow smooth scroll when text is added if game FX Quality is not low
CGameSettings* gameSettings = CCore::GetSingleton().GetGame()->GetSettings();
if (gameSettings->GetFXQuality() > 0)
m_fSmoothScroll -= 1.0f;
do
{
m_uiMostRecentLine = (m_uiMostRecentLine == 0 ? CHAT_MAX_LINES - 1 : m_uiMostRecentLine - 1);
pLine = &m_Lines[m_uiMostRecentLine];
szRemainingText = pLine->Format(szRemainingText, (m_vecBackgroundSize.fX - (10.0f * m_vecScale.fX)), color, bColorCoded);
pLine->SetActive(true);
pLine->UpdateCreationTime();
} while (szRemainingText);
}
///////////////////////////////////////////////////////////////
//
// CVideoModeManager::SetVideoMode
//
// Returns true if restart is required
//
///////////////////////////////////////////////////////////////
bool CVideoModeManager::SetVideoMode ( int iNextVideoMode, bool bNextWindowed, bool bNextFullScreenMinimize, int iNextFullscreenStyle )
{
bool bRequiresRestart = false;
// Resolution
if ( iNextVideoMode > 0 && iNextVideoMode < (int)m_pGameSettings->GetNumVideoModes () )
{
if ( m_iNextVideoMode != iNextVideoMode )
{
m_iNextVideoMode = iNextVideoMode;
if ( m_iCurrentVideoMode != iNextVideoMode )
{
bRequiresRestart = true;
}
}
}
// Windowed
if ( m_bNextWindowed != bNextWindowed )
{
m_bNextWindowed = bNextWindowed;
if ( m_bCurrentWindowed != bNextWindowed )
{
bRequiresRestart = true;
}
}
// Full Screen Minimize
m_bCurrentFullScreenMinimize = bNextFullScreenMinimize;
// Fullscreen style
if ( m_iNextFullscreenStyle != iNextFullscreenStyle )
{
m_iNextFullscreenStyle = iNextFullscreenStyle;
if ( m_iCurrentFullscreenStyle != m_iNextFullscreenStyle )
{
if ( m_iCurrentFullscreenStyle == FULLSCREEN_STANDARD || m_iNextFullscreenStyle == FULLSCREEN_STANDARD )
{
bRequiresRestart = true;
}
else
{
m_iCurrentFullscreenStyle = m_iNextFullscreenStyle;
}
}
}
SaveCVars ();
return bRequiresRestart;
}
CSpecialFX* CGibFX::CreateGibTrail(HLOCALOBJ hObj)
{
if (!hObj || !m_pClientDE) return LTNULL;
CGameSettings* pSettings = g_pInterfaceMgr->GetSettings();
if (!pSettings) return LTNULL;
uint8 nDetailLevel = pSettings->SpecialFXSetting();
if (nDetailLevel == RS_LOW) return LTNULL;
PTCREATESTRUCT pt;
pt.hServerObj = hObj;
pt.nType = (uint8) (m_eModelType == eModelTypeHuman ? PT_BLOOD : PT_GIBSMOKE);
CSpecialFX* pSFX = debug_new(CParticleTrailFX);
if (!pSFX) return LTNULL;
pSFX->Init(&pt);
pSFX->CreateObject(m_pClientDE);
return pSFX;
}
///////////////////////////////////////////////////////////////
//
// CVideoModeManager::LoadCVars
//
// Loads to current
//
///////////////////////////////////////////////////////////////
void CVideoModeManager::LoadCVars ( void )
{
// Upgrade display_alttab_handler
bool bAltTabHandlerWasEnabled = CVARS_GET_VALUE < bool > ( "display_alttab_handler" );
int iFullscreenStyle = CVARS_GET_VALUE < int > ( "display_fullscreen_style" );
if ( bAltTabHandlerWasEnabled && iFullscreenStyle == 0 )
{
CVARS_SET ( "display_alttab_handler", false );
CVARS_SET ( "display_fullscreen_style", FULLSCREEN_BORDERLESS );
}
// Apply override
if ( GetApplicationSettingInt( "nvhacks", "optimus-force-windowed" ) )
{
SetApplicationSettingInt( "nvhacks", "optimus-force-windowed", 0 );
CVARS_SET ( "display_windowed", true );
}
m_iCurrentVideoMode = m_pGameSettings->GetCurrentVideoMode ();
CVARS_GET ( "display_windowed", m_bCurrentWindowed );
CVARS_GET ( "display_fullscreen_style", m_iCurrentFullscreenStyle );
CVARS_GET ( "multimon_fullscreen_minimize", m_bCurrentFullScreenMinimize );
}
LTBOOL CProjectileFX::CreateObject(ILTClient* pClientDE)
{
if (!CSpecialFX::CreateObject(pClientDE) || !m_hServerObject) return LTFALSE;
CGameSettings* pSettings = g_pInterfaceMgr->GetSettings();
if (!pSettings) return LTFALSE;
uint8 nDetailLevel = pSettings->SpecialFXSetting();
LTVector vPos;
LTRotation rRot;
g_pLTClient->GetObjectPos(m_hServerObject, &vPos);
g_pLTClient->GetObjectRotation(m_hServerObject, &rRot);
//m_pClientDE->CPrint("Client start pos (%.2f, %.2f, %.2f)", vPos.x, vPos.y, vPos.z);
//m_fStartTime = m_pClientDE->GetTime();
if (nDetailLevel != RS_LOW)
{
if (m_nFX & PFX_SMOKETRAIL)
{
CreateSmokeTrail(vPos, rRot);
}
if (m_nFX & PFX_LIGHT)
{
CreateLight(vPos, rRot);
}
}
if (m_nFX & PFX_FLARE)
{
CreateFlare(vPos, rRot);
}
if (m_nFX & PFX_FLYSOUND)
{
CreateFlyingSound(vPos, rRot);
}
// Do client-side projectiles in multiplayer games...
if ( g_pClientMultiplayerMgr->IsConnectedToRemoteServer( ))
{
// Set the velocity of the "server" object if it is really just a local
// object...
if (m_bLocal)
{
VEC_COPY(m_vFirePos, vPos);
m_fStartTime = m_pClientDE->GetTime();
LTVector vVel, vF;
vF = rRot.Forward();
m_vPath = vF;
// Special case of adjusting the projectile speed...
LTFLOAT fVel = (LTFLOAT) m_pProjectileFX->nVelocity;
if (m_bAltFire)
{
fVel = (LTFLOAT) m_pProjectileFX->nAltVelocity;
}
LTFLOAT fMultiplier = 1.0f;
if (m_pClientDE->GetSConValueFloat("MissileSpeed", fMultiplier) != LT_NOTFOUND)
{
fVel *= fMultiplier;
}
vVel = vF * fVel;
g_pPhysicsLT->SetVelocity(m_hServerObject, &vVel);
}
}
return LTTRUE;
}
////////////////////////////////////////////////////////////////
//
// CRenderItemManager::GetDxStatus
//
//
//
////////////////////////////////////////////////////////////////
void CRenderItemManager::GetDxStatus ( SDxStatus& outStatus )
{
outStatus.testMode = m_TestMode;
// Copy hardware settings
outStatus.videoCard.strName = m_strVideoCardName;
outStatus.videoCard.iInstalledMemoryKB = m_iVideoCardMemoryKBTotal;
outStatus.videoCard.strPSVersion = m_strVideoCardPSVersion;
outStatus.videoCard.depthBufferFormat = m_depthBufferFormat;
outStatus.videoCard.iMaxAnisotropy = g_pDeviceState->AdapterState.MaxAnisotropicSetting;
outStatus.videoCard.iNumSimultaneousRTs = g_pDeviceState->DeviceCaps.NumSimultaneousRTs;
// State
outStatus.state.iNumShadersUsingReadableDepthBuffer = m_ShadersUsingDepthBuffer.size();
// Memory usage
outStatus.videoMemoryKB.iFreeForMTA = m_iMemoryKBFreeForMTA;
outStatus.videoMemoryKB.iUsedByFonts = m_iFontMemoryKBUsed;
outStatus.videoMemoryKB.iUsedByTextures = m_iTextureMemoryKBUsed;
outStatus.videoMemoryKB.iUsedByRenderTargets = m_iRenderTargetMemoryKBUsed;
// Option settings
CGameSettings* gameSettings = CCore::GetSingleton ().GetGame ()->GetSettings ();
outStatus.settings.bWindowed = GetVideoModeManager()->IsDisplayModeWindowed();
outStatus.settings.iFullScreenStyle = GetVideoModeManager()->GetFullScreenStyle();
outStatus.settings.iFXQuality = gameSettings->GetFXQuality(); ;
outStatus.settings.iDrawDistance = ( gameSettings->GetDrawDistance () - 0.925f ) / 0.8749f * 100;
outStatus.settings.iAntiAliasing = gameSettings->GetAntiAliasing() - 1;
outStatus.settings.bVolumetricShadows = false;
outStatus.settings.bAllowScreenUpload = true;
outStatus.settings.iStreamingMemory = 0;
outStatus.settings.bGrassEffect = false;
outStatus.settings.bHeatHaze = false;
outStatus.settings.iAnisotropicFiltering = 0;
outStatus.settings.aspectRatio = gameSettings->GetAspectRatio ();
outStatus.settings.bHUDMatchAspectRatio = true;
outStatus.settings.fFieldOfView = 70;
outStatus.settings.bHighDetailVehicles = false;
CVARS_GET ( "streaming_memory", outStatus.settings.iStreamingMemory );
CVARS_GET ( "volumetric_shadows", outStatus.settings.bVolumetricShadows );
CVARS_GET ( "allow_screen_upload", outStatus.settings.bAllowScreenUpload );
CVARS_GET ( "grass", outStatus.settings.bGrassEffect );
CVARS_GET ( "heat_haze", outStatus.settings.bHeatHaze );
CVARS_GET ( "anisotropic", outStatus.settings.iAnisotropicFiltering );
CVARS_GET ( "hud_match_aspect_ratio", outStatus.settings.bHUDMatchAspectRatio );
CVARS_GET ( "fov", outStatus.settings.fFieldOfView );
CVARS_GET ( "high_detail_vehicles", outStatus.settings.bHighDetailVehicles );
if ( outStatus.settings.iFXQuality == 0 )
{
// These are always off with low fx quality
outStatus.settings.bVolumetricShadows = false;
outStatus.settings.bGrassEffect = false;
}
// Display color depth
D3DFORMAT BackBufferFormat = g_pDeviceState->CreationState.PresentationParameters.BackBufferFormat;
if ( BackBufferFormat >= D3DFMT_R5G6B5 && BackBufferFormat < D3DFMT_A8R3G3B2 )
outStatus.settings.b32BitColor = 0;
else
outStatus.settings.b32BitColor = 1;
// Modify if using test mode
if ( m_TestMode == DX_TEST_MODE_NO_MEM )
outStatus.videoMemoryKB.iFreeForMTA = 0;
if ( m_TestMode == DX_TEST_MODE_LOW_MEM )
outStatus.videoMemoryKB.iFreeForMTA = 1;
if ( m_TestMode == DX_TEST_MODE_NO_SHADER )
outStatus.videoCard.strPSVersion = "0";
}
// Build the folder
LTBOOL CFolderGame::Build()
{
CreateTitle(IDS_TITLE_GAME_OPTIONS);
CGameSettings* pSettings = g_pInterfaceMgr->GetSettings();
if (g_pLayoutMgr->HasCustomValue(FOLDER_ID_GAME,"ColumnWidth"))
kGap = g_pLayoutMgr->GetFolderCustomInt(FOLDER_ID_GAME,"ColumnWidth");
if (g_pLayoutMgr->HasCustomValue(FOLDER_ID_GAME,"SliderWidth"))
kWidth = g_pLayoutMgr->GetFolderCustomInt(FOLDER_ID_GAME,"SliderWidth");
//crosshair menu
AddTextItem(IDS_CONTROLS_CROSSHAIR, FOLDER_CMD_CROSSHAIR, IDS_HELP_CROSSHAIRMENU);
CCycleCtrl *pCycle = AddCycleItem(IDS_DISPLAY_SUBTITLES,IDS_HELP_SUBTITLES,kGap-25,25,&m_nSubtitles);
pCycle->AddString(IDS_OFF);
pCycle->AddString(IDS_ON);
if (pSettings && pSettings->IsGoreAllowed())
{
CToggleCtrl *pGore = AddToggle(IDS_DISPLAY_GORE,IDS_HELP_GORE,kGap,&m_bGore);
pGore->SetOnString(IDS_ON);
pGore->SetOffString(IDS_OFF);
}
CToggleCtrl *pFadeBodies = AddToggle(IDS_FADEBODIES,IDS_HELP_FADEBODIES,kGap,&m_bFadeBodies);
pFadeBodies->SetOnString(IDS_YES);
pFadeBodies->SetOffString(IDS_NO);
//always run
CToggleCtrl* pToggle = AddToggle(IDS_ADVCONTROLS_RUNLOCK, IDS_HELP_RUNLOCK, kGap, &m_bAlwaysRun );
pToggle->SetOnString(IDS_YES);
pToggle->SetOffString(IDS_NO);
// Add the Difficulty option
m_pDifficultyCtrl = AddCycleItem(IDS_DIFFICULTY,IDS_HELP_DIFFICULTY,kGap-25,25,&m_nDifficulty);
m_pDifficultyCtrl->AddString(IDS_NEW_EASY);
m_pDifficultyCtrl->AddString(IDS_NEW_MEDIUM);
m_pDifficultyCtrl->AddString(IDS_NEW_HARD);
m_pDifficultyCtrl->AddString(IDS_NEW_INSANE);
pCycle = AddCycleItem(IDS_HUDLAYOUT,IDS_HELP_HUDLAYOUT,kGap-25,25,&m_nLayout);
for (int hl = 0; hl < g_pLayoutMgr->GetNumHUDLayouts(); hl++)
{
pCycle->AddString(g_pLayoutMgr->GetLayoutName(hl));
}
CSliderCtrl *pSlider=AddSlider(IDS_HEADBOB, IDS_HELP_HEADBOB, kGap, kWidth, &m_nHeadBob);
pSlider->SetSliderRange(0, 10);
pSlider->SetSliderIncrement(1);
pSlider=AddSlider(IDS_WEAPONSWAY, IDS_HELP_WEAPONSWAY, kGap, kWidth, &m_nWeaponSway);
pSlider->SetSliderRange(0, 10);
pSlider->SetSliderIncrement(1);
pSlider=AddSlider(IDS_PICKUP_MSG_DUR, IDS_HELP_PICKUP_MSG_DUR, kGap, kWidth, &m_nPickupMsgDur);
pSlider->SetSliderRange(0, 10);
pSlider->SetSliderIncrement(1);
pToggle = AddToggle(IDS_OBJECTIVE_MSGS, IDS_HELP_OBJECTIVE_MSGS, kGap, &m_bObjMessages );
pToggle->SetOnString(IDS_YES);
pToggle->SetOffString(IDS_NO);
// Make sure to call the base class
if (! CBaseFolder::Build()) return LTFALSE;
UseBack(LTTRUE,LTTRUE);
return LTTRUE;
}
void CWeaponFX::CreateSurfaceSpecificFX()
{
CGameSettings* pSettings = g_pInterfaceMgr->GetSettings();
if (!pSettings) return;
// Don't do gore fx...
if (m_eSurfaceType == ST_FLESH)
{
if (!pSettings->Gore())
{
return;
}
if (m_pAmmo->eType == VECTOR && m_pAmmo->eInstDamageType == DT_BULLET)
{
CreateBloodSplatFX();
}
}
if ((m_wFireFX & WFX_EXITMARK) && ShowsMark(m_eExitSurface))
{
CreateExitMark();
}
if (m_wFireFX & WFX_EXITDEBRIS)
{
CreateExitDebris();
}
if (!m_pAmmo || !m_pAmmo->pImpactFX) return;
if (!m_pAmmo->pImpactFX->bDoSurfaceFX) return;
// Create the surface specific fx...
int i;
SURFACE* pSurf = g_pSurfaceMgr->GetSurface(m_eSurfaceType);
if (pSurf)
{
if (IsLiquid(m_eCode))
{
// Create underwater fx...
// Create any impact particle shower fx associated with this surface...
for (i=0; i < pSurf->nNumUWImpactPShowerFX; i++)
{
CPShowerFX* pPShowerFX = g_pSurfaceMgr->GetPShowerFX(pSurf->aUWImpactPShowerFXIds[i]);
g_pFXButeMgr->CreatePShowerFX(pPShowerFX, m_vPos, m_vDir, m_vSurfaceNormal);
}
}
else
{
// Create normal fx...
// Create any impact scale fx associated with this surface...
for (i=0; i < pSurf->nNumImpactScaleFX; i++)
{
CScaleFX* pScaleFX = g_pSurfaceMgr->GetScaleFX(pSurf->aImpactScaleFXIds[i]);
g_pFXButeMgr->CreateScaleFX(pScaleFX, m_vPos, m_vDir, &m_vSurfaceNormal, &m_rSurfaceRot);
}
// Create any impact particle shower fx associated with this surface...
for (i=0; i < pSurf->nNumImpactPShowerFX; i++)
{
CPShowerFX* pPShowerFX = g_pSurfaceMgr->GetPShowerFX(pSurf->aImpactPShowerFXIds[i]);
g_pFXButeMgr->CreatePShowerFX(pPShowerFX, m_vPos, m_vDir, m_vSurfaceNormal);
}
// Create any impact poly debris fx associated with this surface...
if (g_vtCreatePolyDebris.GetFloat())
{
for (i=0; i < pSurf->nNumImpactPolyDebrisFX; i++)
{
CPolyDebrisFX* pPolyDebrisFX = g_pSurfaceMgr->GetPolyDebrisFX(pSurf->aImpactPolyDebrisFXIds[i]);
g_pFXButeMgr->CreatePolyDebrisFX(pPolyDebrisFX, m_vPos, m_vDir, m_vSurfaceNormal);
}
}
}
}
}
LTBOOL CWeaponFX::CreateObject(ILTClient* pClientDE)
{
if (!CSpecialFX::CreateObject(pClientDE) || !g_pWeaponMgr) return LTFALSE;
CGameSettings* pSettings = g_pInterfaceMgr->GetSettings();
if (!pSettings) return LTFALSE;
// Set up our data members...
// Set the local client id...
uint32 dwId;
g_pLTClient->GetLocalClientID(&dwId);
m_nLocalId = (uint8)dwId;
m_nDetailLevel = pSettings->SpecialFXSetting();
// Fire pos may get tweaked a little...
m_vFirePos = CalcFirePos(m_vFirePos);
m_vDir = m_vPos - m_vFirePos;
m_fFireDistance = m_vDir.Mag();
m_vDir.Norm();
g_pLTClient->AlignRotation(&m_rSurfaceRot, &m_vSurfaceNormal, LTNULL);
g_pLTClient->AlignRotation(&m_rDirRot, &m_vDir, LTNULL);
SetupExitInfo();
// Calculate if the camera can see the fire position and the impact
// position...
g_bCanSeeImpactPos = LTTRUE;
g_bCanSeeFirePos = LTTRUE;
g_bDistantImpactPos = LTFALSE;
g_bDistantFirePos = LTFALSE;
if (g_vtWeaponFXUseFOVPerformance.GetFloat())
{
HOBJECT hCamera = g_pGameClientShell->GetCamera();
LTVector vCameraPos, vU, vR, vF, vDir;
LTRotation rCameraRot;
g_pLTClient->GetObjectPos(hCamera, &vCameraPos);
g_pLTClient->GetObjectRotation(hCamera, &rCameraRot);
g_pLTClient->GetRotationVectors(&rCameraRot, &vU, &vR, &vF);
vDir = m_vPos - vCameraPos;
LTFLOAT fImpactDist = vDir.Mag();
if (fImpactDist > g_vtWeaponFXMaxImpactDist.GetFloat())
{
g_bDistantImpactPos = LTTRUE;
}
vDir.Norm();
LTFLOAT fMul = VEC_DOT(vDir, vF);
g_bCanSeeImpactPos = (fMul < g_vtWeaponFXMinImpactDot.GetFloat() ? LTFALSE : LTTRUE);
// In multiplayer we need to account for impacts that occur around
// our camera that we didn't cause (this is also an issue in single
// player, but due to the singler player gameplay dynamics it isn't
// as noticeable)...
if (!g_bCanSeeImpactPos && IsMultiplayerGame())
{
// Somebody else shot this...if the impact is close enough, we
// "saw" it...
if (m_nLocalId != m_nShooterId && fImpactDist <= g_vtWeaponFXMaxMultiImpactDist.GetFloat())
{
g_bCanSeeImpactPos = LTTRUE;
}
}
vDir = m_vFirePos - vCameraPos;
if (vDir.Mag() > g_vtWeaponFXMaxFireDist.GetFloat())
{
g_bDistantFirePos = LTTRUE;
}
vDir.Norm();
fMul = VEC_DOT(vDir, vF);
g_bCanSeeFirePos = (fMul < g_vtWeaponFXMinFireDot.GetFloat() ? LTFALSE : LTTRUE);
}
// Determine what container the sfx is in...
HLOCALOBJ objList[1];
LTVector vTestPos = m_vPos + m_vSurfaceNormal; // Test a little closer...
uint32 dwNum = g_pLTClient->GetPointContainers(&vTestPos, objList, 1);
if (dwNum > 0 && objList[0])
{
uint32 dwUserFlags;
g_pLTClient->GetObjectUserFlags(objList[0], &dwUserFlags);
if (dwUserFlags & USRFLG_VISIBLE)
{
uint16 dwCode;
if (g_pLTClient->GetContainerCode(objList[0], &dwCode))
{
m_eCode = (ContainerCode)dwCode;
}
}
}
// Determine if the fire point is in liquid
vTestPos = m_vFirePos + m_vDir; // Test a little further in...
dwNum = g_pLTClient->GetPointContainers(&vTestPos, objList, 1);
if (dwNum > 0 && objList[0])
{
uint32 dwUserFlags;
g_pLTClient->GetObjectUserFlags(objList[0], &dwUserFlags);
if (dwUserFlags & USRFLG_VISIBLE)
{
uint16 dwCode;
if (g_pLTClient->GetContainerCode(objList[0], &dwCode))
{
m_eFirePosCode = (ContainerCode)dwCode;
}
}
}
if (IsLiquid(m_eCode))
{
m_wImpactFX = m_pAmmo->pUWImpactFX ? m_pAmmo->pUWImpactFX->nFlags : 0;
}
else
{
m_wImpactFX = m_pAmmo->pImpactFX ? m_pAmmo->pImpactFX->nFlags : 0;
}
m_wFireFX = m_pAmmo->pFireFX ? m_pAmmo->pFireFX->nFlags : 0;
// Assume alt-fire, silenced, and tracer...these will be cleared by
// IgnoreFX if not used...
m_wFireFX |= WFX_ALTFIRESND | WFX_SILENCED | WFX_TRACER;
// Assume impact ding, it will be cleared if not used...
m_wImpactFX |= WFX_IMPACTDING;
// Clear all the fire fx we want to ignore...
m_wFireFX &= ~m_wIgnoreFX;
m_wImpactFX &= ~m_wIgnoreFX;
// See if this is a redundant weapon fx (i.e., this client shot the
// weapon so they've already seen this fx)...
if (g_pGameClientShell->IsMultiplayerGame())
{
if (m_pAmmo->eType != PROJECTILE)
{
if (!m_bLocal && m_nLocalId >= 0 && m_nLocalId == m_nShooterId)
{
if (m_wImpactFX & WFX_IMPACTDING)
{
if (g_vtMultiDing.GetFloat())
{
PlayImpactDing();
}
}
return LTFALSE;
}
}
}
// Show the fire path...(debugging...)
if (g_cvarShowFirePath.GetFloat() > 0)
{
PLFXCREATESTRUCT pls;
pls.vStartPos = m_vFirePos;
pls.vEndPos = m_vPos;
pls.vInnerColorStart = LTVector(GetRandom(127.0f, 255.0f), GetRandom(127.0f, 255.0f), GetRandom(127.0f, 255.0f));
pls.vInnerColorEnd = pls.vInnerColorStart;
pls.vOuterColorStart = LTVector(0, 0, 0);
pls.vOuterColorEnd = LTVector(0, 0, 0);
pls.fAlphaStart = 1.0f;
pls.fAlphaEnd = 1.0f;
pls.fMinWidth = 0;
pls.fMaxWidth = 10;
pls.fMinDistMult = 1.0f;
pls.fMaxDistMult = 1.0f;
pls.fLifeTime = 10.0f;
pls.fAlphaLifeTime = 10.0f;
pls.fPerturb = 0.0f;
pls.bAdditive = LTFALSE;
pls.nWidthStyle = PLWS_CONSTANT;
pls.nNumSegments = 2;
CSpecialFX* pFX = g_pGameClientShell->GetSFXMgr()->CreateSFX(SFX_POLYLINE_ID, &pls);
if (pFX) pFX->Update();
}
// If the surface is the sky, don't create any impact related fx...
if (m_eSurfaceType != ST_SKY || (m_wImpactFX & WFX_IMPACTONSKY))
{
CreateWeaponSpecificFX();
if (g_bCanSeeImpactPos)
{
if ((m_wImpactFX & WFX_MARK) && ShowsMark(m_eSurfaceType) && (LTBOOL)GetConsoleInt("MarkShow", 1))
{
LTBOOL bCreateMark = LTTRUE;
if (g_bDistantImpactPos && m_nLocalId == m_nShooterId)
{
// Assume we'll see the mark if we're zoomed in ;)
bCreateMark = g_pGameClientShell->IsZoomed();
}
if (bCreateMark)
{
CreateMark(m_vPos, m_vSurfaceNormal, m_rSurfaceRot, m_eSurfaceType);
}
}
CreateSurfaceSpecificFX();
}
PlayImpactSound();
}
if (IsBulletTrailWeapon())
{
if (IsLiquid(m_eFirePosCode))
{
if (m_nDetailLevel != RS_LOW)
{
CreateBulletTrail(&m_vFirePos);
}
}
}
// No tracers under water...
if ((LTBOOL)GetConsoleInt("Tracers", 1) && (m_wFireFX & WFX_TRACER) && !IsLiquid(m_eCode))
{
CreateTracer();
}
if (g_bCanSeeFirePos)
{
// Only do muzzle fx for the client (not for AIs)...
if ((m_wFireFX & WFX_MUZZLE) && (m_nLocalId == m_nShooterId))
{
CreateMuzzleFX();
}
if (!g_bDistantFirePos &&
(LTBOOL)GetConsoleInt("ShellCasings", 1) &&
(m_wFireFX & WFX_SHELL))
{
CreateShell();
}
if ((m_wFireFX & WFX_LIGHT))
{
CreateMuzzleLight();
}
}
if ((m_wFireFX & WFX_FIRESOUND) || (m_wFireFX & WFX_ALTFIRESND) || (m_wFireFX & WFX_SILENCED))
{
PlayFireSound();
}
// Only do fly-by sounds for weapons that leave bullet trails...
if (IsBulletTrailWeapon())
{
PlayBulletFlyBySound();
}
return LTFALSE; // Just delete me, I'm done :)
}
void CWeaponFX::CreateBloodSplatFX()
{
CGameSettings* pSettings = g_pInterfaceMgr->GetSettings();
if (!pSettings || !pSettings->Gore()) return;
CSFXMgr* psfxMgr = g_pGameClientShell->GetSFXMgr();
if (!psfxMgr) return;
CSpecialFX* pFX = LTNULL;
LTFLOAT fRange = g_vtBloodSplatsRange.GetFloat();
// See if we should make some blood splats...
ClientIntersectQuery iQuery;
IntersectInfo iInfo;
iQuery.m_From = m_vPos;
LTVector vDir = m_vDir;
// Create some blood splats...
int nNumSplats = GetRandom((int)g_vtBloodSplatsMinNum.GetFloat(), (int)g_vtBloodSplatsMaxNum.GetFloat());
LTVector vU, vR, vF;
g_pLTClient->GetRotationVectors(&m_rDirRot, &vU, &vR, &vF);
for (int i=0; i < nNumSplats; i++)
{
LTVector vDir = m_vDir;
// Perturb direction after first splat...
if (i > 0)
{
float fPerturb = g_vtBloodSplatsPerturb.GetFloat();
float fRPerturb = (GetRandom(-fPerturb, fPerturb))/1000.0f;
float fUPerturb = (GetRandom(-fPerturb, fPerturb))/1000.0f;
vDir += (vR * fRPerturb);
vDir += (vU * fUPerturb);
}
iQuery.m_To = vDir * fRange;
iQuery.m_To += m_vPos;
iQuery.m_Flags = IGNORE_NONSOLID | INTERSECT_HPOLY;
if (g_pLTClient->IntersectSegment(&iQuery, &iInfo) && IsMainWorld(iInfo.m_hObject))
{
SurfaceType eType = GetSurfaceType(iInfo);
if (eType == ST_SKY || eType == ST_INVISIBLE)
{
return; // Don't leave blood on the sky
}
LTBOOL bBigBlood = (LTBOOL)GetConsoleInt("BigBlood", 0);
// Create a blood splat...
BSCREATESTRUCT sc;
g_pLTClient->AlignRotation(&(sc.rRot), &(iInfo.m_Plane.m_Normal), LTNULL);
// Randomly rotate the blood splat
g_pLTClient->RotateAroundAxis(&(sc.rRot), &(iInfo.m_Plane.m_Normal), GetRandom(0.0f, MATH_CIRCLE));
LTVector vTemp = vDir * -2.0f;
sc.vPos = iInfo.m_Point + vTemp; // Off the wall a bit
sc.vVel.Init(0.0f, 0.0f, 0.0f);
sc.vInitialScale.Init(1.0f, 1.0f, 1.0f);
sc.vInitialScale.x = GetRandom(g_vtBloodSplatsMinScale.GetFloat(), g_vtBloodSplatsMaxScale.GetFloat());
if (bBigBlood) sc.vInitialScale.x *= g_vtBigBloodSizeScale.GetFloat();
sc.vInitialScale.y = sc.vInitialScale.x;
sc.vFinalScale = sc.vInitialScale;
sc.dwFlags = FLAG_VISIBLE | FLAG_ROTATEABLESPRITE | FLAG_NOLIGHT;
sc.fLifeTime = GetRandom(g_vtBloodSplatsMinLifetime.GetFloat(), g_vtBloodSplatsMaxLifetime.GetFloat());
if (bBigBlood) sc.fLifeTime *= g_vtBigBloodLifeScale.GetFloat();
sc.fInitialAlpha = 1.0f;
sc.fFinalAlpha = 0.0f;
sc.nType = OT_SPRITE;
sc.bMultiply = LTTRUE;
char* pBloodFiles[] =
{
"Sfx\\Test\\Spr\\BloodL1.spr",
"Sfx\\Test\\Spr\\BloodL2.spr",
"Sfx\\Test\\Spr\\BloodL3.spr",
"Sfx\\Test\\Spr\\BloodL4.spr"
};
sc.pFilename = pBloodFiles[GetRandom(0,3)];
pFX = psfxMgr->CreateSFX(SFX_SCALE_ID, &sc);
if (pFX) pFX->Update();
}
else if (i==0)
{
// Didn't hit anything straight back, do don't bother to
// do anymore...
return;
}
}
}
LTBOOL CProjectileFX::CreateObject(ILTClient* pClientDE)
{
if (!CSpecialFX::CreateObject(pClientDE) || !m_hServerObject) return LTFALSE;
CGameSettings* pSettings = g_pInterfaceMgr->GetSettings();
if (!pSettings) return LTFALSE;
uint8 nDetailLevel = pSettings->SpecialFXSetting();
LTVector vPos;
LTRotation rRot;
m_pClientDE->GetObjectPos(m_hServerObject, &vPos);
m_pClientDE->GetObjectRotation(m_hServerObject, &rRot);
if (nDetailLevel != RS_LOW)
{
if (m_nFX & PFX_SMOKETRAIL)
{
CreateSmokeTrail(vPos, rRot);
}
if (m_nFX & PFX_LIGHT)
{
CreateLight(vPos, rRot);
}
}
if (m_nFX & PFX_FLARE)
{
CreateFlare(vPos, rRot);
}
if (m_nFX & PFX_FLYSOUND)
{
CreateFlyingSound(vPos, rRot);
}
// Do client-side projectiles in multiplayer games...
if (g_pGameClientShell->IsMultiplayerGame())
{
// Set the velocity of the "server" object if it is really just a local
// object...
if (m_bLocal)
{
VEC_COPY(m_vFirePos, vPos);
m_fStartTime = m_pClientDE->GetTime();
LTVector vVel, vU, vR, vF;
m_pClientDE->GetRotationVectors(&rRot, &vU, &vR, &vF);
VEC_COPY(m_vPath, vF);
// Special case of adjusting the projectile speed...
LTFLOAT fVel = (LTFLOAT) m_pProjectileFX->nVelocity;
if (m_bAltFire)
{
fVel = (LTFLOAT) m_pProjectileFX->nAltVelocity;
}
LTFLOAT fMultiplier = 1.0f;
if (m_pClientDE->GetSConValueFloat("MissileSpeed", fMultiplier) != LT_NOTFOUND)
{
fVel *= fMultiplier;
}
VEC_MULSCALAR(vVel, vF, fVel);
m_pClientDE->Physics()->SetVelocity(m_hServerObject, &vVel);
}
}
return LTTRUE;
}
LTBOOL CParticleTrailSegmentFX::Update()
{
if (!m_hObject || !m_pClientDE) return LTFALSE;
if (!CBaseParticleSystemFX::Update()) return LTFALSE;
CGameSettings* pSettings = g_pInterfaceMgr->GetSettings();
if (!pSettings) return LTFALSE;
uint8 nDetailLevel = pSettings->SpecialFXSetting();
LTFLOAT fTime = m_pClientDE->GetTime();
if (m_bFirstUpdate)
{
if (!m_hServerObject) return LTFALSE;
m_bFirstUpdate = LTFALSE;
m_fStartTime = fTime;
m_fLastTime = fTime;
// Where is the server (moving) object...
LTVector vPos, vTemp;
m_pClientDE->GetObjectPos(m_hServerObject, &vPos);
// Current position is relative to the particle system's postion (i.e.,
// each puff of Particle is some distance away from the particle system's
/// position)...
m_pClientDE->GetObjectPos(m_hObject, &vTemp);
VEC_SUB(vPos, vPos, vTemp);
VEC_COPY(m_vLastPos, vPos);
}
// Check to see if we should just wait for last Particle puff to go away...
if (m_bWantRemove || (fTime > m_fStartTime + m_fFadeTime))
{
if (fTime > m_fLastTime + m_fLifeTime)
{
return LTFALSE;
}
LTFLOAT fScale = (m_fLifeTime - (fTime - m_fLastTime)) / m_fLifeTime;
LTFLOAT r, g, b, a;
m_pClientDE->GetObjectColor(m_hObject, &r, &g, &b, &a);
m_pClientDE->SetObjectColor(m_hObject, r, g, b, fScale);
return LTTRUE;
}
// See if it is time to create a new Particle puff...
if ((fTime > m_fLastTime + m_fOffsetTime) && m_hServerObject)
{
LTVector vCurPos, vPos, vDelta, vTemp, vDriftVel, vColor;
// Calculate Particle puff position...
// Where is the server (moving) object...
m_pClientDE->GetObjectPos(m_hServerObject, &vCurPos);
// Current position is relative to the particle system's postion (i.e.,
// each puff of Particle is some distance away from the particle system's
/// position)...
m_pClientDE->GetObjectPos(m_hObject, &vTemp);
VEC_SUB(vCurPos, vCurPos, vTemp);
// How long has it been since the last Particle puff?
LTFLOAT fTimeOffset = fTime - m_fLastTime;
// What is the range of colors?
LTFLOAT fRange = m_vColor2.x - m_vColor1.x;
// Fill the distance between the last projectile position, and it's
// current position with Particle puffs...
int nNumSteps = (m_fLastTime > 0) ? (((m_nType & PT_BLOOD) || (m_nType & PT_GIBSMOKE)) ? 20 : 5): 1;
if (nDetailLevel != RS_HIGH)
{
nNumSteps /= 2;
}
VEC_SUB(vTemp, vCurPos, m_vLastPos);
VEC_MULSCALAR(vDelta, vTemp, 1.0f/float(nNumSteps));
VEC_COPY(vPos, m_vLastPos);
LTFLOAT fCurLifeTime = 10.0f;
if (nDetailLevel == RS_HIGH)
{
fCurLifeTime /= 2;
}
LTFLOAT fLifeTimeOffset = fTimeOffset / float(nNumSteps);
LTFLOAT fOffset = 0.5f;
int nNumPerPuff = GetNumParticles(m_nNumPerPuff);
for (int i=0; i < nNumSteps; i++)
{
// Build the individual Particle puffs...
for (int j=0; j < nNumPerPuff; j++)
{
VEC_COPY(vTemp, vPos);
if (m_bIgnoreWind)
{
VEC_SET(vDriftVel, GetRandom(-m_vDriftOffset.x*2.0f, -m_vDriftOffset.x),
GetRandom(5.0f, 6.0f),
GetRandom(-m_vDriftOffset.z, m_vDriftOffset.z));
}
else
{
VEC_SET(vDriftVel, g_vWorldWindVel.x + GetRandom(-m_vDriftOffset.x*2.0f, -m_vDriftOffset.x),
g_vWorldWindVel.y + GetRandom(5.0f, 6.0f),
g_vWorldWindVel.z + GetRandom(-m_vDriftOffset.z, m_vDriftOffset.z));
}
vTemp.x += GetRandom(-fOffset, fOffset);
vTemp.y += GetRandom(-fOffset, fOffset);
vTemp.z += GetRandom(-fOffset, fOffset);
GetRandomColorInRange(vColor);
m_pClientDE->AddParticle(m_hObject, &vTemp, &vDriftVel, &vColor, fCurLifeTime);
}
VEC_ADD(vPos, vPos, vDelta);
fCurLifeTime += fLifeTimeOffset;
}
m_fLastTime = fTime;
VEC_COPY(m_vLastPos, vCurPos);
}
return LTTRUE;
}
// Called when the folder gains or focus
void CFolderDisplay::OnFocus(LTBOOL bFocus)
{
CGameSettings *pSettings = g_pInterfaceMgr->GetSettings();
if (bFocus)
{
m_bEscape = LTFALSE;
m_bHardwareCursor = (GetConsoleInt("HardwareCursor",0) > 0 && GetConsoleInt("DisableHardwareCursor",0) == 0);
m_pHardwareCursor->Enable(GetConsoleInt("DisableHardwareCursor",0) == 0);
// The current render mode
RMode currentMode;
g_pLTClient->GetRenderMode(¤tMode);
// Set the renderer controls so that they match the currently selected renderer
unsigned int n;
for (n=0; n < m_rendererArray.GetSize(); n++)
{
unsigned int i;
for (i=0; i < m_rendererArray[n].m_resolutionArray.GetSize(); i++)
{
RMode mode=GetRendererModeStruct(n, i);
if (IsRendererEqual(¤tMode, &mode))
{
// Set the renderer index
m_pRendererCtrl->SetSelIndex(n);
// Setup the resolution control
SetupResolutionCtrl();
// Set the resolution index
m_pResolutionCtrl->SetSelIndex(i);
}
}
}
m_bTexture32 = pSettings->GetBoolVar("32BitTextures");
UpdateData(LTFALSE);
SetSelection(1);
}
else
{
UpdateData();
if (m_bEscape)
{
LTBOOL bTexture32 = pSettings->GetBoolVar("32BitTextures");
WriteConsoleInt("HardwareCursor",(int)m_bHardwareCursor);
pSettings->SetBoolVar("32BitTextures",m_bTexture32);
LTBOOL bRebind = (bTexture32 != m_bTexture32);
// Set the render mode if we are losing focus
if (m_pRendererCtrl && m_pResolutionCtrl)
{
int oldMO = (int)pSettings->GetFloatVar("MipmapOffset");
LTBOOL bSet = SetRenderer(m_pRendererCtrl->GetSelIndex(), m_pResolutionCtrl->GetSelIndex());
// If we didn't switch resolutions and the mipmap offset changed, rebind textures.
if(!bSet)
{
int curMO = (int)pSettings->GetFloatVar("MipmapOffset");
if(curMO != oldMO)
{
bRebind = LTTRUE;
}
}
}
if (bRebind)
{
g_pLTClient->Start3D();
g_pLTClient->StartOptimized2D();
g_pInterfaceResMgr->DrawMessage(GetSmallFont(),IDS_REBINDING_TEXTURES);
g_pLTClient->EndOptimized2D();
g_pLTClient->End3D();
g_pLTClient->FlipScreen(0);
g_pLTClient->RunConsoleString("RebindTextures");
}
}
if (GetConsoleInt("BitDepth",16) == 16)
WriteConsoleInt("DrawPortals",0);
else if ((GetConsoleInt("BitDepth",16) == 32) && (GetConsoleInt("PerformanceLevel",1) == 2))
WriteConsoleInt("DrawPortals",1);
g_pLTClient->WriteConfigFile("autoexec.cfg");
}
CBaseFolder::OnFocus(bFocus);
}
LTBOOL CPolyGridFX::Update()
{
if(!m_hObject || !m_pClientDE || !m_hServerObject)
return LTFALSE;
if(m_bWantRemove)
return LTFALSE;
// Set the flags of the polygrid based on the the server object...
uint32 dwServerFlags;
g_pCommonLT->GetObjectFlags(m_hServerObject, OFT_Flags, dwServerFlags);
if (dwServerFlags & FLAG_VISIBLE)
{
g_pCommonLT->SetObjectFlags(m_hObject, OFT_Flags, FLAG_VISIBLE, FLAG_VISIBLE);
}
else // We're hidden, no need to update...
{
g_pCommonLT->SetObjectFlags(m_hObject, OFT_Flags, 0, FLAG_VISIBLE);
return LTTRUE;
}
// Don't update if not drawn :)
uint32 dwFlags;
g_pCommonLT->GetObjectFlags(m_hObject, OFT_Flags, dwFlags);
if (!(dwFlags & FLAG_WASDRAWN) && !m_bAlwaysUpdate)
{
return LTTRUE;
}
// Update the position of the polygrid to reflect the position of the
// server object...
LTVector vPos;
g_pLTClient->GetObjectPos(m_hServerObject, &vPos);
g_pLTClient->SetObjectPos(m_hObject, &vPos);
// If we're not using polygrids (or special fx are set to the lowest
// detail setting), don't update...
if (m_bUseGlobalSettings)
{
CGameSettings* pSettings = g_pInterfaceMgr->GetSettings();
if (!pSettings) return LTTRUE;
uint8 nVal = pSettings->SpecialFXSetting();
LTBOOL bOn = pSettings->PolyGrids();
if (!bOn || nVal == RS_LOW)
{
return LTTRUE;
}
}
//if we are paused we shouldn't bother updating
if(g_pGameClientShell->IsServerPaused())
{
g_pLTClient->Common()->SetObjectFlags(m_hObject, OFT_Flags, FLAG_PAUSED, FLAG_PAUSED);
return LTTRUE;
}
else
{
g_pLTClient->Common()->SetObjectFlags(m_hObject, OFT_Flags, 0, FLAG_PAUSED);
}
// Update the plasma based on the type of plasma...
switch (m_nSurfaceType)
{
case PGSURFACE_PLASMA_FOUR_RING :
UpdateFourRingPlasma();
break;
case PGSURFACE_PLASMA_NORMAL:
UpdatePlasma();
break;
case PGSURFACE_WAVE_PROP:
UpdateWaveProp(g_pGameClientShell->GetFrameTime());
break;
default :
//default surface...
UpdatePlasma();
break;
}
if( m_sSurfaceSprite.size( ))
{
UpdateSurface();
}
return LTTRUE;
}