mirror of
https://github.com/unknownworlds/NS.git
synced 2024-11-27 06:42:56 +00:00
19b458f8bc
git-svn-id: https://unknownworlds.svn.cloudforge.com/ns1@141 67975925-1194-0748-b3d5-c16f83f1a3a1
660 lines
17 KiB
C++
660 lines
17 KiB
C++
#include "ui/UIHud.h"
|
|
#include "textrep/TRFactory.h"
|
|
#include "cl_dll/cl_util.h"
|
|
#include "cl_dll/hud.h"
|
|
#include "vgui_Scheme.h"
|
|
#include "vgui_Panel.h"
|
|
#include "mod/AvHClientVariables.h"
|
|
#include "vgui_App.h"
|
|
|
|
// for FindFirst and FindNext
|
|
#include <windows.h>
|
|
#include "fmoddyn.h"
|
|
|
|
using namespace vgui;
|
|
|
|
extern BitmapTGA* LoadTGA( const char* pImageName );
|
|
|
|
// Initialize hud from specified input file
|
|
UIHud::UIHud(const string& inFilename, UIFactory* inFactory) : CHud(), mFilename(inFilename), mManager(inFactory)
|
|
{
|
|
|
|
this->mFMOD = NULL;
|
|
|
|
// Set flag false so we load the first time
|
|
this->mInitted = false;
|
|
this->mSoundInitialized = false;
|
|
this->mMusicEnabled = false;
|
|
this->mMusicAllowed = false;
|
|
this->mCurrentSongStream = NULL;
|
|
this->mCurrentInternetStream = NULL;
|
|
this->mBytesInCurrentSong = 0;
|
|
this->mTimeSongEnded = -1;
|
|
this->mSongIsPlaying = false;
|
|
this->mRandomSecondsBetweenSongs = 0;
|
|
this->mCurrentVolume = 0;
|
|
this->mCurrentChannel = -1;
|
|
this->mInternetStreamChannel = -1;
|
|
|
|
// Init cursor variables
|
|
this->mArrowBitmap = NULL;
|
|
this->mArrowCursor = NULL;
|
|
|
|
if(TRFactory::ReadDescriptions(mFilename, this->mDescriptionList))
|
|
{
|
|
}
|
|
else
|
|
{
|
|
// TODO: Emit error
|
|
}
|
|
|
|
this->mSchemeManager = NULL;
|
|
}
|
|
|
|
UIHud::~UIHud(void)
|
|
{
|
|
this->ShutdownMusic();
|
|
}
|
|
|
|
bool UIHud::GetIsTimeForSong(float inCurrentTime) const
|
|
{
|
|
bool theTimeForNewSong = false;
|
|
|
|
if(this->mMusicEnabled && this->mMusicAllowed && !this->mSongIsPlaying)
|
|
{
|
|
float theTimeElapsedSinceSongStopped = inCurrentTime - this->mTimeSongEnded;
|
|
if((this->mTimeSongEnded == -1) || (theTimeElapsedSinceSongStopped > this->mRandomSecondsBetweenSongs))
|
|
{
|
|
theTimeForNewSong = true;
|
|
}
|
|
}
|
|
|
|
return theTimeForNewSong;
|
|
}
|
|
|
|
UIManager& UIHud::GetManager(void)
|
|
{
|
|
return this->mManager;
|
|
}
|
|
|
|
const UIManager& UIHud::GetManager(void) const
|
|
{
|
|
return this->mManager;
|
|
}
|
|
|
|
string UIHud::GetTextHeader(void) const
|
|
{
|
|
return "Default header\r\n";
|
|
}
|
|
|
|
void UIHud::Init(void)
|
|
{
|
|
CHud::Init();
|
|
}
|
|
|
|
void UIHud::InitializeSound(void)
|
|
{
|
|
|
|
char theFileName[2][_MAX_PATH];
|
|
|
|
sprintf(theFileName[0], "%s/fmod.dll", getModDirectory());
|
|
sprintf(theFileName[1], "fmod.dll");
|
|
|
|
for (int i = 0; i < 2 && mFMOD == NULL; ++i)
|
|
{
|
|
|
|
mFMOD = FMOD_CreateInstance(theFileName[i]);
|
|
|
|
// Check sound version
|
|
|
|
if (mFMOD != NULL && mFMOD->FSOUND_GetVersion() == FMOD_VERSION)
|
|
{
|
|
// Init sound
|
|
if (mFMOD->FSOUND_Init(44100, 32, 0))
|
|
{
|
|
this->mSoundInitialized = true;
|
|
}
|
|
else
|
|
{
|
|
char theErrorMessage[512];
|
|
sprintf(theErrorMessage, "say %s", FMOD_ErrorString(mFMOD->FSOUND_GetError()));
|
|
//ClientCmd(theErrorMessage);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FMOD_FreeInstance(mFMOD);
|
|
mFMOD = NULL;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
bool UIHud::InitializeScheme(const char* inName, Scheme* inScheme)
|
|
{
|
|
bool theSuccess = false;
|
|
|
|
// TODO: How to detect if invalid scheme handle?
|
|
SchemeHandle_t hPrimaryScheme = this->mSchemeManager->getSchemeHandle( inName );
|
|
{
|
|
int r, g, b, a;
|
|
|
|
// font
|
|
inScheme->setFont( Scheme::sf_primary1, this->mSchemeManager->getFont(hPrimaryScheme) );
|
|
|
|
// text color
|
|
this->mSchemeManager->getFgColor( hPrimaryScheme, r, g, b, a );
|
|
inScheme->setColor(Scheme::sc_primary1, r, g, b, a ); // sc_primary1 is non-transparent orange
|
|
|
|
// background color (transparent black)
|
|
this->mSchemeManager->getBgColor( hPrimaryScheme, r, g, b, a );
|
|
inScheme->setColor(Scheme::sc_primary3, r, g, b, a );
|
|
|
|
// armed foreground color
|
|
this->mSchemeManager->getFgArmedColor( hPrimaryScheme, r, g, b, a );
|
|
inScheme->setColor(Scheme::sc_secondary2, r, g, b, a );
|
|
|
|
// armed background color
|
|
this->mSchemeManager->getBgArmedColor( hPrimaryScheme, r, g, b, a );
|
|
inScheme->setColor(Scheme::sc_primary2, r, g, b, a );
|
|
|
|
//!! need to get this color from scheme file
|
|
// used for orange borders around buttons
|
|
this->mSchemeManager->getBorderColor( hPrimaryScheme, r, g, b, a );
|
|
inScheme->setColor(Scheme::sc_secondary1, r, g, b, a );
|
|
|
|
theSuccess = true;
|
|
}
|
|
return theSuccess;
|
|
}
|
|
|
|
void UIHud::LoadSchemes(void)
|
|
{
|
|
// Create scheme manager, we have screen dimensions by now
|
|
this->mSchemeManager = new CSchemeManager(ScreenWidth(), ScreenHeight());
|
|
|
|
Scheme* pScheme = App::getInstance()->getScheme();
|
|
this->InitializeScheme("PieMenuScheme", pScheme);
|
|
// this->InitializeScheme("TechButtonScheme", pScheme);
|
|
// this->InitializeScheme("ChainOfCommandScheme", pScheme);
|
|
// this->InitializeScheme("TitleFont", pScheme);
|
|
// this->InitializeScheme("Heading1", pScheme);
|
|
}
|
|
|
|
bool UIHud::PickRandomSong(string& outRelativeSongName) const
|
|
{
|
|
WIN32_FIND_DATA theFindData;
|
|
HANDLE theFileHandle;
|
|
StringList theSongList;
|
|
bool theFoundSong = false;
|
|
int theNumSongs;
|
|
|
|
// Find random song in directory
|
|
string thePath;
|
|
if(strcmp(cl_musicdir->string, ""))
|
|
{
|
|
thePath = cl_musicdir->string;
|
|
}
|
|
else
|
|
{
|
|
thePath = string(getModDirectory()) + string("\\") + string(kMusicDirectory);
|
|
}
|
|
|
|
string theFileQualifier = thePath + string("\\*.mp3");
|
|
theFileHandle = FindFirstFile(theFileQualifier.c_str(), &theFindData);
|
|
if (theFileHandle != INVALID_HANDLE_VALUE)
|
|
{
|
|
do
|
|
{
|
|
theSongList.push_back(thePath + string("\\") + string(theFindData.cFileName));
|
|
}
|
|
while(FindNextFile(theFileHandle, &theFindData));
|
|
|
|
FindClose(theFileHandle);
|
|
theFileHandle = INVALID_HANDLE_VALUE;
|
|
|
|
}
|
|
|
|
// Pick a random song in the list
|
|
theNumSongs = theSongList.size();
|
|
if(theNumSongs > 0)
|
|
{
|
|
int theSongOffset = gEngfuncs.pfnRandomLong( 0, theNumSongs -1 );
|
|
outRelativeSongName = string(theSongList[theSongOffset]);
|
|
theFoundSong = true;
|
|
}
|
|
|
|
return theFoundSong;
|
|
}
|
|
|
|
void UIHud::ClearStream(FSOUND_STREAM*& ioStream)
|
|
{
|
|
// TODO: Check error codes to make sure we don't leak?
|
|
if (mSoundInitialized)
|
|
{
|
|
mFMOD->FSOUND_Stream_Stop(ioStream);
|
|
mFMOD->FSOUND_Stream_Close(ioStream);
|
|
}
|
|
ioStream = NULL;
|
|
}
|
|
|
|
bool UIHud::PlaySong(string& inSongName, int& ioVolume, bool inLooping, FSOUND_STREAM*& outStream, int& outChannel, int& outBytesInSong, float inTimeElapsed)
|
|
{
|
|
bool theSuccess = false;
|
|
|
|
// Replace '/' with '\\'
|
|
std::replace(inSongName.begin(), inSongName.end(), '/', '\\');
|
|
|
|
// Load song
|
|
char theSongName[255];
|
|
strcpy(theSongName, inSongName.c_str());
|
|
|
|
// Open
|
|
unsigned int thePlayMode = FSOUND_STEREO;//FSOUND_NORMAL;
|
|
thePlayMode |= (inLooping ? FSOUND_LOOP_NORMAL : FSOUND_LOOP_OFF);
|
|
|
|
if(!this->mSoundInitialized)
|
|
{
|
|
this->InitializeSound();
|
|
}
|
|
|
|
if (mSoundInitialized)
|
|
{
|
|
|
|
// If alt-tabbing away at exactly the wrong time, music initialization can fail, don't crash
|
|
//ASSERT(this->mSoundInitialized);
|
|
|
|
outStream = mFMOD->FSOUND_Stream_Open(theSongName, thePlayMode, /*FSOUND_NONBLOCKING*/ 0, 0);
|
|
if(outStream)
|
|
{
|
|
outChannel = mFMOD->FSOUND_Stream_Play(FSOUND_FREE, outStream);
|
|
if (outChannel >= 0)
|
|
{
|
|
// Set song progress
|
|
if(inTimeElapsed != -1)
|
|
{
|
|
int theOffsetInMS = inTimeElapsed*1000;
|
|
int theSongTimeInMS = mFMOD->FSOUND_Stream_GetLengthMs(outStream);
|
|
|
|
if((theOffsetInMS > theSongTimeInMS) && inLooping)
|
|
{
|
|
theOffsetInMS %= theSongTimeInMS;
|
|
}
|
|
|
|
mFMOD->FSOUND_Stream_SetTime(outStream, theOffsetInMS);
|
|
}
|
|
|
|
// Set volume to half way. TODO: This should use a real music volume variable
|
|
mFMOD->FSOUND_SetPan(outChannel, FSOUND_STEREOPAN);
|
|
|
|
ioVolume = min(max(0, ioVolume), 255);
|
|
mFMOD->FSOUND_SetVolume(outChannel, ioVolume);
|
|
|
|
outBytesInSong = mFMOD->FSOUND_Stream_GetLength(outStream);
|
|
|
|
theSuccess = true;
|
|
}
|
|
else
|
|
{
|
|
//MessageBox(NULL, "Error. Cannot start song", "Playing a song", MB_ICONHAND|MB_OK|MB_SYSTEMMODAL);
|
|
int a = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// TODO: Print out this error message somewhere
|
|
char theErrorMessage[512];
|
|
sprintf(theErrorMessage, "say %s", FMOD_ErrorString(mFMOD->FSOUND_GetError()));
|
|
}
|
|
|
|
}
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
bool UIHud::PlayInternetStream(const string& inStreamName, string& outError)
|
|
{
|
|
bool theSuccess = false;
|
|
|
|
// Initialize sound system
|
|
if(!this->mSoundInitialized)
|
|
{
|
|
this->InitializeSound();
|
|
}
|
|
|
|
// If initialized
|
|
if(this->mSoundInitialized)
|
|
{
|
|
// If steam is currently playing, clear/stop it
|
|
// Reset stream channel
|
|
if(this->mInternetStreamChannel != -1)
|
|
gHUD.StopInternetStream();
|
|
|
|
// If stream channel is reset
|
|
if(this->mInternetStreamChannel == -1)
|
|
{
|
|
// Set buffer size and properties
|
|
mFMOD->FSOUND_Stream_SetBufferSize(100);
|
|
mFMOD->FSOUND_Stream_Net_SetBufferProperties(64000, 60, 80);
|
|
|
|
// Open stream for playing
|
|
this->mCurrentInternetStream = mFMOD->FSOUND_Stream_Open(inStreamName.c_str(), FSOUND_NORMAL | FSOUND_NONBLOCKING, 0, 0);
|
|
if(!this->mCurrentInternetStream)
|
|
{
|
|
outError = FMOD_ErrorString(mFMOD->FSOUND_GetError());
|
|
}
|
|
else
|
|
{
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
void UIHud::StopInternetStream()
|
|
{
|
|
this->ClearStream(this->mCurrentInternetStream);
|
|
|
|
this->mInternetStreamChannel = -1;
|
|
}
|
|
|
|
bool UIHud::UpdateInternetStream(float inCurrentTime, string& outError)
|
|
{
|
|
bool theSuccess = true;
|
|
|
|
// If we're playing a stream
|
|
if(this->mCurrentInternetStream)
|
|
{
|
|
if(this->mInternetStreamChannel < 0)
|
|
{
|
|
this->mInternetStreamChannel = mFMOD->FSOUND_Stream_PlayEx(FSOUND_FREE, this->mCurrentInternetStream, NULL, TRUE);
|
|
mFMOD->FSOUND_SetPaused(this->mInternetStreamChannel, FALSE);
|
|
|
|
//if (channel != -1)
|
|
//{
|
|
// FSOUND_Stream_Net_SetMetadataCallback(this->mCurrentInternetStream, metacallback, 0);
|
|
// }
|
|
}
|
|
|
|
// If we get an error, add it as a tooltip
|
|
int theOpenState = mFMOD->FSOUND_Stream_GetOpenState(this->mCurrentInternetStream);
|
|
if((theOpenState == -1) || (theOpenState == -3))
|
|
{
|
|
//printf("\nERROR: failed to open stream!\n");
|
|
//printf("SERVER: %s\n", );
|
|
//break;
|
|
|
|
outError = mFMOD->FSOUND_Stream_Net_GetLastServerStatus();
|
|
theSuccess = false;
|
|
gHUD.StopStream();
|
|
}
|
|
|
|
int read_percent = 0, driver = 0, channel = -1, status = 0, bitrate;
|
|
unsigned int flags;
|
|
mFMOD->FSOUND_Stream_Net_GetStatus(this->mCurrentInternetStream, &status, &read_percent, &bitrate, &flags);
|
|
}
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
void UIHud::PlayRandomSong(void)
|
|
{
|
|
// Pick random song first
|
|
string theRelativeSongName;
|
|
if(this->PickRandomSong(theRelativeSongName))
|
|
{
|
|
// Remove current song if any
|
|
if(this->mCurrentSongStream)
|
|
{
|
|
this->StopMusic();
|
|
}
|
|
|
|
// Load song
|
|
// char theSongName[255];
|
|
// strcpy(theSongName, theRelativeSongName.c_str());
|
|
// this->mCurrentSongStream = FSOUND_Stream_OpenMpeg(theSongName, FSOUND_NORMAL | FSOUND_LOOP_OFF);
|
|
// if(this->mCurrentSongStream)
|
|
// {
|
|
// // Play default song
|
|
// //FMUSIC_PlaySong(mod);
|
|
//
|
|
// this->mCurrentChannel = FSOUND_Stream_Play(FSOUND_FREE, this->mCurrentSongStream);
|
|
// if (this->mCurrentChannel < 0)
|
|
// {
|
|
// // MessageBox(hwnd, "Error. Cannot start song", "Playing a song", MB_ICONHAND|MB_OK|MB_SYSTEMMODAL);
|
|
// }
|
|
// else
|
|
// {
|
|
// // Set volume to half way. TODO: This should use a real music volume variable
|
|
// FSOUND_SetPan(this->mCurrentChannel, FSOUND_STEREOPAN);
|
|
//
|
|
int theVolume = (int)(cl_musicvolume->value);
|
|
// this->mBytesInCurrentSong = FSOUND_Stream_GetLength(this->mCurrentSongStream);
|
|
|
|
if(this->PlaySong(theRelativeSongName, theVolume, false, this->mCurrentSongStream, this->mCurrentChannel, this->mBytesInCurrentSong))
|
|
{
|
|
this->mCurrentVolume = theVolume;
|
|
int theDelay = (int)(cl_musicdelay->value);
|
|
this->mRandomSecondsBetweenSongs = gEngfuncs.pfnRandomLong(0, theDelay);
|
|
//this->mTimeSongEnded = -1.0f;
|
|
this->mSongIsPlaying = true;
|
|
|
|
}
|
|
// this->mCurrentVolume = (int)(cl_musicvolume->value);
|
|
// this->mCurrentVolume = min(max(0, this->mCurrentVolume), 255);
|
|
// cl_musicvolume->value = this->mCurrentVolume;
|
|
// FSOUND_SetVolume(this->mCurrentChannel, this->mCurrentVolume);
|
|
//
|
|
// this->mBytesInCurrentSong = FSOUND_Stream_GetLength(this->mCurrentSongStream);
|
|
// this->mRandomSecondsBetweenSongs = gEngfuncs.pfnRandomLong(5, 90);
|
|
// this->mTimeSongEnded = 0.0f;
|
|
// this->mSongIsPlaying = true;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// // TODO: Print out this error message somewhere
|
|
// char theErrorMessage[512];
|
|
// sprintf(theErrorMessage, "say %s", FMOD_ErrorString(FSOUND_GetError()));
|
|
// }
|
|
}
|
|
}
|
|
|
|
|
|
void UIHud::PostUIInit(void)
|
|
{
|
|
}
|
|
|
|
int UIHud::Redraw(float flTime, int intermission)
|
|
{
|
|
int rc = 0;
|
|
|
|
rc = CHud::Redraw(flTime, intermission);
|
|
|
|
// Now that the file has been parsed, pass it off to the UI manager to build everything
|
|
// This has to happen after CHud::VidInit because the components depend on the screen resolution to
|
|
// be sized properly
|
|
if(!this->mInitted)
|
|
{
|
|
this->LoadSchemes();
|
|
|
|
if(this->mManager.Initialize(this->mDescriptionList, this->mSchemeManager))
|
|
{
|
|
this->PostUIInit();
|
|
|
|
this->mInitted = true;
|
|
}
|
|
else
|
|
{
|
|
// TODO: Emit error
|
|
}
|
|
|
|
// Initialize music the first time through
|
|
this->InitializeSound();
|
|
}
|
|
|
|
string theErrorString;
|
|
this->Update(flTime, theErrorString);
|
|
|
|
return rc;
|
|
}
|
|
|
|
void UIHud::ResetGame()
|
|
{
|
|
this->mTimeSongEnded = -1;
|
|
this->mRandomSecondsBetweenSongs = 0;
|
|
}
|
|
|
|
void UIHud::SetMusicAllowed(bool inState)
|
|
{
|
|
this->mMusicAllowed = inState;
|
|
}
|
|
|
|
void UIHud::SetUsingVGUI(bool inState)
|
|
{
|
|
this->mManager.SetUsingVGUI(inState);
|
|
}
|
|
|
|
void UIHud::Shutdown(void)
|
|
{
|
|
this->ShutdownMusic();
|
|
}
|
|
|
|
void UIHud::ShutdownMusic(void)
|
|
{
|
|
if(this->mSoundInitialized)
|
|
{
|
|
this->StopMusic();
|
|
|
|
this->StopInternetStream();
|
|
|
|
mFMOD->FSOUND_Close();
|
|
|
|
FMOD_FreeInstance(mFMOD);
|
|
mFMOD = NULL;
|
|
|
|
this->mSoundInitialized = false;
|
|
|
|
}
|
|
}
|
|
|
|
void UIHud::StopMusic()
|
|
{
|
|
if(this->mCurrentSongStream && this->mSoundInitialized)
|
|
{
|
|
this->ClearStream(this->mCurrentSongStream);
|
|
this->mSongIsPlaying = false;
|
|
//this->mMusicEnabled = false;
|
|
//this->mMusicAllowed = false;
|
|
}
|
|
}
|
|
|
|
void UIHud::Think(void)
|
|
{
|
|
CHud::Think();
|
|
}
|
|
|
|
void UIHud::ToggleEditMode(void)
|
|
{
|
|
// For now this also changes us into edit mode
|
|
if(this->mManager.InMouseMode())
|
|
{
|
|
if(this->mManager.ToggleEditMode())
|
|
{
|
|
|
|
// Now save this bad-boy out!
|
|
this->mManager.Save(this->mFilename, this->GetTextHeader());
|
|
}
|
|
}
|
|
}
|
|
|
|
void UIHud::ToggleMouse(void)
|
|
{
|
|
// For now this also changes us into edit mode
|
|
this->mManager.ToggleMouse();
|
|
}
|
|
|
|
bool UIHud::Update(float inCurrentTime, string& outError)
|
|
{
|
|
this->mManager.Update(inCurrentTime);
|
|
|
|
this->UpdateMusic(inCurrentTime);
|
|
|
|
bool theSuccess = this->UpdateInternetStream(inCurrentTime, outError);
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
int UIHud::UpdateClientData(client_data_t *cdata, float time)
|
|
{
|
|
return CHud::UpdateClientData(cdata, time);
|
|
}
|
|
|
|
void UIHud::UpdateMusic(float inCurrentTime)
|
|
{
|
|
bool theJustTurnedOnMusic = false;
|
|
|
|
// When song is done, wait a time, then pick another song
|
|
if(this->mSoundInitialized)
|
|
{
|
|
if(!this->mMusicEnabled && this->mMusicAllowed)
|
|
{
|
|
this->mMusicEnabled = true;
|
|
theJustTurnedOnMusic = true;
|
|
}
|
|
else if(this->mMusicEnabled && !this->mMusicAllowed)
|
|
{
|
|
this->StopMusic();
|
|
}
|
|
|
|
if(this->mSongIsPlaying && ((int)(cl_musicvolume->value) != this->mCurrentVolume))
|
|
{
|
|
this->mCurrentVolume = (int)(cl_musicvolume->value);
|
|
this->mCurrentVolume = min(max(0, this->mCurrentVolume), 255);
|
|
cl_musicvolume->value = this->mCurrentVolume;
|
|
mFMOD->FSOUND_SetVolume(this->mCurrentChannel, this->mCurrentVolume);
|
|
}
|
|
|
|
// If the current song is done and a random time has elapsed since OR
|
|
// we just turned on music
|
|
if(theJustTurnedOnMusic || this->GetIsTimeForSong(inCurrentTime))
|
|
{
|
|
// Play a random song
|
|
this->PlayRandomSong();
|
|
}
|
|
|
|
if(this->mMusicEnabled && (this->mCurrentSongStream != NULL))
|
|
{
|
|
if((int)(mFMOD->FSOUND_Stream_GetPosition(this->mCurrentSongStream)) >= this->mBytesInCurrentSong)
|
|
{
|
|
this->mTimeSongEnded = inCurrentTime;
|
|
this->mSongIsPlaying = false;
|
|
}
|
|
}
|
|
// if(this->mTimeSongEnded != 0.0f && thi)
|
|
// {
|
|
// float theTimeElapsedSinceSongStopped = inCurrentTime - this->mTimeSongEnded;
|
|
// if(theTimeElapsedSinceSongStopped > this->mRandomSecondsBetweenSongs)
|
|
// {
|
|
// this->PlayRandomSong();
|
|
// }
|
|
// }
|
|
}
|
|
}
|
|
|
|
void UIHud::VidInit(void)
|
|
{
|
|
CHud::VidInit();
|
|
|
|
GetManager().VidInit();
|
|
}
|
|
|
|
FMOD_INSTANCE* UIHud::GetFMOD()
|
|
{
|
|
return mFMOD;
|
|
}
|
|
|