//----------------------------------------------------------------------------//
void CEGuiBaseApplication::updateFPS(const float elapsed)
{
// another frame
++d_FPSFrames;
if ((d_FPSElapsed += elapsed) >= 1.0f)
{
if (d_FPSFrames != d_FPSValue)
{
d_FPSValue = d_FPSFrames;
CEGUI::Font* fnt = CEGUI::System::getSingleton().getDefaultGUIContext().getDefaultFont();
if (!fnt)
return;
// update FPS imagery
char fps_textbuff[16];
sprintf(fps_textbuff , "FPS: %d", d_FPSValue);
d_FPSGeometry->reset();
fnt->drawText(*d_FPSGeometry, fps_textbuff, CEGUI::Vector2f(0, 0), 0,
CEGUI::Colour(0xFFFFFFFF));
}
// reset counter state
d_FPSFrames = 0;
float modValue = 1.f;
d_FPSElapsed = std::modf(d_FPSElapsed, &modValue);
}
}
_MEMBER_FUNCTION_IMPL(GUIFont, getFontHeight)
{
CEGUI::Font * pFont = sq_getinstance<CEGUI::Font *>(pVM);
if(!pFont)
{
sq_pushbool(pVM, false);
return 1;
}
sq_pushfloat(pVM, pFont->getFontHeight());
return 1;
}
void SceneSetup::setupGUI (void)
{
if (!guiSetup)
{
// Attach and start the CEGUI renderer.
mGUIRenderer = &CEGUI::OgreRenderer::bootstrapSystem(*mWindow);
// Initialise the CEGUI renderer
// Load the fonts and set their sizes.
CEGUI::Font* pFont;
CEGUI::Font::setDefaultResourceGroup("Fonts");
pFont = &CEGUI::FontManager::getSingleton().create("DejaVuSans-10.font");
pFont->setProperty( "PointSize", "10" );
#ifdef COLLISION_DOMAIN_CLIENT
//pFont = &CEGUI::FontManager::getSingleton().create("Verdana-outline-10.font");
//pFont->setProperty( "PointSize", "10" );
#else
// Load the fonts and set their sizes.
CEGUI::Font::setDefaultResourceGroup("Fonts");
pFont = &CEGUI::FontManager::getSingleton().create("DejaVuMono-10.font");
pFont->setProperty( "PointSize", "12" );
pFont = &CEGUI::FontManager::getSingleton().create("DejaVuMonoItalic-10.font");
pFont->setProperty( "PointSize", "12" );
#endif
// Register font as default
CEGUI::System::getSingleton().setDefaultFont("DejaVuSans-10");
// Create skin scheme outlining widget (window) parameters.
CEGUI::Scheme::setDefaultResourceGroup("Schemes");
CEGUI::SchemeManager::getSingleton().create("VanillaSkin.scheme");
CEGUI::SchemeManager::getSingleton().create("TaharezLook.scheme");
CEGUI::SchemeManager::getSingleton().create("GWEN.scheme");
CEGUI::WidgetLookManager::setDefaultResourceGroup("LookNFeel");
// Register skin's default image set and cursor icon
CEGUI::Imageset::setDefaultResourceGroup("Imagesets");
CEGUI::System::getSingleton().setDefaultMouseCursor("Vanilla-Images", "MouseArrow");
// Tell CEGUI where to look for layouts
CEGUI::WindowManager::setDefaultResourceGroup("Layouts");
// Create an empty default window layer
mGUIWindow = CEGUI::WindowManager::getSingleton().createWindow("DefaultWindow", "root_wnd");
CEGUI::System::getSingleton().setGUISheet(mGUIWindow);
// Prevent the GUI from being initialised again
guiSetup = true;
}
}
_MEMBER_FUNCTION_IMPL(GUIFont, getTextExtent)
{
const char * text;
sq_getstring(pVM, -1, (const char **)&text);
CEGUI::Font * pFont = sq_getinstance<CEGUI::Font *>(pVM);
if(!pFont)
{
sq_pushbool(pVM, false);
return 1;
}
sq_pushfloat(pVM, pFont->getTextExtent(g_pClient->GetGUI()->AnsiToCeguiFriendlyString(text)));
return 1;
}
/*************************************************************************
Does whatever is required in one single frame
*************************************************************************/
void CEGuiOpenGLBaseApplication::drawFrame(void)
{
CEGUI::System& guiSystem = CEGUI::System::getSingleton();
// do time based updates
int thisTime = glutGet(GLUT_ELAPSED_TIME);
float elapsed = static_cast<float>(thisTime - d_lastFrameTime);
d_lastFrameTime = thisTime;
// inject the time pulse
guiSystem.injectTimePulse(elapsed / 1000.0f);
// update fps fields
doFPSUpdate();
// do rendering for this frame.
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.0, 0.0, 12, 0.0, 0.0, -100, 0.0, 1.0, 0.0);
guiSystem.renderGUI();
// render FPS:
CEGUI::Font* fnt = guiSystem.getDefaultFont();
if (fnt)
{
guiSystem.getRenderer()->setQueueingEnabled(false);
fnt->drawText(d_fps_textbuff, CEGUI::Vector3(0, 0, 0), guiSystem.getRenderer()->getRect());
}
glFlush();
glutPostRedisplay();
glutSwapBuffers();
// here we check the 'quitting' state and cleanup as required.
// this is probably not the best way to do this, but since we're
// using glut, and glutMainLoop can never return, we need some
// way of checking when to exit. And this is it...
if (d_quitFlag)
{
// cleanup cegui system
CEGUI::Renderer* renderer = guiSystem.getRenderer();
delete CEGUI::System::getSingletonPtr();
delete renderer;
// exit
exit(0);
}
}
void Console::appendTextRow(const CeGuiString& text, const colour color)
{
const float MIN_SPACE_POS = 0.5;
CeGuiString textLeft = CeGuiString(text);
CEGUI::Font* font = const_cast<CEGUI::Font*>(mDisplay->getFont());
unsigned int width = mDisplay->getPixelSize().d_width * 0.95f;
while (textLeft.length() > 0)
{
CeGuiString textLine;
if (font->getTextExtent(textLeft) > width)
{
unsigned int numLastChar = font->getCharAtPixel(textLeft, width);
unsigned int numSpace = textLeft.find_last_of(" \t\n", numLastChar);
if (numSpace == CeGuiString::npos || numSpace < MIN_SPACE_POS*numLastChar)
{
textLine = textLeft.substr(0, numLastChar);
textLeft = textLeft.substr(numLastChar);
}
else
{
textLine = textLeft.substr(0, numSpace);
textLeft = textLeft.substr(numSpace+1);
}
}
else
{
textLine = textLeft;
textLeft = "";
}
ListboxTextItem* item = new ListboxTextItem(textLine);
item->setTextColours(color);
mDisplay->addItem(item);
mDisplay->ensureItemIsVisible(item); // scroll to bottom;
}
//ListboxWrappedTextItem* item = new ListboxWrappedTextItem(text);
//item->setTextColours(color);
//item->setTextFormatting(CEGUI::WordWrapLeftAligned);
//mDisplay->addItem(item);
//mDisplay->ensureItemIsVisible(item); // scroll to bottom;*/
}
_MEMBER_FUNCTION_IMPL(GUIElement, setFont)
{
CGUIFrameWindow * pWindow = sq_getinstance<CGUIFrameWindow *>(pVM);
CEGUI::Font * pFont = sq_getinstance<CEGUI::Font *>(pVM, 2);
if(!pWindow || !pFont)
{
sq_pushbool(pVM, false);
return 1;
}
// Adjust the size of the element when the font is changed
float fTextWidth = pFont->getTextExtent(pWindow->getText());
float fTextHeight = pFont->getFontHeight();
pWindow->setSize(CEGUI::UVector2(CEGUI::UDim(0, fTextWidth), CEGUI::UDim(0, fTextHeight)));
pWindow->setFont(pFont);
return 1;
}
//----------------------------------------------------------------------------//
void CEGuiBaseApplication::updateFPS(const float elapsed)
{
// another frame
++d_FPSFrames;
if ((d_FPSElapsed += elapsed) >= 1.0f)
{
if (d_FPSFrames != d_FPSValue)
{
d_FPSValue = d_FPSFrames;
CEGUI::Font* fnt = CEGUI::System::getSingleton().getDefaultGUIContext().getDefaultFont();
if (!fnt)
return;
// update FPS imagery
char fps_textbuff[16];
sprintf(fps_textbuff , "FPS: %d", d_FPSValue);
const size_t bufferCount = d_FPSGeometry.size();
for (size_t i = 0; i < bufferCount; ++i)
d_renderer->destroyGeometryBuffer(*d_FPSGeometry.at(i));
d_FPSGeometry.clear();
fnt->drawText(d_FPSGeometry, fps_textbuff, glm::vec2(0, 0), 0, false,
CEGUI::Colour(0xFFFFFFFF));
updateFPSGeometry();
}
// reset counter state
d_FPSFrames = 0;
float modValue = 1.0f;
d_FPSElapsed = std::modf(d_FPSElapsed, &modValue);
}
}
_MEMBER_FUNCTION_IMPL(GUIText, setText)
{
const char * text;
sq_getstring(pVM, -1, (const char **)&text);
CGUIFrameWindow * pWindow = sq_getinstance<CGUIFrameWindow *>(pVM);
if(!pWindow)
{
sq_pushbool(pVM, false);
return 1;
}
CClientScriptManager * pClientScriptManager = g_pClient->GetClientScriptManager();
pClientScriptManager->GetGUIManager()->Add(pWindow, pClientScriptManager->GetScriptingManager()->Get(pVM));
// We have to use the element's font to get the real extent
CEGUI::Font * pFont = pWindow->getFont (true);
float fTextWidth = pFont->getTextExtent(text);
float fTextHeight = pFont->getFontHeight();
pWindow->setSize(CEGUI::UVector2(CEGUI::UDim(0, fTextWidth), CEGUI::UDim(0, fTextHeight)));
pWindow->setText(CGUI::AnsiToCeguiFriendlyString(text, strlen(text)));
sq_pushbool(pVM, true);
return 1;
}
void FontDemo::checkIfEditButtonShouldBeDisabled(CEGUI::Font &font)
{
bool isEditable = findFontOption(font.getName());
if(!isEditable)
{
d_fontEditButton->disable();
d_fontEditButton->setTooltipText("This demo won't allow editing of\n"
"fonts that were created outside the demo or\n"
"were loaded from .font files");
}
else
{
d_fontEditButton->enable();
d_fontEditButton->setTooltipText("");
}
}
//----------------------------------------------------------------------------//
bool CEGuiD3D10BaseApplication::execute(CEGuiSample* sampleApp)
{
sampleApp->initialiseSample();
float clear_colour[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
//
// This is basically a modified Win32 message pump
//
bool idle;
while (Win32AppHelper::doWin32Events(idle))
{
if (idle)
{
CEGUI::System& guiSystem = CEGUI::System::getSingleton();
// do time based updates
DWORD thisTime = GetTickCount();
float elapsed = static_cast<float>(thisTime - d_lastFrameTime);
d_lastFrameTime = thisTime;
// inject the time pulse
guiSystem.injectTimePulse(elapsed / 1000.0f);
updateFPS();
char fpsbuff[16];
sprintf(fpsbuff, "FPS: %d", d_FPS);
Win32AppHelper::doDirectInputEvents(pimpl->d_directInput);
// get render target view
// this is a bit wasteful, but done like this for now since the
// resize code can change the view from under us.
ID3D10RenderTargetView* rtview;
pimpl->d_device->OMGetRenderTargets(1, &rtview, 0);
// clear display
pimpl->d_device->ClearRenderTargetView(rtview, clear_colour);
// main CEGUI rendering call
guiSystem.renderGUI();
// render FPS:
CEGUI::Font* fnt = guiSystem.getDefaultFont();
if (fnt)
{
guiSystem.getRenderer()->setQueueingEnabled(false);
fnt->drawText(fpsbuff, CEGUI::Vector3(0, 0, 0),
guiSystem.getRenderer()->getRect());
}
pimpl->d_swapChain->Present(0, 0);
rtview->Release();
}
// check if the application is quitting, and break the loop next time
// around if so.
if (isQuitting())
PostQuitMessage(0);
}
return true;
}
// Direct3DDevice9::Reset
void Direct3DReset()
{
// If our GUI instance does not exist create it
if(!g_pGUI)
{
g_pGUI = new CGUI(g_pDevice);
if(g_pGUI->Initialize())
{
// Version identifier text
g_pVersionIdentifier = g_pGUI->CreateGUIStaticText();
g_pVersionIdentifier->setText(VERSION_IDENTIFIER);
CEGUI::Font * pFont = g_pGUI->GetFont("tahoma-bold");
float fTextWidth = pFont->getTextExtent(VERSION_IDENTIFIER);
float fTextHeight = pFont->getFontHeight();
g_pVersionIdentifier->setSize(CEGUI::UVector2(CEGUI::UDim(0, fTextWidth), CEGUI::UDim(0, fTextHeight)));
float fTextX = pFont->getTextExtent("_");
float fTextY = -(fTextX + fTextHeight);
g_pVersionIdentifier->setPosition(CEGUI::UVector2(CEGUI::UDim(0, fTextX), CEGUI::UDim(1, fTextY)));
g_pVersionIdentifier->setProperty("FrameEnabled", "false");
g_pVersionIdentifier->setProperty("BackgroundEnabled", "false");
g_pVersionIdentifier->setFont(pFont);
g_pVersionIdentifier->setProperty("TextColours", "tl:FFFFFFFF tr:FFFFFFFF bl:FFFFFFFF br:FFFFFFFF");
g_pVersionIdentifier->setAlpha(0.6f);
g_pVersionIdentifier->setVisible(true);
/*#ifdef IVMP_WEBKIT
g_pWebkit = new CD3D9WebKit();
#endif
*/
// TODO: Make the default stuff (Chat window, main menu, e.t.c) a xml layout so it
// can be edited by users
// TODO: Also load the font from an xml layout so it can be edited by users
// TODO: Ability to output all server messages to the client console?
// TODO: A script console when client side scripts are implemented
CLogFile::Printf("GUI initialized");
}
else
CLogFile::Printf("GUI initialization failed");
}
else
{
// If our GUI class does exist inform it of the device reset
g_pGUI->OnResetDevice();
}
// If our graphics instance does not exist create it
if(!g_pGraphics && g_pDevice)
g_pGraphics = new CGraphics(g_pDevice);
else
g_pGraphics->OnResetDevice();
// If our main menu class does not exist create it
if(!g_pMainMenu)
g_pMainMenu = new CMainMenu();
else
g_pMainMenu->OnResetDevice();
//// Show loading screen
//if(!CGame::IsGameLoaded() && !CGame::IsMenuActive())
// g_pMainMenu->ShowLoadingScreen();
// If our credits class does not exist create it
if(!g_pCredits)
g_pCredits = new CCredits(g_pGUI);
// If our fps counter class does not exist create it
if(!g_pFPSCounter)
g_pFPSCounter = new CFPSCounter();
// If our fps counter class does not exist create it
if(!g_pChatWindow)
g_pChatWindow = new CChatWindow();
// If our input window class does not exist create it
if(!g_pInputWindow)
{
g_pInputWindow = new CInputWindow();
RegisterCommands();
}
// If our name tags class does not exist create it
if(!g_pNameTags)
g_pNameTags = new CNameTags();
}
/*************************************************************************
perform final rendering for all queued renderable quads.
*************************************************************************/
bool DirectX9Renderer::doRender(void)
{
d_currTexture = NULL;
if ( !d_buffer )
return false;
initPerFrameStates();
bool locked = false;
QuadVertex* buffmem;
// iterate over each quad in the list
for (QuadList::iterator i = d_quadlist.begin(); i != d_quadlist.end(); ++i)
{
const QuadInfo& quad = (*i);
LPDIRECT3DTEXTURE9 d3dTexture = quad.texture->getD3DTexture();
// flush & set texture if needed
if (d_currTexture != d3dTexture)
{
if (locked)
{
d_buffer->Unlock();
locked = false;
}
// render any remaining quads for current texture
renderVBuffer();
// set new texture
d_device->SetTexture(0, d3dTexture);
d_currTexture = d3dTexture;
}
if (!locked)
{
buffmem = NULL;
if (FAILED(d_buffer->Lock(0, 0, (void**)&buffmem, D3DLOCK_DISCARD)))
{
return false;
}
if ( buffmem == NULL )
{
return false;
}
locked = true;
}
// Hack: Inform the Font class that this glyph has been used recently, if it's a glyph being drawn
if ( quad.image )
{
unsigned long ulCodepoint = quad.image->getCodepoint();
// Is it a glyph?
if ( ulCodepoint != 0 && ulCodepoint > 127 && ulCodepoint < 65534 )
{
CEGUI::Font* pFont = quad.image->getFont();
if ( pFont )
pFont->refreshCachedGlyph(ulCodepoint);
}
}
// setup Vertex 1...
buffmem->x = quad.position.d_left;
buffmem->y = quad.position.d_top;
buffmem->z = quad.z;
buffmem->rhw = 1.0f;
buffmem->diffuse = quad.topLeftCol;
buffmem->tu1 = quad.texPosition.d_left;
buffmem->tv1 = quad.texPosition.d_top;
++buffmem;
// setup Vertex 2...
// top-left to bottom-right diagonal
if (quad.splitMode == TopLeftToBottomRight)
{
buffmem->x = quad.position.d_right;
buffmem->y = quad.position.d_bottom;
buffmem->z = quad.z;
buffmem->rhw = 1.0f;
buffmem->diffuse = quad.bottomRightCol;
buffmem->tu1 = quad.texPosition.d_right;
buffmem->tv1 = quad.texPosition.d_bottom;
}
// bottom-left to top-right diagonal
else
{
buffmem->x = quad.position.d_right;
buffmem->y = quad.position.d_top;
buffmem->z = quad.z;
buffmem->rhw = 1.0f;
buffmem->diffuse = quad.topRightCol;
buffmem->tu1 = quad.texPosition.d_right;
buffmem->tv1 = quad.texPosition.d_top;
}
++buffmem;
// setup Vertex 3...
buffmem->x = quad.position.d_left;
buffmem->y = quad.position.d_bottom;
buffmem->z = quad.z;
buffmem->rhw = 1.0f;
buffmem->diffuse = quad.bottomLeftCol;
buffmem->tu1 = quad.texPosition.d_left;
buffmem->tv1 = quad.texPosition.d_bottom;
++buffmem;
// setup Vertex 4...
buffmem->x = quad.position.d_right;
buffmem->y = quad.position.d_top;
buffmem->z = quad.z;
buffmem->rhw = 1.0f;
buffmem->diffuse = quad.topRightCol;
buffmem->tu1 = quad.texPosition.d_right;
buffmem->tv1 = quad.texPosition.d_top;
++buffmem;
// setup Vertex 5...
buffmem->x = quad.position.d_right;
buffmem->y = quad.position.d_bottom;
buffmem->z = quad.z;
buffmem->rhw = 1.0f;
buffmem->diffuse = quad.bottomRightCol;
buffmem->tu1 = quad.texPosition.d_right;
buffmem->tv1 = quad.texPosition.d_bottom;
++buffmem;
// setup Vertex 6...
// top-left to bottom-right diagonal
if (quad.splitMode == TopLeftToBottomRight)
{
buffmem->x = quad.position.d_left;
buffmem->y = quad.position.d_top;
buffmem->z = quad.z;
buffmem->rhw = 1.0f;
buffmem->diffuse = quad.topLeftCol;
buffmem->tu1 = quad.texPosition.d_left;
buffmem->tv1 = quad.texPosition.d_top;
}
// bottom-left to top-right diagonal
else
{
buffmem->x = quad.position.d_left;
buffmem->y = quad.position.d_bottom;
buffmem->z = quad.z;
buffmem->rhw = 1.0f;
buffmem->diffuse = quad.bottomLeftCol;
buffmem->tu1 = quad.texPosition.d_left;
buffmem->tv1 = quad.texPosition.d_bottom;
}
++buffmem;
// update buffer level
d_bufferPos += VERTEX_PER_QUAD;
// if there is not enough room in the buffer for another sprite, render what we have
if (d_bufferPos >= (VERTEXBUFFER_CAPACITY - VERTEX_PER_QUAD))
{
if (locked)
{
d_buffer->Unlock();
locked = false;
}
renderVBuffer();
}
}
if (locked)
{
d_buffer->Unlock();
locked = false;
}
renderVBuffer();
return true;
}
void CSpawnSelection::ProcessLocalPlayer(CLocalPlayer *pLocalPlayer)
{
CCamera *pGameCamera;
CPlayerPed *pGamePlayer;
DWORD dwTicksSinceLastSelection;
Vector3 vPlayerPos;
float fDrawX=25.0f;
float fDrawY=250.0f;
char szMsg[256];
if(FALSE == pLocalPlayer->IsActive() && !pLocalPlayer->IsWasted() && m_bClearedToSpawn)
{
// DONT ALLOW ANY ACTIONS IF WE'RE STILL FADING OR WAITING.
if((GetTickCount() - m_dwInitialSelectionTick) < 2000) return;
pGame->ToggleKeyInputsDisabled(TRUE);
if(GetKeyState(VK_SHIFT)&0x8000) // SHIFT PRESSED SO SPAWN
{
pGameCamera = pGame->GetCamera();
pGamePlayer = pGame->FindPlayerPed();
pGameCamera->Restore();
pLocalPlayer->SpawnPlayer();
pGame->DisplayHud(TRUE);
pGame->ToggleHud(TRUE);
pGame->HideRadar(FALSE);
pGameCamera->SetBehindPlayer();
pGamePlayer->GetPosition(&vPlayerPos);
pGame->PlaySound(10, vPlayerPos);
pGame->ToggleKeyInputsDisabled(FALSE);
pGamePlayer->TogglePlayerControllable(TRUE);
m_pGUIText->setVisible(false);
return;
}
else if(m_bClearedToSpawn) // WE ARE CLEARED TO SPAWN OR SELECT ANOTHER CLASS
{
pGame->ToggleHud(FALSE);
pGame->HideRadar(TRUE);
// SHOW INFO ABOUT THE SELECTED CLASS..
szMsg[0] = '\0';
strcat(szMsg, "> Use Left and Right arrow keys to select a class.\n");
strcat(szMsg, "> Press Shift button when ready to spawn.\n");
if(!m_pGUIText)
{
m_pGUIText = pGUI->CreateGUIStaticText();
m_pGUIText->setText(szMsg);
CEGUI::Font * pFont = pGUI->GetTahomaBold10Font();
float fTextWidth = pFont->getTextExtent(szMsg);
float fTextHeight = pFont->getFontHeight();
m_pGUIText->setSize(CEGUI::UVector2(CEGUI::UDim(0, fTextWidth*3), CEGUI::UDim(0, fTextHeight*3)));
float fTextX = pFont->getTextExtent("_");
float fTextY = -(fTextX + fTextHeight);
m_pGUIText->setPosition(CEGUI::UVector2(CEGUI::UDim(0, fTextX), CEGUI::UDim(0.8, fTextY)));
m_pGUIText->setProperty("BackgroundEnabled", "false");
m_pGUIText->setProperty("FrameEnabled", "false");
m_pGUIText->setProperty("Font", "Tahoma-Bold-10");
m_pGUIText->setProperty("TextColours", "tl:FFFFFFFF tr:FFFFFFFF bl:FFFFFFFF br:FFFFFFFF");
m_pGUIText->setAlpha(155);
m_pGUIText->setVisible(true);
}
CD3DFont *pD3DFont = pChatWindow->m_pD3DFont;
//pD3DFont->DrawText(fDrawX,fDrawY,0xFFFFFFFF,szMsg);
// GRAB PLAYER MATRIX FOR SOUND POSITION
pGamePlayer = pGame->FindPlayerPed();
pGamePlayer->GetPosition(&vPlayerPos);
pGame->DisplayHud(FALSE);
pGamePlayer->ClearAllWeapons();
pGamePlayer->TogglePlayerControllable(FALSE);
dwTicksSinceLastSelection = GetTickCount() - m_dwLastSpawnSelectionTick; // used to delay reselection.
// ALLOW ANOTHER SELECTION WITH LEFT KEY
if( (GetKeyState(VK_LEFT)&0x8000) && (dwTicksSinceLastSelection > 250)) { // LEFT ARROW
m_bClearedToSpawn = FALSE;
m_dwLastSpawnSelectionTick = GetTickCount();
m_iSelectedClass--;
pGame->PlaySound(14, vPlayerPos);
pLocalPlayer->RequestClass(m_iSelectedClass);
return;
}
// ALLOW ANOTHER SELECTION WITH RIGHT KEY
if( (GetKeyState(VK_RIGHT)&0x8000) && (dwTicksSinceLastSelection > 250)) { // RIGHT ARROW
m_bClearedToSpawn = FALSE;
m_dwLastSpawnSelectionTick = GetTickCount();
m_iSelectedClass++;
pGame->PlaySound(13, vPlayerPos);
pLocalPlayer->RequestClass(m_iSelectedClass);
return;
}
}
}
}
void Draw_Static_Text( const std::string &text, const Color *color_text /* = &white */, const Color *color_bg /* = NULL */, bool wait_for_input /* = 1 */ )
{
// fixme : Can't handle multiple lines of text. Change to MultiLineEditbox or use HorzFormatting=WordWrapLeftAligned property.
bool draw = 1;
// Statictext window
CEGUI::Window *window_statictext = CEGUI::WindowManager::getSingleton().loadWindowLayout( "statictext.layout" );
pGuiSystem->getGUISheet()->addChildWindow( window_statictext );
// get default text
CEGUI::Window *text_default = static_cast<CEGUI::Window *>(CEGUI::WindowManager::getSingleton().getWindow( "text_default" ));
// set text
text_default->setProperty( "TextColours", CEGUI::PropertyHelper::colourToString( CEGUI::colour( static_cast<float>(color_text->red) / 255, static_cast<float>(color_text->green) / 255, static_cast<float>(color_text->blue) / 255, 1 ) ) );
CEGUI::String gui_text = reinterpret_cast<const CEGUI::utf8*>(text.c_str());
text_default->setText( gui_text );
// align text
CEGUI::Font *font = &CEGUI::FontManager::getSingleton().get( "bluebold_medium" );
float text_width = font->getTextExtent( gui_text ) * global_downscalex;
text_default->setWidth( CEGUI::UDim( 0, ( text_width + 15 ) * global_upscalex ) );
text_default->setXPosition( CEGUI::UDim( 0, ( game_res_w * 0.5f - text_width * 0.5f ) * global_upscalex ) );
text_default->moveToFront();
float text_height = font->getLineSpacing();
text_height *= 1 + std::count(text.begin(), text.end(), '\n');
// set window height
text_default->setHeight( CEGUI::UDim( 0, text_height + ( 12 * global_upscaley ) ) );
while( draw )
{
Draw_Game();
// draw background
if( color_bg )
{
// create request
cRect_Request *request = new cRect_Request();
pVideo->Draw_Rect( NULL, 0.9f, color_bg, request );
request->m_render_count = wait_for_input ? 4 : 1;
// add request
pRenderer->Add( request );
}
pVideo->Render();
if( wait_for_input )
{
while( SDL_PollEvent( &input_event ) )
{
if( input_event.type == SDL_KEYDOWN || input_event.type == SDL_JOYBUTTONDOWN || input_event.type == SDL_MOUSEBUTTONDOWN )
{
draw = 0;
}
}
// if vsync is disabled then limit the fps to reduce the CPU usage
if( !pPreferences->m_video_vsync )
{
Correct_Frame_Time( 100 );
}
}
else
{
draw = 0;
}
pFramerate->Update();
}
// Clear possible active input
if( wait_for_input )
{
Clear_Input_Events();
}
pGuiSystem->getGUISheet()->removeChildWindow( window_statictext );
CEGUI::WindowManager::getSingleton().destroyWindow( window_statictext );
}
int cDialogBox_Question :: Enter( std::string text, bool with_cancel /* = 0 */ )
{
Init( with_cancel );
// get text
CEGUI::Editbox *box_text = static_cast<CEGUI::Editbox *>(CEGUI::WindowManager::getSingleton().getWindow( "box_question_text" ));
box_text->setText( reinterpret_cast<const CEGUI::utf8*>(text.c_str()) );
// align text
CEGUI::Font *font = &CEGUI::FontManager::getSingleton().get( "bluebold_medium" );
// fixme : Can't handle multiple lines of text
float text_width = font->getTextExtent( text ) * global_downscalex;
if( text_width > 250 )
{
box_window->setWidth( CEGUI::UDim( 0, ( text_width + 15 ) * global_upscalex ) );
box_window->setXPosition( CEGUI::UDim( 0, ( game_res_w * 0.5f - text_width * 0.5f ) * global_upscalex ) );
}
// Button Yes
CEGUI::PushButton *button_yes = static_cast<CEGUI::PushButton *>(CEGUI::WindowManager::getSingleton().getWindow( "box_question_button_yes" ));
// Button No
CEGUI::PushButton *button_no = static_cast<CEGUI::PushButton *>(CEGUI::WindowManager::getSingleton().getWindow( "box_question_button_no" ));
// Button Cancel
CEGUI::PushButton *button_cancel = static_cast<CEGUI::PushButton *>(CEGUI::WindowManager::getSingleton().getWindow( "box_question_button_cancel" ));
// if without cancel
if( !with_cancel )
{
button_cancel->hide();
}
// events
button_yes->subscribeEvent( CEGUI::PushButton::EventClicked, CEGUI::Event::Subscriber( &cDialogBox_Question::Button_yes_clicked, this ) );
button_no->subscribeEvent( CEGUI::PushButton::EventClicked, CEGUI::Event::Subscriber( &cDialogBox_Question::Button_no_clicked, this ) );
button_cancel->subscribeEvent( CEGUI::PushButton::EventClicked, CEGUI::Event::Subscriber( &cDialogBox_Question::Button_cancel_clicked, this ) );
finished = 0;
while( !finished )
{
Draw();
while( SDL_PollEvent( &input_event ) )
{
if( input_event.type == SDL_KEYDOWN )
{
if( input_event.key.keysym.sym == SDLK_ESCAPE )
{
if( with_cancel )
{
return_value = -1;
}
else
{
return_value = 0;
}
finished = 1;
}
else if( input_event.key.keysym.sym == SDLK_RETURN || input_event.key.keysym.sym == SDLK_KP_ENTER )
{
return_value = 1;
finished = 1;
}
else
{
pKeyboard->CEGUI_Handle_Key_Down( input_event.key.keysym.sym );
}
}
else if( input_event.type == SDL_KEYUP )
{
pKeyboard->CEGUI_Handle_Key_Up( input_event.key.keysym.sym );
}
else
{
pMouseCursor->Handle_Event( &input_event );
}
}
Update();
}
Exit();
return return_value;
}
